Update: I see that social_mandog is getting downvoted for /h(er|is)/ post. I can understand why, but I want to explain why I gave it a ++.

social_mandog, from what I read in the above post, seems to be suggesting that a CS degree is useless (at least, if you accept the anology that critics can't create). So, social_mandog made a post, stated a thesis, and asked for others to comment. Now, if you're downvoting the post because it's off-topic, I can see that. If you're downvoting because social_mandog is apparently stating a view that you don't agree with, then I don't agree with that - though it's your prerogative. An argument was put forward and discussion was asked for. I like that.

You're absolutely correct. Literary criticism can be useful for writing a good story :)

I've definitely met CS majors who couldn't tell you the difference between a global variable and a lexically scoped one -- or why the latter is preferred. I've met CS majors who are programming language bigots and forget that different languages have different strengths. In fact, many of the CS majors that I have met seem clueless about programming.

Programmers that I have met without a CS degree are even worse.

Everyone knows that the bubble sort is useless, right? What, you didn't learn that when you studied algorithmic efficiency? Oh, wait, you did learn about it. Did you know that the bubble sort is often the fastest possible sorting algorithm on nearly sorted data? Do you know the difference between a b-tree and a binary tree? Have you used a heap? What about a linked list, double linked list and the like? Why are linked lists so common in other langauges but seldom used in Perl?¹

It's questions like the ones above that trip up people who aren't CS majors. Personally, I only have an Associate of Science degree. I'm working my tail off trying to make up for it. I think this is the difference between "coders" and "programmers". Many coders can tell you, down to minute detail, why pseudo-hashes were invented, how to implement one, what's wrong with them, and why their apparent performance gain was illusory. Of course, these same coders often can't program their way out of a paper bag (whatever that means). Programmers, on the other hand, won't necessarily know everything about a language (but they often do), but they know how to develop programs. They know when to optimize, when not to optimize, when to break rules, and - more importantly - what the rules are.

Having a CS degree probably means that you have studied algorithmic efficiency. You probably understand how different data structures work² You might just know that the particular graph software that you are working on would be better off using adjacency lists than adjacency matrices. By being exposed (hopefully) to a wider variety of ideas and programming languages, you bring a greater set of tools to any given language. Perl, for example, may be the swiss army chainsaw, but you are the one using Perl, not the other way around; you have to know exactly where Perl has the corkscrew hidden.

This isn't to say that CS majors make better programmers, per se, but they have a much better foundation to build on. People who learn to program but don't study computer science³ have a great knowledge gap but often don't know what they don't know, so they sneer at those who do.

It reminds me of a famous quote by a chess grandmaster (whose name escapes me right now) when he was commenting about Bobby Fisher's brilliance at chess. He said that he could also see the brilliant moves that Bobby Fisher found in any given position, he just couldn't figure out how to get to that position. Many of us see the brilliance in the work of Dominus, TheDamian, or merlyn, but if you read the above post again very, very carefully, you might get a glimmering of how to reach their positions.

Cheers,
Ovid

1. To be perfectly fair, I'm just learning about many of these things myself. I realized that one of my greatest weaknesses as a programmer is lack of knowledge of algorithms, so I'm trying to make up for. I have Mastering Algorithms with Perl sitting beside me now (as if you couldn't tell :)

2. Knowing about data structures is at least as important as knowing about algorithms. And when I say data structures, I'm not talking about something as trivial as an array of arrayrefs of hashrefs or anything like that. I'm talking about deques, stacks, doubly-linked lists, etc.

3. When I say "study computer science", I don't necessarily mean "at university". There are plenty of excellent programmers out there who know "computer science", but never went to school for it. We can learn anywhere.

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

While it's hard for me to say how useful a CS degree would be (high school dropout 'cause of Math of all things... ), I don't think by any means it's a necessity. I've met plenty of CS Majors that were bigger hacks than Danielle Steele.

I don't think anything is a replacement for experience (and books). With the abundance of computing power today, it's really easy to churn out bloated code that merely functions. This has it's place in some limited situations, but it's also why even though PC's are 20 times faster than 6 years ago, the actual performance gains lag far behind. (Windoze anyway). On the other hand, "Premature optimization is the root of all evil."

Slightly OT, I think the fundamental picture of PC Computing is lost on many a college student. I think a great project for someone new to computing would be to have write a game or some similarly complex simulation on an old 386/486 (or something with constraints) that was way too ambitious to actually run on such an old system.

They would get their hands dirty. Once they got it running (slowly), they'd be forced to look at the efficiency of their algorithms. Once that was tweaked, they'd have to turn to look at the operation of the system itself for further speed, then finally, compromise features. I can only speak from my own experience but these are issues that come up quite routinely in the programmers line of work and are hard to teach from a book.

I also think every programmer should do some assembler, at least for awhile. While it's tedious as hell, it gives you a great feel for what is actually going on under the hood.

my $two_cents && 'Happy Holidays';

-Lee

First, let me say this is not a rant at shotgunefx. I replied to this post because it hit several topics that I wanted to touch on. I don't think anyone disputes the fact that college systems turn out an inordinate number of hacks, whether CS or literary. I also doubt that many would dispute that there are a goodly number of bad CS and Literary university programs.

However, some of these examples listed above actually represent the basics of any decent CS curriculum:

• CIS students on a systems information track usually have to write a multitasking operating system simulation. I had to do this in Advanced Operating systems.
• <OLDFART>I was in college from 1983-1987. When I graduated, we still had IBM PC Jr.s in the PC labs and an IBM 4341 mainframe with 8MB of core memory. Do you think that the scope of our assignments were limited because of the hardware constraints? Mind you there was no such thing as CPAN back then, we had to write everything from scratch using the quaint data structures Ovid mentioned.</OLDFART>
• Students in the systems information track were also required to take Compiler Construction and Design. I was exempted from this because I requested to take a graduate course in Artificial Intelligence instead. My project was a 3d tic-tac-toe game on a 5-by-5 cube. with graphics.
• Assembler was required for all CS majors and was a prerequisite to Data Structures. Digital Logic, required for systems information, also provided valuable insights on how computers work.
One of the points I'm trying to make is that universities are a lot like computers: Garbage in, garbage out. Those that apply themselves and learn the required material will benefit from a college degree.

Colleges do provide the opportunity for real hands on (paid) experience for their students, it called co-op. I had one friend that worked with the local Corps of Engineers and two at QMS (Quality Micro Systems) R&D. One is currently upper management at Adobe.

People should also consider the fact that most intelligent college students do more than just attend class and do homework. Some work, have families, belong to professional organizations and also find time to further personal projects or research as well (computer related or not).

Here are some interesting statistics lifted from here:

Table 1. Highest level of school completed or degree
         received, computer programmers, 1998

    Level completed                                  Percent
    ------------------------------------------       -------
    High school graduate or equivalent or less          10.6
    Some college, no degree                             20.5
    Associate degree                                    10.2
    Bachelor’s degree                                   45.3
    Graduate degree                                     13.4

    About 3 out of 5 computer programmers had a bachelor’s
    degree or higher in 1998 (see table 1). Of these, some hold a
    degree in computer science, mathematics, or information
    systems, whereas others have taken special courses in
    computer programming, to supplement their study in fields
    such as accounting, inventory control, or other areas of
    business. As the level of education and training required by
    employers continues to rise, this percentage should increase
    in the future.

--Jim

Interesting. When I read mandog's post my first interpretation was "CS doesn't teach people how to program" and I agreed with it.

Because my definition of "programming" is getting your code down, tested thoroughly and working properly.

Knowing when to break things into a module, just how much you can code before you need to test it, what a good variable name is, and why. These are the things I think of as "programming". And since I haven't seen anyone try to teach them outside of "The Practice of Programming" by Kernighan and Pike and "Large Scale C++ Software Design" by Lakos, I tend to think of them as things you learn through experience.

Picking algorithms, mapping out data structures, choosing an overall program architecture that works with everything else. I think of all these things as "Software Engineering". In a way they're easier to learn. Most are things that people can measure easily (e.g. testing the performance of various sorting algorithms). Much of it has a strong scientific basis and there are a million books about it. It's covered in every CS curriculum.

I don't think you can be good at developing software without both. The two parts are like the difference between architects and carpenters. One can tell you what to do, the other how to do it, and you aren't going to get a good building without both.

I've got a Computer Engineering degree (not quite CS - but the only relevant difference was that I had EE classes instead of electives, and a few extra semesters of math) and I must say that it didn't teach me anything about programming. Professors lectured on data structures, analysis of algorithms, language syntax, etc. But nobody ever tried to sit a class down and say "this is how you write code".

Nobody ever mentioned that you shouldn't write 2000 lines of code, then see if it compiles. And I saw CS students just about to graduate do exactly that. People in their last semester, with good grades, who didn't know how to break a C program up into more than one .c file and still get it to compile, much less use multiple files to make the code more reuseable.

This is a very real problem. Did anyone else go to a school where the CS department didn't offer a class, or even a lecture on debugging? Debugging isn't a big research topic. People don't write theses about whether debuggers are more efficient than print() statements. It won't make a professor's career. But you can't be a professional programmer without it.

You can't be a good professional without the theory of algorithms, different development cycles, a good gut feel of what happens when someone makes a O(n^2) algorithm, etc. CS is where you learn that. I'm just not sure that it's "programming".

Without understanding *how* software works (i.e. having studied Computer Science), it's possible to write software that works - that accomplishes the task.

print "Hello, world!\n";
[download]

Without understanding the mechanisms of drama and storytelling, it's possible to tell a story.

I was hungry.
I ate an apple.
I'm not hungry anymore.
[download]

The key is the study. Whether achieving a formal degree or not, study improves practice.

So, yes, I agree that Computer Science is as useful for writing good software as the ability to Read Critically is for writing a good story. Whatever you do, study how others do it in order to improve!

...or were you being facetious... :-)

