Why a Computer Science Degree Matters | Hacker News Reader

Why a Computer Science Degree Matters

blog.jaredshort.com

26 pointsshortj51 comments

How is this a case for a degree? It's really a case for being educated, a case for studying your field and understanding concepts like "finite state machine". You don't have to go to college to get that, and lots of people seem to get through college CS degrees without gaining that understanding.

Depends on the kind of person you are. Under the pressure of a deadline, and the mantra of 'get things done', will you be able to step back and say, 'hey, what's the meta problem here?' 'Is there a better way?'

Some people just solve the same problems over and over again without realizing it.

Much of the theoretical underpinnings behind some of the stuff I use, I might not have ventured to look into it were it not for my college degree (nor could I have figured it out by myself). The more basic stuff you know, the easier it is to pick up the harder stuff. Trick is to know which stuff is the basic stuff first. In college you get a shortcut to the basic foundation stuff. If you have a nose for that sort of thing, then good, but it's very hard to do so in the beginning.

CS courses aren't designed to give you practical programming knowledge. It's designed to teach you theoretical underpinnings that you can carry throughout your career, regardless of what the technology du jour is in vogue.

Sometimes, it's just good to have had a brush with something, so you can pattern match and say...I remember seeing something similar before. Or even to know what something's called, so you can look it up later. Hard to search for things when you don't know what they're called.

Many, many people who get degrees from CS programs won't step back to think about the problem, will solve the same problems over and over again, will not really understand the theoretical underpinnings of what they are doing, and so on.

> Hard to search for things when you don't know what they're called.

I tend to disagree. You don't need to search for things by name, you only need to recognize some common cases for the pattern and then look for people talking about those cases, which is pretty easy to do. From there you'll find the pointers to what you need to know.

