Atomic Object’s blog on everything we find fascinating.

The Deep End of the Pool

After having taught introductory programming (CS 1) for the past six years, and having watched many students struggle through this course and the subsequent course (CS 2), I have come to the conclusion that it is absurd to expect students who don’t have any prior programming experience to be well prepared to study Computer Science after a single 15-week course (i.e., CS 1).

In particular, I believe that expecting a student to learn to program well enough to study Computer Science in a single 15-week course is almost as absurd as expecting a student with no instrumental musical experience to be ready to join the university orchestra after 15 weeks. There are, of course, musical prodigies that can handle this challenge. Likewise, there are many “natural born programmers” who learn how to program with very little apparent effort. However, these individuals are the exception, not the rule.

Why the 15-week expectation is absurd

Almost every college program of study sits firmly upon the standard high school college-prep curriculum. Some majors, such as Math, Chemistry, Physics, English, Literature, and Writing, follow almost directly from the high school curriculum: The college courses for these majors are the logical, direct successors to high school courses. Other majors, such as Psychology, History, Engineering, Accounting, and Business, are strongly based upon standard high school math, writing, and scientific reasoning skills.

Music is one of the few college programs that does not sit firmly on the standard high school curriculum. Nobody expects a student who has never played an instrument to be able to enter college and be ready to enter an instrumental music program within a year.

Although programming has very strong mathematical foundations, it requires a style of thinking that is not emphasized anywhere in the standard high school curriculum. (I can think of only one standard college-prep topic that comes anywhere close to the “algorithmic thinking” needed to write computer programs: proving trigonometric identities.) Consequently, for many students, learning to program is almost as far from their academic experience as learning to play an instrument. Therefore, I believe that expecting the typical student to learning to program at a “college level” in 15 weeks is almost as absurd as expecting the typical student to learn to play an instrument well enough to join a college orchestra after 15 weeks.

Consequences of the current system

The “almost” in the previous paragraph is important because it allows many CS programs to survive in spite of a “sink-or-swim” entry point that drives away talented students.

The number of students with the innate musical talent to be ready to join a college orchestra 15 weeks after picking up an instrument for the first time is so small that college music programs simply assume that all of their students have been playing for years before entering college.

In contrast, most Computer Science programs assume that a student with no programming experience can be successful. This assumption appears reasonable because there are enough “natural-born” programmers and students with programming experience to populate CS programs. However, in my experience, this assumption causes a lot of “collateral damage.”

Almost every student who has taken my CS 1 course without the benefit of either programming experience or a strong natural aptitude for programming either (1) did not succeed in CS 1, or (2) went on to struggle even more in CS 2. It is possible, through a lot of hard work and sheer tenacity, for these “normal” students to earn a ‘C’ or better in CS 1. The problem is that, while these “survivors” have demonstrated a minimal amount of proficiency with the basics of programming, they cannot yet program “fluently”: Writing code requires a deliberate, focused effort.

This lack of fluency greatly hinders these students in CS 2. CS 2 covers topics such as inheritance, polymorphism, object-oriented design, and basic data structures. However, while I’m presenting these higher-level concepts, the “non-fluent” students are still thinking about the code. It takes most of their mental energy to process the sample code I’ve put on the whiteboard, leaving almost none to actually process the topic at hand. Likewise, when working on assignments, it takes so much time and effort just to get the code work, they have neither the time to complete the assignment, nor the mental energy to focus on the higher-level concepts the code is supposed to illustrate.

As a result, many, many, talented students get frustrated and quit before successfully completing CS 2. It is very frustrating as an instructor to see so many intelligent students struggle and fail —- especially at a subject I love. Worse yet, this failure is bad for the profession. Computer Science is so much bigger than programming, yet we are filtering out most of the students who are not naturally talented programmers.

What is the solution?

Ideally, people would learn to program the same way “normal” people learn to play instruments: Slowly over several years, with lots of practice. However, this is not practical at the university level.

The foreign language model is closer to being practical. At Grand Valley, students study a foreign language for four semesters before beginning a serious study of literature and composition in that language. In theory, I think a similar model would for programming would be much more effective. As with foreign language, students could test into the appropriate place in the four-semester sequence. However, I see two problems. First, it would be difficult to fit a such a program into a four-year program. Students who don’t begin the programming sequence during their first semester would have almost no hope of graduating in four years. Second, I don’t know if I could make four semesters of programming sufficiently challenging and interesting. Whereas there is a huge set of interestingly different practice music for students of any level, and a huge set of literature in any language at any level, there are not a lot of interestingly different programming problems to solve at the very basic level. It is not until one has covered conditionals, loops, methods, and arrays that the variety of interesting programming problems becomes very large. (I would expect a set of 100 practice programming problems utilizing expressions and conditionals only to feel more like a sheet of arithmetic problems than a set of programming challenges. Such a set may help students learn a langage’s syntax, but doesn’t do much for developing “deep” programming skills.)

I simply do not have a good answer. I really don’t see what we can do (practically) at the college level to make Computer Science more accessible to the majority of students who don’t already have either programming experience or a strong aptitude. (Choosing a non-programming course as an entry point may help, although I see that as a better solution for other computing majors like IS and IT.)

Recent progress

There has been a lot of excellent work in the past few years that promises to help more students succeed in CS 1:

BlueJ and Greenfoot provide development environments that are designed to support learning Java. These environments have a much lower learning curve than professional IDEs, thereby allowing students to focus more on programming and less on managing their environment.

Mark Guzdial and Barb Erickson have shown that introducing students to programming by teaching them Python and writing programs that manipulate images and sound (an approach they call Media Computation) clearly improves overall success rates for students in CS 1 and CS 2. (The use of Pyton lowers the learning curve, and the user of muti-media based assignments improves interest and motivation.)

I am confident that this and other research will reduce the number of students who quit CS out of frustration; however, my gut still tells me that 15 weeks is not enough for most students to truly become “fluent” enough programmers to learn advanced CS concepts to the best of their ability. My guess is that, even if we were to somehow begin teaching CS 1 perfectly, we would still loose a disappointingly large percentage of students simply because 15 weeks isn’t enough time to develop the algorithmic thinking skills programmers need.

What do you think?

What does your gut tell you? I get a lot of feedback from students who are “natural-born” programmers and excelled in my course, and from students who did not make through CS 1; but, I rarely hear from the students in the middle: Those who entered college without the benefit of previous experience or an unusually strong aptitude for programming and survived.

Am I right? Are our expectations absurd?

Am I wrong? Are the people who are not prepared for CS 2 simply those that didn’t try hard enough?

Should Computer Science programs focus on those who enter college ready to program and advise the rest to consider less programming-intensive areas of study (e.g., IS, IT)? (In other words, should we use CS 1 as a “sink-or-swim” filter?)

Am I just not well-suited to teaching CS 1 and CS 2? As a “natural-born”, but not prodigious, programmer, the answer may very well be “yes”. I personally don’t understand why programming is so difficult. I’m sure that affects my effectiveness in the classroom.

What could your university done to improve your experience at the beginning of your CS program?

Please leave a comment. Your observations may spark the next big innovation in teaching programming.

136 Comments

I have a 4 year IS degree from GVSU. I’m happy to see a post like this from a professor because all of it is true. I have a background in web programming, design, and development and I’ve always been interested in all of it, at least from the time I started learning HTML when I was 12.

Having gone through the Java grind courses circa ’05 I can’t help but feel like Java is the wrong thing for GVSU students to be exposed to as their initial “test”. Maybe I’m biased with a web background. Knowing what I know now, Python should be the programming course since its syntax is easier. I found Java lacking in its ability to convey main concepts as an “introductory” language. Students have to push through syntax hell to see the big picture and even someone like myself found it annoying at times. The intro CS/IS courses should be focused more on the raw concepts and not the language. I think learning programming languages during both CS and IS degrees is very important. The timing of “syntax hell” introduction needs to be adjusted though.

Java is a popular language and it is very useful to know. However, in the beginning GVSU should not be trying to kill two birds with one stone (learning the language specifics along with the concepts). The skew should be more towards the concepts for the reasons you mentioned. Syntax should take a back seat because GVSU has no idea what language someone is going to pursue after graduation or in their spare time. I think they could even go so far as to teach the same course and let students choose which language they’re going to complete assignments in. That could of course just complicate things further…

Since the curriculum depends on students learning a language at the same time as core programming concepts, pick the easiest language to learn that’s used in real world applications. I’m not sure Java fits all of those requirements…

Indeed, there are some very good reasons that scheme used to be such a standard in many places for the first serious CS courses, and I think it’s probably not for the best that it’s fallen out of favor for more ‘useful’ languages.

Scheme was the first programming language taught during my University training just shy of twenty years ago. The real question is one of approach, rather than language and syntax. At the time, the math-heavy approach computer-as-calculator (as graphics were intensive and primitive, comparatively, at the time) worked fine. The key was having an available REPL and encouraging experimentation. Homework was assigned with an up-front assumption that ten hours of work would be required (minimum) for each assignment. Grading was scaled to conform to this model as well.

The “functional” aspects of Scheme can be just as easily used in Python. In fact, learning how to program in a functional manner can make Python (or any other language) a more effective tool. Myself, I think the “media composition” model, aimed at building confidence during the first semester is key. The focus should be on extending the entry into a CS program by a semester (if needed). Think more in terms of the weight loss program model. Every successful diet program starts by building confidence with “instant” results and much encouragement. The first semester of CS should be focused on such tasks. The second can then focus on providing fluency and introducing discussion on “functional” versus “procedural” programming.

In brief, instead of focusing on all programming, the intellectual pursuits of computer science and the experimentation should be more evenly spread through the course of study. Encourage exploration, not programming.

I had a similar experience to the one you’re describing 15 years ago at the University of Michigan. Of course, back then they didn’t throw us into Java, they threw us into C and C++. I had essentially no computer experience before college, but became interested mostly because of online games (MUDs). I tried to enter the computer science program a few times but really struggled in the introductory courses. They were throwing a whole new way of thinking at me, and for the first time in my academic life I failed to understand what was going on.

I eventually graduated with a degree in Anthropology, but with enough PC repair and networking experience outside of the university to enter the IT field. I’ve been working my way back into programming over the last decade, and Python has been a big help with that. It strips away a lot of the unnecessary verbiage of languages like Java while hiding the disastrous frailties of lower level languages (pointers were the bane of my existence). I now lead the Grand Rapids Python User Group, so let me know if we can help you in any way.

You mention that other disciplines (Math, Sciences, English, etc) sit upon a multi-year high school curriculum. I think an obvious solution you failed to mention is introducing students to programming before college, just like these other subjects. I think that technology and computers should be used throughout school, not as a separate subject, but as a tool that’s used in every class. Coming into high school, kids know how to read and write because they’ve been doing it for every class for years. They then move on to subjects that build upon reading and writing, such as literature and composition. If computers were taught the same way, kids who’ve been using them ubiquitously for years would be ready for more advanced computing courses, like programming. Obviously this would better prepare them for college-level computer science.

It is certainly helpful for students to have computing experience when entring college; but, I hesitate to rely on that. I don’t want to effectively require students to choose early in high school whether or not they want to study Computer Science in college. While computing skills are clearly beneficial for everybody, I hesitate to make the claim that computing courses are more worthy of limited curriculum time than other disciplines such as foreign language. In the ideal world, students who don’t decide to study Computer Science until after they arrive at college would have as much chance of succeeding as those who have known since middle school that they want to study Computer Science.

I aslo would like to point out that there is a big difference between computer literacy and Computer Science. Many schools today are still unclear about the difference. Standard computer literacy (i.e., “how to use Microsoft products”) courses don’t effectively prepare students to learn how to program. (See this article for more details.)

>”I think that technology and computers should be used throughout school, not as a separate subject, but as a tool that’s used in every class.”
I like this and I totally agree.

>”Standard computer literacy (i.e., “how to use Microsoft products”) courses don’t effectively prepare students to learn how to program.”
But this is also true.

Right now, “computer class” is taught as an elective at most high school, in much the same way that “home economics” is (quoted because the title is misleading and I believe that we REALLY need a mandatory “personal finance” class — a topic for another time). This is sad given that most jobs now require interaction with a computer on at least some level, and lots of people using computers do not even have a clue about even the most basic concepts, such as “safety on the internet” (i.e. not getting tons of malware).

Consider this: in high school, we are forced to study somewhat deep levels of math, science, and english (which we really need to find a way to make more fun / interesting because so many “professionals” are awful at basic language / grammar concepts). Some popular things that come to mind are geometry concepts, working with polynomials, linear equations, etc. While I think that these and related concepts are pretty useful for getting an understanding of currying and algorithmic thinking / code refactoring, I think that they’re somewhat “too deep” for highschool when lots of highschool graduates are so awful at basic english and have no knowledge of even computer basics beyond what they learn on their own.

Still show people how to use Office, but teach a lot more than just that. It’s hard because you have so many kids at so many levels. I was programming in visual basic and making my first PHP / MySQL websites when I was 13. I really wouldn’t expect this from most students, and I think that those who are naturally motivated / interested would do just fine without traditional academic help. However, I also wouldn’t expect a complete ignorance of computer basics, but I would be careful to cover them again because lots of computer understanding problems begin with core concepts being misunderstood.