A computer science degree is as useful for writing good software as a literary arts degree is for writing a good story.

A person with either degree has demonstrated that they have met the minimum requirements necessary to obtain that fundamental knowledge base. They have at least been exposed to those fundamentals. The same is much more difficult to assess for someone without a degree.

As the others have already said, having a degree doesn't necessarily make one individual smarter or a better programmer/author. But it does show to prospective employers that they have been exposed to the fundamentals.

BTW, I ++'d every node in this thread (including the original one) because they stimulate thoughtful discussion. The sign of a good Meditation.

--Jim

First, it is trivially true that degrees in a subject are not a good indicator of having really learned it. As Biker pointed out, that is true in both CS and literary criticism.

Secondly I think it is true that mastery of the current research in either, particularly of the current fads, is both not necessary to producing the product (be it literature or programs), and I think that a survey of noted professionals of either topic would back me up.

However, and this is a big however, I suspect that it is hard to impossible to find a good author who has not thought long and hard about the writing process, and I have never to the best of my knowledge met or heard of a good programmer who has not thought long and hard about the programming process. And that thinking inevitably includes exposure to and thinking about the academic study of the topic in question (programming or literature).

So I agree with the thesis in several ways. I don't think that degrees indicate knowledge, I think that academic fashion can and does depart from what is useful for the practice, but practitioners are well advised to understand the fundamentals of the academic theory.

