Practicality vs. Theory would be high on my agenda.
Chris J
2010-02-23 21:10:41
Are you saying CS courses teach too much programming theory and don't focus enough on practical programming practices?
Randy
2010-02-23 21:13:56
More about understanding that all the wonderful theory and best practices they have learned aren't always practical or sometimes even useful in the real world. It's wonderful that design patterns and other tenets of programming are engrained in students, but most courses fail to teach the flipside in that the best practices are only good insofar as they remain useful. This isn't to say abondon them altogether, but use them as they are needed, not as they might fit this situation even though they are overkill.
Chris J
2010-02-23 21:59:22
+4
A:
I would talk to them about how to write descriptions, draw diagrams on whiteboards, and file bugs/questions.
All the rest is just typing ;)
Seriously, the ability to express oneself coherently makes all the difference in real world software engineering. If you can write clean and concise design documents, judge the level of documentation required for an API to make it easy to use without being daunting, and get answers on sites like this one quickly, you'll be streaks ahead of those who can't string two sentences together.
Jon Skeet
2010-02-23 21:12:19
A:
To generalize some of the other questions, I'd teach less of Computer Science, and more of Software Engineering. Most of these CS majors will be doing Software Engineering for most of their careers, and it would be nice if the colleges got them started (and didn't wait for Business to do so).
John Saunders
2010-02-23 21:16:15
What about the students who *are* there to study comp sci? Why trade the instruction they expect to receive for something they can't necessarily use?
mipadi
2010-02-23 21:28:27
@mipadi: obviously, students who want to focus on CS (for a Research or Academic career, maybe) should not have to learn Software Engineering (though a "Software Engineering for CS Majors" class might be useful to them).
John Saunders
2010-02-23 23:22:51
A:
More focus on process that is applicable in today's world. Covering waterfall in great depth is likely not as useful as it once was.
brian
2010-02-23 21:16:19
The problem with this is that what's applicable in TODAY'S world will not be applicable next year. Of course we don't know what will be, and covering things that are clearly not applicable anymore is a bad idea, but you can't just teach to the current environment.
Brian Postow
2010-02-23 21:39:49
@Brian: completely agree. Today's was more meant to indicate this decade perhaps.
brian
2010-02-23 21:57:01
+3
A:
It's important to actually develop functioning applications aside from class projects, in whatever domain interests you. Develop a mobile application, a web-based game, a music player, or whatever else you find appealing. This will allow you to use source control and to begin to learn how to organize a larger code base.
ElectricDialect
2010-02-23 21:17:02
+1 Most university assignments are ~100LOC in one file, the limit of what somebody can read and correct. There is no limit for size and complexity of code in the real world.
Otto Allmendinger
2010-02-23 21:19:39
@Otto: But that's why because people are focused on correcting the code itself. That's a good thing for the most part, but a big app that isn't code corrected but instead checked for how it works could be better for ending studies.
Vinko Vrsalovic
2010-02-23 21:29:09
@Otto Really? When I taught, in CS 1 I would have more than 100 LOC and several files. The 1st project would be less than 100 LOC, but by the second project, you're into several hundred lines of code, and by the 4th multiple files...
Brian Postow
2010-02-23 21:50:28
IIRC, the final project for my freshman (1st year) CS course was several thousand LOC - and the criteria for grading was that it had to work correctly (had to generate correct output). Of course this was a "weed out" class that 30% of people flunked...
Ken Liu
2010-02-24 00:27:53
A:
I'd like to impress upon them that they don't know everything, neither do I, and none of us ever will. In short, your code sucks, my code sucks, and that is never going to change. Once they get off their high horse and realize their inefficiencies while kicking their ego out the door, development will be so much easier for everyone involved.
hmcclungiii
2010-02-23 21:17:35
+1
A:
Near the end of their studies, I would have them on a year long course building together a big application with two releases.
The teacher would act as lead developer, guiding the design, teaching how to use version control, issue trackers, how to polish an application for release, etc.
Not that I think any university would actually do such a thing. I know I would've liked it.
Vinko Vrsalovic
2010-02-23 21:19:03
Most universities have a Software Engineering course that involves creating an actual application, dealing with requirements, bugs, etc.
Ken Liu
2010-02-23 21:25:30
Really? A whole year collaborative effort of a really big app? My own uni had something like @Ken says, but still on the scale of a toy app.
Vinko Vrsalovic
2010-02-23 21:31:10
Rereading your post now I see what you mean. Usually these classes are one semester long. My school encouraged all CS students to get a co-op/internship position to get "real world" experience. IMHO, this is better experience than any kind of fake project done for a class.
Ken Liu
2010-02-24 00:17:24
A:
The contents of great books such as The Mythical Man Month, The Pragmatic Programmer and Clean Code. Those were more useful to me than half of the subjects in CS.
Hans Westerbeek
2010-02-23 21:21:00
A:
Debugging (for a first course in CS).
I am still constantly amazed that the vast majority of students are not taught what to do when a program they've written doesn't work. You see a lot of 'twist' this and 'adjust' that and then pray it now magically works.
Basic debugging is not rocket science, but it's a specific methodology and it's not intuitive. Yet teachers and professors seem to assume that the concept of calculating what the program should do on paper, seeing what it is actually doing in fact, and then determining the reason for discrepancies between the two should somehow be intuitive for students. (And it is, for about 10%.)
Spending an hour or two teaching how to debug would save students dozens of hours and probably decrease the drop rate substantially. (Note, debugging theory doesn't actually require a sophisticated debugger - print statements can do just as well for basic debugging.)
Tom West
2010-02-23 21:27:45
A:
If you can't figure out HOW to use source control, you picked the wrong major. If you don't think you need source control, that's why you're still in school.
Formating code is really important.
In many situations, you will be the most technically savy person at the table, so don't abuse the Technical Trump Card too often to shoot down other ideas. You don't like it when the CFO keeps saying everything is too expensive.
Go back to your code every 6 months and if you don't ask yourself "WTF was I thinking?" you've stopped learning, so get started. And when you're taking over the other guy's code, you're probably not under the same time pressure he had to endure because it was impreritive that the feature be available the next morning at 7:00 AM for the VC firm balancing their 100 million dollar decision on it (At least that's what they told him).
Most programmers in real life do not wear costumes to work like they do on TV/movies. If you get credited with programming some super successful application, you can get away with being eccentric; otherwise, you're just an unemployed slob.
Jeff O
2010-02-23 21:37:36
+1
A:
Having taught at college for several years, I'm sure that 1) I have a very different view than most people here, and 2) my vote probably doesn't count much being seen as "Part of the problem".
However, my view is that the thing that is most needed is flexibility. It's not important to teach specific tools, and specific languages because in 5 years, those will all be out-dated. It's important to teach general techniques and ideas.
So, explaining why version control is important, and maybe showing them how to use one. Teaching them SEVERAL different languages, so that when the next Python, or Ruby or sequoia comes along, they're ready, is important. Learning how to pick up a book and learn what you need in an hour is vital, because the thing that you ABSOLUTELY Need to know 5 years from now may not exist yet.
The alternative is to turn CS programs in college into technical schools, the equivalent of car mechanics.
Brian Postow
2010-02-23 21:46:33
A:
(1) Working in a team... tough to do in school because of the whole how-do-you-calc-a-grade problem, but certainly needs to be done
(2) working with REAL api's that don't do what you expect or are buggy. I understand that MIT does this sort of thing by teaching how to control a robot with existing Python libraries
(3) Handling the Awkward Squad -- which might be better put in learning what purity is, why it matters, and where you want it.
Kevin Won
2010-02-23 21:49:01