Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

In college, I was never interested in theory. I never read it. No matter how much I tried, I was unable to read stuff and not know what was actually happening practically. Like for example, in my course on automata theory, my professor told me everything possibly related to the mathematical aspect of it, but not even once did he mention where it would be used practically. This is just an example.

I managed to pass my college and interned with a company also, where I did a project and thankfully they didn't bother about my grades, as they were above average.

Now, I am interested in knowing what subjects should a CS student must absolutely and positively be aware of? Subjects that can have relevance in the industry. This is because I have some free time on my hands and it would help me better to have a good understanding of them.

What are your suggestions? Like for one, algorithms is one subject.

share|improve this question
3  
Regular expressions are based on automata theory, and it will help you if you ever have to parse anything. I've done and learned things in school that proved irrelevant to the jobs I've had, but that says at least as much about what I've worked on as what I've learned. Nothing I learned would be useless in the field under all circumstances. –  David Thornley Dec 30 '10 at 16:23
1  
I hate working with your type ... jk (sort of). If I were you, I would first take time to review things that you ought to know from school - that way you would not look like an idiot at your next interview. After that I would learn a reasonable amount of data structures and algorithms which look like they can be used in a real world. You need to figure out where you want to be. If a game developer, then you probably need linear algebra, 3d graphics, computational geometry. In general you need to review data str, alg, database, os and compiler stuff at a minimum and keep learning. –  Job Dec 30 '10 at 23:17
1  
You're getting lots of great CS answers below, but I think by limiting your question like that you're missing a couple of the most useful things I've seen in the 15 years since I got my BSCS, what has differentiated the folks that have done well in the industry: small group communication & teamwork skills. Silly as it seems, head over to the speech/language/theatre department and take a class like "small group communications" or "team/group leadership/management". Even if you don't plan to do management, the skills you pick up there will make you a better engineer and team member. –  cabbey Jan 5 '11 at 6:01

19 Answers 19

up vote 36 down vote accepted
+500

Believe it or not, one of the things that turned out to be of critical importance to me in later life was Compiler Construction. Not the modern namby-pamby version using Lex and Yacc, thats for dummies.

REAL compiler construction where you write your own symbol scanner and parser from the ground up.

This is something I thought I would never, ever, use again. But on the last 20 years that course has proven its weight in gold 4 times over. Ever command processor I've had to write, every incoming-message-scanner, every user dispatcher, every script interpreter, has used the principles from that course. Do it that way and life is sweet, clear and simple. AND I even gave all the info to a colleague who had not done it - he had to actually write a compiler for an abstract machine. Which I might add has gone on to be very commercially successful.

If I had to go up and thank a university course lecturer in any one subject, this would be it. Without that I would have got by but my solutions would have been much much uglier.

(And before somebody jumps up and says "well you could have used lex and yacc..." the answer is, perhaps - it depends a lot on the system. In some cases the programming languages were not C (eg PL/M and Ada), in some cases no readily available Lex or Yacc were available for the platform. Knowing basics means a solution is at hand instead of wringing hands trying to figure out how to bend some tool to fit the problem.)

share|improve this answer
6  
+1 Compilers was one of my favourite courses at uni, and is always useful. I've rarely used lex/yacc/bison, the fundamentals are of much more concrete use. –  Orbling Jan 1 '11 at 14:57
1  
"This is something I thought I would never, ever, use again." If I had a dollar for every time I said that to myself when I was younger.... –  Nick Jan 8 '11 at 5:35

After talking to a couple of company representatives and friends that had many interviews:

  • Databases
  • OOP
  • Algorithms
  • Data Structures

tend to be "musts" for new hires (or as they said, "highly recommended" courses).

Other courses that may be useful are computer security, assembly, and machine architecture. Many of my professors have recommended to me a compiler course too. Also, if you have time I would highly recommend math courses like graph theory, discrete mathematics, and combinatorics. You learn a lot of reasoning skills in those classes that most CS courses gloss over, but end up being very useful when writing very complex programs.

Hope that helps!

share|improve this answer
1  
Would agree with OOP and data structures. –  apoorv020 Dec 30 '10 at 11:17
4  
Basic data structures... sooooooooooo important. MORE important, I think, than OOP. You need to be able to think about how to store and organise information. And if on embedded system the in-memory layout of your data structures is life-or-death stuff. –  quickly_now Dec 30 '10 at 11:26
3  
+1 for the math classes. They also help you learn to keep track of large problems/systems. –  Michael K Dec 30 '10 at 13:45
1  
Networking is a good one to do also. –  Keyo Jan 1 '11 at 16:01