If I change the proposition to

A knowledge of computer science is as useful for writing good software as a knowledge of literary criticism is for writing a good story.

However, since no one else posting here has let that get in the way, I'll go along and make a stab at an answer—hell, why let a little thing like 'undecideability' get in the way?

If I assume that a degree in computer science and a degree in literary criticism are the stand-ins for the original statement, then I still have to agree. I say this without even having to deal with the value of either. No matter how bad the academic scene may have become, I doubt that it is possible for someone to gain a degree and truly wind up knowing less than when they started. And that is what it would take for the possession of either to be less than 'useful' in the pursuit of the assigned tasks. Necessary? No, I didn't say that, just 'useful'. Any knowledge at all from such a source would be in addition to that already had. So useful? Well of course!

–hsm

First of all, taking this at face value, I think you're comparing apples and oranges. Computing science is about creating software. Literary criticism is not about writing stories, it's about appreciating and understanding the literature that's already there.

Now, since I read this as a veiled attack on computing science, let me respond to that.

A good grasp of computing science is absolutely essential for a serious programmer. Notice that I did not say that a CS degree is essential; I'm talking about concepts and understanding, not paper credentials.

CS, as distinct from software engineering, is about the theory of making computers do exactly what you want them to. That means stuff like big-O notation, algorithmic analysis, a proper understanding of the various paradigms of programming (as opposed to: "Object oriented? You mean Java?" and suchlike), and the theory of all the "practical" aspects of programming. You can pick this stuff up from books, probably even from experience (which is how it was done originally, of course), but the easiest way of getting it is by taking a CS degree.