Here are a few courses that I think should be mandatory because they’re not “deeper” than anything that is already taught in math / science courses (remember learning about biomes and Kingdom Phylum Class Order Family Genus Species?):

- How the internet works (overview of how DNS works, how websites operate, networking basics, a bit about how wifi works, a bit about servers [what is a web server / web-scale strategies/ cloud computing overview] etc. Just the basics here, i.e. it probably wouldn’t go into wireless frames or DNSSEC or anything). There are a lot of basic misunderstandings here (just think how many people believe that ‘www’ is something other than a regular [albeit common] subdomain). If we could make this class NOT all about figuring out how to work a subnet mask and calculate CIDR ranges, that would be GREAT. I work in IT and when I need to figure that stuff out, I use a calculator or the chart on my wall…but school loves teaching useless computation like that.

- Operating System basics (would mainly focus on Windows and Mac because those are the most popular, but it’d cover BASIC things like “how computers start up”, “managing files and folders”, “how files are stored on the hard drive”, etc. Should probably be an elective. Might also use Linux since I really think that linux has easier-to-understand concepts (consider linux with config files in /etc vs windows with “the registry, ooh and INI files, ooh and stuff stored in XML files in who-knows-where, ooh and manifest files and lots of other little fun tidbits scattered about)

- Computer hardware basics (let’s please just not make this a straight-from-the-book A+ cert walkthrough) It’d cover different components and what they do and how they interact. As an optional project, you would have the chance to purchase your own parts and assemble your own computer. I think lots of young adults would enjoy this and it’d teach people to not be scared to open their computer and poke around (safely).

Reading back through those, I can’t help but think of how they relate to automotive topics. Everyone uses a car, so why would teaching auto repair basics / basic auto maintenance not be just as important? The answer is I don’t know and I’m probably just biased and none of this will ever get into highschools. At least I can cross my fingers and hope for a mandatory personal finance class so people stop getting ripped off by banks and credit cards.

>”but, I rarely hear from the students in the middle: Those who entered college without the benefit of previous experience or an unusually strong aptitude for programming and survived.”

That’s because those students are probably the ones who just push their way through college because their parents told them that they should or because they feel that “going to college will make [my] life better somehow” without actually caring about what they’re studying. I see so many kids going to college for something they’re not passionate about, and I have to wonder what part of our education system failed them so bad that they don’t even want to do anything professionally in the future.

Without going off on a tangent, I think that you don’t get feedback from the C/D students is because they really don’t care. At all. College to them is just getting the paper at the end and “making lots of money” when they get out (and probably end up going into something other than what they studied — see dude above with anthropology degree).

College isn’t for everyone. College isn’t even for all the people who try to go. We need more people to stay out of college and do other useful jobs. Bring back apprenticeships. Make vocational schools not “a place to go and mess around and waste your life”. Not everyone can be a doctor, lawyer, programmer, engineer, marine biologist, or (lol) english major…so why are they trying to be? If you’re going to college for an english degree and you’re not interested in perusing professional journalism or writing professionally…do you really need to be going to college?

College isn’t for everyone. College isn’t even for all the people who try to go. We need more people to stay out of college and do other useful jobs.

I heartily agree. I do not have a degree from an institute of higher education. I think the four years I spent working under a programmer, learning and applying these skills on the job, were more beneficial than anything I could have gotten pursuing a CS degree.

College is important, and I think most people should go, if it supplements their natural inclination toward a particular profession (also, many kids don’t actually know WHAT they want to do, so college facilitates decision-making). Many employers won’t even consider hiring someone who doesn’t have at least a bachelor’s degree. But the kind of company who values experience and talent more than that piece of paper is the kind of company I want to work for.

I think we should not take it as an excuse of not building good teaching materials and courses. :) ’cause even good students will benefit from that a lot. And speaking of engineers, biologists, chemists etc. taking CS1 – they will benefit the most.

And, as Brent Williams has said “The key was having an available REPL and encouraging experimentation.”, REPL is a must have.

I am an informatics teacher in Slovakia, and I think I understand your concern. It is not possible to start teaching programming at college from zero level and expect that after a few weeks all students will get it, so we can move to advanced topics. And it is also not possible to press high schools to actually teach programming, and to do it right. What now?

I would say that we are in a similar situation as if we’d try to teach literature at college in a country where elementary schools and high schools refuse to teach reading and writing. The situation seems pretty hopeless.

It would probably be good to do intensive programming for the first year. As you say, hundreds of problems. Now there are a few students who already know programming… so they could get more difficult problems, or a few more complex projects, or they would learn some optional subjects instead, or possibly skip the first year completely.

It would also help to write a self-study book, or even better an interactive programming environment, where students could learn the programming concepts on their own, during the last years of high school, or during the summer between high school and college. Thus they would not enter the college with zero knowledge.

Anyway, hundreds and hundreds of examples seem like the only way to go. To reduce burden on teachers, there should be a web page where students can upload their programs; the page will check syntax, run tests, and report the results to the student. In college, the students will only ask if they did not understand some feedback from the web page. With sufficiently smooth learning curve it could be like playing a computer game.

It would be interesting to introduce students to programming earlier (I’m thinking middle school or early high school), but without actually programming. I do not know what such a curriculum might like like: algorithmic problem solving, as a geeky name that conveys my meaning, however.

There are a few interesting things you can do even with 10-years old kids.

In a web game “Light Bot” you navigate a robot through different levels by writing a simple programs. The program is built from blocks like “go forward”, “turn left”, “turn right” and “jump”. There are also blocks “call procedure 1″ and “call procedure 2″. The game forces you to use procedures by putting an artificial limit of 12 blocks in the main program (and 8 blocks in procedure 1 and procedure 2), so need to put repeating patterns into procedures to solve a large level. A set of such games could make an interesting curicullum.

There is a programming language “Ren Py”, in which you make interactive text games with graphics. On a basic level, it is like scripting a powerpoint presentation (“show picture X”, “display text Y and wait for any key”, “hide picture X”…). Each child will understand this. Then you can add conditions, jumps, variables, and generally any Python syntax. If you prepare game pictures for children, and give them exercises, you teach them programming computer games, which they can send to their friends. It is motivating.

I tried teaching a “programming without a computer” where students built their programs from commands printed in paper. Everyone built a program, then they changed places and executed their classmate’s program. With these programs they navigated a knight piece across the chessboard with obstacles (commands: “go forward”, “turn right”, “turn left”, “jump if obstacle”) or did computation with buckets of match-sticks (commands: “use bucket X”, “add match”, “remove match”, “jump if empty”). Basicly you simulate a computer memory with toys.

The biggest chalenge is to find enough examples for the same programming concept. How many different exercises can you make for an “IF-THEN” command? You need at least five to make sure kids really understand it, not only remember the correct solutions.

At least in Russia, I see the following problems with the “rely on official pre-colledge education” approach.

Students still have very different knowledge level at the entry point, because, although the “informatics” three-year course is mandatory, every school teaches it completely differently. In some schools it is reduced to practical skills of using MS products (just because parents want something practical). Other schools raise Turbo Pascal programmers that already know all the syntax stuff, have procedural programming skills and can quickly learn any other procedural language.

So, for that approach to work, the state (or some other central authority) would have to formulate sensible requirements for such pre-colledge courses. But even that is not really practical, and has a lot of potential of being poorly implemented for political reasons or for incompetence/corruption at higher levels – e.g. because what you would call sensible requirements for a CS course may interfere with what parents would call practical skills.

The real problem is that computer science, unlike any other school topic, has very fast and visible evolution, and thus imposes special requirements on the teachers and those authorities who are responsible for the official exam programs. For all other school disciplines, 40-year-old textbooks would still mostly work (e.g. school physics doesn’t go beyond special relativity even in advanced schools), and this mostly hides the requirement for the school teachers to self-educate (and that’s why bad scientists that mastered the art of interacting with young people can still be good school teachers). In fact, in my education as a physicist, I was not exposed to any moving-target courses until after I obtained my bachelor’s degree, and even there, the professors relied mostly on my self-education.

So (if we ignore the fact that it is illegal in Russia for universities to rely on things not taught in schools) it may well be that the most viable way to raise CS professionals is indeed a 15-week CS1 course that reiterates and formalizes the things that you already find good students to know on their own – i.e. a “sink-or-swim” filter.

One more note: 20 years ago the problem didn’t seem to exist (but I was in a school at that time). Basically, the “real” tools that programmers used (Turbo Pascal and such) and the toys suitable for education were the same, and there was no real gap with that and the fundamentals discovered by Knuth and Dijkstra. In other words, things were simple. So it may well be that Python is the answer to this requirement for a useful toy.

As a recent graduate of GVSU’s CS program, I’d like to echo the sentiments from the comments above that Java is a less than suitable choice for Intro to Programming. As a transfer student, I took the intro-level courses at MSU taught in C++ and had to understand a lot of fundamentals that Java sweeps under the rug. If a student struggles through CS162/163 and then has to cope with much harder concepts in later years, they’ve invested a lot of time and money to learn that they don’t have a good match with Computer Science. Perhaps it is better to have a higher attrition rate than to slow down students who are innately skilled at CS and string along those who are not. Joel Spolsky has covered this topic before and his particular anti-Java schools entry makes what I consider to be some intelligent points. http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html

One option would be to provide a more training-wheels approach by lowering the difficulty of the introductory courses and also adding a more difficult intermediate level. I would suggest following the model of mathematics programs where any student can test into more advanced coursework as an entering freshman. Those who do not test ahead still have the option of beginning with the introductory courses.

I knew I was interested in programming in high school so I started learning Perl and PHP because they were accessible to me for toy programs that might be marginally useful. My first semester of college I took an intro to programming class using C so that I HAD to learn all about pointers, machine architecture, representation, etc. Later on in college I took the requisite data structures & algorithms class, operating systems (where you write toy schedulers and other OS features) and such. Two different compilers classes.

I actually went to school to be an Electrical Engineer though I ended up doing both EE and CE and then got a masters in Computer Engineering. So programming is more of a side topic rather than something that gets crammed down your throat every day. I think that made me a better programmer as I had time to use what I’d learned on side projects or things that I found interesting before I had to take another programming class. That gave my brain time to adjust and incorporate the knowledge as the new, expected reality.

You have to give people time to get to unconscious competence of some of the basics before teaching them the advanced material.

Finally I think teaching computer science as a field unto itself can be done but it’s much easier to engage people by presenting real problems and then the solutions people have come up with. O(nlogn) sorting doesn’t matter if nobody wants to sort. I’ve learned far more about programming from needing a way to solve a problem at work than because a teacher told me to write some toy program that inserts elements into a heap.

To start, I think I’m more of the demographic you’re asking after. CS at college was my intro to programming and CS. And I struggled a bit, but not so much to make me want to quit.

My first exposure to CS was actually a Scheme class. We read SICP. The material was interesting. Some of it was way over my head. But one issue was that I had no idea how to hack the scheme environment to do things like, hey, make a GUI that looked like the operating system I was working on. It wasn’t until I followed it up with a course in C that I started to grok more of what a computer was.

I love that media computation idea. It might just inspire students to “look behind the curtain”. Give them some fun APIs to make little projects, but also give them the tools to completely break everything.

The “two year prep” period a-la language study is interesting. The first two years of my undergrad program was basically “survey courses”. The third year was where I felt like I took my first “real class”. So saying that CS majors have two years before they really have to worry about “real concepts” isn’t much of a stretch to me.

I had been in the CS program at CSU Pomona for about a year when I decided to attend a programming contest hosted by the CS club. I sat there for two hours trying each of the problems in turn but could not submit even an attempt at an answer. I was not prepared to think algorithmically at all. I managed to struggle my way through to a degree, then went into an unrelated field. Looking back, I certainly wish I had tried harder to become fluent. However, I also think students need to be given the basic tools necessary to succeed. Your point is quite valid that expectations are too high. I think that any introductory course should focus less on code and more on algorithmic thinking. A book like “How to Design Programs” would have helped me immensely.

As someone who’s been programming for about 15 years off and on, I’d always been the one who’d ruin the curve in most classes until I got to university where I only did a second major in CS. Even then I skipped ahead a few courses, because of my involvement in the Advanced Placement program in highschool. Thinking about that, however, had me recalling the other factors and motivations that’ve lead me to where I am now, and when I consider everything objectively, I’ve no reason (or right? haha) to be cocky, because it all makes sense.

Early peripheral exposure to computers (not being allowed to play comp. games in kindergarten because I wouldn’t stop talking) had something to do with it. When I came across computers again about 6 years later, I was all over it. At the same time, my friend had found a really old book (late 70s, early 80s?) about programming in BASIC. Though the book had a lot of diagrams, it was probably like two whole years before I had the lightbulb moment where I really understood the concept of variable manip. and the nature of -iteratively- controlling execution.