I would also add Software Engineering or Design Practices to the list, though their content is usually picked up by students in the industry.

Also, in my opinion(not backed up by much experience though) companies don't really want most of the theoretical things taught in courses like databases etc., they want people to understand and be able to use these things.

EDIT: Due to the downvote, I feel like explaining my answer. I am a final year computer science student, and my experience is based on my internship and job interviews with leading companies in the field. In my experience, people are rarely required to use complicated algorithms or code very complicated data structures in interviews or in jobs.

More useful if you can create and use databases, use source control, know how to debug properly, know how to use design patterns etc. However, as I said, these skills are typically picked up in the industry and not covered in courses. Software Engineering/Design Practices typically involves building a mid-sized project, very useful for learning all theses skills.

share|improve this answer

Data Structures and Algorithms.

share|improve this answer
3  
@Mark Trapp: I don't think it is right to downvote for a lack of detail. Down votes are generally used a bit more sparsely, for incorrect/offensive answers. –  Orbling Jan 1 '11 at 15:05

When I was at college there were quite a few topics that I couldn't see a use for in my real life and sometimes that intuition has been proved right ( Formal Methods really are only practical for trivial problems in most cases ) and other times it has been entirely wrong ( Big-O notation is very useful ) so I guess on the whole my younger self was part right.

If you want to prepare yourself for the real world, in addition to the stuff @K-Ran recommends above, I suggest reading Code Complete and using that as a basis for deeper research into any topics you find difficult or don't feel you have sufficiently covered.

share|improve this answer

I think you should study the following :

Operating System :- Even though you may not not need it to work as a programmer but it is worth to know how an operating system works and it is expected from a CS grad. Any good book can help.

OOP :- This is bread and butter. A must. Books if you want to ask: Your first book should be :- head first OOAD, then you can go for Grady Booch and Ivar Jacobson's book

Data Structures and Algorithms :- Very important to develop the logical thinking and mindset .

To me this much is enough. It's never too late. :)

share|improve this answer

It largely depends on what you plan do with the degree. It appears that most CS majors end up as software engineers of some kind. With that in mind, I am really not sure why more people don't just major in software engineering. I suspect that there are not enough software engineering programs available especially at public institutions.

I come from an embedded back ground. Every single person that I work with either had a EE degree or CE degree and that is partially because the when the "old guys" when to college there weren't that many CE programs available. So, it is pretty obvious that if you want to work in the embedded field that a hardware background is desirable.

Regardless of the field you want to work in however, I believe that every programmer should take a course in assemble programing. You might never user it, but it will teach exactly what is happening at the processor level during a function call, how interrupts are handled, how memory is structured or how the different addressing modes are used. I believe all this things will make you a better programmer.

Also, though it may not be apparent so some these are all important topics when considering Data Structures and Algorithms for a specific platform.

share|improve this answer

Things that I learned in college that I use every day:

  • Object-oriented design methodology
  • Design patterns
  • Regular expressions
  • Basic algorithms and analysis
  • Data structures

I wish I took a database course. (I have picked up enough to get by since I graduated, but I wish I knew more.) I also wish version control was taught -- it's ubiquitous, extremely useful, and was completely ignored in my school's curriculum.

I had to take several math courses. I haven't used calculus since I graduated. I wish I took a statistics course. (Again, I've picked up enough to get by since graduating, but I wish I knew more.)

Beyond the CS department, take a writing course. Good written communication skills are essential for success.

share|improve this answer
  1. Data Structures/Algorithms especially Graphs. The amount of real world situations in which I've managed to use graph-related algorithms has been a surprise to me. Focus on knowing the characteristics of when a data structure or algorithm is appropriate. Being able to see a problem and know to use dynamic programming/greedy algorithm for example is important and can save you a lot of time.

  2. Working knowledge of computational complexity. You don't have to know off the top of your head what the lower-bound of radix sort is but knowing how to figure out what worst-case running time of something you write is important, especially for performance critical projects.

  3. O.S. concepts. Memory management, Schedulers, etc. Every developer really should have a solid understanding of operating systems given that the code you write is constantly interacting with it.

  4. NetSec. I have encountered very few developers who have a solid understanding of basic security concerns with development (buffer overflows, xss, SQLI, etc). This is really a must if you want to be successful in industry. It is great if you can write the next big thing but you won't have many users for long if you don't secure their data.

  5. Programming paradigms. Know the characteristics of and differences between OO/Functional/Procedural programming. One of the best undergrad classes I ever had was writing simple 20 instruction interpreters for fortan, scheme, prolog, etc in the languages themselves. Just the exposure itself can really help you understand the fundamental concepts of software development.