Most problems in CS (or at least things you'll be solving without moving into postgraduate research) are solved by existing algorithms and patterns that have been used elsewhere for a long time, so there is tons of data to look back on.

Yes, OP. This is a first-fruit of the CS degree. Might I suggest looking at threads and continuations and pondering the interrelation, as well as the pi-calculus & the Occam language?

Metacomment: incoming list of people saying cs education is for "sheeple" and any real hacker can get a job/learn it on his own.

And this is the metareply,

That's not the point of an education. Mistaking college for that is thinking college is trade school training. It generally hasn't been, it usually isn't, and it shouldn't be.

Loosely, the purpose of education ( as opposed to training ) is to provide (i) a broad base of understanding across a wide variety of areas nearly inaccessible without portals created by experts, (ii) a theoretical grasp of the field, providing a framework and sense of theoretical possibilities present, past, and future, (iii) a structured and systematic mechanism to go through these subject areas in ways that are (a) thought-through, (b) approximately complete, and (c) pedagogically competent, and finally, (iv) a standard way to attain a certain competence in the area that is generally agreed upon to provide a base understanding.

It would be disingenuous to suggest, imply, or to ignore the fact that many educational institutions do not fully live up to their promise. It would also be disingenuous to ignore the fact that a vast number of incoming students really just want to be trained for a job and go make a decent wage, which is an entirely morally acceptable desire. These facts are connected by the economics of supply and demand.

Generally there is no way for one degree to get you 'a broad base of understanding across a wide variety of areas'. Most degrees are going to get you a semi-deep understanding of only a couple area, and then a very shallow understanding of a few more.

My university went into a semi-deep understanding of complexity theory, graph theory, logic and a few areas relating to bioinformatics. I also got a shallow introduction to logic gates, assembler languages, java, etc etc.

Most university degrees are similar with the emphasis changing around a bit. I feel a university degree is still very important as it gives you something far greater than a few pieces of theory: an understanding of how to learn more.

Most self taught programmers will have gotten their knowledge from experimentation, books, Google searches, and sites like this one. In general, they aren't going to be able to grab academic research from the 60s in optimizing graphs and apply that to their code when needed as the type of language and math involved is going to push them away. Meanwhile, a CS grad has probably had to go through these types of papers for their degree and will understand how to approach them. The confidence of doing it before in their degree is also incredibly important when reading something that looks like Greek.

EDIT: And don't knock the knowledge you can gain from a paper written by some professor back in the 60s - the concepts, algorithms and recommendations are nearly always just as valid today.

"Most self taught programmers ... aren't going to be able to grab academic research from the 60s in optimizing graphs and apply that to their code when needed as the type of language and math involved is going to push them away."

The average person with a CS degree isn't familiar with the research literature either. That's the kind of background you usually get from doing a PhD.

I am a graduate student at a big state university, studying complexity theory. I TA for the (required) introduction to discrete mathematics sometimes, and when we study FSM's I get to have a lot of fun motivating them for the students.

Automata theory may seem arcane, but if you want to truly understand concurrent programming, protocol design, robust systems, etc, you need good cognitive models. Heck, Erlang (one of my favorite languages for massively distributed computing) has some nice OTP stuff (http://www.erlang.org/documentation/doc-4.8.2/doc/design_pri...) built in for using FSMs to make your code sane and robust.

FSM's are one of the theoretical CS concepts that it is easiest to see the practical use for, but other TCS tends to be just as useful if you look at it right. Eg, space complexity right? For the most part that doesn't matter, does it? Nope. A bunch of modern internet-sized problems end up being streaming problems (http://geomblog.blogspot.com/2005/05/streaming-algorithms.ht...), and you need to understand basic space complexity, linear algebra, and probability, all of which a good CS degree will get into your head. I think the role of a good CS degree is to get some theory into people's heads, so that they have the right cognitive models for tackling difficult problems that come up in the real world.

I'm not saying that a CS degree is necessary to be a good programmer, or that you can't pick up those mental tools without a CS degree if you need them. But, it is easiest for most people to learn that kind of stuff in a university environment. I for one didn't know that I needed theory to work on the sorts of massive-data problems I was interested in, before going to university. A good CS degree knows about your unknown unknowns.

"Why a CS Degree Matters" is totally different from "Why Choosing a Good CS Program Matters". In the end, we all get similar pieces of paper, but what they teach you can be completely different. Some schools offer CS by the Faculty of Science; some schools teach software engineering in their CS classes; some schools do not distinguish between computer and software at all.

It does not takes a degree to know about FSMs.

You have to know several hundred things in order to be a good programmer, and a good chunk of these aren't even on CS program.

But you have to know what to look for to know what they are. HS is not going to teach you that

True. Empirically though, very few self-taught programmers seem to know about FSMs or other core CS topics like complexity theory. This has been my experience interviewing programmers at least.

CS programs aren't designed to turn out programmers.

I interviewed a guy once whose list of data structures was "bit, nybble, byte, float, char, int". As I recall, he didn't have a CS degree, and had over a decade of experience in the field. He did not get the job.

Sorry but a decade of experience is not allit is cracked up to be. Neither is college or determination or raw intelligence. People have good careers lacking one or two of those and if I had to choose college would be the one I could live without the easiest. But Plato, Newton or Feynman show that a perfect hand can lead you to big things

If he was someone who gets things done, I wouldn't really care if he doesn't know much about data structures.

Depends on the job he was applying for. Data structures might be important.

The fact that he didn't rhyme off data structures to your question alone doesn't mean he is unfamiliar with them. He may just use a different naming convention and calls them whirligigs instead.

There is something to be said about using a common nomenclature, and I understand why you might be hesitant to hire someone who isn't speaking the same language as the rest of your team, but underneath he could still be an algorithms genius.

Then what is designed to turn out programmers? What if I don't really want to be anything else?

I don't personally know of programs that are designed to turn out straight-up programmers. Some CS programs dial pretty far over that way, but they still retain the CS-ness.

There are software engineering degrees, but I don't personally have a high opinion of academic software engineering research & practice, so I personally don't recommend them.

Which is strange if you think of it. Imagine you come to the shop and it does not have any kettles, buuut you can buy a stew pot and boil water for tea in it.

Put another way, the value of a degree is that it forces you to expose yourself to a broad range of ideas. Self-education is a great way to learn about things that interest you, but less effective at ensuring you try things that seem boring or unpleasant at first.

A degree is useful for systematically covering some topics. However, without substantial self-education in areas you might not be interested in, the limitation of a CS degree is that it still has some rather large gaps in terms of what you are exposed to. The discipline to do substantial self-education is still necessary to be a well-rounded computer scientist, and sufficient to become a well-rounded computer scientist. Which is a good rule of thumb for most things.

With the hindsight of plenty of time in the field, I find it remarkable how many fundamental concepts you still need to learn that they do not teach in current CS programs. In my area of work, massively parallel algorithms and distributed systems, the core theory, never mind practice, still has to be learned outside of school and the initial barriers are not trivial. (Small-scale parallelism and distribution is based on functional programming concepts and mutability. Large-scale parallelism and distribution is based on topology and Nash flows. Very different conceptual models.)

> Large-scale parallelism and distribution is based on topology and Nash flows. Very different conceptual models.)

Totally OT, but I don't suppose you have a reference to some introductory material on that (seminal paper, textbook, etc would be fine)? I've been getting massively more interested in distributed systems & reliability thereof.

I've always considered a degree to be a ticket to an interview. It's proof that you're somewhat knowledgeable about a broad range of topics relating to a single subject matter (in this case, computer science). You don't really know enough to be an expert on it -- at least not any more so than anyone else with that degree, and certainly not to the level of professors. Post-grad degrees are where you become experts... but I digress.

I consider a degree to be proof that a) you can be trained, b) you can start and complete a program of study (i.e., project), and c) you have a good idea of what you're talking about.