Perhaps I’m being heavy handed here, but I’m trying to make a point; I sometimes wonder if the underlying concepts need to come after the understanding of code and syntax and execution. I think rich diagrams – much more so than anything out there in CS literature, but maybe someone’s doing it on the web – and perhaps even “game play” or scenario-acting, giving the student simple, physical “machines” to illustrate the concepts. Perhaps even just a set of trays (registers) and index cards (values) to demonstrate a stack, for example. In fact, an entire simple program can be “acted out” by a group of children (or adults…haha) to demonstrate exactly what happens in a computer during the execution of code.

What’s important about these seemingly ridiculous approaches is that they are process – and therefore temporally – based: something hard to convey just by listening to someone talk about it or reading it in a book. When a process is broken down into simple steps, even young children can learn them, despite the steps adding up to be a complex set of rules and regulations. If one can understand the necessary concepts on a level this fundamental, syntax becomes a secondary thing of coincidence. You point out, and I agree, that it’s often syntax that holds people back from the major concepts at play. Why not start with those (top-down), and see if you can’t get students comfortable with language some other way (bottom-up) and the two will meet somewhere in the middle.

I coded C/C++ from a young age, and so when I started the CS program in college, I tutored my peers who had enrolled as CS majors but who had never learned to program before entering the university.

This program taught CS 1 and 2 with C++. Although this was a great review and reinforcement for those us who already knew the language, the unprepared freshmen were thrown to the wolves. These students couldn’t simultaneously learn the language and the details like pointers, allocations, the toolchain, preprocessor directives, files, etc.

I know that several of the kids who dropped out of this program during CS 1 or CS 2 are now engineers in other fields, so mentally they were cut out for a technical major. Perhaps it would have been better to teach naive freshmen a single semester prep course using a dynamic, high-level language like Python, and only thereafter feed them to the lions of C and C++.

As for Java, I’ve enjoyed my career programming mostly Java, but I think it’s too industrial to make a great introductory teaching environment. Unlike Python, it’s too bureaucratic to reward experimentation with small problems, and Java’s maximalistic syntax distracts from the basics. Unlike C, Java entirely obscures the hardware-software interface.

I’m from the UK, where our education structure is slightly different from the US, but I agree with your article.

I’ve just completed the first year on my CS degree. Unlike many of my classmates, I had absolutely no programming experience before I began the course. I persevered, and for the most part it was one of my favourite subjects. However we have just finished our exams, and the programming test was the only exam in which I really struggled; I’m not looking forward to getting the results.

I really worked hard this year and initially I felt very disappointed with myself. I put it down to poor preparation on my part (which part of it probably was – I spent more time focusing on the other subjects), but after reading your article I feel a little better knowing that I’m not the only student who struggles with the subject. I guess this means I’m not a natural programmer, but I plan on spending my summer simply practicing what I learned this year. Something I probably should have been doing a few months ago…

While it might not be ideal to rely on a student having experience before attending college, I strongly believe they must demonstrate a very strong desire to explore and learn on their own. Computer Science requires a significant investment from the student (as does any engineering or science field), and without the proper commitment is doomed to failure. It simply cannot be taught solely in a classroom. The classroom however serves a vital role in guiding the student in the right direction, answering questions, and providing key insights. This is just my humble observation as a student (have never taught a course myself).

>The classroom however serves a vital role in guiding the student
>in the right direction, answering questions, and providing key insights.

You’re absolutely right! Cheers!
And it’s the same way many teachers think of that.

But there’s a problem – many students don’t think that way. :-( They think that they don’t need to read textbooks on their own. They think that the tasks they recieve _is_ a level they should stop at. When it’s the other way around – it’s the minimum level they have to achieve and explore more and more.

So, I’m looking for an insight on how to convince and motivate those students to use the classroom effectively. (we have some here, buried in the comments, :) but we need more)

P.S. Ofcourse, that’s the problem with all the courses at schools and colleges – not only CS.

About me: I’m a 4th-year CS student at Northeastern U. I consider myself a “natural programmer”, but not even close to a prodigy.

I think the problem is as you stated, there is not really an analogous course or area of study at the high school level that properly prepares students for freshman level CS courses. The AP CS course has a pretty good curriculum, but I would assume that it is plagued by poor instructors and differing cultures surrounding AP classes. At my high school, AP classes were pushed hard, and most students took at least 1 while some took as many as 6 or 7 their senior year (out of a possible 7). Our AP CS class had about 35 students in it and a pretty good instructor, but I have classmates currently who took the AP CS class at their respective high schools and say it was almost a personal study period. Others didn’t have any class available at their high school and came into college blind to what goes into programming. Some people just wanted to make video games. Our freshman class had what I felt was an incredibly high drop out rate of close to 30%, between actual drop outs and major transfers. I think the blame does not fall on my freshman professors, or the college itself.

While I can’t judge any other colleges for their freshman CS curriculum, I thought that mine was pretty solid (most of my friends who are in CS go to either Boston University, MIT, or Maryland, so I don’t have a very broad view of CS curricula). I’ve seen a bunch of these “Am I a bad professor?” blog posts, and I think most people are giving themselves a hard time. If I could improve CS education at any level, I think improving high school CS classes, clubs, and outreach programs is paramount. People say that the best way to improve as a programmer is to program, so why not engage students earlier and start the learning process before freshman year?

On that note, check out Bootstrap, an after-school programming workshop for middle school students that some of my friends are involved with.

And for what it’s worth, our freshman courses were taught in PLT Scheme (now Racket), and followed in the second semester by Java. People say Lisp is “too tough” for beginning programmers, but Matthias Felleisen and Shriram Krishnamurthi defend their choice in a couple places (including here).

I’ve just finished a 23 week evening course in Spanish, two hours each Monday evening. It was an absolute beginners course, I’ve not studied Spanish before, though I do speak some French and Dutch. The longest piece of text we had looked at by the end was a short paragraph, and it was entirely natural for the whole class to sit and work through it word-by-word. (The existence of verbs was not acknowledged until the second half of the course.)

So, my strongest reaction to this article is here: “Such a set may help students learn a langage’s syntax, but doesn’t do much for developing “deep” programming skills.” Yes, there my be literature available at any level, but the bottom level is so low you would struggle to call it literature – just a paragraph or two in a beginners book. Don’t worry about “deep” programming skills, it feels like this line contradicts the rest of the article. If you’re going to start at the bottom, you’ve got to cover syntax. For many people the idea of syntax is new all by itself. There was an article somewhere suggesting to start not with a programming language at all, but with markup languages, as an introduction to structured text. Specifically, the first “programming” module for the maths students back when I was at university was to build a web site. (Us physics students started with the binary definition of floating point numbers, I think HTML would have been a much better place to start…)

Finally an anecdote: I still remember my first revelation about programming when I was about 9, when I announced to my parents, “It matters which order you put the lines!”

One of the issues appears to be the definition of being able to program. We could whittle this down to being able to write an imperative program i.e. control flow using if statements and some looping. There are other valid definitions, but I’m using this one for the sake of simplicity.

In a 15 week CS 1 course we need to teach people how to program. Under the assessment criteria in my institution, if a student meets the goals of the course they get a B. An A is generally awarded for extra work on top of a B. And this is where the bi-modal distribution in marks rears its ugly head. What does it mean to pass a programming course? Can you use control-flow using ifs but not understand iteration?

Effectively, programming becomes binary. You can either program or not. We have no idea in CS of being able to do a little programming. I’d say in Chemistry you could get a C if you produce a solution within a certain tolerance or an A if you correctly do everything right. In CS we have no tolerances (c.f. the work of David Parnas etc…)

I think CS2 should focus on programming tools, not object-oriented techniques. OO is not a fundamental tool, it’s a high-level discipline designed to solve problems with large software systems.

Object-oriented design is not needed to understand algorithms, operating systems, networks, databases, compilers, or most other advanced computer science concepts and in fact probably gets in the way as often as it helps.

I’ve been in the field of computing all of my adult life, and IMHO it all boils down to this: About 2% (or thereabouts, I’m not very scientific about this :-) of the population ever “gets” programming. The rest don’t. The set of personality traits that’s necessary to become a good programmer seems to be a combination of fascination with problem solving, some (but not abnormaly high) raw intelligence, and perhaps most importantly an ability to live with frustration over stuff that don’t work over prolonged periods of time. Given the cooperative nature of most programming projects these days, one also needs a well developed ability to get along with other people in a cooperative environment. You need to have all of these trait or you just won’t be any good. Not too surprisingly, most people don’t have this combination.

I’ve seen very intelligent people that has completed CS courses, some even with CS Ph.Ds. that couldn’t program themselves out of a wet paper bag if their life depended on it. At the other end of the spectrum I’ve got friends with hardly more than high school degrees (and one even less than that) that are excellent programmers and have enjoyed successfull careers as software engineers at top notch companies, including Google. Beeing good at programming is somewhat correlated with intelligence and somewhat correlated to having a CS degrees, but mostly it seems to be a trait that is randomly distributed in the population.

So, any school that admits lots of people from the general population into a CS course will basically get applicants from three groups: Those that already know how to program and just want to polish their existing skills, we’ll ignore them for now, but for top notch schools like MIT these guys will probably represent the bulk of the freshman CS class. The rest of the people will be divided into two groups; the couple of percents that haven’t programmed before but are predetermined to do so and will catch on very quickly, and the remaining 98 percent that will never be good programmers. Of the latter group some will get passable grades but will never do any practical programming, the remainder will neither get good grades nor will they have any useful skills after completing the course.

I may be wrong, but all of my personal experience supports the views expressed above, so until someone presents me with another set of facts I’ll continue to believe what I believe now: Most people will never, ever be good programmers.

I was lucky to have SICP as my introduction to programming (at age 30, with no formal programming instruction previously, after getting a BA in English after high school).

All computer science students should be so lucky. The syntax barrier is non-existent with scheme. If students don’t like thinking about the concepts in SICP, they should not expect to go on and be good software engineers.

I think the small success rate is because we are not teaching it right. If we found a right way, we would not get 100% success rate, but we would get rates comparable with mathematics.

The average intellect is enough for mathematics, if students learns systematically (because the textbooks and teachers teach systematically) and does hundreds of exercises. In similar conditions the average intellect should be enough for programming. Problem is, we do not have anything close to similar conditions.

Frustration can be reduced by smoother learnign curve with many simple exercises. This is how get across the basics. To reduce frustration in more complex projects, use an IDE with syntax highlighting and write unit tests. In such way the frustration would be non-zero, but less than today.

I agree with your analysis of people who go to college CS course. But I think this is so because the high schools did not do their jobs right. Otherwise we would also get many students who maybe never wrote their own computer game or any other program, but they still can write a quicksort, or solve a simple problem. These people are missing now because high schools do not produce them.

>The average intellect is enough for mathematics, if students learns
>systematically (because the textbooks and teachers teach systematically)
>and does hundreds of exercises.

IMHO.

Average students do not _understand_ mathematics the depth they should understand programming to get any useful results.

Nither they can produce a new mathematical model of any given real-world process. And in programming we expect them to be able to do this.

The level of mathematics they (average students) learn is similar to this:
a) being able to read the program line by line;
b) being able to execute program in ones’ mind;
and more advanced learners:
c) being able to write a program based on a particular type of a very sophisticated sorting algorithm.

Programmers abilities and traits:
In programming it’s essential to be able to formalize any part of a real-world, to combine stuff and to invent the unknown.
(and the last two are inevitable to enter even the beginners leage :) )

I think that Media Computation is going in entirely the right direction, echoing Alan Kay’s assertions that computers are a kind of media (and, if anyone should be listened to about the education of programming, Kay has to be pretty high on the list). I think that immediate, interactive, graphical programming environments such as Processing can open up both programming and many practical aspects of math and physics as methods for doing things that are, if not useful, cool and interesting. Perhaps, if Donald Knuth was right that computer programming is an art, then maybe computer programming has a place in a modern arts education.

Interesting, but I wouldn’t go so far as to assert that 15 weeks is simply too little time. Rather, 15 weeks is too little time for certain methods of teaching; Other styles have shown promise, and there is a significant population of students who evidently did just fine in that 15 weeks (that is: nearly every person in who currently holds a CS degree.)

There are problems with CS1 though, and a big one is that there’s a growing need for CS1 to cater to both majors and non-majors. CS1 classes which try to support both tend to leave one group unprepared for CS2 and the other group unfulfilled in the only CS class they ever take.

I wrote a survey paper about this topic for my Master’s degree; you might find it interesting: http://bit.ly/mKMWok

I think some of the comments about simpler syntax (moving from Java to Python, for example) are in the right direction, but not far enough down the path. I think the fundamental problem is that of generalization. Someone may intuitively understand how to do a specific task themselves, but how do you take that idea and make it generic enough to be useful?

Programming is communication about how to solve a problem. So let’s skip the whole computer language implementation detail. Don’t start with computers. Start with problem solving. Make the implementation language a list of steps to be performed. Split off people into pairs – have them write down descriptions of how to solve some problem, and then have their partner act it out. You get to talk through parse/compiler errors instead of having to translate something that only really makes sense when you’ve seen it a couple hundred times.

Once people are comfortable with taking a problem and producing steps to solve it, picking up a syntax to say the things they’re already comfortable talking about seems like a much smaller step.