share|improve this answer
1  
+1 Entire list is pretty much required, (4) in particular is ever so important in the modern distributed era. –  Orbling Jan 1 '11 at 15:03
1  
+1 on Data Structures/Graphs. The number of programmers I know who doesn't know how to use correctly a Hashtable or why an Linked List instead a simple array in some cases surprises me everyday. –  Machado Jan 3 '11 at 20:32

There are 2 ways to answer your question. Let me attempt both. The first way is to look at things from a potential job market standpoint, coding skills etc. So here's my list:

  1. Data Structure
  2. Algorithm Analysis
  3. Object Oriented Programming
  4. Either a specific course in C++ or Java
  5. Operating Systems
  6. User Interface Design
  7. Parallel Programming

The second way is to look at things from a bit abstract perspective, and who knows, may be a bit philosophical too. The list that follows may not have the hottest skills the job market demands, but I am pretty sure by the time you come out of these courses you'd have a deeper appreciation of the art of developing software.

  1. Finite Language and Automata Theory
  2. Compiler Construction
  3. Graph Theory
  4. Artificial Intelligence
share|improve this answer

Meeting the graduation requirements is not necessarily sufficient for being the best computer scientist you can be. For a typical college curriculum, here are the top ten things you should be sure to learn:

  1. The basics of economics - An introductory course covering topics like complements and substitutes is vital for working in the greater economy, or just simply understanding it. While the concept of a Giffen Good won’t necessarily help you, knowing about externalities will. It might also help you appreciate that more situations are win-win than you might have realized.

  2. How to write a proof - All computer science majors should know how to write a proof. And discrete math, while a part of a well balanced breakfast, doesn’t count. [Induction is just one proof technique, and you can get by without actually knowing much about proofs.] A course in algebra or real analysis is necessary to really write proofs. And by algebra I mean group theory or abstract algebra, not the course you took in high school. For the full benefit, take algebra and real analysis in the same term.

    Why is proof writing essential? Because it’s programming! Think about when you first learned how to program: if a task required an if and a loop, you might not have had any intuition on where to put them in relation to each other. But now the same task would feel completely natural. Writing a proof is very similar. There is a set of tricks that you learn, and once you learn them things look quite different.

  3. How to write - Written communication skills are essential, whether you’ll work in the industry or academia. It’s best if you can find a mechanics course, and not a writing course that is effectively about a different topic. That is, many schools will try to make the writing courses more relevant or interesting by making it be about a special topic. Try to go for the “boring” version of the course.

  4. Probability and statistics - There are some things that you’ll only pick up properly by taking a course. Together with the CS major requirements (which should give you discrete math, single variable and multiple variable calculus, and linear algebra) and algebra and/or real analysis, picking up statistics will probably give you a minor in math. Learning statistics can help you work with other scientists on their projects.

  5. The current hot topic - In previous decades, it might have been databases, or object-oriented programming. Today it might be web programming or service-oriented architecture. Whatever the current fad is, be sure to take a course in it. If only to see what the fad is about.

  6. The halting problem - Most problems cannot be solved by machines. This is a fairly deep idea that our culture has absorbed so well that it no longer sounds shocking. The same goes with radio, Goedel, and the atomic bomb; it wasn’t until postmodern art and the cold war that we could once again cope with these concepts. However, taking a course in computability theory can re-sensitize you to this pretty amazing proof.

  7. Pure functional programming - You most likely won’t go into pure functional programming, unless you do research in it or work for a select few companies, but knowing it will help you be a better programmer. The reason is that you will learn many new forms of abstraction, and concepts like Church numbers and continuations and monads and, yes, recursion, and these tools can be applied to your next Java program too.

  8. P and NP - OK, this one is already on your critical path, but pay attention anyway. You want to be sure you can correct someone when they incorrectly call NP “non-polynomial.” As if!

  9. The topics from the course you’re sure to hate - This could be a CS course you find too-low-level, too-theoretical, or a non-CS course you find too-objectionable, too-hard, or too-boring. If a course like this seems to be an issue for you, and you find yourself explaining to others why you’re so glad you don’t have to take so-and-so, it should tell you that you’ll learn a lot by taking the course! Perhaps you won’t learn the materials of the course, but you’ll learn about your own limits and perhaps more about the justifications you make to yourself. [Hint: They are usually weak.]

  10. The non-CS course you’re sure to love - In the end, you should have some fun. This is the course you’ll probably get the least out of, but take it anyway. Do it once. If you happen to love many courses, then good for you, but be sure it doesn’t get in the way of covering the rest of the courses on this list.