A programmer with a good understanding of CS will not spend hours trying to save two cycles in the inner loop of an O(n^2) sort; he will spend twenty minutes replacing the bubble sort with heapsort. For that matter, he won't spend hours trying to re-code an exponential-time algorithm as a polynomial-time algorithm if the problem is NP-hard (well, not unless the object of the exercise is to prove P=NP). A "self-taught" programmer with no grasp of CS might design and set up a database, but won't be able to normalize it, and will end up with redundant (and probably inconsistent) data. He'll write two hundred lines of procedural code to solve a problem that could be expressed in ten lines of functional code... or two lines of declarative code. And so on.

In short, I think you're full of it. Computer science is as useful for writing good software as a sense of plot, character, and eloquence is for writing a good story.

See also Why Theory Doesn't Suck.

--
:wq

The foundation of any creative endeavor is craftsmanship. There are many paths that can lead you there, but in the end all that matters is what is created.

Craftsmanship is building things well.

But you have to know what you're building. Beyond the very small, you must have design.

No matter how good the construction workers, they still ask an architect to design the sky scraper.

Computer Science tries to provide the design expertise in software development.

I think that is an over-simplification.
If you are "engineering" a program then design is important and helpful. If you are "creating" a program then just sitting in front of a text-editor and feeling the code flow from you is just as efficient and just as "good".


Sometimes closing your eyes and letting your hand wander across the page can produce the most beautiful, elegant lines of all.


billybofh.

I completely disagree with your premise.

Assuming that you are talking about the theory of computing, I would argue that it is essential to writing good software. Knowing the difference between an array and a hash, or when to use a linked list rather than an array, is quite necessary for writing good software. Anyone can churn out a script to accompish a given task, but whether it's well-written depends on whether or not he/she/it understands what he/she/it is doing.

Having said that, computer science is not necessarily something learned in the classroom.

Most of what I know (which is not a great deal ;]) I learned through extracurricular study. I play with computers for the simple fact that I enjoy it. I like coding, I like admining, I like doing stupid things like dd'ing a kilobyte of hda over hda1 and tearing my hair out trying to fix it. On an arguably basic level, I have an understanding of computer science. Without it, I could not write good software. And without furthering it, I cannot write better software.

Attaining a degree in something is simply a means to an end, one of many. We're all free to choose a different route.

Casablanca anyone?

Whole discussion: http://slashdot.org/article.pl?sid=01/12/25/0718229&mode=thread

One it's thread "CS vs. lack of it": http://slashdot.org/comments.pl?sid=25301&mode=thread&cid=2758789

--
Ilya Martynov (http://martynov.org/)

This is the precise reason there are so many shitty programmers out there. Yeah, I said shitty. Too many people feel that programming is simply stringing syntax together to produce output.

Let me tell you, this is wrong. You arent a good programmer until you feel the code and get a sense for how it is written and how it works. There are quite a few posts around that explain the methods programmers use from being monkeys-on-typewriters-trying-to-come-up-with-shakespear to actual code-slinging-hackers.

There are people who code with the notion that its not a science, and often these people get employed as programmers. They are not. They are the people who think:

open MAIL, "$foo |";
[download]

I think you seriously need to evaluate whether you should be programming at all, let alone attempting to describe the profession (caste, religion, whatever). I very much hope youre not planning to write a paper or publish anything with this nonsense.

sizzle,
brother dep.

--
Laziness, Impatience, Hubris, and Generosity.

whoa dep! The assertion as it stands makes no pejorative comment on the usefulness of the degree relative to the crafts! It merely seeks to compare the two. :)

I think it's obvious to anyone who reads that literary criticism or equivalent work experience is very necessary to good literature of all sorts. Sure, this can often take the form of working in a team with an editor who does have a degree in the field, but that an author can produce good books without it is a funny assertion.

Ditto the lowly coder. Sure, some rank amateurs have gotten lucky. But in general the analogy stands, software will be vastly improved when a CSci type is attached to the project. Now editors and computer scientists may not be able to come up with great plots and characters or architect applications; their own prose may be stilted and clumsy, their own programming may be similarly awful; but this is not their role in the work at hand.

They are there to look at some of the problem areas, algorithms that go haywire, sentences that lack verbs. That sort of thing. If I had to get a code review, I'd prefer a CSci major over Joe Hacker who doesn't know a bubble sort from a linked list. Similarly, if I were authoring a textbook, novel, or self help book, I would want someone with solid lit skills to be involved pre-press.

So I'd say it's a perfect analogy, even if it is a troll which meant to cast aspersion on CSci majors and Lit Crit types.