This is in a line with Bjørn Remseths’
“The set of personality traits that’s necessary to become a good programmer seems to be a combination of fascination with problem solving, some (but not abnormaly high) raw intelligence, and perhaps most importantly an ability to live with frustration over stuff that don’t work over prolonged periods of time.”

I agree with both of you. We should teach problem solving, goal identification :) , etc. from the very young age. We have to create such a course. Maybe starting from college level and then going down to the roots ?

A similar problem surfaces in medical and dental schools. Insane amounts of information are dumped onto hapless students (to the tune of 36 credit hrs/semester). The only ones that survive are those that are part of the savant crowd in one form or another, or those that already have a big head start. For example, someone who has worked professionally in a dental lab (traditionally a “technician” sort of job) has a significant leap ahead of the typical first year dental student that came straight from a university at age 21 when it comes to the difficult-to-teach skills that dentists must learn: the art part of dentistry. And then the schools increase the likelihood of failure by cramming that clinical coursework (along with scads of science) into the shortest possible calendar possible. (roughly four calendar years) I often wondered why schools did this. Would it hurt them to extend the curriculum to five or six years? It seems to me that they would produce more and better quality dentists, for example (I’m most familiar with dentistry). Instead, they have miserable retention rates (would you believe 50% of my first year class?), constant (well-founded) worries amongst the administration about student’s mental health issues, suicide, drug/alcohol dependence, and students that regularly state upon graduation: “Given the chance to do that over again, I would not.”

My suggestion would be to stay away from compiled languages in the introductory courses and make use of an interpreted language such as Python or Scheme. The key is to give the student access to a prompt that allows the student to type in individual lines and watch the progression of the data as it is manipulated. With perseverance, the student will eventually learn to do the data manipulations in their head.

It might also be wise to move the object oriented concepts to a later course and just cover data structures and introductory algorithms in CS2. There’s no need to confuse students with inheritance and polymorphism so early on when those concepts really aren’t necessary until they start learning about software engineering and design.

I just finished a semester of CS 1 (using C++) at my community college. I agree that our ~16 week curriculum was very fast paced, but I was motivated and interested enough to learn the concepts and successfully complete the labs. The majority of people never understood the “logic” behind programming, so they ended up copying their code from those who did understand.

I think the problem with Intro CS classes is that they fail to teach the logic behind programming. Anybody can learn enough syntax to write some output statements to the console, but most people (in my class) never understood how incorporate if statements with loops and arrays and structs and all the other fancy stuff. The syntax is easy to learn, but understanding programs conceptually is very difficult, especially for a beginner like me.

I have to strongly disagree with this. As a high school student I never created any code but found myself fascinated with the concepts that computers provided. Even now, having graduated with a B.S. in CS from GVSU, I don’t have the passion to code outside of work for the fun of it. But at work, I lose myself in my code and will easily burn 9 or more hours, often skipping lunch. Not everyone has a passion for a subject that will translate to life outside of their chosen career.

Where it may be likely that those who teach themselves programming at a young age have the passion, the inverse is not true (those who don’t teach themselves at a young age will never have the passion). That’s a failure of basic logic. And to then automatically rule them out from pursuing a CS degree is narrow-minded.

I’ve recently entered into the college scene to get my bachelors in Computer Science. I already have a huge self-taught experience with programming in a large range of languages. It is scary how high the percentage of people are scraping through the classes. The bombardment of vocabulary and their concepts are probably the hardest part for most people.

High Schools should have programming classes as electives. I remember taking one in 9th grade. At my current job, we’ve hosted Lego Mindstorm competitions for High School students. They had to create a program to automate their Lego Mindstorms. It wasn’t text based, but it gave them the basic concepts, loops, if/else.

I’m not a CS student, but I recently had to take a C++ course CS121 as part of my engineering program. There was this long list of recommended prerequisites, and they strongly advised me to take the “lower level” C course as an introduction. I didn’t have time for that, nor did I have time to fit the lecture course into my schedule, so I just took the C++ class online. Later, I came to find out that only students who already had programming experience were supposed to be allowed to take the online version. Whatever. I figured I’d give it a go anyway.

My only prior experience with any programming was just cutting and pasting basic html. The school did everything they could to scare the shit out of me and try to convince me to not take the course, yet in the end I scored a 98%, and I was tutoring other people in the class. It was the most fun I had the entire term.

I’m really not that smart or anything. I just don’t get why some people struggle so much with programming. There seem to be those that just “get it” and those that don’t, and probably never will. I don’t think the education system needs to be changed in order to accommodate these students that “don’t get it” after 15 weeks, because in my experience those students will end up being lousy programmers anyway. Better to steer them into something more fitting to the way their minds work.

So, I disagree with the idea that schools are “driving away talented students.” Entry level programming courses are not that difficult. You don’t need prior exposure to programming in order to succeed. I can personally attest to that, and I don’t think I’m some sort of anomaly. If students can’t cut it in the entry level classes, then they should choose a different field because programming probably isn’t for them. That’s the harsh reality.

In my assessment, the real problem at hand here is that CS programs are filled with naive video gamers that just want to make the next Grand Theft Auto or World of Warcraft, and then become frustrated when they find out that programming has little to do with video games and actually turns out to be a lot of hard work.

I think your success in that CS course may be partly attributed to your engineering background. A big part of learning CS pertains to models, interaction, abstraction, etc. AND being able to process them in your head. Your brain was already wired to think that way.

I’ll chime in and say I also had only done html when I took intro CS (no formal engineering background, but a strong “huh, I wonder how that works? …tinker…tinker…tinker…Aha!” multidisciplinary hobbyist background, with a strong inclination to apply concepts learned across different fields).

The intro CS course was a challenge, but fun, and I did well (and went on to the CS degree, etc.). I’m not a prodigy or a superstar, but I’m still learning and using new languages and tools and algorithms, usually as they become useful/appropriate for projects (sometimes just for fun, too, but I learn best when solving problems – so I aim for the projects that will let me use new things).

To those who are saying “anyone who is going to succeed at all would have started on their own, at the age of childhood/adolescence that I did or earlier”, I would note that there are a lot of interesting things in the world, and each individual encounters them in a different order (both because of environmental exposure, like owning programmable calculators and/or having friends who do this sort of thing, and because of the weird timing of “Aha! I can do that!” moments). Not everyone needs exactly the same head start or prerequisites to do well; some of the commenters here might have done just fine being chucked into intro CS without previous programming experience, but it’s hard to tease apart the exact implications belonging to experience vs. natural aptitude when you have both.

In terms of teaching, I think it’s good to have an awareness, as you do, that people are starting intro CS from different places. To help people get over roadblocks, perhaps occasional one-shot afternoon newbie sessions might be helpful, where no question is too stupid/basic/obvious (“what is scripting?”, “we’re repeatedly told in class that global variables are BAD and that we shouldn’t EVER use them; what are they and why do they exist?” “how can I stop getting linker errors?!”). Google can help with most basic questions, but beginning CS students may not know which sources are most reputable or up-to-date (or, in some cases, the terminology to formulate the question for a search engine), and having a trusted source would be helpful.

In high school there was an elective computer course (which was a continuation of a required computer course (word, excel, powerpoint)) with some basic programming and hardware use.

The first year of CS was a filter. The teachers & student all knew this. It was stated at the beginning of the first course. (And i think stated multiple times after)
What would you rather have: take one year or less to decide that CS is not for you fail (or less likely finish) the university and decide its not for you.

I learned FORTRAN at the age of sixteen in 1965. I’m still programming, in C++, C#, PHP.

I think that as far as programming is concerned, we are still living in the Middle Ages. There were no engineering schools where you could go to learn how to build cathedrals and castles. A few skilled, self-taught architects persisted, driven by passion to innovate. Many mistakes were made, and people killed.

Over the years, standard systems and procedures were developed that provided a consistent and predictable way of building. Today we graduate architects and engineers by the thousands that crank out buildings that don’t fall down.

The only difference is that people rarely get killed if a programmer makes a mistake (radiation machines and airplanes excepted). The barrier to entering programming is so low, that we will continue to not require any certification and licensing.

The level of creativity and skill required to innovate in programming will forever be beyond the grasp of the majority of technicians working in this field. Until we can develop standard components and procedures that enable average people to produce cookie-cutter results in an assembly line fashion, we will flounder in the age of artisans and amateurs.

I know that specifically for GVSU, a first year requiring Logic (PHI 103) and Structure of Programing Languages (CS 343) would probably be a tremendous help in retaining students in the program. Logic demands a strong ability in algorithmic thinking and will force that mindset to the fore. I know that when I returned to school after a number of years away, it took me a while to get back into the mindset necessary for CS, but that class really helped to clear away the fog. I still did extraordinarily terrible in your class (and all the other classes I took that semester). The other thing that would help, is a course detailing how to go about learning on your own. Maybe I’m just obtuse (and with ADHD, it’s possible), but I was never able to find anything that took me from the basics taught in the classroom to the more complex implementations in projects and career work. To mangle an analogy, I often felt as though I was taught to fish, but no one showed me how to clean and gut the fish. I just had a pile of dead fish on the ground next to me. And that can be frustrating and overwhelming al on its own.

I have a BS in CS. I agree with your expectation that kids going to college to learn to program should not be virgins to programming. However, schools are not the only way to learn prior to college. I remember as a kid in high school with the neighbors TI99/4A – we would stay up all night long at sleep overs reading the programming manuals so that we could write our own adventure games. I did have one computer programming class in high school.

And why exactly are you working on the assumption that someone who has never seriously tried out programming should manage to stay afloat?

We are after all dealing with a craft that requires the brain to think in ways most people have no experience with, and takes years to acquire. And I’ve met quite a few of those who never seemed to touch programming outside of course assignments and they didn’t have much in the way of the skills required to write proper code.

Computer science is as much a creative profession as math and music, and you don’t expect those who have no passion to do well in the latter.. Why then the former? We’re not dealing with accounting here.

Because a college course in which prior programming experience is not a prerequisite should be designed to build up and reinforce the skills and thought processes in a logical and coherent manner and at a reasonable pace. And it should use the tools (e.g., language(s)) that help this process. And so while topics such as pointers, heap-allocated memory, the use of first-class functions, closures, continuations, meta-programming, semaphores, parallel, multi-threaded, and distributed computation, etc. should eventually be covered in the degree’s coursework, they shouldn’t come too early and their use should be motivated.

And of course there can be other tracks for those who do come in with prior programming skills.

As a college teacher of CS myself, I have to say that there is something wrong with the model, but as you noted it presents real challenges. Personally, I started programming when I was 9 (1980s), so I had 9 years of experience before I took my first college CS class. I was able to concentrate on the computer science aspect rather than just getting the hang of logical/algorithmic thinking. Perhaps making a distinction between *programming* (this is C syntax) and *computer science* (sorting, stack vs queue, etc) may help. We already do this to a certain degree with data structures and other courses, but I wonder if we could better serve students with no experience by providing courses explicitly for learning what programming is before we dump them into CS classes. It would mean earlier courses or longer programs for some, but ultimately I think it is better than the “sink or swim” mentality.

I think there are some fundamental problems in primary and secondary schools that as college instructors we have no control over too. I firmly believe that any person of normal intelligence can engage in the kind of logical thinking required to program on some level – just look at how quickly young kids take to new technology and figure it out. Heck, even most elementary school kids could get into Sketch, LOGO, or BASIC. Like it or not, our futures are tied to computers, and basic programming skills should really be a part of core curriculum. As it is CS already gets less time than music does in most US schools.

Beyond that, our academic system in general probably isn’t tolerant enough of failure (it’s a big part how we learn, after all), but that’s a whole new box of worms… :)

Pain. Advanced programming concepts are mostly about avoiding pain. If students never experience that pain to begin with it becomes a cargo cult. Set them a goal, then keep moving the goalposts. As their once simple functions grow twisted with flags and exceptional cases, and as their beautiful class hierarchies lie dusty and unused, make sure they learn the right lessons in ruthless economy.

Nah, I kid. Programming ability isn’t all that necessary in computer science. You just have to believe in weird things convincingly and use some fancy language.

Programming is not something you learn at school. That would require you to stay at school for your entire life to keep up with the industry. I don’t think students who couldn’t even be bothered to learn the basics by themselves should be allowed to study CS.

I believe that I qualify as one of the “middle” students. I entered college at Truman State University back in 1998. At that time my only programming experience was on a TI-83 calculator. For me the introductory CS programming classes were just something I had to push through to get to what I really wanted to study, which was networking. Our courses used Ada95 as the base language which did serve to try to balance the playing field slightly because none of us knew it’s syntax.

I came very close in my second semester to changing my major to business because of the difficulties that I had with my CS2 class. Thankfully older “mentor” students in the CS program helped me through and now I have a very good career in computer networking, but am still able to do some coding when the job requires it. If I was designing a program, I would definitely be inclined to have multiple tracks. One would be the traditional “I want to be a programmer” or “I want to teach CS” track. The other would be “I want to be in IT”. Both would have programming components, but the latter would have programming interspersed with how it can be used within a non-programming job.

I come from a different school system where students have the option early on to choose a few units every year which pretty much gives the responsibility back to the student. If you want to study a subject on a higher level, prepare for it or work harder when you start university.