My approach here has been practical, based on courses you can actually take. And I’ve focused on learning objectives that are likely to be learned. Note: This answer was adapted from a blog posting of mine on Ten Things Every Computer Science Major Should Learn.

share|improve this answer
1  
@ijw: Regarding economics for CS students, Joel has a good discussion worth reading: joelonsoftware.com/articles/CollegeAdvice.html –  Macneil Jan 15 '11 at 3:00

As someone who interviews candidates regularly for programming jobs, and someone who after being in the industry for 12+ years feels reasonably accomplished, I would suggest the following

  • Database Design & SQL: It is amazing how many programmers do not know simple SQL, and those with good SQL skills are invaluable. To be able to design a good database may not be useful in a company that has a set database structure, for start-ups and companies going through change, it is a MUST!
  • Design Patterns. They will simply help you make better decisions about good design
  • OOP: This is usually a pre-req for most courses, but it will help.
  • Algorithms: Because so few people know what recursion is, let alone understand when it could save them a lot of complex coding
  • Data Structures: Most modern languages deal with this stuff for you, but understanding them is the key to good design.

Then, some extra curricular work, read:

  • Certification type books. They often teach you the beneath the covers type of syntax and operators. It is far more important to KNOW why you are doing something, rather than 'because it works', which is so commonplace.
share|improve this answer

IT'S DEPENDS, there isn't a one good answer for this question.

Programmer is a general world to identify a someone who writes computer software.

Now, out there there is software of all kinds. For example, using wikipedia as a source of generalization we can meet 3 great generalization:

  • system programming
  • programming software
  • application software

In the first field system programming develop device drivers, operating system, servers, so for example you can follow an operating system course.

but what about programming software ? here as wikipedia wrote you can code compilers, debuggers, interpreters, linkers, text editors, so, a course in automate theory, language theory, language and compilers can be useful.

Not we can talk about application software of any kind:
- video games : algebra, physics, object oriented courses ?
- mathematical software : mathematical courses ?
- image editing: mathematical, physics, algorithm courses ?
- industrial automation: mathematical, physics, algorithm, robotic courses ?
- medical software: biology, medical, what else course ?
- a lot of stuff here : a lot of courses here .

As you can see there is a lot of course you can follow and will become useful for your work.

In my experience, I'm a system software engineering and application software in the security (you want follow a security course?) field, starting from a little very experience in programming i am getting more interesting in algorithms and distributed system and again i feel uncomfortable in the simplicity of the general purpose application i wrote (sniffer, network intrusion detection system, protocol dissector and detector, etc).

As you have sourly learned in theoretical computer science! have you fllow this courses ? :P

You have learned for example that all computer language can be fitted in a set of computable mathematical function and for example if your experience get my same path, soon you be uncomfortable in this little set of calculus and like me you can start to see how developing software is not so engaging and amazing because the same DESIGN PATTERN come back again an again (have you follow design pattern courses?) and for example you can start to get more interest in WHY and HOW language can be translated in mathematical function and starting to learn that computer language is not so very complex! you can soon for example be more surprised about person and psychology, and you can get more interest about it and become a good project manager! have you follow the courses about software life-cycle ?

So now, what is the MUST-HAVE course in your CS career ?

I suggest to learn as much as you can learn in all field, specially in theory field, because in common work field you can feel soon really bored about the little complexity around you, and becoming a full time worker you have really less time to learn how things really work and much more time to see how people with strong theoretical knowledge have projected things to work and give to you the possibility to code to get food at home.

there is a wrong sense of reality in computer science. computer scientist for example sometimes is really far away from software developer.

take a look at the wikipedia explanation.

have fun with life :)

my 2 cents.

sorry for my really bad English.

share|improve this answer