It doesn't mean you are any good at it (or even above average, really). It doesn't mean that you're a programmer or a scientist. It just means that you're trainable.

And in that regard, the major you choose doesn't really matter one bit. You can get a degree in biology or theater or business, and you'd still be trainable. You might not have the fundamentals, but those are easily taught. If you can learn bio-chemistry, then you can learn FSMs and pick up the fundamentals of programming.

So as others have pointed out, it's not a computer science degree that matters. It's trainability and the capacity and desire to learn that matter. I'd hire a hard-working, self-directed, knowledge-hungry theatre major over an entitled, I-don't-want-to-do-anything-but-program CS major any day of the week.

I have known about FSMs before starting studying. What I had to relearn though was how to draw them, like basically reading and drawing stuff is what always was/is the big problem to me. I prefer to write stuff down and I am sure in a few years and actually in a few months I'll have forgotten about all of this.

It's actually the reason for really disliking papers that prove something. You forget stuff after you got that paper, but keep your degree.

Also one simply has to say that there are HUGE differences between what you need to get that sheet of paper, even if you went to the same school and often if you attended it at the same time.

Agree wholeheartedly with you, being forced to learn the concepts that seem mundane at the time has it's value.

It depends on the University. I am from University of Ottawa, and I wish I took Computer Science instead of Software Engineering. They made me take Geology/Evolution/Italian Cinema while I begged the dean I would like to take Computer Graphics/Artificial Intelligence/Cryptography etc. Software Engineers in my University let the student focus on the higher level vision to know everything, but I kid you not, I totally forgot everything I learned in Geology/Evolution/Italian Cinema/etc. So if I took Computer Science, then I would have done the fun stuff, the important stuff that would help me prepare for job hunting. Instead, I just focused on Open Source, and personal projects to prepare, and that worked.

I'm with you.

After my second year at uni I felt that I should just quit and get a job. Everything I needed for landing a job in the industry, I was getting from my own side projects. I wasn't learning about things like scalability, or robust system architectures, or code deployment, yet half of the interviews I went through expected me to know about them, even if it was for a graduate position.

I still haven't used the vast majority of the theory I was taught at uni, but sometimes, when you come up with an elegant solution and trace it back to that 'Computer Vision' course you've done at uni, it feels like it's all worth it. As others said, coding skill is very important but when you know the theory you know where to look for solutions.

It matters so you can win programming competitions?

Drop the "Degree". Computer Science matters.

What he said