No one is forcing students to take CS degrees, if you have no interest or background in a subject why choose it as your career?

Second, University studies is supposed to be hard. What you lack in talent you can make up with determination or the other way around, but you can’t make it through without one of them.

The basic problem with computer science is that too many professors have a religious belief in The Right Way To Do It. Take object-oriented programming. It is taught early on in the curriculum because it is The Right Way To Do It. They totally disregard the fact that it took the brightest minds in the field several decades to get around to it. OOP is not easy to understand unless you have some background in programming. If you want to see more people succeed in programming start them with way the field was developed. Start them with BASIC and show how it relates to assembly. Have them experience for themselves what spaghetti code is. Then introduce structured programming. Add to it data structures. And finally, then you can introduce OOP with some expectations of wide-spread success.

My guess is that this is the order you learned things in and therefore you think it is the right way. Lisp first appeared in 1958, well before BASIC (1964). According to your model we should teach LISP first (or actually Fortran and then LISP, perhaps preceded by flipping arrays of switches).

Over the years languages have introduced useful abstractions. And some of those abstractions are about right when it comes to introducing computer programming techniques and allowing students to do something interesting early and start to build the process of thinking like a programmer. From those abstractions you can dig down to see how they’re implemented (e.g., assembly language, managing dynamic memory). Or you can build up to further abstractions (e.g., functions as first-class types, continuations).

This is the way people learn best. Children don’t start at the bottom (Belgian Malinois) or the top (mammal) but somewhere in the middle (dog) and work their way up and down the hierarchy. And that is how to teach computer programming as well.

I think you have clearly and succinctly articulated the problem, so props on that.

It seems like one obvious solution, based on your observation that programming/music “does not sit firmly on the standard high school curriculum” is to address the problem right there! Why shouldn’t 11th and 12th graders be learning programming as a math/science based elective?

I think that the choice of language is a big factor, too. C/C++ or even Java are two complicated/powerful for introducing people (not just students!) to programming. They’re too far from any conceivable problem domain of interest. Just the concept of a String data type is hard enough for many beginners, never mind the fact that they are obtuse or immutable in these languages. Not to mention the difficulty of setting up a sane development environment on Windows (where do I set my JAVA_HOME again?). Formerly, the “MIT” approach (adopted by my alma mater, WPI, just before I arrived) was to throw them both out and teach CS101 in Scheme.

I think the new MIT approach, to teach Python is a much better alternative. It’s incredibly easy to run a Python program (ie `python assignment1.ohcrapwrongfileextensionbutitdontmater`). The syntax error messaging is much more helpful, and logical errors (such as accessing a Dict key that doesn’t exist) throw runtime exceptions. Compare to the black magic of reading a C++ compilation message and having to realize “Oh, actually I think I just left off a semicolon”.

[…] = {"data_track_clickback":true,"ui_cobrand":"GeekSphere"};Eli just sent me this post entitled The deep end of the pool. I think this has show how backwards computing schools have become, and how they are being […]

I have for some 25 years taught CS 101 as an Introduction to CS, emphasizing binary, digital logic, subcomponents (from BASIC GOSUB to C++), artificial languages, state machines, data structures, etc — an introduction to CS!! The course has a lab component emphasizing small
programs done with pairs in a subset of C++. The assignments this fall will range from square (and cube) roots to work with fractals (glut) and user interfaces (LWTK).

One of the things I learned from Klaus Wirth was that the easiest thing in the world is blowing prospective students away with big assignments on short schedules. CS 101 is not a baby graduate course nor a strong vocational course, but an intro.

As a guitar teacher, I like that you chose learning a musical instrument for your example. Having said that, as a guitar teacher I am routinely finding “these days” that people’s expectations for what “learning to play an instrument” is about to be drastically underestimated to the point of being incomprehensible. When I was a kid for fun I learned Trash-80 BASIC, some C and assembly, and now as a guitar teacher I occasionally encounter self-professed “programmers” who make web pages with plug in programs – they don’t even know HTML. I’ll casually ask “do you know what a “Hello world” program is?” and I’ll just get a blank stare.

The bottom line is that society has now created a (large) category of people who cannot fathom that there are pursuits that require more effort/concentration/intellect than learning to play a video game. One couldn’t possibly face a pursuit that maybe requires more than average intelligence: everyone is equal. What makes me a good guitarist/musician, or someone else a programmer, is just a few weeks and an “Idiots Guide” away. Ahrrghh.

After retiring as a professor in the humanities, I returned to college as a computer science major. My institution taught the first-semester course in competing sections using Python or C++. I took the Python section and did extremely well — as you have described, it was possible to construct serious projects by the end of the course. But the second-semester course used C++ throughout, and I found the lack of articulation from the first semester an brutally high hurdle.

Data structures probably should not be taught without attention to pointers and other low-level elements that give meaning to linked lists and so forth, but because these don’t exist in Python, a much more sophisticated way of managing the whole curriculum must be found. Starting in Python and continuing in C++ without time for intensive practice in the latter is a recipe for disaster. I would compare it to a first-semester course in spoken French followed by a second-semester in written German.

The good side is that students who survive this mistreatment are more confident of their abilities.

I really like your bringing up the foreign language model. I hadn’t actually thought about the teaching model much before, but I do see one problem. We aren’t teaching “code reading” and “code reasoning” first. Certainly we learn to read first, then to write. I think the same should be true of programing. Learn to read first; learn the parts of language (that’s a conditional, that’s a function, etc); and then apply that knowledge to writing new code.

Surprisingly, I can actually see an entire semester long course dedicated primarily to code reading and code reasoning. Start with small samples and build to large multi-million multi-threaded code bases. Teaching them the power of good tools along that way. And once you can proficiently read code, then you can begin writing code. Certainly the first semester course should have some small bits of writing, but perhaps we are having students write too much too early.

I agree completely. I think focusing on reading before writing could significantly improve success rates. However, there are two problems:

(1) I can’t come up with enough code that is sufficiently interesting to engage students for a semester. You can write a lot of stories and music at a beginner’s level; but, it doesn’t seem to work that way for code. If you disagree, try to put something together. If it works, you would be a hero to many CS professors.

(2) I can’t fit it into the curriculum. Specifically, if I want to add an entire course on code reading, I would have to remove a course somewhere else. (Of course with enough evidence supporting the benefit of such a course, I might be able to work something out.)

I came into college with 2 years of high school programming experience so cs1 was not a struggle for me. If I compare my intro class in high school vs cs1, I think the big difference is the amount and scale of the assignments. In high school I did many more assignments though each assignment focused on one concept or lesson. In cs1 we probably only had 5 or 6 assignments though each one required understanding multiple concepts that were taught in class. Failure to understand one of those concepts would most likely derail the entire assignment. To truly help introduce students without previous comp sci experience, universities need to offer an introduction course that is structured like a class teaching someone to read for the first time. Start with the basics and reinforce at each step. Of course people with previous experience or a natural inclination should be able to test out.

I have to say that I feel myself torn. I was someone who was “natural born”, in your words, but I had no programming experience before entering college. While on one hand, I agree that this program is pretty intensive to pick up in 15 weeks, another part of me feels that there are those people who simply aren’t meant to be programmers. The 40 year old who’s going back to school to get a more “marketable” degree and still can’t wrap his mind around loops after 15 weeks is not someone who will be writing code professionally after 4 years.

Computer Science is not a field that you can decide to do on a whim. People who look at a CS program and think, “There are lots of jobs in computers”, are not always the type of people who can pull it off in the long run.

That isn’t to say that programming is something that certain people can’t learn. I think it uses fairly universal concepts that anyone can understand. I just don’t think that some people will grasp the levels of abstraction necessary to be able to program at a professional level.

That being said, I still do feel that there are those “in the middle” who get hurt by the way the current system is set up. These are the ones who have a love for computers, but may not have the technical experience needed to program effectively. I have no idea how to handle them.

You mention not finishing the degree in four years without previous experience. At some universities, including the one I am just getting my MA from, students in music performance with no prior experience are welcomed, but they take at least an extra year to graduate. You might choose to emulate a remedial year model where you teach students to think logically, algorithmically, iteratively, and so forth maybe even before touching code.

I believe the best solution is requiring an introductory programming course at the high school level.
As far as my background is concerned, I am studying physics and CS at CMU. I took one programming course in high school (C++). I hated it at the time, due to terrible course structure and a teacher that could barely program himself. However, I think having gone though this course allowed me to understand the thought process of programming, which set me up for success in college. Having a few years in between this course and my first year in college was very useful.
Moreover, since the world is moving so quickly into everything being computerized, it’s really silly to think that people should not understand what is going on around them. I believe that everyone, at a basic level, should understand a bit about programming and what is going on with their computers. After all, we don’t expect people to operate in the economy without some knowledge of basic arithmetic; the same should be true for interacting with computers and programming.

This approach does leave something to be desired, in that it will likely be years, if not decades, before the secondary education system is reformed. For the more immediate solution, particularly pertaining to the introductory CS courses, there are a number of different, excellent ways to go about teaching students.

Personally, my intro class was taught in Processing. The course began with graphics. It was useful for providing the distinction between compilation and runtime. With only a very basic knowledge, students could play around and do some very fun things with the environment. We eventually brought in concepts like loops and modularity to make a fairly broad intro course. Since it is built on Java with a more streamlined syntax, it gives you most of the tools of Java, so later teaching OO design in Java will come much more easily.

Another great option is to an interpreted language such as Python. This gives students a good way to test little chunks of their programs for compilation errors, allowing them to work on smaller, more manageable chunks of code at any given time. It is very useful in taking away the screen of errors students can often get the first time they compile a program.

Finally, I believe there was a mention of functional programs in the comments. I think using a functional language would be a terrible idea for an intro course. While an entirely functional approach does abstract away many of the difficult things about programming, it leaves out useful code constructs like loops that really serve as a key component to programming. Not only that, but recursion can be really hard for people to grasp.

As far as those who say it’s best to leave CS to people it comes naturally to, I believe you might be missing a large part of what CS is. It’s hardly just programming. Yes, programming is useful, but it’s not required if you are on the deeply theoretical side of CS. Moreover, the best way to get the largest growth in the field is to include as large a demographic as possible, getting people with all different types of thinking. By alienating parts of your demographic, you only hurt the field as a whole.

Twenty years ago I graduated from a similar university no one has ever heard of. In addition to my Podunkville U experience, I’ve been to a big state school, an Ivy League “name”, and will be starting at a big Canadian grad school this Fall. All the smaller schools follow the lead of the big names. They are built on the weeder model. The programs are not designed to teach, but to encourage drop-outs. You want students who can learn the material on their own instead of taking up valuable time you, as an Assistant Professor, should be devoting to research and grant-writing.

Even if you were able to solve that big problem, Computer Science suffers from the “way we’ve always done it” syndrome – ironic for such a new discipline. From 20 years of professional experience and a number of satellites in orbit, I can assure you that the mathematical foundation of computer science is seriously overemphasized. Another fallacy is that some new programming language will fix anything. Assembly, Pascal, Lisp, C, C++, Java, Scheme, and Python haven’t done that yet. It seems illogical to assume any future language X will. The whole language aspect is just marketing so that parents will be reassured that Johnny will be able to get a job upon graduation. There is nothing wrong with that. You can, and should, focus on delivering on marketable skills. The concepts are the important parts after all.

If you really want to teach computer science, you are going to have to get creative while acknowledging certain realities. Using language learning is a good start. As others have pointed out, just the idea of syntax is foreign to most people. From my experience, it is foreign to most programmers too. At the same time, you have to toe the ACM line to maintain accreditation.

The actual education students receive at a school like Grand Valley State University is likely to be better than that received from better known schools. The key is to acknowledge that the deck has been stacked against you. Get creative, but don’t let anybody find out. Computer science students still need calculus, but they don’t need to master, or even pass it. Computer science students need to know the hip languages and buzzwords to get jobs, but they also need to understand programming in order to succeed. Computer Science and programming are not the same fields. To provide value to your university, you need to do a good job teaching programming. But succeeding in that that will not provide any benefit to your career or credibility in Computer Science.

Discuss this with your dean and get administration support for it. Stop posting blogs about it.

I’m sorry, but I think you misunderstand. Students aren’t light bulbs that rely on good courses and teachers to switch them on, they are bees looking for the flower that suits them best. A good education should really just help a student find what lights them up, and otherwise get out of the way. Whether the school recognizes this basic fact or not is immaterial, because students will categorize themselves this way regardless.

The “natural born” experts (programmers, mathematicians, writers, etc…) don’t really need the professor or the course, this is why they learn and score well in even terrible classes. Furthermore, they will actively seek out the educational opportunities when the system fails them (clubs, competitions, labs, or making their own videogame). They rock at what they do because they love it, not because they got a paltry 1 year head start in high school. Bottom line: they don’t need the system to succeed.

