Slashdot Mirror
Improving CS Education?
"I've been reading through the ACM SIGCSE proceedings and there are some studies I'd like to do in order to give myself some research training (we don't get much of that in our regular curriculum). We're also trying to organize peer mentoring and code clinics (but that brings up interesting ethical questions). What are other things students can do to improve the quality of their CS education?
My university's already doing some pretty cool things. One of my professors sneaked some patterns into an introductory course. The teachers are super-approachable. But it's just that I look at our curriculum and classes and teachers and I realize that there's so much more that can be done.
I want to know this:
Lots of people have probably already tried this before - improving the way CS is taught/learned. I want to know how it turned out or how it's turning out. Do you have any advice? Notes? Ideas? Know anyone I should talk to? I'm an insanely motivated geek here and I want to make sure I get the best CS education with the (rather limited) resources available. If it incidentally helps other people, then that would be a Really Good Thing. =)"
In the last group of interviewes I had, I asked them to describe their C++ skills. The ones who said "very strong" I asked them a couple of questions. "What is an abstract class? "and "Can a child access it's parents private data?". No one got either question yet they are "strong" c++ developers.
With all the companies paying high salaries to moderatly skilled cs majors. The incentive to achive a good education decreases.
One of the most important CS classes I took was taught in a MADE-UP language. A la SPIM or others, it was an assembly language. The prof explained to us the syntax of the very-simple language, and we wrote very simple programs. He then showed us more complicated aspects of the language, and we wrote more complicated programs. The fun part was - he could change the language. One week it was a single-operand language. The next it was a three operand language. We got to really see how various architectures differed in concept. By the end of the semester, we were writing assembly subroutines, stack frames, local variables, etc etc. Not only did I grasp this made-up language, but I understood this made-up machine. When I went to learn x86 asm, I realized "my god - he wasn't far off!" I already knew what was happening. This is the fundamental class that changed my path from being a Network Admin to being a programmer. Thanks Dr. Sanders.
I'm in a position where I work to interview people for programming positions in C++ or Java. Sometimes we look for entry level programmers, fresh out of school. I can tell you the things that I, as an interviewer, look for.
First, I really need someone who knows C++ or Java. That's because we program in those two languages, and we don't have time or money to train people to make the jump from something like Modula-2 (or are they on 3 now?) or Scheme or some other language. That's a practicality for us.
I pay attention to coursework. I like asking people about the courses they took: which ones, which did they like the best, which didn't they like? What did they take as electives? I like it when people receive such basics as software design principles, algorithms, databases, and data structures. I don't expect new grads to be up on the latest technology. A lot of schools don't teach java, a lot of schools don't mention object-oriented databases... these are things that upper level courses might address, but not undergrad courses. That's okay. I want to see that people are learning the basics.
As far as I'm concerned, here are some things that are good for people to learn in their 'computer science' training:
- How to learn. You're not going to know everything, ever. Learning is vital.
- How to communicate. Communication is a big, key skill in the workplace. I wish more colleges had group projects. Whenever I hear about someone working on a group project, I have lots of questions for them. The workplace is one large group project. Besides playing well with others (tm), communication involves how you express your thoughts both in groups and one-on-one situations.
- How to design. Object-oriented design skills are especially useful in today's job market, at least. Just learning how to structure code in a logical manner, how to think in terms of objects, the basics are what I look for.
- How to differentiate between what you know and what you don't know. This goes back to the "you won't know everything" principle. Maybe someone had a database class that touched on object-oriented databases, so they mention that in passing. I might ask more questions, when really it was just a brief overview they received. They can go on and try to fake it, or realize that oftentimes "I don't know" is a perfectly valid answer.
Anyway, this is going slightly off-topic, in the direction of CS as the means for entering the job market. In summary, though, what I think CS programs should emphasize most are the basics: data structures, algorithms, good design techniques, etc. It's nice to have the option to learn the latest technology, and obviously the world isn't looking for a lot of Fortran 77 and Cobol programmers these days. But I don't think CS courses should necessarily worry about teaching the latest and greatest bleeding edge technology. Teach students how to think, create, organize, design, communicate, and learn. How? More basics. More group projects. More projects in general. Accessible professors and TAs, and students that take advantage of them. It's the sum of the whole that you get from a CS degree, not '15 cool uses for XML' or 'how to use java to make a drawing applet'.I don't want to sound like a devil's advocate here, but there are a lot of places in code where a debugger does little to any help...
Logic errors come to mind, which as I'm sure most of you know, are 99.9999% of software bugs. Sometimes a debugger catches an improperly derefed or typed pointer, but again, it doesn't catch things like
c=0; while(c1) { do_stuff(); };
Personally, being one of thwe many of zillions of CS students who never finished their degree program, I would like to see more 'guts' in CS classes. Ie, good uses of bit twiddling and assembler, compiler theory in the first 2 years. Algo's of course are normally taught in this period (if not indirectly through higher level math classes). Driver development would also be a big one at the top of hte list.
And, a class on reading and writing MAINTAINABLE source code. This is easily my #1 beef with working with other programs, the programmers name extern vars things like 'my_foo' or 'pointer', define macros with lowercase variables or don't dictate type expectations for more complex ones, which drives me nuts. If you tack in that I work with a lot of PERL as well, you can see where this goes. PERL is an elegant language in the right hands, but outright evil in the wrong ones.
Frankly, I choose the above because after these classes, there's not much of a way that you *can't* learn the rest of the conventions.
As for your algo hell, dunno, but we were taught stacks and sorts in our CS 111 class, as we were learning C. I found it to be very useful.
I was under the impression that the OSI model was 7 layers - Application, Presentation, Session, Transport, Network, Datalink, and Physical, while the TCP/IP model has 4 layers: Application, Transport, IP Layer(Network), Datalink/Physical.
The latter model is usually more useful, unless you are working outseide the realm of IP (I've only ever done Net programming for TCP/IP).
There are a few problems with this approach.
:-)
1. For the sake of purity, Java is NOT purely OO, because it has primitive types (among other things). For a truly OO experience, try Smalltalk
2. Not every student wants to be a high-level programmer. Teaching OO is fine, but the best students I know are those who have a good understanding of what's happening under the hood, e.g., what's going on inside a Java VM, for example. Some kids just want to hack C, not Java.
3. It's not just the issue of OO itself, but actual Software Engineering. The problem here is good Software Engineers tend to want to enter industry, but a lot of professors that I know are more interested in students going for grad school to do research. The head of the department at my university, for example, is planning to REMOVE Software Engineering courses from the curriculum, and I think his motivation is to keep as many people from entering the industry. ACM's recommended curriculum focuses quite a bit on Software Engineering, though.
it's way easier to blow the system
No it isn't. A stray pointer in asm is the same as in C -- either one will crash your program (or maybe your OS if you are using some crap like a MacOS or Win9x derivative).
The enemies of Democracy are
Well that's why you need the calculus. I like calculus, a lot. I almost switched to be a math major instad of CS. I liked linear algebra too. I can't wait to take numerical analysis. =p
You don't even have to go to a top notch university to get professors whose actual job is teaching. Ball State University is not the greatest college, but it isn't a research university and all of the classes are taught by REAL LIFE PROFESSORS. In my two years here so far I have had no classes taught by TA's. The class sizes are pretty small and all of the professors are required to have reasonable set office hours every week so that students can go and get help if they need it. I have never had a problem getting a hold of a professor if I needed it. That's not to say that I have liked all of my professors, but that's another store. :P
Worse than that, the others don't know how to find those answers, and if they did know, wouldn't have the attitude that they should go looking for them. This is a basic problem involving schools and schooling, and the damage which the school system does to people's psyche. The only answer to this is to replace schools with something less rigid, something that works. They are beyond reform.
Got time? Spend some of it coding or testing
``Amen, brother, amen!'' (-:
Got time? Spend some of it coding or testing
More than that, the aspects of maths and science taught in school (``all your mind are belong to us'') are generally taught in a way incompatible with feminine strengths. Women pick up better on things with a wider range of information and perceptual channels available (relatively speaking, men just become more confused as more data channels open). School is in the business of narrowing channels of perception, blandifying information (lopping off sidebands), and chopping data down into such small pieces that the big picture, if any, is at best elusive. School (realschule) was designed to do this specifically to stop people from learning to think.
Femmes actually make better CS experts in many cases because of their built-in greater ability to sift through masses of information for specific items. This is why many wives are able to find their husbands' keys when the husband (who actually put the keys wherever they are) cannot. They pay a price in things like spatial perception (think of reverse-parallel parking).
There are some interesting biases: femmes are often better at low-level OO because they are landmark-oriented, their opposite numbers are often better at structure because they are map-oriented.
Got time? Spend some of it coding or testing
--Xantho
After many years in IT, working on enterprise computing, I have relunctantly concluded that there is very much a "research-like" scientific element to extending or maintaining/debugging complex systems.
When you are dealing with huge interacting systems with 100's of millions (billions?) of lines worth of code, its total absolute behaviour ***IS*** impossible to predict. Yes there are guidelines, requirements, previous behaviour, etc. but when a bug pops out, especially during new development, it takes forensic skill and competence to unmask the metasolutions that went into these systems that produced unexpected results. This requires "understanding" a solution that was implimented perhaps decades earlier. This understanding can be very much a scientific pursuit requiring enquiry and investigation, and sometimes even hypothesis and experimentation to uncover.
I think CS depts in general completely ignore this aspect and rarely (if ever) teach the skills necessary to perform this task. Further, CS depts have yet to teach or promote what it means to work in a team. For those with experience working in Labs, this can be an essential element in scientific thinking because doing scientific research usually involves building on the work of others, not necessarily in the sense of results obtained, but in understanding procedures and protocols that were used in determining those results.
Yes,
:-)
You're right about the application of Pascal to demonstrate the concepts of programming.
top-down design or bottom-up? I cannot remember anymore it was so long ago.
I thought about mentioning that in the original post, but then... I have a point to make
They have no interest in learning - they just want the degree to go make some money.
-
HA! I thought that was what college was all about? After all, why only accept students who want to learn when you can just take in the vast majority of them and charge them an arm and a leg for tuition? Seems like a good way to make money to me.
If you were being forced to go to college by society (and/or your parents), wouldn't you want to get the best out of it--even though you don't want to be there, don't want to learn anything, and just want to make more money? By "the best out of it" I mean choosing the degree that gives you the best "peice-of-paper-to-money-making ratio".
Higher education stopped being a place to learn for most people after the Vietnam war. It filled the job market with degrees. Eventually it became the norm--because to compete in the job market, you needed to look better than the other guy... Who had a degree--because he was drafted and then had is education paid for by the government.
So if you really want something to blame for the lack of interest in college, blame the Vietnam war.
-Riskable
"I have a license to kill -9"
http://YouKnowWhat.com
-------------------------
-Riskable
-Riskable
"Those who choose proprietary software will pay for their decision!"
Then you go to teach, and the top few students seem pretty decent (they're much like you) and the rest of the class seems to suck. Well, no. The rest of the class sucks as much as they ever did, only now you have to notice, because you're grading all the papers, instead of hanging out with the leet geek types.
Crispin
----
Crispin Cowan, Ph.D
Research Scientist, WireX Communications, Inc.
Immunix: Security Hardened Linux Distribution
----
Research Assistant Professor of Computer Science
Oregon Graduate Institute
Does the BMath make much of a difference? I know Waterloo students have to take a couple more Math courses that at other Canadian universities -- but obviously not that many more because entrance to the MMath program doesn't specify. Should other universities be looking into a Faculty of Mathematics?
Show assembly to most first years and if you don't scare them off computing immediately they'll get stuck in a mess of pointers and never get anywhere. You certainly won't be able to do any programs of a reasonable size, and you probably don't end up teaching the most important aspects of computing (like handling complexity with abstraction).
Second session is C (used to be Java, but they went back to C because later subjects need it), and only in second year do they start seeing assembly in conjunction with digital logic (which is where it actually makes sense).
--
--
We apologise for the inconvenience.
Object orientation has proved itself very valuable when it comes to writing large programs in a modular and maintainable way, which is a major goal of software engineering. However, the initial year(s) of computer science has quite different requirements: here the students are likely to write quite small programs, no longer than some hundreds of lines, and much of the emphasis is on proving that the algorithms used are correct and efficient.
Many universities use a functional language in their first courses, and I think that might be a better choise. Functional languges tend to be conceptually simple so that the beginner don't have to struggle with the many syntactic details as Java/C++/..., and inductive correctness proofs and recurrance relations for the time complexity can often be simply read from the program itself in a natural fashion.
At the end of their CS program, the students will want to have seen examples of several different types of languages anyway, so it makes sense to hold of the OO a bit.
I just realized that in all my talking about Scheme, I never once mentioned the "Teach Scheme!" project which has some notes and presentations on just this topic.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
hee hee... in mindstrm's defense, Bill Gates made just the same malapropism in The Road Ahead, substituting "factor large primes" for "find prime factors of large numbers".
Sometimes I wonder if I learned anything that was valuable to me in the real world. At the time I attended my university ('95-'99), they had just started teaching C++ as the primary language.
I am a C++ developer now. My school was using a HORRIBLE book for advanced C++ (Data Structures & Other Objects Using C++, Michael Main). This book is really a C book masquerading as a C++ book. It teaches you linked lists using a non-OO link list toolkit. Why!!?!? The professors all praised the book, I can now look back and see it was substandard. Where was Code Complete? C++ Primer? Inside the C++ Object Model? Or even the Stroustrap book? All of these books have proven invaluable to me in my career and probably would have prepared me much better while I was in college.
I remember the last year I was at my school they made some changes to the program to bring it in line with an Association for Computing Machinery (ACM) recommendation. I believe this is the only hope we have for the robustness of CS programs across the board. A good association like ACM, needs to come up with a strong set of guidelines, that universities can adhere to. Why not suggest well known books in these guidelines?
Execute? [Y/N] _
I'm currently a CS major at URI. From what you said, it seems like you never got past CSC110, the FIRST CS course. Can you judge an entire program based on one basic course probably taught by a grad student? I think not...
I found the major problem with my CS program (I just finished, thankfully) was that the classes were nowhere near as useful as the reading or the assignments/projects. More often than not, the professor wasn't covering any material that couldn't be gotten from the textbooks, and generally in more detail. The project work I've done in my last year has certainly been the most in-depth and rewarding work I've done in my entire college career. It challenged me to work on problems I would never have faced on my own, and that's what made it so useful.
I guess my suggestion is this: if you want a real CS education, find a job. Or a project. Work with some friends or a professor. Coursework alone will never offer as great a learning experience as having a real project to sink your teeth into.
First off - scheme is a functional language, not an OO language.
Second, pseudo-code is how we describe algorithms, which, as we all know, is a large part of CS. Perhaps this table will enlighten you:
Degree/Diploma Focus
Computer Engineering Hardware design
B. Sc. Computer Science Algorithms, language design, computability, structures of data, efficiency.
Software Engineering Handling obscene amounts of code and making it managable
Programming Diploma VB
Third: I disagree with learning scheme as a first language - the nature of C/Pascal being close to assembler helps people to fundamentally understand what the machine is doing - further, in practical terms, very little is being done in scheme in terms of volume of code 'in the real world' which is, where the majority of grads go. Toy languages are good for 3rd year.
Fourth: C++ is such a bad adaption of OO to C that you can code entirely in C while using a C++ compiler. This means that, you have the worst of both worlds - poor maintainability of C (structure s that run around and things that are changing all over the place) and OO footprint.
Fifth: from our experience at U. of Victoria teaching java as a first language does harm because memory allocation, pointers, etc. are not taught. Even though most languages in heavy use today - java, perl, python, etc. all have garbage-collection, these concepts are KEY, and should be taught in 1st year.
Don't like my sig? I don't either.
I think it speaks more to what kind of previous coding experience you can expect from a student entering a college CS program. I would say that any college using OO off the bat is assuming that students have a solid enough platform upon which to build the abstractions OO offers. I do worry about the bulk of students who don't have that background and thus won't understand the abstraction or have any kind of internal conceptualization of what the computer is really doing. So, like most things, it comes down to individual difference, and what might be the best CS program for one person could be the worst for another.
Ok, so suppose we make a square manhole with a rim the size of the smallest axis of the cover. The rim is then round. Well, if we're going to have a round rim, it doesn't make very much sense to have a square cover, as you just waste material. However, saying a square manhole is just as good is like saying that the manhole should be thirty feet in diameter with a rim 3 feet in diameter. A circular manhole is the only shape that won't fall into the hole where the rim is similar to the shape of the cover.
For any prime p, its factors are p and 1.
If we allow negatives, then -p and -1 work too.
How fast is that?
--Mizerai
Employer: "Well, your resume looks pretty skimpy, why didn't you list any of the programming languages you know?"
You: "That's because I don't know any! I know how to think!"
Employer: "Oh. Next!"
Later,
ErikZ
Democrats or Republicans. They are both taking us to the same place and they are not afraid of us anymore.
What do you think a PHD is? ;-)
It's a Doctorate of Philosophy
And yes, CS is largely fields or math applied...
SOme people like to say that the fields of math are the essence, some people like to say the application is the essence.. I think they are both partly wrong...
Blessed are the pessimists, for they have made backups.
Other than that it needs to be iteresting... the only people who goto class regularly (at least where I am) are the ones who can't program anyway, at least that is my experience with the first 2 years.
Hey, maybe you should get together with Bill Gates on that factoring-prime-numbers project.
--
Obfuscated e-mail addresses won't stop sadistic 12-year-old ACs.
Win dain a lotica, en vai tu ri silota
You're wrong. Never underestimate the power of ... you know how this ends. At Karlsruhe University in Germany they're using Java to teach their students non-object-oriented programming. But that doesn't matter really as actually knowing how to even use a computer is hardly on their curriculum for computer science until the 4th term.You'll get lots of useless maths, though.
My comp sci program was 50% math courses, the way it should be. The intro course was taught in Pascal (in 1994), and the sophmore course (Data Structures) was all C++, which we had only 2 weeks to teach ourselves before we were expected to know it completely. We had a huge attrition rate, well over 50% from freshmen to about the junior year. Anyone can can learn a language and program, you need the math to do it well and efficiently, so your program executes in 0.021 seconds, rather than 30 seconds. 30 seconds ain't much, unless you're doing it 200 million times.
How's writing in assembler for two years going to help you with functional programming ? Language Semantics ? Are you really going to get a good intuitive understanding of algorithms when you're worrying about minutiae ? Sure it'll help a bit you for compilers, but beyond that...
Don't get me wrong, I can see your point about actually implementing data structures yourself; but you can implement them yourself in Java; what's to stop lecturers from making students write their own hash table classes ?
If you restrct yourself to low level stuff, or slavishly follow whatever brain-wrong industry is currently touting, you'll miss out on one of the fundamental aspects of computer science, ie the use of abstraction.
If you can teach students how to think abstractly (or rather provide an environment which leads them to learn about it), to see the connections and correspondences between languages, you've got someone who can teach themselves and come to a good understanding of any new language in a few days or less. Students should be taught the tools they need to look at and understand new concepts, and then apply them. This is what a good CS course should do, and you can't do it if you make them piss around with assembler for two years.
Can you sum it up in a word? *No.* In a noise? *Whuuuurghhhhh!*
From what I've seen, CS seems to be taught poorly far more often than it is
taught well. Many places seem to teach it as a set of recipes to memorize --
I've actually seen a course where the students were taught "the seven kinds
of linear search"! Other places aren't as bad, but still teach it as if CS
was a matter of knowing what to type when: "Here's how to make a window come
up using Microsoft's Visual C++ 5.1..."
The results tend to be rather dismal. In a Master's level class I once
gave an assignment where teams of four students had one week to find (not fix)
as many bugs as possible in a 400-line C program. Many of them complained
that a 400-line program was impossibly large, and the only "bug" they could
find was that there weren't enough comments. I've seen Ph.D. students
who were unable to learn Java, and others who complained that writing a
linked list in C was absurdly difficult.
I beleive that CS is mainly a matter of building up useful ways to think
about problems. How do you take the problem requirements, and come up with
a mechanism for implementing them? What ways of formulating your problem
allow it to be modified more easily? The particular language or compiler
that you are using isn't very important -- they just give you slightly
different tools to work with.
In one introductory CS course I co-taught, we started by teaching Scheme, then
switched to ML, and then finally had them use Java. Since Scheme's syntax
is so minimal, we could rapidly get to the point where memorizing recipes
couldn't work -- they actually had to think about the problem. ML's type
system made a great forum for showing them data abstraction, and how they
didn't always have to think about what is going on at the lowest levels
of the system when they are programming. Java introduced them to objects
and procedural programming. Most of all, they learned that they didn't have
to worry about learning new computer languages and that their skills didn't
depend on particular language features.
The results? Well, several years previously I had TA'd a traditional CS
course, and had made up an assignment to write a program to manipulate
polynomials. The students had problems with it, and it was decided that
the assignment was too difficult for them. In my class I gave the students
the same assignment, except that I took out all the hints, and added a
second part as long as the first. A bunch of my students came up to me
and thanked me for giving them a short, easy assignment just when all their
other classes were having midterms.
Now, I won't claim that this isn't the only way to teach CS, and probably
there are even better ways. However, I do think that this shows that there
are better teaching methods than the common "How to program such-and-such
using such-and-such language" courses.
at my school. And your question is vague; you say you know whats wrong with your school's program, but you never say what you think that is. What do you think is wrong, and what makes you think its not just your school?
Whether you're at a big institution or a small one, you're right, it's essential for students to be proactive in having contact with faculty. I doubt in _any_ program you've got faculty chasing students down (although at "University A" I did have one excellent professor who, in addition to being very accessible, threw parties to which he invited undergraduate & graduate students.)
At "University B", one of the "name" faculty members was notorious for being so phenomenally rude and standoffish that virtually _nobody_, not even other faculty members, felt comfortable approaching him. I'm a pretty persistent and enthustiastic guy (sometimes too much so...) and had good relationships with non-CS faculty at the same very large institution. But by hiring a bunch of prima donnas, the CS department at "University B" stacked the deck beyond the usual factors of it being "easy to fade into the crowd."
This is pure and simple BS. If you are in computer science, then you are in a discipline where the science of computers is studied. If you want more hands on, practical crap then head on over to your favorite IS department...
I think you have hit the nail on the head. This would be my number one improvement. In school, debugging was the hardest thing, and to this day, I use too many printf()s & exit()s. The other thing is that you need to study algorithms. I didn't complete my degree and I find that I struggle on code that comes easily to people who have had sorts and stacks drilled into them in college.
they should have a special font for signatures so we don't all get confused
Computability stuff I'd term more as "math", like the Halting Problem, etc. There /is/ a difference between programming and computer science, but I think more about computer science as having a combinatorial bent. Knuth's "Art of Computer Programming" books are a little closer to "computer science" than just the high-up language things.
Computer Science is just math with a more applied tilt.
So you're saying that Mathematics is not a branch of science? Some would say that math IS physics. Science is not the explanation of natural phonomenae. It is the pursuit of knowledge. What's over the horizon, why is the sky blue. Science is exploration. Math is an application of science. It is also its tool. (chicken and the egg.) In science we use what we know to figure out what we don't. In math, we use what we know to figure out what we don't.
Kind of a paradox.
-----
Score 3? For what? Being wrong, at length? - smirkleton
I am currently in Computer One. A Pascal class. The point is to understand the CONCEPT of programming, not to make snazzy apps.
I learned a little visual basic before this class. It helped a lot. It was very usefull.
I still don't mind taking pascal. Next year, (or during summer) i plan on taking AP computers, a C++ class of the hardest sort. So you see learning pascal isn't so bad. You learn something. Kind of a pointless post, but whatever...
-----
Score 3? For what? Being wrong, at length? - smirkleton
The correct interesting ethical questions link,
callum
You mean like physics.
And FWIW, my CS degree was taught by the Faculty of Methematics at the University of Waterloo. There aren't many Universities that you can get a BMath at, though.
-no broken link
I graduated from the CS program at Bowling Green State University in May of '99. I can only speak for the strengths and weeknesses of this particular school, but I suspect they're similar for other non-technical universities.
:-)
:-)
The focus of the department was very centered around C++ application development. This is not a bad thing in and of itself, however, they focused on small projects in all but a couple classes. Even in the classes that focused on large projects, they were do-it-yourself. When I graduated and jumped into a hardcore real-world internet job, I felt woefully inadequate for awhile. I eventually learned more in my job in a single month than I had the entire time at school.
What would have made it better, you ask? I propose two classes that should be in every CS program across the country. The first class, there's a single assignment for the whole class. Everyone works together to produce a large piece of open-source software from scratch. Some students
may elect to coordinate a part of the project,
while others do the coding. This teaches students how to work on big teams in real-world situations to produce something meaningful.
The second class would be the continuation of the first, except you don't get the same project. You take a "completed" project and maintain it. Add features, fix bugs, learn how to take code you've never seen and take ownership of it. We all know fun maintenance is..
This could be a very big help for the open-source movement, as well. A website filled with project ideas from the Internet could help determine the demand for programs. Plus, it exposes everyone to open source, which means there may be fewer Microsofties in the future. *grins* Just my thoughts, anyone want to lobby the big universities to start this?
---
Josh Woodward
Josh Woodward
CS programs have long had a difficult problem to balance. Quite simply, the skills that a CS student needs to know to be successful over a lifetime don't look good enough on paper to pass by an HR person. From the other direction, the skills the working world are looking for is useless in really understanding how things work.
The real skills that programmers need are theoretical skills. Things like the advantages of procedural vrs object oriented programming, or how to look at a solution and do things like "Big O" computations in order to decide how it compares to another solution. Let's face it, in big projects programmers don't write a lot of code, they make sure the small amount of code they write and the existing code are all put together correctly.
Employers are typically concerned with more mechanical aspects of programming. They want to know if someone knows "C", or "Java", or sometimes if they have ever used "the microsoft development enviornment", or "CVS". They want to make sure that someone brought into the team is not going to distract other memebers from programming to teach them the mechanics of what needs to be done.
One of the measures of a university is how easily their grads can get jobs. They get a lot of feedback from companies on how good the grads look coming out of school, but far too often this is provided via HR people through multiple levels of management. As such you get stuff like "we have lots of java projects, and your people don't know java". There is great pressure as a result to put Java in the curriculum as a result.
I think the best way to solve this is to spend the first two years teaching in a single, low level language lots of fundamentals. You want a language that provides few features, and a small library so the students get exposure to doing everything themselves. C makes an excellent choice, as does Pascal. Programs should be text in, text out, there's no place for GUI's and such in learning how to program.
Once the students have a good foundation the second two years should be the application of that in larger projects, and in other languages. Here students should learn about OOP, giving them Java, C++, and ObjC. They should learn a LISP based language. They should learn an assembly language. Students should work on larger projects, where part of the project is provided to them before they start so they get used to making their code work with existing code.
I think this leaves the students with a good base, as well as with all of the resume buzz words to get them past HR. Who knows, they might even write good code.
Couldn't have said it better myself. You don't teach people how to fly in a helicopter. *grins*
Education is the silver bullet.
First two years all assembly is a little extreme. I almost like the idea of Programming Assignment 1, write a program in C to find the first 100 prime numbers. Assignment 2, translate your code to assembly. Always give them carrots to push the envelope of their understanding of design, and then beat them with the stick of understanding how the computer actually executes that design. *grins*
Education is the silver bullet.
I'm reminded of the joke of the mathematician who awoke in a burning hotel room. He excitedly got out of bed, ran to the sink, lit a match, and poured running water over it. Observing that the match went out, he relaxed, asserting, "A solution exists!"
Education is the silver bullet.
People still use Bubble Sort! Think about it, it's not as if finding source code to sort a list requires a lot of knowledge - but when Computer Science departments don't effectively teach people about the resources available - or how to distinguish between good and bad - it's a shame.
How you code is way more important than what you code in. Granted, there are some interesting languages that do bizarre things, and take some serious mental adjustments to use. Most of those languages are very special purpose, though. They should branch off of a curiculum, not be central to it. Teach someone how to survive in the real world of programming, since that's where most of them are going to end up. Then, if they're interested, teach them how to apply their skills in weird environments.
I agree that it's too bad people can't find what they want, and universities are often deaf when it comes to hearing those pleas. But, I disagree that the "latest and greatest" languages are vital to an education. If universities jumped ship every time there was media hype, we'd all be trying to train neural networks to make income tax forms in VRML under Netscape on a BeOS machine that people had to use a force-feedback PowerGlove to use. Sure, that sounds interesting, but you have to agree that there are often easier, more conventional ways, of accomplishing the same thing.
Education is the silver bullet.
Traditionally, the science of computing is all about math. Theoretical computer science is almost all about math. Practical computer science (ie programming) is almost all about design, interfaces (PROGRAMMING interfaces, not visual), and encapsulation. Those things don't have nearly so much math in them as your argument implies.
CS is about programming. Your assertion that it is not is weak. If you want to talk about the theoretical branch or aspect of Computer Science, that's fine - and I'll agree - programming is essentially an exercise left up to the reader. But you know what? Most people who use math have to apply it to a real-world problem. Unless you're in education or some wacky research, to earn a paycheck, math is applied to a real-world problem. Same thing with Computer Science.
Education is the silver bullet.
You're either sinister or hilarious. For the sake of the people mod'ing you up, I hope you're hilarious.
Education is the silver bullet.
switch (a)
{
case 0:
printf("a = 0\n");
break;
case 1:
printf("a = 1\n");
break;
case 2:
printf("a = 2\n");
break;
case 3:
printf("a = 3\n");
break;
case 4:
printf("a = 4\n");
break;
}
When I asked them why they didn't code
printf("a = %d\n", a);
They said that their way was "easier." *shudders* That's one of the reasons why I fear teamwork-oriented teaching. Some people can just get lost and never find their way back.
Education is the silver bullet.
So much programming has to do with a fundamental understanding of Algebra. And as most mathematicians would agree, the best way to learn a concept is to take a class that builds on that knowledge. (Or teach it to someone else, if you get the chance!) Nothing builds on algebra in a practical way as much as calculus does. If you do well in calculus, you know enough algebra to survive. If, on the other hand, you can't survive calculus - you're going to have a hard time mastering algebra. You're right, you likely won't end up using Calculus, but you're sure as hell going to need a firm understanding of Algebra - and Trig never hurt, either. Calculus is the best way to make sure you know Algebra and Trig.
Education is the silver bullet.
Your advice is excellent, though. College fundamentally is what you make of it. Get involved as much as you can in any projects that interest you, or lacking that, make a new project that you do in your spare time and beg the university for publicity or any support you need.
I did an internship at IBM my Sophomore year in college. While I didn't necessarily enjoy my job, it was an experience that I'll treasure. I learned that I don't want to work for IBM! In all seriousness, though - I saw people being mismanaged, project heads who didn't understand the problem space as well as those they managed, and projects that were allowed to fall into disrepair and obscurity at the hands of the inept. Also, I saw a lot of busy people. Not effective, just busy.
Back to the point, you have to direct your efforts. Perhaps we should be instead listing things that are important to learn or that helped us...?
Education is the silver bullet.
That's absurd. Physics should be a branch of applied mathematics, by your argument. Hell, let's go all the way back to the root of things - everything which isn't Agriculture or ASTROLOGY or Ship Building or Carpentry should be Philosophy. Or applied Philosophy. Think about it, you can get a PhD (Doctor of Philosophy) in just about any field - let's be honest and call things what they really are. Math, too.</sarcasm>
Education is the silver bullet.
perl and PHP are not the "latest and greatest" programming languages by any stretch. Do they really teach that at universities (outside of "web programming" or "unix scripting" classes)?
High level languages are high-level because they abstract away from the machine, not because they include primitives for hash tables or linked lists. Why can't one learn the difference between hash tables and linked lists by programming them in Java, for instance? That's what we do at my school.
I'm about to graduate from Kent State with my CS degree. In the five years that I spent in taking classes (both in CS and in Computer Technology), I have discovered the following.
More money needs to be spent on upgrading the labs. If the university is spending money on new construction and renovations to existing buildings, then there should be some money budgeted to improving the education. By improving the education is how you get your students to stay in the university.
Professors need to care more for their students. Of all the professors that I've had, only four have shown that they care about their students learning the subject matter. The classes that I've taken with these profs, I have done well in.
Exams either need to be programming projects, or open book. Outside of the university, people are not going to tell you that you can't use any references to complete a programming assignment. You also can't learn every single detail about everything that is taught in any CS program. This is why I kept all of my books, and only study if I really need to commit something to memory.
but the fact is that the very first "real program" I wrote at my job was in C. Not C++, not Object C, damn sure not Java: straight C. And if I'd only been trained in Java at that point, I'd have been fucked.
All of your points mentioned, (pointers, main, GC) really don't have anything to do with OO programming. Ok, maybe the "main()" comment had something to do with it, but I couldn't really see how having a main outside of an object could cause someone much grief. Besides, OO programming does not necessarily demand that construct.
The points you mentioned are for lower-level languages and against higher-level ones. You could have easily said "Perl programmers have problems understanding freeing their data and pointers" instead of Java programmers having those problems, and the argument still fits.
i'm assuming you don't mean real algebra...
---------
At my school, object oriented programming is taught from the very beginning. When they use a language, it's Java, although most of the lectures are not about any specific language at all. They are very proud that "we teach CS like no other school in the country." However, last month, they did not give tenure to the assistant professor who teaches (and designed) the intro curriculum. Now, the school wants to go to a more 'traditional' (read: pragmatic and vocational) CS curriculum. I don't get their logic.
I'm not sure exactly what they'll do next year; I don't know whether they're just going to modify the previous professor's curriculum a little or start from scratch. If they do start from scratch, I hope they do stay with OOP from the beginning (and I'll be taking the intro course next semester, so they better have it ready).
(In the interest of full disclosure, note that I (a freshmen this year) did not take any CS courses, so everything I know about the curriculum is based on one conversation with the professor and a few friends who are in the intro course.)
I agree and disagree with both of you. Having taught beginners, both at the University and corporate levels, I've come to two conclusions.
OO, taught properly, is *easy*. It is not terribly different from how most people operate in the real world, after all. Everyone classifies via similarities and differences. Everyone abstracts away the "unimportant" details. Everyone groups. And so on.
It's just a matter of identifying what people do in the real world, and mapping this back to OO concepts. I still recall Booch's cat diagrams, for example.
On the other hand, I find Java to have too rich a syntax to make a good first language. It's too easy to get bogged down in details there, which costs time spent on the concepts.
For one small example, consider a class method. I'd rather teach this second, and object methods first. Yet, in Java, one cannot build a program w/o a static main().
So instead, one teaches class methods first. But now one must describe the "static" keyword as "magic" to be explained later.
And that is a second example. An ideal first language would have a syntax that permits the first program to be built with a minimum of constructs.
And what is wrong with thinking of each object as "an independent little program"? Such reasoning serves a person well in a distributed or multithreaded programming environment.
But your posting is exactly the sort of thinking that, as an educator, I have to work out of many people with prior programming experience. Your "from the ground up" approach puts an emphasis on implementation instead of interface. This yields a tendency to discuss pieces of "how" before knowing all of the "what" or "why".
Obviously, a programmer needs to be concerned about implementation details. But these tend to come very late in the process, for successful projects.
Of course, there are exceptions. Real time or embedded systems, for example, have as a part of their description what would normally be considered low level details (ie. memory management). But these can be taught later, perhaps after circuit design and assembler classes have explained the building blocks involved.
But perhaps we're begging the question of "what is the CS program to produce?" Is the goal to produce programmers, or to produce software engineers? I generally view the goal as the latter.
Actually, a CS program could probably move in either direction: from circuits up, or from concepts down. I'd tend to choose the later, simply because a greater number of engineers work at high levels than low.
But the final result should be the same in either case. The program should yield professionals that can discover requirements, synthesize designs, and produce implementations. They should be equipped with a wide array of "tools" towards these goals, including understandings of algorithms, proofs, sets, concurrency, resource management, various forms of decomposition and design (ie. OO, functional, procedural, etc.), and so on.
When you look at it this way, it actually becomes less important where you start the students, and more important how you fit it all in.
OOP and "visual" programming languages are nothing more than the digital manifestation of the lazy tendencies our society has sunken into.
Oh my god! Lazy programmers! What comes next -- Impatience and Hubris? The horror!
Slashdot is jumping the shark. I'm just driving the boat.
I have no idea where to find them, but it's been said that people have implemented MIX virtual machines, and even his more recently risc-based theoretical architecture. They should be available for free _somewhere_.
Most of CS hasn't changed since the eighties. Processors have been made faster, and applications became more complex and feature-encrusted, but most of the theory has been the same for years if not decades. What does change is the languages and the buzzwords, but if you have your theory down pat these aren't terribly hard to pick up. (Except COBOL. And Visual Basic. Ugh.) You can learn CS on a 386 running MINIX, and then turn around and use that knowledge to build complex systems on modern machines. And most wizards do in fact learn more from hacking on code in their spare time than they do from college. But college CS courses establish the foundation, and can start high school computer kiddies on the way to becoming good professional coders. (Notice I said can; it apparently didn't help this girl I knew who thought a "compiler" was a magical C++-crunching chip in her machine.)
N4st0r, trixx0r h0bb1tz0rz! Th3y st0l3 0ur pr3c10uzz!
I think one of the most important things about a CS education is not to get caught up in the "rapid change" of computers.
I think the most important element of a good CS education is the teaching of fundamentals of computers. Even though everyone says Computers are rapidly changing, there are certain underlying algorithms and theories that do not change. These are the bedrock of computer science, and once these are firmly grasped learning the modern concepts becomes and extension of this.
An example of this is languages. As one RITer has complained (all too commonly), we learned our first year of CS in Eiffel (now done in Java). Who uses that? No one. But the focus of the curriculum isn't to teach a language, it was to teach the ability to learn any language quickly. That is why in later courses, they teach you the underlying general types of languages, and their differences.
I feel this is the most important aspect of a CS education. When an education fails to stress these it becomes more like an IT education (another vaguely defined term) where you learn specific technologies and applications (VB, WYSIWYG web editors) without learning the "meat" of them underneath.
---Lane Westlund
What's the point of moderating?!
just my $.02
It IS. That was my point. Everything I said that I learned was incorrect.
heheh!
CS at URI was horrible.
We were getting tought about the 5 layer OSI model, SNMP(Simple Network Mail Protocol), ASCII (the first character set) and many other totally incorrect facts.
I quit URI. I am now going part time at another school and working fulltime at a ISP.
You missed the whole fucking point.
Just want to chip in my opinion to respond to the arguments of teaching the latest technology in CS courses. Technology changes so rapidly that it's very hard for CS depts to try to keep up with it. Also, technology becomes obsolete. So IMHO, CS depts may teach courses related to the latest technology, however you define it, when they have sufficient resources. However, what's more important is for CS depts to teach on longlasting subjects and give the students the skill necessary to keep up with the latest technology on their own. I think this is a much more valuable skill to have.
Heh, I thought you said:
Professors have been made faster
and I laughed...
Yours Sincerely, Michael.
But that's programming. That's praxis. Computer Science is more than that.
Junior and senior year, I hardly had to do any programming. The focus was on theory, and if there was a programming project, we could choose any language to implement it. All that mattered was if you understood and knew how to use the theory.
I'm currently on my last semester, and no, university didn't teach me everything I will ever need to know. I'm continuously reading trade magazines and books. How could a university ever catch up with that? They simply can't; the responsibility is yours. University gave me enough to understand and learn on my own.
While I am sure there really are problems out there, I think much to blame is on the students. They are expecting the wrong things from the program. I believe that a programming language is a tool. Tools can get outdated or superceded by something better. Students should not be focusing on how to use a particular tool, but on how to use any tool. To draw an analogy, what if your doctor still used the same equipment since he or she graduated medical school?
Now, to be fair to your question, I think research opportunities are an excellent idea. My school implemented a pilot program this semester, which I am participating in. It offers students a wonderful chance to research something primarily on their own (with the help of a faculty member). It's done outside of classes and not for a grade, but we answer to the people who are funding our projects. That seems like good prepartion for the business world or academia.
I truly hope you are as motivated as you say, then you shouldn't have any problems using your education to make it out there.
I'll be getting my CS bachelor's degree here in about 7 weeks, plus I've been working in the industry for the past 5 years, so I've seen the results of a college CS education. They're not good. I'll tell you right now, if most of my graduating class came in to ask me for a job, I'd tell them to get lost.
CS has become the popular degree to get, mostly because of the promise of big bucks upon graduation. What I find though, is that a lot of people coming into the CS program aren't hobbyists, but people who are drawn to making lots of money. That's problem number one. They don't care about what they're doing, only that it'll make them semi-rich. Getting past that, to the students who do care about their degree, the problem of specialization arises. You go through an entire CS program learning little bits of this and little bits of that. That's fine and dandy for the first year or so, but after that it's pointless. CS brings together many different areas. Some people go into scientific programming, others into database applications, and yet others into game/graphics programming and so on. At a base level these are all very similar, yet at an advanced level they're very different. I'd suggest after the first or second year, allowing students to pick a specialization block and then take only classes that deal with that specialization.
The big problem I see with graduates coming into the industry is they know how to do lots of little piddly crap at an average skill level, but no one thing at an (at least somewhat) advanced skill level. You don't get any advanced training through a degree program. Currently if you want to learn enough to do important stuff, you have to be a hobbyist and be willing to spend your own time between classes learning the really useful stuff.
But, If the students are sheltered from all the messy stuff like memory leaks, etc, they're gonna be in really big trouble when the get into the real world and are gonna have to deal with these things.
I have to agree with the poster that stated ASM first, and move up from there. I think there are a lot of 'programmers' out there who simply can't handle stuff like ASM or even C (I work with some of these people).
I feel that, while you're not likely to need to code assembly in most jobs these days, if you're comfortable with it, and uderstand how you're systems work on that most basic level, you can be a FAR better programmer.
I disagree. My first few CS courses were taught in Java, we're just learning C++ now... however there's a huge problem with that.
Although Java is a good language, it does one very bad thing from a pedagogical point of view: it doesn't have pointers. Sure, it has references... but they're implicit, not explicit like pointers are. Students are getting screwed because it's not an easy thing to grasp for the first time.
I'd recommend a language like Pascal (to start with) which has pointers, but also has a good, structured language, to make teaching easy. There exists OO in Pascal too... so you've got that base covered. Then, when students are ready, have them learn Java AND C++, because they're both very good languages.
"Free beer tends to lead to free speech"
The art programs at my school require you to show them a portfolio. CS does not. So the CS classes are half coders like me and half people who never coded before.
University of Waterloo has a good solution for this. There are three starting points for CS. CS 120: you've never coded before; CS 130: You've coded, but not OO; CS 134: You know OO fairly well. You are required to submit some code with your application to prove you know what you're talking about, but people have to know the basics, but if you already know them, you can skip ahead. It tends to improve things.
I learn nothing from someone teaching me how to code.
If your CS program is someone teaching you how to code... you're in the wrong place.... I'm only in 2nd year and we've stopped taking "coding" classes (well, with one exception). It's all algorithms, DS and theory now...
"Free beer tends to lead to free speech"
"Free beer tends to lead to free speech"
Flat5
The Guitarist Forum
The second intro course is taught using Java, which I felt was a very good course. It gave a good intro to OO, and if taught right, you can link Scheme to Java in introducing the basic concept and process of object orientation (as was done for me.) It's important to learn OO, but I agree with you that Java is a very difficult introductory language to teach with because of the amount of syntax to learn, in addition to the basic data structures. Scheme Worked very well in this respect.
He's dead, Jim. You grab his wallet, I'll grab his tri-corder.
I go to WPI where we have 4 7-week terms. I'm a sophomore now. So far I've seen and used C/C++, Java, Prolog, Scheme, Assembly. The languages are diverse to help suggest that there is not just 1 language or programming technique. In fact, we have an entire course devoted to how some languages are better than others for certain problems. I think it would be helpful to people to see other languages and techniques. It opens up new ways of looking at problems and helps to create new solutions to old problems.
You're not talking so much about CS as you are about work experience and job suitability after graduation.
There are multiple parts to the problem, among them:
Analytic thought
Process and practicies
Theory and understanding
Ability
There are probably a handful more categories I've left out.
But to have excellence in one without being capable in all the others won't help you when you graduate. What you're advocating helps to teach process and practices, and perhaps ability, without mentioning analytic thought or theory. Some people naturally have skill or talent in analytic thought. Most don't. Most people have no theory until taught it; some are self taught.
But you need all four, at the minimum, which means good coursework (language and platform is irrelevant!) to teach analytic thought, theory, and process. An excellent course taught with LISP can cover all three, despite being an unpopular development language. Once you figure out theory, thought, and process, it should be a breeze to pick up the flavor of the year, be it Java, C, or whatever.
Geek dating!
GPL Deconstructed
I'm in Data Structures right now at the University of Arkansas, and I really don't like the way it's taught. The teacher's philosophy seems to be the complete opposite of open source, which is puzzling since there are a few open source links on his website.
A student looking at any code not written exclusively by himself is not permitted. We cannot look at other student's code, and code isn't shown in the lessons. The teacher just 'discussses' the basic ideas of the algorithms. Then, we are expected to complete these humongous assignments that are very time-consuming.
For me, the most immediate way to understand how an algorithm works is to look at the code that implements it. I don't understand why teachers don't get this. How am I supposed to learn how to program if they just talk about it and never show it to me? Once, when I suggested to the teacher that he might should show more code examples in his lecture, he actually told me that he wasn't here to teach me how to program. He's here to teach me the "ideas of the algorithms", or some such nonsense. Whatever that means.
What's really interesting to me though, is that even though the assignments are pretty hard, everyone seems to be doing okay on them. I realize now more than ever that most CS students just teach themselves, because there's no way anyone could complete the assignments based on the lecture. I'm not dogging the teacher though, just the basic ways that i've seen CS taught today. Last time he actually spent most of the class time going over code examples, and it really seems like people were learning a lot better to me. I guess he took my suggestion.
In my mind there's a lot of problems with the usual CS curriculum at schools. For one thing people don't really make a distinction between it and CIS when they enter school. What the defined distinction is I really could not tell you except that its more "business technical" than CS, but that's really quite fantastic when the CS degree is so much more rewarded in the business world. Now with from what I understand most people seem to learn C++ or JAVA in their first CS classes. Isn't that an insane language to start with? In a country that has low mathematic scores in high school, it seems like a contradiction to make the lowest level programming course one of the most difficult to learn. And really lets ask ourselves how many people working in the technical field really program in C++? And while Java is more marketable certainly, you're not really going to learn how to apply this to internet apps You're just going to learn recursion, logic etc. And they typically follow these courses with Computer Architecture something equally as esoteric. What does that have to do with programming? Why would we want to learn Assembly? 80% of people entering those courses are doing it to get a big paycheck someday, yet the majority of the skills they're forced to learn are not prized in the market place. But in changing the curriculum you have to keep in mind that many schools out there conform to the curriculum requirements of the CSAB, and while I doubt the B stands for beurocracy, it sounds like it could be an uphill battle.
Anyways, in general, if you want to learn something specific, you will probably have to teach yourself. Your school probably has an "independent study" type class. If you can get a professor to sponsor you, you would then be able to clear space in your course load to do so without actually dropping below "full time".
"Watch these suckers jump when I get Administrator."
Yup, this guide is pretty good; however, it points out some really sneaky places, even the broken part of the map in de_cbble (the hole between the boards blocking the door in the sniper tower, which was probably fixed when CS11 was released).
"Ancillary does not mean you get to rule the world." --U.S. Circuit Judge Harry Edwards, speaking to the FCC's lawyer
My school does the first two years in Java as well. I agree, they really should at least expose us to something not OOP. Luckily I already knew C.)
The need for this was really obvious when I went to a job fair and my resume mentioned that I knew Java and almost everyone who saw that was like, "oh...java...isn't that some web-based gui thing?" And as for memory management? My prof was always like "well, java lets you clean up memory, but don't because memory's cheap and the development costs more than the RAM. Besides it takes care of most of it for you." *sigh*
At least my EE profs know what they're doing.
Just because they don't come to discuss the material doesn't mean they aren't discussing it. I never once went to a TA, because I had my own group of friends to discuss the class concepts with.
I've been a TA for courses with over a hundred students, so I've observed this. After you've graded a few homeworks, you can see who has worked together-- all sorts of answer idiosyncracies cluster in groups that correspond to study groups; in particular, mistakes and misconceptions that I could have cleared up in 2 minutes if I had been asked.
And it wouldn't even have required coming to my office hours-- email would have been fine.
That's sad.
And you people wonder why engineers don't respect CS people.
I see what you're getting at but I think it might be a problem with teaching style. To paraphrase, you're saying that you can't take a procedural way of thinking and map it into an OO world. With this I would agree.
But instead of teaching the students to think in terms of procedures from the start, teach them to think in terms of objects. Teach them that building a program is like building a clock. You take parts and put them together in a certain way and the "procedure" falls out of that structure just as it does within a clock. Now we can rewrite what you said as:
Now, about the above point of OO making more sense, naturally. Firstly, think about how you tend to build machines: come up with an structure, plug in the parts to get it to work. Note that there is nothing about procedures in there. An OO model translates a lot easier to a Java program than it does a C program.
Then teach them that in software you can't usually order the parts from someone else and you need to build those, too. Work your way down into the tiny procedures needed inside your objects methods. This puts the emphasis in the right place - on the overall model and structure. A top down approach makes a whole lot more sense for teaching OO.
Devon
Now to reply to the people who replied to me. All at once. First of all I don't think that people who never programmed before should not be allowed into CS. The thing is that CS here is taught very quickly. It is currently the third quarter of my first year here. That means that if you don't fail a CS class you should be in CS 3 now, which I am. However there are currently only 3 lecture sections of CS3. They all hold 45 people. There are multiple large sections of CS2 and even a couple CS1 sections. I heard something like 25% of the people who were initially CS switched to IT. I think the person who said that they have different levels for entry into CS is on the right track.
As for my lack of tags I know HTML. I just forgot to switch the little combo box to plain old text. I don't format my notes nicely either, I lose my train of thought when I have to stop and put in a
tag. As for the people who joined CS programs and did well without knowing any previous coding, good for you. Not many people can do that. Especially here as the statistics show.
Now that part about KDE2 instead of CDE. The real reason I put that in there was because it just came to my mind when I was thinking about the problems in the CS department. Whenever I go to the lab people always ask me how I got an image file for my wallpaper (can't be done in CDE). So I take the five minutes to change their dotfiles to startkde and they get very happy. The thing is that the CS department doesn't even tell you about this. We wasted multiple days in the beginning of CS1 and wasted money on a UNIX book (not me) before we started coding. Since KDE is a lot like windows if the CS department defaulted to it we could have wasted less time and money. It's not really relevant it's just a personal gripe I have with the department. There are so many cool things on their network and they keep them all a secret. The only way to find out is to ask the teaching assistants.
Basically the CS department here at RIT is pretty good. The program has a reputation of being difficult because so many people leave and fail classes. After the first year of the program it really changes for the better. There are classes like Intro to Digital Design and Operating Systems that area really cool and such. And in CS4 you get switched from Java to C++.
For a better look at RIT's CS program go to http://www.cs.rit.edu
The GeekNights podcast is going strong. Listen!
I'm a CS Major at RIT. And the current CS program is pretty good. Except for the fact that lots of people drop out and join the IT program. The first problem is the misunderstanding of what CS is. Kids in high school who like computers are told oh, you should be a computer science major then. When really they should be IT majors because they don't know the first thing about coding. They are interested in networking and web page making. The second problem is the fact that they require no previous coding experience to join the CS program. The art programs at my school require you to show them a portfolio. CS does not. So the CS classes are half coders like me and half people who never coded before. The people like me sleep and skip class and get A's. The rest go to class and study hard and get F's. The third major problem with our CS department is the teachers. The teachers we have are quite intelligent, and a few of them are really good computer scientists. However some of them are just not qualified. We ask them all kinds of advanced questions and they don't have answers. There are only two teachers we can take our complex problems to because the rest don't know. There are other ways of improving the program besides solving these problems. For example at RIT java is learned first. They teach you object oriented concepts and such right off the bat. I think that for the never coded before folk they should have them write simple C programs where they store data in variables, manipulate it, make loops, printf, etc. So they actually understand the code writing concept before they get object oriented concepts. Another thing, that isn't so major, that would be nice is if they changed to a different os besides Solaris. We're running on a bunch of Ultra 10's so they come with Solaris and I really dont' like it. I set my account up to use KDE, (I would use KDE2, they don't have it) but everyone around me is using Solaris CDE. KDE should be the default. Half these people didn't know what UNIX was until they got here they should have the most user friendly desktop environment available. The last thing I would like to do to improve CS class is make it all lab. Currently I have 3 1 hour lectures and 1 2 hour lab every week. I want to have 3 2 hours labs a week. I learn nothing from someone teaching me how to code. I don't learn the week's lessons (if we learn something I don't already know) until I get to lab. That's really all that's wrong with the CS program at RIT. I don't know if your CS program is any different. The one really great thing I can say about our CS program is that it gets people really good jobs. We have a 100% job placement rate and a lot of those guys and girls make a lot of dough right off the bat.
The GeekNights podcast is going strong. Listen!
Do you really believe that men and woman have vastly different "basic philosophies." Even if they did, it would not be relevant.
CS is a science because there are methods one can use to determine which OS implementation for example will work best.
Woman can program just as well as men, but they're not as likely to get into it, because computers were still considered geeky when us college students were still growing up. This of course also caused by the societal pressure against women to study math in primary education.
I think your REAL problem with the field being mostly male, is that you don't know where else you can meet woman.
Hmm. I suppose teacher training's one of the factors that ultimately affects the success of such a program. New curricula have to be really well thought-out. I'm a student - I have so much to learn about CS ed! =)
I am a senior at a mid-size university and the one problem that I seem to see that no one else at my school has figured out is that our "advanced computing lab" has by far has the least powerful computers on campus. The general lab computers are on avg. 400mhz faster! And every classroom lab has brand new thinkpads. You might think the CS students may need a powerful computer but I guess the english majors need there papers written on lightning fast MS Word....
I am currently a comp sci major at Drexel University. Personally, I think object oriented programming needs to be tought FROM THE VERY BEGINNING! We start by learning C++ (you know the basics), and its not until 2nd term sophomoe year that you even start learning object oriented stuff. I truely think that one of the BEST languages to teach stdents would be JAVA as it is entirely an object oriented language. You can't not make things into classes and objects with JAVA.
So what did they teach you in MCSE? The things Windows (fill in whatever version) should be doing under certain circumstances or the facts?
People replying to my sig annoy me. That's why I change it all the time.
I don't want to change it! I like being one of very few women in CS! :)
Seriously though, I think that the gender issue has to do with the fact that women are generally not encouraged as much to excel in fields of math and science. Think about it -- in high school, a girl who does well in English or history can still be "cool", but it's much more difficult for girls who do well in math and science to still be seen as "cool." It's a social issue, not a CS curriculum issue.
I guess that explains the BA in English that I got before I realized that about all it was good for was answering all the literature questions on Jeopardy... I'm now midway through my BS in CS.
"The herbivores ate well cause their food didn't ever run..." - Phish
Pointers are only really useful when you're doing hardcore systems programming - which is a small minority of the programming that gets done.
...).
I would disagree. Pointers are only really useful when you are pushing the boundaries of what the machine can do. This is not just systems programming but also problems for which machines of appropriate power do not yet exist (and since the problem size tends to scale with the machine,
A big part of the problem, and it's reflected here at Slashdot, is that CS is about 80% male. You should take steps to improve the gender equity, especially since once you get into the workplace, you will work with women.
I'm not sure how to do this, perhaps some of the courses can be geared to topics women understand and appreciate. Perhaps you could do a study on Barbie's Dressmaker, a huge hit for girls.
Perhap's a woman's view could be incorporated into operating system design? Most operating systems are heirarchal in nature, reflecting men's basic philosophy (there will be one process controlling everything, very patriarchal). Could you imagine an operating system where everything is shared and every process cooperates? Good bye to heap exhaustion, and you probably wouldn't even need mallocs, either.
Actually, calc is supposed to get us to think about our work...its like a course on logical thinking for the CS majors, (thats one of the many reasons)
But, seriously, its very frustrating, and in my school, you are only allowed to take courses twice! So, if you need that one calc course over again to get that degree and don't get it, but still you know whats going on though..hypothetical suitation, but it can happen
Slashdot Hypocrisy at work?
That's much later, like the 3rd or 4th year here. The first two years is coding oriented..later we learn the theory of computation, theories of OSes etc.
Slashdot Hypocrisy at work?
Well..first off, eliminate the need for calc courses!
At my school we have calc requirements for a CS degree. Now, from what I've heard from my friends, graduates of my college (Uni of Buffalo), and those that have been out in the CS field, calc is used rarely! If you're going to teach some sort of math, teach CS-related math and stop giving headaches!
Ok, now onto the topic at hand:
One can only learn coding from coding and not books. Thats the advice my CS professor gives out. But we have exams anyway. Coding strengthens your ideas of coding and we do have to take exams, and if you did the lab yourself, it shows in the exam grade.
How to make it better? Well first off, reduce those giant class sizes, (my intro course had 177 people in it! That was reduced 177-120-98-70) Seventy people left standing. Of course, thats what a intro course is supposed to do.
They should be teaching the ideas of what CS language is and not the language itself for the beginning and later on cement that with the very close details of the language.
Java? It seems everyone is being taught this language, although I haven't seen a good I can use being done with it, I don't know, that may be my own ignorance, and there's lots of grumbling about we should learn C++, but that's because everyone knows C++.
Slashdot Hypocrisy at work?
the problem with teaching asm in school is that it's way easier to blow the system (most of our puters run windows ...) !! You don't want your students to reboot all the time when doing applications. Same stuff with pointers, forget to allocate memory and you're crashed.
$man microsoft
Crowded elevator smell different to midget. -Chinese Proverb
I went into CS because I like creating solutions to problems, and I like computers. The first year was cool, we of course learned the basics, and I picked up a few tricks that I didn't know about. The second year was just as good, learning about data structures and algorithms. The third year sucked. The first two years, most of the curriculum was learning a new trick, then writing a small app to demonstrate comprehension. Nothing was more than 5,000 lines. When I got to the third year, I was hoping to do some really cool stuff, like tying it all together. While of course there is going to be some overlap, and you're going to use previous knowledge to help with the new stuff, it was the same old stuff: writing small apps to demonstrate comprehension. The projects had become mundane because I could be given a project, think about it for a half hour, and I knew how to do it. After that it was just a matter of sitting down and writing the code. There wasn't anymore challenge to it because there wasn't any discovery during the code writing. To me, in education, you should be learning new stuff all the way through your projects, not just drudging through the code till you're done with the project that you already knew how to do. I got REALLY bored, I stopped going to class, my grades dropped, and I ended up taking a break from school because I felt my brain turning to mush. I'm in the workforce now, doing interesting stuff, receiving accolades from my peers and employers. I excel because it's interesting. I know that what I'm creating is going to be used by people. I get REAL feedback from endusers about what they'd like to see changed to make the software better. During my first 2 years in CS education, I was an 'A' or 'B' student, my third year I was a 'C' student. It's not like I was always a bad student. After 3 months as a professional, I had learned more about CS and programming then I did during those three years in school. My advice, if you want to keep your students engaged and excited about your class, is to make it REALLY interesting. I know that you have certain topics to cover in a course, but how about this: starting with second year students, have them pick an application that they want to do at the beginning of the semester. Pick one that will use the topics that you need to cover. Make it a group effort (you know, like the real world works). Assign tech leads. Do code reviews. CS can be fun, let it be that way. Before I took my vacation from school, I had one class that was this way. We were split into 5 person teams and our first assignment was to establish a team lead, and find a client. From there, most of the class was a question and answer about the technologies that we were using. We even were paired up with graphic designers for our user interfaces. It was a collaberative effort. It was very close to the way things are in the real world. But most importantly, EVERYONE worked real hard at it. Everyone got 'A's and 'B's because of that. And why? Because we had clients who were going to actually enjoy the fruits of our labor, we were going to make business' happy. There is a certain amount of oomph that goes into it when you know that what you are doing is genuinely going to help someone. That really counts for a lot. Everything that I learned in school was interesting, there was never a doubt about that. The problem was that I didn't have much of an opportunity to use what I was learning. Give your students the opportunity to really use it to make someones' lives better, and I think you'll see more smiling faces when you get up there in class.
$man microsoft
Crowded elevator smell different to midget. -Chinese Proverb
Also, most CS courses seem to have a Unix bias. Now I am all in favor of unix (especially the free varieties), but I have to wonder if Unix is relavent for the vast majority of CS students who will end up writing applets or PHP or perl to run on W2K servers.
What do others think ?
I'm currently a 5th year Comp. Eng. / Comp. Sc. and a key difference between the 2 degrees has been the Comp. Eng. requirement that 12 weeks in a relevant workplace (i.e. with a qualified engineer) is *compulsary* to get your degree.
I have found the Comp. Sc. only students at my Uni to be very technically sound but totally unprepared for the workplace life.
For example, you *can't* teach stuff like face to face communication, office politics, learning the right approach to talk to the boss etc. in a CS degree.
A minimum of 12 weeks work at a company can do the world of difference. It did for me anyway.
Having taken the "ground-up" version of an introductory CS class, only to TA in the "top-down" version a few years later, I can honestly say that I witnessed more confusion in the latter. The whole notion of objects is very difficult to people who are having enough problems understanding what the heck a function call is. And yes, it's terrible for people to think that an object is an independent little program, because... well, they're not. It leads to the mistaken belief (which can be quietly harbored for months) that an object runs independently (ie, it's like a thread.)
This yields a tendency to discuss pieces of "how" before knowing all of the "what" or "why"
When I was younger and first learning to program (in my case, on a Mac), I encountered some difficulty understanding the concept of multiple inderection (pointers to pointers.) Of course, you can go round and round trying to explain that a pointer is a reference to a data structure, but what's that mean? Until I actually understood the basics of how memory was arranged, and realized that a pointer was just a piece of memory containing the address of another piece of memory (this may sound more complicated, but it really is much easier to visualize than the abstract concepts in the textbook explanation), I had a great deal of trouble making sense of these concepts. Dealing with students in the later class, I saw the same thing. This ignores the rather confusing issue that in Java there are no pointers, or maybe everything's a pointer (not to mention that whole String/StringBuffer thing kludge.)
Learning from the ground up may require slightly more work, but the problems can be spoon fed. Learning about OO front-loads the process, putting a huge burden of comprehension on intro students. The ones that get through it do it largely on faith, with less understanding of what's going on. They then have great difficulty understanding non-OO languages, which they will inevitably have to deal with. And finally, making them learn with Java lets them ignore little things like memory management, things that you really need to be concerned with in most real-world applications-- and upon inevitably being exposed to a lower-level language, learning these things is hard to do quickly.
With the sentiment of the original poster that is... I should really use that Preview button more.
A program that seemed to work well (as far as I could see) was the CS/CompE program at the University of Southampton (in the UK) - I just saw the tour and talked to some kids, so if there are any Soton students here, feel free to correct me. For the most part, Microsoft 0wnz the place. there are huge MS banners in various labs, they have enough licences to give any student that wants a copy of any MS OS, and you can get pretty much any piece of MS software that you could possibly want (like Vis, Interdev, O2K, you name it) by simply going to the CS office and borrowing the CD for the night, and you were encouraged to burn yourself a copy if you needed.
If the situation was only what I have described above, then this would be very detrimental to the prospects of Joe Student. Innundated in a one-company (insert RedHat/Corel/NA/Symantec instead of MS if it makes you feel better) environment, the kids will learn to do all their Database programming with Access. Why? It may not be the best, but it's so easy for them to get it and get support for it. They will code everyting using Vis, because it's there. This situation, however, screws them because it's not like that in reality. Entities use many types of software, and they usually don't all interact like the MS suites.
To continue the Southampton scenario, it gets better (in a way that I think is fabulous). If it was MS-sponsored only, it would be bad. But it's not. Red Hat also 0wnz them, but to a lesser degree. They run RH where needed, and MS where needed. Again, I'm not saying that this is good BECAUSE it's Linux, but because it's variety and somtthing totally different. It also allow ppl who just don't like MS software an alternative.
This is what I think a sponsored program (public-private partnership?) should be like. Sponsored yes, but not by one company only, and NEVER exclusively.
Cue The Sun...
>not clear (to me),
If they can't then what good are they? What would they do outside talk theory?
>but they certainly should be able to
>design computer algorithms to solve problems.
>Once you can do that, actually writing the
>code is generally not difficult.
This attitude pisses me off to no end. Writing code is that difficult. If it's so easy why do people suck at it so bad? We are talking about writing a system here, not a class exercise, not yet another standalone version of bubble sort that nobody will ever care about again. Writing good code for a product is extremely difficult and is clearly not well taught. From most of the attitudes written about here it's clear why. Coding seems to be something people pick up in an hour or two when it really is a multi-year process.
Or maybe it was a required course for those students and you BORED them to death? Why is it always the student's fault? I'd like to be in an environment where the teacher is excited about teaching and makes the student excited about learning and going to class. Most of my teachers here are boring and methodically go over the material. I think the problem is not with the students but with the teachers thinking they can just get up in front of a class and talk and think people are automatically interested.
How do I know? I am a C.S. student.
A little background on the subject... I started as a student, became a TA (Teacher Assistant), then I became an RA (Research Assistant... hard to believe as an undergrad producing papers.), and after a long battle with one class that was copied right from the grad level course (projects too) I never finished my degree. Everything I learned was from research and personal time. I completely agree with the education ``system'' needing changes. But is not just CS.
The prof's are interested in their research, that is true. But many of them feel that teaching the undergrads is not worth much time. Reseaons: undergrads, as a majority, do not respect the prof, show up on a non-regular basis, and go to college because most other people are. As if college is a motion of life, not a choice. Grad students go on because they like to. The problem is cyclic in this case. To change the prof's is asking them to change how they feel about under-grads when they have every right to feel the way they do.
As for the people at the top. Some of these people do not know the cold war is over.
Targetting particular classes might get you further. At my old college, if so many people complained or their end of semester review from the students was so low... they wouldn't teach the course again. I do not know if this is done at every school.
One might be better off talking to the prof directly as the course is going on or talking with their supervisor. The prof's are no different then you or I, they love seeing a few students after class to talk about the course. To even talk about their research might help. Getting to know them first helps a lot. You will know where they sit on a topic and why it is the way it is. Starting off as the ``good guy'', getting to know the system (in detail) and becoming more friendly with the people in the school will get you further then imaginable. Then politly start asking some questions, but never tell them how you feel or what you think should be changed until they ask it from you.
Wanting to make changes now and wanting to point out the flaw in something doesn't get you very far. Tact and getting in ``good'' with the people pays off. Even when you are looking for a job, you have some one to refer to. This would apply for those heading into grad school.
There is so much that goes into this, a simple post to /. isnt't enough....
OO is not about understanding, its a state of mind.
Oh, how I wish that were true here. Our CS curriculum is outrageously Microcentric. We're heavily funded by Microsoft (isn't that a Good Thing?) and most of the classes involve MS technology. You can even take an entire course in Word. Whee.
The degree curriculum here is divided into "emphases": Programming, Hardware, Internet, Network, Information (database). Only one Unix course is offered, and you only get to take it if you're doing a Hardware or Network emphasis. Only one Java course, and you'd better be doing a Programming emphasis (same with C/C++). Because I'm doing an Information emphasis, apparently all I need to know is Visual Basic, all of the MS operating systems up through NT Server, and the two major MS RDBMSs. That means I'll be trotting off to my very first job as a DBA in June having never touched Unix. Hmmm.
Now, I've taken a lengthy course in C in my spare time and am planning to learn C++ and Java because I think it's important (the logical programming experience, if nothing else). One flavor or another of Linux is going on a partition in the next few weeks because I think I should learn at least the basics. I plan to enroll at the local extension of the state college (WSU) at some point in the near future to take courses in Oracle and other (I think) useful subjects. But I know I'm not the "usual" CS student who thinks he/she has completed a CS degree and now knows everything necessary to go out and make lots of money. What I know is a drop in the bucket compared to what I really need to know to be effective in the real world.
Think I'll shut up now before I start ranting about the quality of our instructors and disorganization of the college in general. *grin*
By the way, can anyone recommend a really good book on C++ (by really good I mean a book you could teach yourself from effectively)?
~Being a geek means never having to say "y'want fries with that?"~
I can totally agree with you there... I am currently a senior finishing my undergrad degree, and i have assisted with the intro CS classes over the past few years and it's amazing sometimes how some people don't even try. There was one person once, when given a packet of directions during the lab, asked me what he should do, and i would ask him if he's followed the steps in the instructions, and he said no, and I told him i'll help him ONLY after he's read the instructions and given it a try, he was expecting me to do his lab for him, which i told him was NOT my job. If someone is lost in the class, but trying to do their best, I respect them for trying, but some of these people who don't even try, it frustrates me....
At our school, we don't have an option of taking a summer internship. I had asked about it, hoping to get some full time experience in, but they said during the summer they don't have the staff to administer CS Internships. We don't even really have any plan setup with any companies, all we're told is that there is an internship program, but 9 out of 10 times you have to go find the internship yourself, they don't provide much guidance... I wish more schools had a focused internship/coop program in place, since the experience is one of the most important aspects of CS. I particularly like the way our CS program is planned out otherwise, they start you off with basic C++, then you move on to Assembly Programming (MIPS) and Data Structures (C++), then you get to go on to classes such as Advanced C (low-level UNIX system programming), and similar classes. Most of the time they've not focused on the language as much as the principals. They stress subjects as different data structures (lists, linked lists, etc), object orientation, stacks, etc. Fundamentals should come first. If you learn fundamentals, you should be able to adapt to almost any language.
Hey! An IC student. I've just got an offer to do the MSc computing conversion course at IC (just about to finish Chemical Engineering) this year, and I'm torn between a chem eng phd (which means earning some money at least) and doing the computing course (which means big loans). Am I likely to learn all that much in DOC that I could apply to a real world job, and couldn't teach myself while doing a phd (which will involve much C++ coding anyway)?
I a attend a fairly well know school, and the first thing we do, is get taught OO in Java. The emphasis is basically on OO first, and Java second. We are taught that EVERYTHING is an object. Really basic programs are broken up into many classes. They actually get upset if any given method has more then a few lines of code (with a few exceptions), they want everything to be done in small blocks. We spend most of our class time learning theory and good programming concepts, then its basically up to the student to learn how to code these functions. Granted there is lots of support on the course websites and many TA's. Most projects for first year classes are provided with large support code. They show us what they want done and we have to fill in the pieces.
Year two starts with a basic computer engineering course. Teaching how computers work. This really works nicely to teach students how everything works, and gives a greater understanding to what they are doing. So when you get to C++, and someone says that '#' are for pre-compiler commands, you know what they are talking about. When someone says linker, you REALLY get it. Also in year two is introduction to C++.
Then in the next two years, you start taking all of the system, os, ai, etc. classes. Years 1&2 are the basics, 3 and 4 you start doing stuff.
They can better understand the science
They can better preform a funcion in the computer world by having appyable skills.
"Umk. So maybe it was a stupid plan after all." -God to his angels, just after creating the universe
Agreed.
"Umk. So maybe it was a stupid plan after all." -God to his angels, just after creating the universe
most CS courses seem to have a Unix bias. Now I am all in favor of unix (especially the free varieties), but I have to wonder if Unix is relavent for the vast majority of CS students who will end up writing applets or PHP or perl to run on W2K servers.
I disagree with this. Students should be taught basic skills that can be applied to any new situation or language. Trying to only teach what is "relevant" is a mistake, because it presumes that we know what will be useful in the future. Martin Vermeer has written a number of convincing reasons why everyone, not just CS majors, should learn unix. He says:
The basics to be taught -- presumably on the secondary school level -- would include: using vi (probably the only modal editor anybody will ever see!), using the command line, file system directory structure, mounting, finding and understanding configuration files, writing simple programs (such as "hello world") in C, shell or perl, regular expressions, basic networking (ping, traceroute etc), ftp, email, usenet, mark-up languages, overview of the way standards are created, e.g., in the Internet Engineering Task Force, and other essentials.
You may notice that these are precisely the "tough" things you will never learn by just clicking around, but which kids will pick up almost in play if made to -- after all, this is nothing but language learning. Few people would ever learn Spanish or Russian if not in school! And some of these skills will be immediately useful, like "regular expressions", that will immediately give a better basic understanding of how to effectively use search engines on the World Wide Web. Or mark-up languages such as HTML/XML, offering a glimpse of a better world in which documents can be freely transferred, without risk of illegibility, to someone using an ever-so slightly different system -- or even to yourself, after a system upgrade.
One argument must immediately be put to sleep: that because Windows is the dominant operating system in the world today, one should teach that and not some esoteric alternative. The answer to this is plain and simple. The task of education is to instill generalist abilities and not the skill of "operating" one product. Someone who has acquired the skill of reading books will easily absorb also comic strips, but the reverse is not true... similarly, someone versed in Unix will feel right at home in many other environments including Windows. And for children, learning Unix is not that hard, as experience has shown, due perhaps to its internal consistency and logic.
"Weapons should be hardy rather than decorative" - Miyamoto Musashi
I think that goes for OS's too
I agree with your idea of focusing on the fundamentals instead of new, trendy languages, but I think it should go even one step further; we need to focus on using the fundamentals *correctly*. The vast majority of security problems are due to easily avoidable mistakes that fall into catagories that have been familiar for years. Lyons was talking about race conditions back in 1983, and we still see them. I attended a security conference last year where the speaker said he had sat in on several differen't Boston school's introductory programming classes, and they all taught students to use insecure techniques when they code. His recommended solution was to start a "visiting professor" program where people with real world security experience would come to a school for a few months teach beginning coders how to do things safely
"Weapons should be hardy rather than decorative" - Miyamoto Musashi
I think that goes for OS's too
I always missed (as an undergrad, IC London) and still can't see (now postgrad, Bristol) a course on how to program i.e. general, language independant principles such as coding standards, defensive coding, code reviews and such, as well as principles for when to create branches in development trees, multiple version management, automated testing and builds. You get the idea...
The science in Computer Science is the math and theory. CS is fundamentally and mathematical discipline, it is not about coding in C or Java. These practical languages are taught so one can demonstrate the theory and help to get a job. CS in proving that SAT is NP-Complete or that the Halting problem is an incomputable function not that "static private void" is a particular type of function declaration.
I'm from Europe. At my High School there was taught Pascal, Assembler and JavaScript. Pascal was used to teach classic imperative Programming as well as OOP. Later we switched from Turbo-Pascal to Delphi. The introductory CS-lectures at my university taught the Lisp-dialect Scheme which is great for learning functional and imperative programming as well as OOP and other advanced concepts like "higher order programming" and building interpreters. We used Scheme to program an assembler simulator and used this assembler to implement Scheme. I don't think C++ or Java are the best choices for beginners because with these languages you tent to think less in concepts but more language-specific. It's easier to switch from Scheme to C++ than the other way round.
I am an Information Systems major at Drexel Uni. One of the major flaws of Drexel's CS program are what FKell said earlier, about OOP, but also the lack of Human Computer Interaction classes. They should make an HCI class required for CS majors that teaches the importance of the people who actually use the software we create.
Is this a good idea or am I looking for something here that I'll learn in the industry? I've been told on a few occassions that it's alright if your college is extremely generalized, since once you're out in the industry, you learn these types of things based on where you want to guide your career. Is this a believable statement?
Why bother.
I think your post is a troll or you're going to a community college. If you feel that MCSE classes tought more than that in "CS" I can only feel very sorry for you, and you are very clueless. Go search the CS under course pages for the lectures notes and exams at MIT or Berkeley and then come back and tell us what you think. CS study has ZERO to do with Unix or PHP. Would you equate a laborer who uses a hammer with an architect?
The thing is, in physics, no matter how many equations you use, ultimately, it's the physical world that decides if you are right: either particle X acts as you predict, or it does not. This empirical foundation is what makes science scientific.
Math and Computer Science need not touch the physical world at all -- computer scientists can (and do) prove the correctness of algorithms that can only run on non-existant quantum computers.
The problem in question is that your instructor(s) had no idea how OO should be taught. Even if one can program in an OO style, an instructor used to teaching old-school structured or modular style often results in a machine that makes broken students.
It's nigh-impossible to express "the right way" in a /. comment, but I'll point out that Brown University (formerly using OO Pascal/Delphi, now Java) and Virginia Tech have excellent programs that do OO from the first day. They aren't the only programs that do it right, either. It's a matter of OO requiring a very different teaching style. Brown's old book (Object-Oriented Programming in Pascal, A Graphical Approach, by Conner, van Dam, and Niguidula) didn't hit control structures until chapter 10 or so. Earlier chapters dealt with OO conceptual fundamentals, including non-programming modelling exercises (think in objects), object instantiation, method invocation, composition, and inheritance. Sounds rough? Nope, it's natural as water in the way and order they teach it.
While there are many cases where Calculus is not used, when working in Graphics and Sound, I've found that all that math comes in REAL handy. I know that math isn't something everyone finds second-nature, but it's really worth it, and I wish I had done better in some of my calc classes, looking back.
:-)
If you never expect to write your own graphics or sound library, it may not be as useful
As a simple example, vector calculus is quite useful in 3D graphics programming
So here's my question: What is the relative size of these two groups? Are they roughly the same? Or is the second group (the one that
generally has trouble with pointers) larger?
The latter is larger, but for a different reason. It was only a couple semesters after I took the class that they changed it. This is my 5th year in school, so most who took it with me or before me already graduated, while there are 3 1/2 years of students who took the less intense version.
now-a-days rarely-used aspects of programming
What, are you suggesting that pointers are a rarely used aspect of programming? Pshaw.
But, in my day-to-day work, I almost never find myself needing that ability.
Well, I spend most of my time in Verilog these days myself (which isn't a programming language, but looks like one from a distance). But when I need to simulate something fast, I write it in C.
The enemies of Democracy are
I think the first thing you should teach students is assembly for a simple RISC instruction like MIPS. Why? Because it teaches you what all programming languages are fundamentaly made up of -- the things the underlying hardware can do.
When I took it, our introductory computer engineering course taught assembly, followed by a little C. Later, they changed it to just C, and also changed the 2nd course from C to C++.
Here's what I noticed (in general) regarding the two groups:
Those who took the class with me are as a whole not afraid of pointers. They understand the difference between a memory location and the contents of that memory. When they get to it, they have little trouble adapting to higher level languages, because they understand how those languages work.
Those who took it later are uncomfortable with pointers. They might not even know what one is-- even enough to explain pass by reference. They have a difficult time moving from C++ or Java to something lower-level, such as C.
The problem with teaching OOP is that then they only know OOP, and some would argue that OOP isn't even all it's cracked up to be. If you know assembly, you can code in anything.
In fact, at least in my case, I didn't truly understand C++ until I learned assembly. I did it in the wrong order, and it was hard.
The enemies of Democracy are
The main problem I had with CS at uni (in the UK btw) was that the courses they were teaching were not keeping up with current technology. This is unavoidable to a certain extent, since those teaching the course have to learn all this new stuff before they can teach the rest of us. I started in 94, and that was the first year they started teaching C++. They still didn't have a proper course on Java when I graduated in 98. Unless the uni is well funded and can afford to hire people with the appropriate knowledge, this is going to continue. As far as I can tell, there isn't a simple solution.
A good proportion of the knowledge I gathered during uni was gained from working on my own projects, hacking away til 4 in the morning on some new piece of code that interested me. Had I not gone to uni this would probably never have happened. The enivronment is as important to the learning process as what is actually officially taught in my opinion. As long as you want to learn that is.
There are reasons for this:
Granted, removing software engineering is probably not a good way to get students to come to the department...
Woz
Your point is a good one and has a lot of merit, as does another person who posted a similar thought. I must admit, I do not disagree with you. But I must point out what I (effectively) said at the end of my post: Computer science and Software engineering are not the same thing. Do not confuse the two.
CS is the study of algorithms. SE is the study of systems. Taking an algorithm and translating it into a procedure is more natural in C, but making good use of it is more natural in C++/Java, especially once the notion of OO has been shown to you.
Imagine CS and SE as sets (yes, I see the irony here). CS intersect SE is non-empty, but CS minus SE (and vice versa) is also non-empty. In other words there are parts they do not share.
Any one in SE needs the basic skills of CS. They need to understand data structures, algorithms and basic logic. After that, things diverge. For example, I'm in my last term and for all my courses this term, I have not written a line of code for a course. Yes - I am in computer science! But my courses are theory - what can computation do? how does this algorithm work? etc. I don't care at all about objects, methods or obfuscation. It's not even applicable. In fact, I don't even see how it would help you understand it any easier. Now, if I went to implement something to do with this that was not simple, I would turn to an OO type of design to organize the structure of my solution. This is the crucial difference.
What you describe about teaching is perfect for a SE directed program. In fact, I'd argue with you that it's what it should be.
Woz
There is an old joke about C being portable assembly. This is what I was referring to.
Woz
Instead, university CS programs should start at the beginning. Teach assembly language. Use assembly language for everything, at least for the first two years.
As C is portable assembly, it counts for what you are asking for.
Woz
True, but when everyone is having trouble, it's a good sign they're getting bad advice or not trying very hard. And of course, after they do poorly, they blame the prof, department, etc.
Woz
Somebody has written a Win32 MMIX emulator, complete with source code. If anybody's looking for a project, porting this to Linux/Unix is probably a good one . . .
Any sufficiently advanced technology is indistinguishable from a rigged demo
--Andy Finkel (J. Klass?)
I hear your same complaints from a friend who is a history professor at a major midwestern land-grant university. He says 90% of his students are "knuckle-walking droolers who can barely string four words together".
And this is the problem with achievment of any kind everywhere. Most people are more interested in eating, fucking and getting wasted. Anything that involves work, thought or some kind of introspection is clearly out the window.
I see the same thing at work, and saw the same thing at University and in high school. People just aren't interested.
--
--
Mod up a post Rob doesn't like and you'll never mod again
Ug... We learned Pascal and Fortran77...
Neither of those two got me anywhere. I expect things have changed, but it's still relative.
To make your CS course worthwhile and strictly usable in your future career you should actively seek sponsorship in a software company and take a split year working for that company during your course.
CS courses could be better by ensuring that the University administration actively assists students to find sponsorship and provide options for taking a year out during the course.
Just my petty thoughts...
Should the scientist be able to build up a prototype circuit or something? Sure. But Engineering isn't about just that; it's about procedure and foolproof methods. Your scientist doesn't build the production line; an engineer does. A scientist can tell you what kind of load-bearing materials and shape to make a bridge, but engineers actually build it... because they deal with the actual physical realities.
Of course there is overlap. Just as a technician with no degree can do soldering as well as a highly degreed engineer does not make him an engineer.
One thing I've noticed is that many universities, CS actually stands for 'Computing Science', so its' the science of computing, not of Computers.
Building a faster computer is engineering, finding a faster way to factor prime numbers is CS. Finding out new methods of sorting megateragigabit datbases is CS. Building a faster computer is engineering.
Physics IS a branch of applied math.
And he's right. Traditionally, the science of computing is all about math (and still is).
The problem nowadays is many people are assuming that CS is about Internet, programming, and computer hardware. It's not.
"Computer Science* is the study of data structures and algorithims, which is *DEFINATLEY* a science
No, it is not. Science is the study of natural phenomena, and the use of the scientific method to develop predictive models that describe the behaviour of that phenomena. The study of algorithms is a branch of mathematics.
And as far as being having to understand programming before understanding algorithms, well I feel sorry for your professors. Algorithms were invented 1000 years before computers. The word algorithm is a corruption of the name of the author of the first book on modern algebra, written in the year 830 by Mohammed ibn-Musa al-Khowarizmi.
MOVE 'ZIG'.
According to this definition, physics, biology, math, and computer science are all sciences.
1. Please explain to me what "observation, identification, description and experimental investigation" has to do with computer science?
2. Natural phenomena. 'Nuff said.
3. Such activities applied to an object of study.
Bzzzt. None of these apply to the activities described as computer science.
Mathematics is an extremely important part of the application of the scientific method, however that does NOT make it a science per se. It is merely one of the tools (the most important) used in the pursuit of science.
On a deeper philisophical level there have been attempts to classify mathematics as a science by asserting by induction that the structures of mathematics (sets, numbers etc.) are real objects through holistic continuity with the real objects of science. However this approach fails when you investigate it further, for the application of maathematics to science is always in an idealized sense, for example in the study of the fluid mechanics of waves you do not treat the individual atoms of water in a mathematical fashion, you make an assumption that you have a continuum of fluid, and you do not take into account the depth of the liquid, you merely assume it is infinitely deep. Therefore there is no essential holistic continuity between the objects of the study and mathematical structures used to build models of their behaviour. These objects are fundamental abstractions.
Q.E.D.
MOVE 'ZIG'.
What your definition of 'CS' is?
This first thing is to change that name. Computer Science is an oxymoron. The only science involved with computers is in the making of them. Solid state physics etc.
CS as it is today should be taught as a branch of applied mathematics, which it really is.
MOVE 'ZIG'.
Because if they're round, no matter how the manhole cover falls onto the opening, it won't fall through and hurt the person standing underneath.
While this is the conventional answer, it is an incorrect answer. It is quite possible to make a manhole cover of ANY shape that will not fall into a manhole if the manhole diameter is smaller than the smallest axis of the cover.
The reason that manhole covers are round is because this shape gives them the maximum minor axis size for a given amount of material, i.e. it is the optimal shape from an economic point of view.
MOVE 'ZIG'.
Mathematics is not a branch of science
My premise.
Some would say that math IS physics.
They would be wrong. The study of physics implies the study of some natural phenomena. The study of mathematics does not. Physics does use mathematics intensively in such study, so much so that advances in math are often required to solve physics problems. But it is not true that advances in math always lead to advances in Physics, or that advances in Phyics are always built on advances in math.
Science is not the explanation of natural phonomenae. It is the pursuit of knowledge.
Far too encompassing. Memorizing a poem is not science but is a pursuit of knowledge.
What's over the horizon, why is the sky blue.
the question 'why is the sky blue' is the study of natural phenomena. What is over the horizon may involve sailing around in a boat. Nobody ever called Magellan a scientist.
You are confusing science with philosophy. They are NOT the same thing.
MOVE 'ZIG'.
What happens is at a great school, you have a strong student body. This lets the faculty run the program at a high level (teach fast, advanced content, etc.). This attracts even stronger students, forming a positive feedback loop.
At a not so great school, the students are relatively weak. This forces the faculty to teach slowly, remedial content, etc. Students may also be looking for that "quick fix carreer change", which means teaching technology (Java, JDBC, VB) instead of fundamental concepts (algorithms, data structures, abstraction). This in turn attracts more of the weaker students, forming a negative feedback loop.
So if you're hot stuff, go to a hot school. When the assignments are hard, don't be surprised. If you're more into a slack lifestyle, go to a lesser school.
Of course, teaching quality does vary. But contrary to what some other posters have said, teaching quality is not the inverse of research quality. Some research-oriented faculty are too busy to spend time on their students, while others are also truly great teachers. At small colleges, some faculty are there because they truly love to teach and are great at it, and some are there because they are lamers and a Moo U appointment is the best faculty job they could get. But my basic observation is that these variations are minor compared to the student body feedback effect.
----
Crispin Cowan, Ph.D
Research Scientist, WireX Communications, Inc.
Immunix: Security Hardened Linux Distribution
----
Research Assistant Professor of Computer Science
Oregon Graduate Institute
The thing is, most universities follow a standard curriculum set out the by the ACM.
There are a few versions of this, the most recent completed was Computing Curricula 1991. There is another version in-progress, Computing Curricula 2001. I seem to remember being told that most schools are actually somewhere in between the 1991 curriculum and the previous recommendation, which doesn't seem to be online.
So, the bottom line is that our beef may be with the ACM. This question is well-timed, since the new curriculum is still in development. There are several discussion groups open to the public on the new curriculum proposals.
Greg
Did you learn to drive a car by first studying how a combustible engine works?
This is the kind of argument people seem to be making when they say that Scheme is not a good first language.
But even if you think CS graduates must start by learning concepts like poiinters and memory details, again I'd say Scheme is a good first choice. Just think of the Box-and-Pointer representation of cons-cells in Scheme. You have a very simple view of pointers as well as memory usage (by building or destroying lists). Why not start with a simpler view of pointers and machine memory before you move onto the wild land of C-style pointers and memory segmentation?
Scheme is an OO language as far as I'm concerned - I know it's a functional language but functional vs. procedural is a differnet axis than OO and non OO (whgich are more styles in my mind). In what way do you not consider it OO? Scheme lends itself quite well to OO programming, much moreso than C (which you can use some OO concepts in but it does not lend itself to it).
As for "Pseduo-code is how we describe algorithms". Why? Pseudo-code came from a sort of abstract representation of many langauges like C and Pascal, in order to create readable code that was free of language specific constructs just there for housekeeping (like memory management or strong typing). As languages advance do you not see room for describing algoritms in some other way? Must we always be trapped in psuedo-code, forcing this mind-numbing and ancient way of describing algorithms to students? It has its place but there are always ways to improve communication and thus understanding!
Consider "Scheme and the art of programming". Though it speaks of sorting, queues, and other things we can (and do) demonstrate with pseudo-code, it does not once use pseudo-code. It would be near meaningless in scheme to do so - as I said, that is a bad mapping.
What it does do is use the actual code for a queue is scheme in order to talk about queues, as well as demonstrating Box-and-Pointer diagrams for the same.
Similarily when speaking of sorting, it uses actual code instead of pseudo-code and then shows examples ot the code in action and various states of lists to demonstrate efficency and operation of various sorting algorithms.
Part of the power I see in using Scheme as a teaching tool is that the language is truly simple enough to work with that you can make ideas readable enough to understand instead of having to distill them into pseudo-code. You can work with actual code as a base and then expand on that to learn with, much more powerful than focing someone to convert cryptic pseudo-code into whatever language you are using at the moment and then claiming they understand what the pseudo-code really meant. All you have done is sucessfully created a ((psuedo-code)) to ((Language)) robot that does translation for you.
As far as being a "Toy", Scheme is certainly not going to ever be used widley as a practical language. But I have found many of the concepts I learned working in scheme serve me quite well now working in Java, and before that in C++.
I also wonder why we should let loose programmers into the world that may understand (partially) about memory management but have no idea why they might use a linked-list as the basis for a queue rather than an array or know what a hashtable is. I'd frankly much rather they understand fundamentially the cost of various common patterns than they fully understand what is happening at the machine level. Understanding of mechanics is so much less important than understand of the architecture of systems and sub-systems that I really fear what will happen if we keep on churning out people who understand how to build a bridge but not how to build one to last or be stable under load.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
I don't think the problem there is with teaching OO first - I personally think you should be tought both and it's going to be difficult moving from a procedural language like C to an object oriented language like Scheme or Java, no matter which direction you go.
I think you pointed out the reason yourself why things were not flowing well. Why on earth would you use pseudo-code AT ALL in an OO course? Why wouldn't you use UML diagrams (or somthing like them) to illistrate sets of objects and how they'd work together, or better yet, patterns?
You can't just switch a class to different language, you have to have the class change to reflect the way you would naturally work in the language to be used. You can bet that in the Scheme classes I took they way to approach problems looked a lot different than my C++ classes!
I also agree that Java is not the best language to start with though - I really still think the best route is to learn Scheme and then work outward from there. Scheme really lets you worry mostly about the problem, and not so much about the IDE. I also think it teaches useful ways to approach problems. The interactive nature of it also is easier to work with while you're learning.
Incidentally, your argument points out why I think C++ is really the worst language of all to start with - not only do you have C issues to deal with, but also OO concepts as well. That is too much for any beginner to deal with... I think the path from an OO language like scheme to C++ might be manageable to start to learn the details about what the language is really doing.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
I went to one of those heavily research-oriented schools, and while lectures were quite large (class sizes of like 150-200 people for upper division CS classes), a lot of people still learned a lot. Part of it comes down to your personal style. Are you willing to seek out the professors and ask them questions and talk to them during office hours? While a class of 200 people means that of necessity the professor did NOT go out of his way to get to know any individual person, if you made an effort to speak to them, they definitely remembered you and would have conversations about the work. So in that respect, it's one of those things where if you decided to make the extra effort to get to know your professor, you'd get some of that same one-on-one interaction.
It's MUCH easier to hide in the crowd at a big, research-oriented university. It's much easier to never make the extra effort to get to know your classmates, or your professors. And for some people, that's great because they WANT to blend in. But at least at my school, those who made the extra effort were always rewarded for it.
But there was one advantage which I couldn't have gotten at a smaller program which didn't have a research focus, which was the chance to do research itself. I did a year of research in one of the research groups as an undergraduate, and was a full participating member of the projects I worked on. Having that opportunity (as well as the opportunity to take graduate classes as an undergraduate) was huge for me, and probably was the most defining part of my undergraduate education. If I had been at a school with less of a research focus, it never would have been made available to me. Quite a few of my friends did the same thing. Again, you have to go out of your way to do it, but almost all the professors had extra research grant money to spend on undergraduate research (the NSF does lots of HUGE grants JUST for this).
I'm not saying that this style is for everyone, but being at a research-oriented school doesn't preclude you from having individual one-on-one education, as long as you've got the sort of personality where you'll go out of your way to get that kind of attention.
Because if they're round, no matter how the manhole cover falls onto the opening, it won't fall through and hurt the person standing underneath. If there's any points, that implies a cross section bigger than another cross section, so the cover could fall through and hurt/kill somebody underneath if it came down wrong.
The more things change...
Back in '83-'84, this debate was going on at UC Santa Cruz... The students formed "CISSA" (the CIS Student's Assn.) to influence the department. CISSA wanted more applications oriented teaching. The department wanted theory.
The department was correct, of course, but I think we actually struck a happy medium... We got a few application oriented electives, but the core remained theoretical.
The big classes were Algorithms/Data Structures, Language series (Parsing/Semantics/Compiler Design), OS Theory (not a specific OS, either!), and Digital Logic. A good base, for the upper division theoretical courses and for Real LifeTM.
General Relativity: Space-time tells matter where to go; Matter tells space-time what shape to be.
I am in 4th semester of a Comp Technology course in Ontario. It teaches 1/2 network admin/ 1/2 programming, with a little web design thrown into the mix.
From my experience the best classes I've had have been with teachers that know what they are talking about, have decent teaching skills, and WANT to be there! Teachers don't have to be great at being professors, but a good attitude, and making the classroom more of a fun collaborative place, and not a "sit striagght and listen to me drone for 2 hrs". The best classes I've had are ones where the class contributes to an example program. This was after the theory was presented, and a practical example was being given.
Don't base all your marks on tests!. IMHO grades should be more about skill, and less about fact regurgitation. I can code circles around most of my classmates, but I don't do as well on tests because I forget the minute details sometimes (is it focus() or setFocus()? etc). But since test/quizes are often 80% of the final grade, my marks suffer.
Access to hardware is vitally important. I am in a laptop program, where every student is required to have a laptop, and the contstant access to my development platform is a godsend. Nothing like being able to code up a project on a bus, at home, on 'family trips' etc. This makes learning programming a lot easier. Conversely, the networking && comp repair labs are only accessible 2 hrs a week, and the difference in practical working knowledge among my classmates between the programming and networking sides of the course are remarkable, with programming coming out on top.
Thats my long-winded 0.02c
Dave
DOS is dead, and no one cares...
DOS is dead, and no one cares...
If there's a Bourne Shell, I'll see you there
Should graduates be able to program? That's not clear (to me), but they certainly should be able to design computer algorithms to solve problems. Once you can do that, actually writing the code is generally not difficult. The next difficult step is, of course, testing and debugging the code written. However, the theory involved in there is very limited, as it's more engineering than computer science. Style (readability and maintainablility) are similar in flavor. I'm much more concern that people graduate without knowing Dijkstra's algorithm or being to do dynamic programming rather than actually being able to program either.
If we want people who can program, we need to introduce a course of study to teach them to program. Please don't call it computer science.
My bad
-no broken link
Just because they don't come to discuss the material doesn't mean they aren't discussing it. I never once went to a TA, because I had my own group of friends to discuss the class concepts with.
-no broken link
But since I didn't take the asm first route I'll never know. I learned asm after learning BASIC and C and while learning C++.
-no broken link
Knowing C is not the same as knowing assembly. Before I knew assembly, I had little idea as to how the stack was used in a function call, but I constantly used function calls in C.
-no broken link
Computer Science is a science, it is *not* a natural science. Yes, there is a difference.
Second of all, your statement about algorithims while correct, completley missed the mark. You need a language to describe algorithims in regardless wether its 2000ad or 830 bc. In computer science this language is almost always C/C++ or pseudo code ...
And sure Mohammed ibn-Musa al-Khowarizmi might have come up with some algorithims 2800 years ago, but guess what? Most modern algorithims are designed with rates of millions of operations per second in mind ... If you don't believe me try decoding an mp3 by hand, thus the necessity of computers.
Free Techno/Jazz/DNB/MI Music by guys obsessed with monkeys!
Data Structures, Algorithims, Automata, Langauge Theroy, Performance Evaluation, and compiler construction, which are the meats of computer science ...
However before you can understand any of these advanced topics you need a good base in a few programming languages -- which is where I expect some universities get caught up.
Free Techno/Jazz/DNB/MI Music by guys obsessed with monkeys!
I'm about to graduate from a 4-year program at CMU, and then go on to grad school.
Here's what I'd change:
- Emphasize teaching and TAing; heavily encourage students to TA, and provide training and resources for them and their professors. Since the numbers don't really work if every student is TAing, organize some classes so that they are like teaching (presentations and such). I definitely learned more from TAing 6 (jeez) classes than I did taking them.
- A mentorship/advisor program for senior year, similar to how it is typically done in graduate school.
- De-emphasize low-level programming for beginners. In computer science theory we only worry about algorithmic efficiency, and in industry computers are getting so fast that programmer productivity and the quality of a product matters more than its runtime speed. Of course, systems programming classes are vital to a well-rounded CS program, just that you shouldn't make beginners have to deal with bus errors and core dumps.
- Objects are not everything! I would have loved a course which gave us design problems and asked us to approach them in lots of different ways (objects being one of those, but not the only one).
- "Tracks" for students who want to be industry programmers vs. theory heads vs. etc.
CS != Programming. Thus universities should not be teaching the "latest and greatest" programming languages (java, perl, PHP, etc.).
Instead, university CS programs should start at the beginning. Teach assembly language. Use assembly language for everything, at least for the first two years.
Why? Because in order to understand the tradeoffs involved in, say, using a hash table instead of a linked list, you have to implement them. If you have a high level language which provides hash tables for you, you'll go away with a biassed view of data structures, because you won't understand that the complexity of hash tables is usually undesirable.
Only once students have a firm grounding in the basic concepts of data structures and algorithms should they be introduced to high level languages.
Tarsnap: Online backups for the truly paranoid
The idea is surprisingly easy to pitch to companies, as it makes good business sense. Basically you say to whoever is in charge of Hiring, "Hey, here's my resume. Everything on here is something you can have me do for 1/3 the cost of having a salaried engineer do instead. I require little handholding, learn quickly, play well with others, etc. Plus once I graduate you'll have someone you already know and trust ready to come on full-time. Whaddya say?"
Do this 10 or 15 times and you're sure to get a couple bites. Be persistant! Even moreso that in a normal job market, you are really becoming a salesman whose product is himself (and a very marketable idea).
so good luck, and feel free to email me if you need any help.
p.s. fundamentals first is the way to go. trade school is for weenies ;-)
Karma: Bored. (Thinking about resurrecting the "Anyone else is an imposter" joke.)
- Once you learn X, other people seem dumber when they talk about X. It is much easier to see other people's flawed thinking when you know more about the subject.
- As a graduate student, the classes you took most recently have much more intelligent students than the ones you are teaching. This is true at any level. To a 9th grader, a 5th grader's attempt at solving an algebra problem will look naive and stupid. As a teacher, you must learn to step in other people's shoes. Remember that you did not obtain the knowledge you have overnight.
- As a good student, you probably hung out with other good students. When you are forced to interact with the class en'masse, you have to see the good and bad students.
- Going with the parent poster's point. You probably never got too much info about how good other people's work was in classes you were taking. If you got too much detail, after all, it would be cheating. Without having this information, you probably assumed that you were of average ability. Of course, you were not.
Cheers,Brandon.
Actually, I suspect it has more to do with how manholes and covers were made around 1900. Around then, the available machine tools were drills, planers, and lathes. Metal objects were made by casting a rough shape, then finish-machining. You could make any rough shape, but finished surfaces either had to be round (drilled or turned) or flat outside surfaces (planed). Flat inside surfaces, like a square hole, were very tough to make. If you look at a turn-of-the-century steam locomotive, you'll see this clearly; all finished surfaces on large parts are either outside flats or rounds.
Microsoft used to ask this question in employment interviews, which is why it's well-known.
I don't much like COBOL. It's way too wordy. It's my job though and it pays for me to play with better stuff (and the rest of my life too). I agree with you that a C/C++ programmer would have an easier job learning COBOL than I would (although they'd probably go insane first), but it doesn't make me any less of a programmer. The reason I haven't bothered to learn C yet is that it's a bit obscure and requires me to allocate my own memory and mess around with pointers which, although more efficient, is a pain in the backside. High level languages for me are supposed to allow the programmer to write code without having to worry about allocating and freeing space and cleaning up after myself. The system I'm working on at the moment is a shambles and would be a lot worse in C/C++ due to having to do more low-level stuff. :)
Finally I'd like to apologise if I was a bit ranty, but you seemed to be saying that only C/C++ programmers were the only ones who truly knew how to program. And salary is probably the worst indicator of someone's ability. I've worked with people on way more than me who should have been wearing bright orange wigs, baggy trousers and big floppy shoes
The correct title of the series is The Art of Computer Programming, although Volume I is named Fundamental Algorithms. You can read the details about it, and other forthcoming volumes, on this part of Knuth's home page.
As for MIX, the new editions will continue to use something similar to it, an assembly language for a machine called MMIX. Knuth explains why he continues to use a low-level language on his home page also. There are several reasons, and I can't do justice to them by trying to summarizing them here.
Funny side note: MMIX will have an operating system, NNIX. But the system is open, so
Knuth's way with bad puns is one of his endearing qualities....
--
sorry, there're more, but I've got to head out the door. These things have been part of the MIT freshman CS curriculum for upwards of 25 years, and they'll be lessons you never forget.
You could try Craig Larman's "Applying UML and Patterns." I'll be using it to teach a third-year O-O development course, and the book has gotten generally good feedback from people.
There are advantadges to knowing the older stye linear programming, compared to the more modern object oriented. Just to be perfectly clear in advance: I think people should know both.
Part of the magic of object oriented stuff is that you do not have to get into the lower levels to tweak with things. But, lack of expertise in this regard leads to bloat, lack of efficiency, and another programming layer where flaws can crop up.
an extreme example of the opposite practice are the products at Gibson Research Corp.. [Disclaimer: I am not an employee, and have never been associated with him or his company, aside from just being damn happy with his products] Steve Gibson programs all of his stuff in assembly language. They are damn tight, damn fast, and damn small. If windows were programmed this way, it probably wouldn't be quite so horrid.
Point being, each programming approach brings with it certain strengths, and certain weaknesses. Being able to undercut the weaknesses with bits of magic from a lower level elements makes life easier.
For example, the vast majority of books on things like javascript all cover the basics, but almost everyone each leaves out one or two critical elements needed to get the big picture. Never mind various differences (when you want to do something fancy) and you want to have an integrated page serving all browsers. Never mind that every time your turn around you have another point version of the language to catch up on, and sort out regarding the various levels of compatibility (even though people are trying to push standards).
This last bit becomes the bouncing ball of marketing. Use this language, use that, with this additional layer of muck on it. But is this even an inprovement? And do we want to be teching this in college, etc. without teaching the underlying fundamentals really well?
"It is a greater offense to steal men's labor, than their clothes"
The correct title of the series is The Art of Computer Programming, although Volume I is named Fundamental Algorithms.
Yup. Serves me right for relying on my memory for something I read over 20 years ago! :/
Thanks, too, for the links! Especially for his explanation of why he chose machine language then, and now.
The single biggest impediment to following his examples was that I could not try them out directly. I learn best by DOING. Trying to follow what was provided is one thing. But I seem to learn far more when I can readily experiment and SEE what happens when I try changing different things. I sure hope someone DOES implement an MMIX / NNIX system. Heck, just an emulator that ran on Linux would be a big step in the right direction!
Okay, it's a tactics guide to Counter-Strike, but it's a pretty good one. It discusses strategy in Counter-Strike (yes, there is strategy in Counter-Strike, because CS isn't deathmatch, just like GNU isn't UNIX and LAME isn't an MP3 encoder). Tactics for individual maps, as well as general strategies for each type of map, are discussed in depth. I'd recommend going there if you play CS, or want to castigate the lamers on your CS server.
"Ancillary does not mean you get to rule the world." --U.S. Circuit Judge Harry Edwards, speaking to the FCC's lawyer
In reference to your position that Calc is not needed, where are you coming from?????
W/o calc, discrete math, linear algebra, and basic algebra, how do you purpose to write code with any sort of tolerable time complexity? These higher math courses give you a HUGE set of POWERFUL tools to talk about and manipulate elements in your field.
Already in my undergraduate career I have found uses for vector analysis and Calculus that, with out, I would have some ungly code doing needless calculations on the fly! Specifically calculus helps you reduce complex computations into easy smaller forms!
I can understand that position of some that the math requirements are annoying, but they are VERY worth it if we pupose to educate Computer Scientists and not a bunch of very savy computer users.
Sam
Sam
The problem is, when people learn about objects from the start, some of them actually tend to think too literally. Often times, they will believe that each object is like an independent little program, not that it's just a data structure with some functions for accessing it. These are things you have to learn about from the ground up, without chancing the misunderstandings you'll run into going the other direction.
I must also point out the disadvantage of using Java as a first language, particularly because issues like Memory Management are so completely buried. That's great if you believe your students are never going to have to use a lower-level language in their careers, but when and if they do, they're forced to learn concepts they should have known far earlier. Concepts upon which a much deeper understanding of computer architecture rests.
I feel that one of the best tactics used by the professor was to create a project assignment that lasted the entire semester. We would start out with by writing a basic application framework (say an online catalog) and extend or modify its modules (replacing the data storage mechanism for instance). Students who didn't abstract their code enough via implementing flexible interfaces would end up spending inordinate amounts of time rewriting their applications to accommodate the requirements of each new project unit.
The project forced us to live with a body of code for an extended period of time and made us realize that shortcuts or sloppy coding practices would eventually hurt us. We were all forced to think about our code as an evolving work that we would be reusing and extending. For those who embraced the idea (and in doing so succeeded) it was great training for becoming professional programmers.
Now, after 10 years in the software industry, I've become a v.p. of software development and spend a lot of time reviewing candidates. I always ask the recent college graduates about the structure of their programming classes. The vast majority has only experienced one off assignments, where they write code, submit it for grading and never deal with it again. In many cases, it shows in the quality of their work. It takes a lot of time to retrain these folks so that they write code that not only solves the problem at hand, but is open and clean enough so that it can adapt (or be adapted) to the ever changing requirements of our customers.
yea i stole your sig- whats the big deal, it sucked anyway.
I am currently a TA for the 3rd year OS courses. Nobody, and I mean nobody comes to discuss the material until
This sort of thing only increases the apathy felt by both the students and profs towards each other. The reason for this can mostly be attributed to the mass influx of people taking CS over the last few years. Whenever a huge amount of people start taking something that is "in demand" in the world, you get many people who just want to coast through and get that piece of paper. They have no interest in learning - they just want the degree to go make some money.
Woz
I find this is a great way to learn. There's so much more to CS than what comes from a book or a tenured academic. It also can expose you to fields you never thought about before; for example, I took a coop that wound me up writing code for the huge servers that control your cable TV.
Being at a school where everyone is supposed to be doing the coop program makes it easy because the classes are scheduled around different majors' coop cycles and you don't have to wrry about your course sequences getting messed up because you were out working when the one class you needed was being offered.
But since most universities haven't caught on to this, I would suggest going out and trying to get a summer internship.
There's simply no substitute for real life experience.
Now, as for the academic side, I would give students the opportunity to wrk at their own pace whenever possible. Let them test out of classes if they're learning fine on their own. My school starts students our with a term of HTML, javascript, and "computing fundamentals", which was a complete waste of time for me. But they forced EVERYONE to take it. Luckily the next term was intro to C++ and you had the option of placing out of it and into Data Structures. Yummy stacks, tasty queues, delicious doubly-linked lists!.
Karma: Bored. (Thinking about resurrecting the "Anyone else is an imposter" joke.)
It was all theory. I once embarassed the faculty by pointing out publicly that it was possible to graduate with an AI specialization without ever seeing an AI program run, let alone writing one. Programming instruction was basically "here's the manual". I took a comparative programming languages course, which covered everything from COBOL to Prolog. It didn't actually involve writing and running programs. I got a good grounding in formal methods, though.
I did most of my programming on a Xerox Alto, chosen because few wanted to learn Mesa and use the obsolete things, so they were always available. (The Alto is the original GUI machine from Xerox PARC. Page-sized monochrome screen, mouse, Ethernet, file servers, laser printers, all built with 1970s technology.) Most students used the time-shared DEC-20 machines, accessed through dumb terminals. PCs really hadn't made an impact yet. There were a few original Macs around (no hard drives yet), and they were fun, but curiosities.
At times it was wierd. Exam questions like "does a rock have intentions?" (The classic "Why are manhole covers round" was from the 1974 Stanford Comprehensive Examination on Computer Science). I took "Dr. John's Mystery Hour" (McCarthy's AI seminar), and had good arguments. Met all the big names in '80s AI. But there was an "emperor has no clothes" feeling about the whole thing, because expert systems just didn't do much, and the whole field was stuck.
About a year after I finished, Stanford put CS under the engineering department. The expert systems crowd was pushed off to the side, and the curriculum became much more practical.
The best aspects of my school's CS department had formerly been its focus on the fundamentals of CS ...
Agreed! The languages I learned were helpful, yes, but it's what I learned how to do in those languages that ended up being far more important for me.
Fundamental classes like "Data Structures", "Algorithms" (both the coding of them and being able to assess their performance), and "Assembly" gave me key insights into the CONCEPTS of what I could bring to bear on any given problem.
Macros, subroutines, functions, pointers, queues and stacks and lists, are a means to an end. My success in programming has depended not so much on what FACTS I'd learned (e.g. arcane language syntax) but on how I could organize my thoughts and conceive appropriate levels of abstractions of the problem space.
Slightly OT, but I just remembered Donald Knuth's series of books on the Fundamentals of Computer Programming. There were some truly great things in those books, but I was forever getting distracted by his "MIX" programming language. (And I was reading it well before I could even conceive of writing my own interpreter.) My hangup was that I couldn't type in a program and PLAY WITH IT, to see what it REALLY did. Would that he had written his code in C or some other mainstream language! Do any /.'ers know if Knuth (or anyone else) ever translated his examples into another programming language?
One are where I think CS schools are really short-changing students is testing and debugging. While there are quite a few schools who educate their students well in design, coding, algorithm analysis, and math, I've yet to even hear of a CS curriculum that prepares any student in the areas of testing and debugging.
This is a shame because as we all know, a large portion of any software engineer's time is spent testing and debugging code.
I'm not talking about teaching how to use the specific features of debugger XYZ. I'm talking about the basic sleuthing skills needed to track down defects in your software. How to use basic concepts such as breakpoints, single-stepping through code, data watches, etc. - things that are common to all debuggers. How to systematically use deduction to narrow down where the defect is ocurring. How to do unit testing, and why you should do it. General approaches for dealing with bugs in multithreaded/multiprocessed programs. Learning to write code that supports your debugging efforts and going beyond just using printf() for tracking down defects.
Most CS schools tend to just throw students to the wolves when it comes to testing and debugging - if they teach anything, they may teach how to use a specific debugger's interface. They usually just assume the students will learn various debugging techniques on their own. Some of them do. A lot of them don't.
The ones who don't learn a large array of debugging techniques, when to use them, and why the should be used enter the workforce unprepared. They end up learning on the job, which can cause a lot of stress for them and their employers.
This is pure speculation, but this may be a factor leading to the high number of defects in software programs today. A lot of ink-fresh-on-their-degrees CS students just don't know how to test and debug their software! While I don't think its the only factor, it's something that is rarely discussed.
-vince
I took undergraduate classes from CS departments at two different universities over a period of twelve years (1980-92). (I kept getting jobs and stuff, okay? :-) I've also hired and managed dozens of programmers since then.
First I'll address this question as a student, then as an employer.
Unviersity "A" had a much lower ranking, and did not emphasize research. University "B" was much larger, much better funded, and was rated in the top ten state university CS programs.
I think that undergraduate programs in research-intensive fields such as computer science suffer tremendously when the priority is on research and not on teaching. The poster talks about approachability: this is WHY YOU ARE AT A UNIVERSITY, is so you can interact 1:1 with people who have made studying CS their lives. Spending time with someone whose research is a notch less exciting is infinitely preferable to spending NO TIME with someone whose fascinating research you might as well have just read a book about.
No big surprise, I learned a lot more stuff, both useful and interesting, at University "A" than at University "B". It was also a much more satisfying experience.
I wish that I hadn't been such a slacker in High School, as I hear great things about some of the very, very top programs, that combine the best of both worlds.
So: hire faculty who actually want to teach undergraduates, who will spend 1:1 (or 1:N for small values of N) time with them, and who are good communicators.
As an employer, I really like the increased attention in a number of universities to group projects and methodology. Not that what they teach is necessarily any good (same for theory & algorithms) but because it at least provides some underpinnings and may persuade students that thinking about these things is important.
It's extremely helpful to someone I'm interviewing if, upon graduation, they can sit down and demo a significant piece of software that they worked on with a team.
So: make sure your CS graduates have at least some meaningful group-based project where they create something they can show peopple.
Granted, this is just one school, but I think it's something you'll find in most universities. My students just did NOT want to learn the material. They would skip class and not visit me during office hours, and then complain that they didn't get enough help for the projects (I'm serious!). None of them showed any natural aptitude or curiosity whatsoever.
I was one of those students who generally knew more than the teaching assistants, since I had already been programming for ten years by the time I was a freshman (I miss my TRS-80 :-)). But when it was my turn to teach, I was amazed at the laziness and ineptitude I saw. I know my classmates back in college were never this bad, so I can only assume one of two things:
- I'm a really, really bad teacher and somehow I convinced the students they'd be better off not doing any work.
- My students really were less competent.
Reason #2 makes a lot more sense to me.So before you go trying to improve the CS curriculum, take a look and see if your classmates are worth it. You might be better off finding a good professor and volunteering to work with him on projects.
--
And the men who hold high places must be the ones who start
To mold a new reality... closer to the heart
Someone else has mentioned it already, but I will reiterate: Java does not make a good language to start learning with in a Computer Science program.
I am less than a month away from finishing a four year Honours Computer Science program at the University of Western Ontario. When I started in 1997, we were taught Pascal for the first year course(s) and C for the second year, with C++, Java and others (including Scheme for a course) in third and fourth year, depending on the courses you took. After my first year, they switched to teaching Java off the bat and leaving C out of it (even for second year).
The first thing that profs noticed was how much more difficult it was to get students to understand basic algorithms and simple CompSci concepts (trees, linked lists, etc). The OO stuff just got in the way. Everyone was hung up on trying to figure out how to simple things because of the object stuff like members, function declaration, etc. was just confusing to wade through for students not familiar with the concepts. What ended up happening was profs had to start explaining OO in some minor way, which only confused them further.
Now, some of this can be attributed to growing pains associated with changing a program curriculum. However, I am also currently a teaching assistant (TA) for the third-year operating systems course and the caliber of student I am seeing from a programming perspective is quite lacklustre. The OS course is required, so there are a lot of people taking it and I get to mark about a third of the assignments handed in. I will tell you now that I am, generally, not impressed with what I see. The students are beating themselves up trying to grasp the concepts of C when coming from a world of Java (recall, these third-year students never had C) since Java hides so much from them.
What I'm getting at is that a good language to start with is not OO. Why? Because the concept of OO makes much more sense after you've been introduced to iterative/functional programming. The natural way to solve a problem is not with objects and obfuscation (i.e., good design), but to work out a solution and step through it a la iterative/functional programming. (more on this in a sec)
You want to avoid Java because it hides too much. Java is good after you have an understanding of what is happening in the machine. In fact, Java is a nice language after the fundamentals are known to you.
Now, about the above point of iterative/functional making more sense, naturally. Firstly, think about how you tend to solve problems: come up with an idea, walk through the steps to get it to work. Note that there is nothing about objects in there. A pseudo-code algorithm translates a lot easier to a C program than it does a Java program. Pseudo-code is what a lot of first/second year students see and it should not be a chore to implement it. Functional languages are natural for some (like me) and follow the principle of "when I'm done with this, I'll give it to you", which is also not too tough to grasp once introduced to it.
Bear in mind - I am not anti-OO. I just think it's a more advanced concept that should be saved for later. I design everything around the OO philosophy now in my programs (no matter what language). It is good. It is just not for students starting out.
What your definition of 'CS' is? I ask this in all seriousness. Computing science/Computer Science varies greatly. In some schools, the program is about programming and technical details, in others, it's more about algorithms and theory. One is about science, the other is more about engineering. Which is it you want?
Sysadmin/Web design/administrative programming or banging out simple apps is not computing science...
I can only describe the result as an unmitigated disaster. The best aspects of my school's CS department had formerly been its focus on the fundamentals of CS; lacking a huge, monied department, we were taught how things work rather than how the latest database software interfaced (and this had produced generations of very successful graduates.) This curriculum had evolved over a period of years; naturally, there were newer classes, and we weren't still coding in Fortran, but the curriculum had been tested and slowly improved over time. The spate of sudden 'improvements' wrought by these changes have irrevocably changed the nature of our department. Aside from the fact that we have a generation of majors who don't know what a pointer is, much more effort is expended teaching the latest software or OS, to the detriment of the fundamental cross-language, cross-OS education that I enjoyed. So the point of all of this is that sudden, untested changes in a CS cirriculum can cause as much harm as good.