[disclosure: I'm as CS Grad Student]

The biggest value of a CS degree to me is to be exposed to the cool work of others.

What I mean is, we have people from all over coming here and giving talks on the kind of things they're working on. Sure, many of these things are more 'academic' in nature (in the sense of not being immediately deployable e.g. a new internet protocol), but I think their work is exploring the boundaries of the current state of knowledge.

To get a feel for what kind of crazy stuff intelligent people are up to. That's the reason I love being a graduate student.

I think what OP is trying to say is that there are some things that he would never bother trying to learn on his own because they're just so random, _but_ thanks to what he learned getting his degree, he was able to recall and apply a small concept which really made a big difference.

In my humble opinion anyone can learn to program in any language and most people can produce quite a few examples, but good programers know how to apply theory which helps them produce faster and more reliable code.

But we are not taking into account cases where a CS degree does irrevocable harm.

For example, the tendency to religiously follow patterns, over-complicate things.

IMO these concepts come up all the time. A CS degree might help you to know what they are, but not when and how of applying them.

Also plenty of self-taught developers are aware of these patterns. I can't imagine a "good developer" who wouldn't know about FSM, or someone who would use redis without considering time complexity.

It makes the case that instead of people studying superficial and largely pointless things like treehouse and codeacademy they should instead take MIT OCW.

> How often does that concept come up when you are tossing together a web app?

I end up using some kind of state machine just about every time I build a web app. If you're just tossing PHP together to make something work, you might never happen upon a pattern like that, but as a professional developer these things definitely shouldn't be a mystery, even if you "just" build web apps.

In fact, as someone who does not have a CS degree, a state machine seems like something that is difficult to avoid figuring out, even in web apps. Maybe it is just a bad example of something more underly though.

I rarely use state machines when composing web applications. Of the 20 or so times I've spotted an opportunity to use a state machine, only 2 or 3 of those opportunities actually were the optimal choice.

Like all things, state machines can be overused and over abused, even during times when they are not ideal.

A state machine really isn't a great design for a web app.

For HTTP to work best, you should try and keep it as stateless as possible. Keeping state consistent between multiple servers is very much non-trivial. If your web app takes off and needs to be scaled to more than 1 server, design choices such as state machines can really cause you very nasty issues down the line. You either have to keep state across a memcache system, which can get wonky with multiple requests hitting multiple servers, or you have to keep the state encoded inside a cookie which opens up security issues.

Sticking to stateless webapps is nearly always a better choice. Check out some guides to RESTful services to get started.

Very often state machines are the best representation for domain objects which have a life cycle. If you have a lot of user submitted content shared among other users, a common set of states could be:

"new", "approved-by-other-user", "verified-by-admin", "hidden", "promoted".

I agree that at the HTTP level you shouldn't be using FSMs.

You likely don't want to use a state machine to manage the state of the application here, but there are many other places a state machine comes in handy. If one of your models has several boolean variables, it may benefit from a state machine. Even HTTP parsing itself is often done with a state machine. None of those impact the statelessness of the connections.

Definitely not for application state, but for resource state, a FSM can be invaluable. Take for instance something as simple as a blog comment system, where any administrator needs to be able to transition a "comment" resource into either accepted or rejected states.

They also work great for transactional resources like a shopping cart order.

Apparently it is only 3 years because they skip all the classes where they teach you to not use run-on sentences.

I'm going to hijack this thread for some related opinion (sorry):

For those who _did_ get a CS degree, what things you learned from it do you use in your current programming work? and how?

Edit: or rather, what is the single most important thing you would want self-taught programmers to know about, that you find most don't?

It's not what your degree makes of you, but what you make of your degree (and self-education).

But what might you have learned had you done something other than get a CS degree during those years - maybe just read Knuth? I think what you are really saying is reuse ideas/code/patterns and try and stand on others shoulders.

s/absorbent/exorbitant/ ?

Also first sentence is really awkward. Better:

I will be the first to admit that I absolutely despise the state of higher education. The concept is fundamentally flawed, and I am not thrilled to have spent 3 years (and only 3, thankfully) working towards a piece of paper that “proves my skills”. In my opinion, it does not do that in most cases.

Thanks so much! Grammar is not my strong suit.

I see that "just a piece of paper" trope all the time, and I want to suggest to you that if you graduate from college and then look at your diploma and think "Wow, this is all I got out of college?" then maybe the problem is you and not college.

Ironically, now that this is on HN, there is apparently one less reason to go to school and get a degree to learn this.

People who don't get college, don't get college.

Reply on news.ycombinator.com