The rest of us do need the system to work somewhat. We don’t love the field, we never will, and we’re in it because we need a job. Maybe we love to play music, or act, or write, but we (or our parents) have convinced ourselves we can’t pay the bills that way. Worse, maybe we don’t know what we love, or we love just chilling out or partying. We need to be exercised, like a soldier in a boot camp, and that will take hard work from you, the instructors and the school. You can’t expect us to get ‘interested’, throw that out the window, that just means some lucky student found their flower, not something you should count on, and you can’t expect us to work hard out of class. No, you need to pound us with drills, exercises, drills, and more exercises, forcing us to practice. Think like a good mechanical engineering, electrical engineering, or chemistry course, they’ve been doing this for decades.

I’ve been on both sides of this fence. In high school I was dragged along face down through all the courses, and most of it stuck. However our high school didn’t have a CS course (not really) at the time, but that was my flower, so I pursued it, taking courses at the local university. I even wrote a full code generating C compiler as a senior (for SPIM, using bison, flex, and a lot of horrible C++). In college I went straight into the CS program (although they didn’t want me at first, but I changed their minds after a couple semesters).

Conclusion: a good CS course should be a very good flower, and try to attract all the CS bees in the university. In parallel, create a good boot camp for the poor bastards that couldn’t find their flower for some reason. Good luck, and good work. Great post.

>Conclusion: a good CS course should be a very good flower, and try to attract
>all the CS bees in the university. In parallel, create a good boot camp for the
>poor bastards that couldn’t find their flower for some reason.

Absolutely right. But the problem we have, that the poor bastards usually appear wimps and fell out of the CS training facility in tears. ;)

Never the less we shoud not loose hope and proceed with the work on developing better and better CS courses containing a lot of exercises.

And I agree with other commenters that the exercises’d be carefully crafted and fill each and every small step of the learning process. A bunch for conditionals only, a bunch for combinations of several conditionals, a bunch for loops, a bunch for every combination of loops with conditionals, etc. Much work to do. Maybe someone have links to any stuff from ’70s or ’80s that already have this (with the explanations included :) ) ?

(1) I’ve taught community-college math and CS (stats, intro programming with Java, remedial algebra, etc.) for about 10 years now. Most of my job is really the remedial introductory algebra. Now, this is a subject that students have been studying unsuccessfully for about 10 years once they meet me (since grade 7-8). Nonetheless, the vast majority are totally unable to succeed at it — national success rates are about 30% in classes like these. Students routinely come through course 2, 3, 4, 5 times unsuccessfully (note: I have somewhat higher success rates than most sections at my college). The number of students for whom basic skills are like an abyssal trench is truly staggering.

(2) Saeed Dehnadi has published a couple of papers on giving a programming test BEFORE the CS1 course begins, with the apparent result that people who give consistent answers (regardless of whether or not they’re correct in the specific language syntax) have higher success rates than those who give inconsistent answers. Suggesting that there’s some innate ability apart from knowledge of language syntax basics — http://www.ppig.org/papers/21st-dehnadi.pdf

Just for the record, Python is *not* a procedural language! It is a multi-paradigm language, which IMHO is actually more object-oriented than Java is (there is no primitive types in python. 1 is an object of type integer, period). Of course you *can* do procedural programming with it, but simplifying it like this keeps people referring to it as a useless toy language which leads to poor adoption in the industry which again causes it’s non-existence in the classroom. Java has the better marketing, that’s about it ;)

+1 for ditching Java in the University. As a tutor in various cs classes I really know the problem, but it’s hard to do anything because most teachers are not really open for changes. Doing fun assignments does help a lot. Currently we’re implementing a redcode compiler and interpreter for the “Corewar” game. Some teachers are really creative and put a lot of work in assignments, others… suck ;) There should be more open source material specifically designed to teaching so people could build upon other peoples work.

There’s one thing I think that would really help a lot: removing a bunch of required math courses that a typical programmer will never need and replace them with more programming and software engineering classes. A lot of our students go through the CS curriculum for 3.5 years and then don’t know how to use version control, unit testing or other basic tools of the trade. We should really split our computer science degrees up into theoretical CS (we do have a scientific computing degree!) and a software engineering bachelor.

My recommendation would be to teach with a functional language to get the basics, then use that as a building block for investigating imperative languages.

My CS degree started with Haskell. It was hard to begin with (especially as someone who already had experience of C and BASIC), but my non-programming colleagues begun at the same level as me, and found the similarity to maths theorems helpful. You can easily (mechanically) workout how Haskell (or Lisp, Scheme, F#, etc) process their symbols. With C languages, you immediately get stuck with variables, data structures, stacks, heaps, pointers, etc., etc. – there is way too much plumbing to get right.

The second semester introduced C, but by that time, we at least were beginning to think like programmers. All assignments across the CS modules could be submitted in C or Haskell (sometime both was a requirement), so at least we could use the language that we felt most comfortable with, and, importantly, it did encourage us to understand why certain languages were better for different jobs. I wrote my first basic interpreter in Haskell, then a machine simulator in C, and then the compiler for that machine in Haskell.

I’m happy that I learnt Haskell, as my current employer uses F#, some Haskell, as well as C++, so I think there is also an argument that learning a functional language is not only useful in academia.

I am a student whose first experience to programming was in a CS-1 type of course. It was hard for me, but I loved it, and ended up spending a large amount of time on my own programming and diving into computer science. That helped me catch up to the others who had much more experience.

I am now tutoring a student who is almost exactly described by your article. He did CS 1, and did alright in it, but can’t program fluently after only a few week. He is now in an algorithms and data structures class, and can’t see the forest for the trees. Like you said, he expends so much energy on just following code that he can’t see the underlying concepts. Our tutoring time is basically pair-programming, and he is improving in his ability to abstract away from code to think about algorithms, but it takes a long time and money to pay a tutor, something that not every student will be willing to give.

I’m a 3rd Aerospace Eng. at a 4 year University and I’m taking what would be equivalent to CS 2. I’m taking computer science because of interest and the prominence of programming in the aerospace field (computational fluid dynamics, etc.). I see myself as someone who picked up programming quickly without prior knowledge but certainly did not excel at it (did not get an “A” in CS 1). That’s just a little background about me.

I would certainly agree that those who don’t excel at CS 1 certainly aren’t ready for the major. That’s just the reality of it. But so much of today’s engineering fields require programming, it’s almost a shame to turn students away as such. (did I mention CS is part of the engineering dept. at my school?) Our CS classes are with C++. Our school’s decision is then to offer classes with more “safe” languages: Java and Python. Topics such as memory leaks can be introduce later in CS while students can just focus on pointers at the time.

Like I said, I don’t consider myself a great programmer. I just really enjoy it and I hope telling you how my school does it can help lead to further discussions on this subject.

There is probably a better example of “algorithmic” mathematics than proving trigonometric identities, but this isn’t the topic of discussion.

In many low-level math courses, students can survive by learning algorithms without having a deep understanding of anything. In programming classes, students are asked to create algorithms, which always requires a deep understanding of the problem. Sometimes in math and science, the understanding can be postponed, so you will have a lot of students who get by just by learning algorithms. For example, when a students are asked to complete the square in a quadratic expression, you commonly see them automatically set it to 0 and solve. Even though they don’t understand the question, their solution does include the answer. In programming, this doesn’t work at all. You see students copying and pasting random stuff into code, hoping that it might work, and it never does.

I would suggest several weeks spent on writing (by hand) algorithms which accomplish simple tasks with simple machines using a few well-defined simple operations. At least, the students who think this is lame will understand better why they may not want to study programming.

Since I decided to return to academia a couple years back I have noticed an alarming trend of people who have no prior programming experience either doing poorly or dropping out of intro-level computer science classes. And it’s often not for lack of trying – it’s usually because of bad instructors or completely unrealistic expectations.

I am a firm believer that the standard CS1/2 curriculum is inherently biased against students who have never programmed before, It’s made worse by the choice of C++ and Java as an introductory language. While both are fine languages for some things, they are rough places to learn with because you have to fight the language in order to be successful programmers. More than that, a lot of fundamental concepts get dropped out of CS1/2 classes because they are extremely difficult to implement or teach using C++ or Java. Important concepts, like input sanitization, tend to get sacrificed so that OOP gets introduced. My personal belief is that OOP has no place in CS1 or CS2 – instead it should form a CS3 class so that students have a full semester to focus on grasping the complexities and subtleties of OOP. Students need more experience with procedural programming before moving off into OOP. This also has the benefit of not trying to teach them, say, binary trees and OOP at the same time. Besides, as I like to say: the only thing worse than a mess of procedural code is badly implemented OOP code.

Another problem I mentioned was that of instructors. This is where the humanities type professors and standard science professors have a leg up on computer science professors: they can guarantee that absolutely everyone entering their classrooms are at a certain proficiency and has a certain knowledge base. The education system prepares students for all of these classes before they reach college, but it does not prepare most students for programming. In most of these fields a very poor teacher can get away with teaching a class because the students already have the fundamental basis required for them to learn it. For programming, though, this places the onus of teaching firmly on the professor, but unfortunately computer science as a career field and skill set has very little in common with what is required to actually be a good teacher. Without a doubt the worst professors I have ever had were all computer science professors: I was fortunate enough to already have been exposed to their material in other places, so I am not saying this because of my performance in the class. I’m saying this because I have seen CS2 students handed assignments requiring linked lists when the professor had not even gone over them. I have seen CS1 students having to write programs that require concepts their CS2 counterparts had not learned yet. I have even seen a CS professor flat out tell students that they would not help them because the material was in the book, and showing them how to use it would be tantamount to doing their homework for them. Without a doubt the sloppiest teaching I have ever seen comes firmly out of CS, and it saddens me because it’s a field that I love so much.

Unfortunately, the sink or swim mentality breeds these sorts of problems. I remember what it is like to discover how to program, but unfortunately a lot of the students who are actually making it through these trials by fire do not. They have grown up in a world where computers have always existed and have been programming since they were at a very early age – many for as long as they can remember. They have never known what it is like to not know how to program, and they have never known what it is like to have to wrap their brains around the fundamental basics of programming. The problem is that without this perspective, without knowing what it is like to not know how to program, how can we expect these people to be able to effectively relate it to people who do not know how to program? In many other professions, similar “sink or swim” mentalities were often used to justify discrimination. Even though it isn’t overtly discriminating against any group of people, it still has the same effect: we are removing a large portion of candidates from the pool before they have any reasonable chance to be successful, and we are instead pulling people who already learned this material. In the process, we are eliminating the perspectives that these other people would have brought into the career field, and reenforcing the same stereotypes and concepts and paradigms.

A lot of people seem to forget what it is like to not know how to program, or that people don’t know this stuff inherently. It is not an inherent skill nor a natural skill – computers are a construction of humans, and there is absolutely no innate ability to program that is found in humans. Aptitude yes, ability no. Everyone had to learn it, so why do we expect people to already know how to?

Sink or swim; on something like PHP, Perl 5, Python that is useful but not as syntax intensive as a more C++ like language. Along with a good teacher that takes responsibility for teaching the student. Perl lets you get to something useful relatively quickly and get better with your usage later. Like learning English, one might start out with “Me hungry” at a young age. And later say, “I’m going out for ribs, care to join me?”

The very talented with innate skills will swim, the ones that find they have the innate skills and never knew it will also swim. The strugglers likely would never excel anyhow or need to go develop the underlying skills.

I took an introductory C++ course with no prior programing experience aside from some BASIC in high school. And it was a struggle. A short time later I went off and learned Perl on my own, now I could get fluent in most any programming language, if need be, as the basic algorithms have been assimilated and thought processes developed. Currently I’m working in IT.

As was said earlier, “College isn’t even for all the people who try to go.” Even excluding the ones that are there because a parent made them go and is funding it; some students are in the wrong program, or the wrong school, or just need to go out and figure out what they really want to be when they grow up and come back prepared to develop in that field.

Thinking back, a good ability to solve algebraic math word problems is probably a good indicator of a future programmer. Also Symbolic Logic could be a prerequisite.

I’m currently finishing my masters in CS and thought I’d share my experience. I’m one of the ‘natural-born’ types and breezed through our Into 1 & 2. A lot of the failure I feel comes from two aspects, the ‘art’ aspect of CS and the lack of dedication.

The author’s comparison to music I think is spot on. You expect those you arrive at the college level for music to have had experience in that field. You expect that they have a lot of practice under their belt, but you also expect a certain artistic ability. Even for all the science in CS, there seems to be an innate art to it as well. There is a lot of beauty in design, the aesthetics of simplicity, the brilliance of a binary search. Sadly I think this is connected to the ‘natural-born’ ability in people. Some people have more artistic ability than others. For the record, I am in no way an artist in the traditional sense, but my art school friends have recognized the artistic quality in programming.

Even if you can get past the ‘art’ aspect, the bigger issue is the lack of dedication. Anyone can memorize the factual information in CS, just as you were required to do in elementary, middle and high school. But if you don’t use it on a regular basis, or have the dedication to make it a career, you tend to forget it. Many CS students have a natural intelligence, but many still seem to struggle with composing software that uses the more ‘complex’ concepts like inheritance, interfaces, etc. I’ve talked to many of these students and many are ‘content’ with what they wrote saying “I won’t ever need this code again” or “Well it’s good enough for this assignment.” While this is true in most cases… there aren’t enough assigned projects to fully flex out your programming skills. The real experience you get I’ve found is not from the assignments you are given, but the personal projects you take on outside of class.

Even getting pass the introduction classes gives no indication of a students success. No one taught me inheritance, about the C++ STL, software patterns and other ‘core’ aspects of CS. While this ultimately is a curriculum shortfall, many students don’t go the extra mile outside of class to continue their learning.

Why are those people in CS, if they never programmed a computer before? Of course computer science needs more people than are available. The real problem is that the kids have been doing something in early years of their life, which is not useful for becoming a programmer. Somehow they failed to decide the correct topic for studying or chose something they’re not really interested in. There might not be enough paths for kids to learn programming. Possibly they never bought a computer, or only played some games and never found a development environment… Somehow the learning path for them failed.

There will be very big problems for those people. The complexity of computer software is so large that if you have not spend your whole life doing it, it’ll be impossible understand, much less create one of your own. In fact, I think the whole programming/computer science is broken because of the complexity. It does not help that people write libraries and tools that just hide the complexity behind some simple api. The overall behaviour of the system just cannot be understood properly without spending large amount of effort for it.

Of course, computer science does solve real problems in the world. But it’s also creating very big problem by introducing large amount of complexity. It’s not solving the complexity, but instead just requiring that the same complexity will be reimplemented every time the technology changes. This is very bad for the world.

In my opinion, the problem is that school is trying to cram everything in in a 15 week period. That’s too much. When I took on my degree during the ’90s, we were using Turbo Pascal as the primary teaching language. It was a nice procedural language. For our first course, we covered only first couple chapters that you would find in any “intro” books today. We went through basic concepts of statements, arrays and such. The class “weeded” out people who has not apptitude for programming. I would rather have the first course be the weed out course then find out later that there is no hope. The program I went through required people to have at least 3 semaster of solid programming class before taking on advanced topics. Also I’ll bet most of classes only required people to pass tests in order to pass the class. My classes requires 90% of the homeworks be completed in addition of passing exams. My comp. sci. classes were the only few where homework counts.

BTW, I saw a lot of references about “web” programming and such. HTML is not programming. If HTML is programming, then XML is also a form of programming language. Also just because some language such as perl has “easier” syntax doesn’t make it a good teaching tool. Any decent comp. sci. program has the responsibility of picking a main language where it can be served as a language that can introduce you to as many general concepts as possible.

I think today’s college students do not get enough problem
solving experience from school, play, or work.

At school, students used to learn some algorithmic thinking
by learning how to add, subtract, multiply, and divide, and
continuous use of these skills in math. Nowdays, it’s using
the calculator, so they might learned the manual way, but
it is not something that stays with them.

At play, we used to make up games and rules and argue
about rules, etc. Nowadays, the computer sets the rules,
and there no adjusting them. Also, we used to take things
and (sometimes) put it all back together again. Nowadays,
this discouraged by design or by law.

At work, well for me at least, I grew up on a farm, and there
is plenty of problem solving on the farm. I imagine most work
has gone to more computers and less problem solving.

Personally, I always praised the way my University focused on problems to be solved rather than tools to solve them. My professors approach could be summed up by one of the comments made at the close of their first lecture in Data Structures. “…oh and this course is in C if you don’t know it then you better buy a book”

I kind of dislike the courses where you spend a whole lecture talking about say strings in Java and writing little programs that use strings but essentially accomplish nothing. This approach, that imho used to be strictly the domain of non-degree granting institutions. It seemed to produce people who really only knew how to solve one thing, in one way using one tool.

The “sink or swim” approach IMHO produced people who realized that the language wasn’t the important part of solving the problem. This idea is re-enforced by the fact that some of those institutions have turned to the “Let’s talk about strings” approach and I interviewed one of their graduates, who went on to be a TA and he couldn’t code his way out of a paper bag.

Perhaps I’m one of those Prodigy’s but I went into that course having written only BASIC (and a little assembly) I had heard of C but never written any and never having any trouble with the language.

The problem with teaching a language vs teaching the concepts is a bit of a catch-22. If you don’t do the two in lock step you either end up with, at the end, someone who can spit out reams of information about finite state automita and NP =/!= P, but can’t turn on their computer without help from tech support, or someone who ends up being a cargo cult programmer.

Programming is hard, and the answer to get more to graduate isn’t to make it less hard when it comes to the real world, and applying that degree to a job.

It is a matter of sink or swim, but to be a ‘good’ programmer out of it, you need to be thrown into the deep end and see if you can hack it. For example, if CS1 is taught in Java, you need to explain what an Object is, and then you’re right into theory land. Granted you can ignore the Object and go from there, but then you have the students writing public class HomeWork1 {} without having any idea what the word ‘public’, ‘class’, and ‘HomeWork1′ mean in the language, and I’d be afraid that if they learn that they can ignore those words, they will constantly ignore those words when they get out of school.

In my experience, both as a student and as member of Teaching staff, the problem with Teaching Computer Science, Information Technology, and Software Engineering, is the practically non-existent attempt to make subjects relevant to … well … anything but direct chains.

An example of what I am talking about is Programming 101, relates (somewhat) to Datastructures and Algorithms, which relates to Advanced D&A; Introduction to Databases, relates to Advanced Databases; and Introduction to Networking and Operating systems relates to Operating Systems, and Networking. However, there are generally no unifying subject that allows students to mix all of their previous skills together.

This isolation does two things. a) It means that students are learning concepts out of context of the bigger picture, and b) there is little or no re-enforcement of these skills after you have finished a stream (sometimes even if you stay within the stream previous skill sets are assumed to be frozen in time)