There are many important courses, depending on which direction you're planning to go. However, assuming you can program at all, the most important course has got to be:

  • Data structures and algorithms

    Virtually everything in computing comes back to handling data using algorithms. Pay particular attention to arrays and hashtables, as they're by far the most useful data structures in common use, but lists and trees and graphs (well, lists are restricted types of trees, and trees are restricted types of graphs) are going to be important as well. Moreover, understanding algorithms is vital to producing code that isn't terrible. (Otherwise you'll do things that are just terrible, like using an O(n3) algorithm where an O(n logn) one will do.) If your CS degree does not have a mandatory DS+A course on it, it's not CS. Or software engineering. Or even just programming.

Aside from that, the course that I've found most useful over the years in multiple fields has been:

  • Concurrency

    There are many aspects to concurrency, but I'd expect an understanding of the difference between shared-memory and message-passing. I'd also want there to be strong coverage of locking strategies (mutexes, semaphores, etc.) and transactions.

    This is vital for understanding parallelization, of course, but it's also critical for anything distributed (e.g., writing a service that's exposed to the internet, even if it is single-threaded since the clients will be asynchronous anyway). I understand that it is also useful for writing games (which are typically multithreaded) and working with embedded devices.

Aside from that, I think that it's in most undergraduates' best interest for them to be exposed to as many different ideas as possible. Lots of programming languages and paradigms. Lots of different areas of application. A reasonable amount of math (again, because it's useful so often) and also some exposure to human-factors and psychology (because any software that interacts with users is dealing with people). After all, you never know exactly what you're going to be doing in the future, so planning for flexibility is a great life strategy.

share|improve this answer

Hands down the number one thing CS students should be fluent in is English.

Without an understanding of both spoken and written English you will forever be at a disadvantage.

Just look at the myriad of questions that come in on the Stack sites. Way too many of them are hard to decipher. Some people use a mix of l33t, texting (not sure the correct term). Others make a statement and simply append a question mark while missing important little thinks like verbs or adjectives.

If you can't communicate then you won't be able to make yourself understood much less understand what others are saying.

Everything else is just details. If you can communicate, are of at least average intelligence and can understand what you read then you too can have a successful career programming.

share|improve this answer

I'd add some basic Human Resources / Psychology courses to the list as well.

This might seem like an odd addition, but part of work professionally is learning how to sell yourself and negotiate. Walking into your first 'real' interview without a solid knowledge of the HR-drone's motivations is a recipe for disaster and likely to end with the student getting screwed into a low-balled salary.

Know your enemy so that you can protect yourself.

share|improve this answer

It's strange nobody has mentioned Computer Architecture.

share|improve this answer

1st Year:

  1. Basic OOP in a high level language
  2. Data Structures

2nd Year:

  1. Compiler, you build a simple one form scratch
  2. Concurrency

3rd Year:

  1. Algorithm
  2. Operating System, you add functionalities and enhancements to a simple one
  3. Formal language

4th Year:

  1. Networking
  2. Distributed System
  3. User Interface
  4. Advanced Compiler
  5. Advanced Operating System
  6. Artificial Intelligence
  7. Computer Graphics

Those courses should provide plenty of theory and coding practice.

share|improve this answer

I come at this from a slightly different perspective in that I didn't graduate in CS, I graduated in Electronic Engineering (with a minor in business).

Based on that I think a list of things you must understand is relatively short as I (and many non-other CS graduates) survive happily without knowing a thing about compiler design or the like.

What I would say I've picked up that I do find useful:

  • RDBMS design - RDBMSs sit behind most systems and sites and you should understand at least the basics of what is going on (I learned this on the job).
  • Basic UI Design - all the best programmers I've worked with could produce a usable application that wasn't ugly as hell. Except one but he's the exception that proves the rule.
  • Some basic programming - and I mean basic. I learned some C (for image processing and embedded systems), some Assembly Language (which I'd forgotten within weeks of completing the course) and some Pascal (a basic computing course was standard for all engineers). When interviewing I'm stunned how few CS graduates can really programme in any way commercial organisations would consider useful so I don't expect much, but I do expect them to know the basics.
  • Logic - I learned it through digital electronics, mathematicians through theory, CS grads through programming but however you learn it, you should have a good grasp of it as so much comes down to it.
  • Communication skills - I did a couple of courses at university outside my actual degree, presentation skills and assertiveness. Lots of common sense but it never hurts to be told sensible things a few times.
  • The basics of business and accounting. Some programmers act like it doesn't matter but to my mind it matters to anyone who works in a company - this is how the game works and it's going to control your life so why wouldn't you want to know at least the rudiments of how and why things happen?

And if you get the chance to learn about project management at all then that really wouldn't hurt but that's taught pretty badly at university in many instances and it is something you'll learn a bit about on the job just by working on projects.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.