The University of Queensland took a novel approach to teaching Computer Science in their Information Environments program (InfEnv). Each semester, students took a compulsory subject called Studio. Studios challenged students to solve problems using their existing skill set. So, as students learnt more, their tools for solving problems advanced equally, allowing for eloquent and elegant solutions to be created. As well as allowing students to continually re-enforce their skills over time in context of bigger projects.

Foundation Studios were focused and limited in scope. Quite often the lecturer would have tightened up the scope to such a level that it was easy to predict what everybody would make (design a website for this fictional client that I will represent). However, later Studios became extremely open: it wasn’t uncommon for Lecturers to say “Here is our problem, the InfEnv lecturers are based on two different campuses, Ipswich and St Lucia. Being cross campus is extremely difficult for a list of reasons. Help us solve some of these issues.

This system is flexible to the students who form groups (students always formed their own groups). Students would orientate around their skill sets. Aesthetic groups would focus on solutions that didn’t require technological marvels to pull off, while highly technical groups would pull together amazing bodies of work to generate something wonderful.

It also encourages students to learn through mutual collaboration. There is nothing stopping someone who is highly proficient in programming helping another group solve bugs, or even give in depth support over the duration of a semester (as long as students acknowledge the work of others). Because the students define their own solution, plagiarism is easy to spot early on, so the issue of peer lead learning no longer becomes an issue.

I was a student and tutor in this system, but later taught in more traditional CS programs at other Universities, and I never saw students who gained a similar range of skills and understanding about their disciplines than the students who worked within the InfEnv program. Not to mention, I have never seen undergraduate programs making such cool stuff since.

(individual) Research Proposal. Obviously constrained within the group design document What is it that the individual is wanting to learn? What does the scientific literature say about the problem space, and the proposed solution?

(group) Weekly stand up presentations (5 minutes) of what work has been done so far (what we said we’d do from last week, what we did, what went wrong, what went right).

(group) Formal presentation of work, similar to a conference presentation.

(group) Class expo of work: Work is displayed in an expo like format for people from other faculties, industries, parents, whoever, to talk to students about the work that has been done, and if the work is interactive experience it.

(group) Formal Post mortem

(individual) Formal explanation of what work the individual contributed to the group project.

When started working on speech synthesis project with Linguistics background I was given 10 lectures on Fortran. I could not write even one line of code at the end. So, after 3 months I found a book “Fortran Self Instruction Manual by S.c. Plumb”. I realised that there were three problems to be solved – The natural language problem with lots of missing (assumed) information, the coding language, and the storage structure. Once I broke down the programming into these 3 parts, I could generate code very fast. I wrote a book and published it myself and made money and then went on to write a Book on BASIC and then to C++ etc. The point is who ever is learning and who ever is teaching should write down the assumptions about what is being taught and learnt. Are there any hidden assumptions, are there any previous knowledge and understanding is involved and so on. So, the problem is complex.

As a programmer turned language teacher, I agree that is silly to get students up to speed in such a short space of time. But programming is more than just algorythmic thinking, though that is the part that gets a lot of attention. It is also designing user interfaces, applying problem solving techniques, performing needs analysis and whole lot more. Algorythimic thinking is of course important, and central to a good program. But I think getting people up to speed on the other. areas, is both interesting, and can provide a more reasonably paced introduction to programming. Leave off the heavy duty stuff till later.

Teaching programming is a lot like teaching a foreign language. Without actually using it, only the talented or very motivated will master it. I think students need to write a few programs first given basic programming concepts, by analysing a companies needs, designing user interfaces, and writing the code. After this, going back and covering the more intense subjects is likely to be a lot more successful.

But I agree that without the time to implement such a program, it is tough to teach programming.

The problem is simple: failure to be explicit about the actual prerequisites of CS 2.

If bright students are failing out of their dream for lack of mastery of the equivalent of “arithmetic problems”, then maybe they should be offered the opportunity to improve their skills at such?

There is nothing mysterious about “programming fluency”. It can be taught to any student smart enough to get into a good school. It requires many hours of practice. But it is not a big deal, unless the faculty are not courageous enough to face their own students, and help them understand that some may need to delay their CS degree progress by a semester in order to spend a few hundred hours in order to master some basic material.

Hey,
I was shown this post from a friend and it’s good to know somebody is learning this.

I’m in senior year in my college now and right from my freshman I have seen my fellow freshmen suffer because they were taught C and OOP using C++ in the freshman year. Things became worse in the next two years-OOP was completely removed from freshman year and moved to sophomore aka second year. I’ve interacted with students from all three years and they find it very difficult and makes things even more difficult in the following years in major courses such as Data Structures, Computer Networks and Databases where they spent their time memorizing code rather than understanding the concepts, just like you said.

I’ve conducted introductory sessions to python and the students have enjoyed the ease of python programming. I’ve seen first hand how Python beats C in the freshman year. Still our university fails to see that students just can’t learn C-they conduct bridge courses which are of no use. Then again no students pursued Python after a month since exam and other subjects took over as important.

The key issue which I have is that while computer science courses are 3 credit courses, other courses are 4 credits such as Mechanics. Also, students learn Physics, Chemistry and other such subjects which are of no use in future. Why do they still insist!

I believe that Media Computation is a cool way to teach programming and hope it becomes popular around the world. Students shouldn’t be afraid of programming, they should enjoy it :).

>Also, students learn Physics, Chemistry and other such subjects which are
>of no use in future. Why do they still insist!

‘Cause if you don’t understand physics, chemistry, biology, finance, politics, etc., you’ll have a very poor understanding of the world itself. And you might be suitable as a cooder, but not at all as a software engineer or any other CS professional.

Solution: Start teaching the basics of programming in high-school. Just some introductory stuff in a high-level language such as Ruby or Python. It will get some of the talented folk interested. That’s how I started programming…

I agree with this article. As a retiree from a successful career in IBM, I experienced exactly this problem as a university student at Colgate. My professor had the sink-or-swim attitude to learning programming, and as a result, I failed the class, only to go on and get QUALITY instruction in IBM leading to skills in assembly programming and other languages as time went on. Education is about LEADING students through the learning process, as evidenced by the latin roots of the word education. To ignore the need to spend quality time with students to help them achieve that key breakthrough is a failure to teach, a failure to do the job one is paid to do. I spent a few years in education myself, in IBM, and never forgot that failure, as it drove me to spend the quality time my students needed to master their new field of study.

>To ignore the need to spend quality time with students to help them achieve that
>key breakthrough is a failure to teach, a failure to do the job one is paid to do.
>I spent a few years in education myself, in IBM, and never forgot that failure,
>as it drove me to spend the quality time my students needed to master their new
>field of study.

Absolutely right. And there’s a problem attached – often students have very different background and you’ll need more time than there’s in a day to work with every single person.

To overcome this, teachers can cooperate with each other to split students into groups of similar background/level. And then you can focus on doing stuff well for one or two particular levels of understanding. And another teacher will cover couple of other levels.

I started my CS degree two years ago. I’d never programmed before and hadn’t touched maths in four years. The learning curve was painfully steep, but I’ve managed.

People learn foreign languages fast when they’re immersed in them. I think you could fix the worst of the gap with one intense semester (or bridging course), but more important than the content is the attitude. People haven’t done computer science before, so when the program doesn’t compile, they go ‘well, shit, I don’t know what went wrong’. You have to gain confidence in your own ability to fix the error(s). And you gain confidence faster when you know you’re not holding half the class back with dumb questions.

I dislike this idea that there are programmers and non-programmers and if you can’t program, you can’t program. I tutor 10-14yo kids in maths; most of them think they just can’t do maths, and mostly, they need practice, basic problem-solving strategies, and encouragement. I suspect programming is the same.

I’ve taught CS at University level for many years. I’m also old enough to be part of the generation who never had computers before University, because there weren’t any. I believe the presence or lack of a well developed mode of algorithmic / computational thinking is the key differentiator between those who can and cannot manage our early courses. So those who grow up solving logic puzzles, playing tic-tac-toe, solving Sudoku, getting farmers, goats, lions and cabbages across the river, trying to put 8 queens on a chessboard, playing card games with inference and logic, finding a knights tour around a chessboard, are way ahead, not because of syntax or programming isses, but because their fundamental mode of thinking embraces “step-by-step” algorithms as a core approach to problem solving.

I suggest that the students wishing to do CS be divided into those who have adequate background to succeed in CS1 and those who don’t. This should be handled like the math evaluation that puts a student into “remedial” math if that’s necessary. It should not be stigmatized at all, of course, so let’s call it “supplemental” instead.

A good way to do this supplementary time might be as a summer course between high school and first semester in college. Such a course would ideally be something like half computer play, half work. If you can’t learn to enjoy playing with a computer, I doubt you will get far in programming. The work would be too painful and boring.

I agree with your article entirely. Being a not natural and first time programmer going into school. I just finished 2 years of CIS ( computer information systems ). Looking forward to two more to get my degree.

First semester Programing 111 with Java, taught by an old polish man. He was ( still is ) almost impossible to understand. His lectures literally made no sense what so ever. I struggled very much so but made it through with 50 percent. On several occasions when I asked for help the teacher he told me I should take something easy in school, like photography and arts.

Second semester Programming 112 I decided to switch into the other teachers class ( there are only two teachers for introductory programming at my school) . Again I had a hard time with the course. This teacher was a little smug. When ever I asked him for help he would vaguely say some or just smile and walk away. During his lectures he mostly just talked about things that Java does and its history, or maybe some stories from his past. He would go into OO programming and polymorphism but we were never really tested on them. Anyways about half way through the semester I finally figured out how to code, with the help from some of my friends. It was funny because at this point in the program, I didn’t even know how to write a function. Made it through the course with 66 percent, not really proud but I did it without the help of an teacher.

I should also mention that neither of these teachers knew if they were teaching systems analysis or a programming language. It was not even clear in the course descriptions.

I am still not a very good programmer but I try hard every day. I am really good with SQL and HTML, CSS, and javascript but not as much with Java C or C++. Some times I wonder if I am really cut out for this. Maybe it is a waste of time to finish my degree. My first two programming teachers really made me feel like I will never make it in the field.

Sorry that was a bit of a rant and maybe nonsense too. Its really upsetting when I look back on things. What I am really trying to say is that both of my teachers would sooner give up on me then help me break the seal. So instead I taught my self and here I am.

I have seen a lot of changes from when I went to school for computer science in 1998. Some good changes, and often ones that I don’t quite see as positive in the field. There is a very large separation in talent and drive these days within I.T. and programming. The most current generations in some ways have things at a disadvantage with computing and systems from the older generations.

I recall my first computing experience growing up as a kid at the age of 6. I started learning commands and some basic programming so I could use the TSR-80 my family had. Later it was DOS, then I found Linux in it’s early days (1993) and have been heavily involved with UNIX and UNIX like OS’s since for both personal and work.

I taught an Intro to UNIX course for my University as an undergrad in 1999 (as a suggestion of my advisor given my extensive prior experience). The first question I had for the class was “Who has worked with DOS or UNIX commands before?” About 90% of the class sat there with a blank look on their face and were not familiar with either. These days, I ask kids right out of college I interview if they know how to connect two computers together on a network and get the same blank looks or the usual “I don’t know hardware stuff.” response. It’s sad really. My lego and building blocks to tear apart and create as a child were old computers, electronics, and even software. That intrigue to “know how it works” and drive to find out more pushed me to where I am today. Where is that drive? The first thing I tell folks that ask how to be successful with IT that are starting out is that you must have an interest in technology. The most successful are the ones that want to know more, and will do what it takes to learn on their own to achieve that knowledge and growth. When I interview students at college recruitment sessions, I get the same answers, same projects, same replies as all of their peers. Then on occasions that one or two students go 10 steps beyond their peers. It’s the ones that do things like setup a server for source code repositories just to help out their coding classes, or that decide to hack on hardware for fun and apply that later which make the top cut.

With how complex systems are, how difficult coding can be without a extreme dedication and drive, I don’t feel watering down the difficulty to pass students is the best option. The main question you should ask is “Do you love technology enough to do what it takes to work in the field”. If that answer is no, then why have students graduating that don’t care about their field or have a passion for it?

The College of Charleston has implemented a solution that is currently under test. We started by designing and implementing a four-year computer science curriculum for high school (Porter Gaud School) to broad participation in computing and deliver seniors out of high school with the equivalent of a CS2 course in OOD/OOP. In Fall 2011, all four years of the CS program will be running concurrently.

I concur with your music performance analogy. Programming is a set of cognitive skills that needs time and practice to develop. On another thread, perhaps we could explore how performing music and composing music are fundamentally different and how those differences map to computer science.

Reference: Starr C, Burgman D, Zaubi P. The Development and Implementation of a Context-Based Curricular Framework for Computer Science Education in High School. ACM-ITiCSE 2009, Paris.

I thought the point of this article was that because Universities want to teach Computer Science and not programming. People come in without a knowledge of programming. So essentially “Where does the knowledge of Java or syntax come from?” While I don’t know what your program contains isn’t teaching computer science at the high-school level just creating the same problem? Not to mention that even if successful it may well be because you are simply selecting poor performers out at an earlier level.

I think both the music and language analogies are weak from a curriculum POV. Both have, in most universities entirely different outcomes from CS. A CS degrees desired outcome is someone who can take up a profession in software development. Outside of some very specific school programs rarely are language or music programs geared toward someone becoming a translator or a concert pianist. So when the outcomes are different why on earth would you assume that the curriculum should be the same?

Also there have been a couple of studies to show that experience isn’t a great differentiator among software developers. So again the music analogy may fall down here too if experience is analogous to “practice”

I can only speak from personal experience, I am definitely not a natural born programmer and I would consider myself mid-senior level with 10yrs work experience. The only tinkering I ever did before computer classes was to play with the windows OS settings. My first few classes were c++ & pascal and my thoughts were what the hell am I doing? I went to struggle for the next 2 years in college and it wasn’t until I got to a visual basic class that I was able to start grasping concepts and lights bulbs starting going off. I think this was because I was use to using programs like MS word, etc, and starting backwards with a gui where I can create objects similar to all apps first, then coding, made putting the pieces together a little easier.

The solution is much simpler. Change the high school carriculum by adding a programming course as an elective. In my country everybody who wants to study computer science at college has usually taken programming classes for two years in high school. So, 99% of the students come well prepared when going to university. And if they decide that they don’t like programming then they can use their high school diploma with a good grade in programming to get into other science courses at university such as Physics. And if they decide to do Computer Science at university and they had not chosen Programming in high school then they can take more time to do preparatory classes or try to survive if they so choose. Thus it offer the best of both worlds. If you know that you like programming and want to be well-prepared for college, then you can start learning it at school. If not, you can still take the class and use the grade to get into another compatible college program. If you haven’t taken it at school and you then decide to learn it, you can try to survive in the college courses or take some years off to prepare.

Consider throwing oop out of the curriculum as much as possible. I’m not saying that it doesn’t have its place, but it shines on large projects with reusable parts, just the kind of thing that beginner programmers don’t work on/with.
Instead you could focus on imperative with a small language like C or a friendly language like python. What’s nice about doing this is that students have an overall model for what programming is: a sequence of steps to do something.

You are saying the people who do well are naturally talented. No, they’re just the people who can learn a handful of types and memorize some statements in 15 weeks.

You are saying that the normal student will generally earn a C. This is correct, this is how grades should be distributed.

The way it is phrased, it takes all accomplishment away from those who have done well. “Oh, you’re naturally talented.” It’s like telling someone with a good body that they are lucky, when in reality, they went to the gym every day and worked their ass off.

I took CS. I put in a lot of time and expended great mental energy to understand it (because I liked it and that is what it takes to do well). I made sure to code every concept in that class, doing about 5 times more ‘homework’ than was assigned. Let the people who don’t want to work their asses off take an average grade. We shouldn’t coddle people just because they don’t strive to understand the material.

The average grade in Calculus is a C, should we spread that out over 4 years? No. We should let the people who put in the time get good grades, and let the people who don’t care (willing to not put in the time then drop the course when they are doing poorly) take a junk grade.

Those who are naturally talented or have prior experience are not some strange exception, they are the people who care about Computer Science. Rather than derailing everything for someone who only feigns interest when negotiating a higher grade with you, help the people who do care. Help the people who turn in a homework assignment, get them into their office hours if the solution is incorrect, encourage them to do more if it is correct.

Not so many years ago in the UK, you could study Computer Science before University as an A-level, which looked at sorting algorithms, general hardware and software. These days it has become IT or Computing and takes the form of Visual Basic – is it so bad a language, really, to get to grips with loops and conditionals? (I guess there has been a shift from algorithms to GUI design.)

As part of Mathematics before University, there is the Decision Mathematics modules, but they are very rarely taught or supported in the UK. They are not so much programming as thinking-based.

First, I’ve encountered too many CS instructors/professors who simply cannot program. How can they be expected to teach a skill they have not mastered?

The second comment is based on a successful technique used in the two-year programming degree at Kirkwood Community College in Iowa. All of their students used to start with a course called “Program Documentation and Design” in which they worked entirely on decomposing problems into design. The only programming used QBasic (since replaced with Java) but the programming was secondary to the design and thought process.

For my one thinking, I believe we will make more progress when we remember that the college degree programs were originally based on trade guilds. The undergrad CS student is essentially an apprentice. When finished with a four-year degree, the student goes into the world as a journeyman Computer Scientist. If we use this mindset, we can more easily express the expectations of the students, the requirements of the academic programs, and improve marketing to potential students.

I think the root problem is that many of the things that are considered too hard for beginners are in truth fundamental to understanding whats going on.

Take pointers in C for example. I can’t tell you how many introductions to C that I’ve read that have some variant of “pointers are confusing, we’ll talk about them later.” I think it would be much better just to get it over with. Make an array of ten numbers, read them out with an index, then make a pointer to the first element of the array, dereference it, add one to the pointer, dereference it again, and you won’t have mastered pointers but at least you’ll understand why array indices start at zero.

Most of the concepts aren’t too terribly difficult if you are thinking like the person did who stumbled on them. C is indisputably the language of Unix. If you want your students to understand C (and from it computer science in general) get them inside Dennis Ritchie’s head circa 1978. C in its natural setting is simple and elegant; C outside of Unix is like looking at a wild animal in the zoo, you can’t figure out how it got to be like it is from the surroundings you see it in.

Spending a few weeks learning to use a shell and writing clones for echo or cat would not be wasting time when you should be introducing theory. It’d be immersing students in a milieu that lead to some very productive ideas.

I went to Calvin College in GR, and my freshman year, I took the intro to C++ course (the first programming course.) My previous ‘programming’ experience was limited to creating simple batch scripts, and modifying them. I could not grasp the concepts in my class, and even went to the professor during our ‘group’ projects to plead him to not take my failures out on the rest of the group. He obliged. My senior year, I decided to take the same course again – and despite not having touched much programming since, everything fell into place, and it was a breeze. I decided to stay another year, and crammed in the rest of a CS minor. I’m not sure what the problem was my freshman year, but after giving it the resting period, it was almost easy. I’m not a programmer today – I’m a System Administrator – but I certainly write a lot of perl, php, and apply what I learned in my classes. I’m glad I tried the second time, because I learned a lot, and found an excellent career.

Zack; A good person to talk to is Greg Wilson at U of Toronto who started the Software Carpentry project that Los Alamos funded. He is a great resource for curriculum path design. After going to his workshop, I realized we should create an articulated path in high schools. So I added PHP to my 10th grade course in web design and have repeatedly proposed Python in our programming path. At any rate I am fascinated with your comment on cognitive overhead and the metaphor of mastering an instrument. There are many issues that interfere with learning and mastery that we don’t consider central. Even in the posts here, the issue of stressors outside the course isn’t mentioned. Perhaps the success of mathematicians should be examined as well. Greg has measurements of how much time graduate level science majors spend programming for manipulating data. (highly intelligent non CS programmers)

What about MATLAB? While it’s a language designed for engineers and scientists, I’ve found that some schools have had pretty good luck teaching intro programming classes with it.

Teachers have told us that the informal nature of the language allows students to focus more on the programming constructs than on the syntax. They also like the ability to connect to real-world and interdisciplinary concepts (therefore increasing students motivation) because of the inherent engineering and math functionalities.

Some teachers have started to take advantage of the fairly new good OO support in MATLAB to introduce OO concepts to students.

In the interest of full disclosure, I’m a former professor who now works for MathWorks helping other professors integrate MATLAB into their classroom. I know i come across this post very late in the game, but i’d still like to know people’s opinion about this.

Giampy

Comments are closed.

Atomic does more than talk about software. We also make it — for clients large and small in all kinds of industries.