Students who did not have the privilege of hacking since they were young are at a disadvantage in Computer Science (CS). However, CS departments can teach introductory programming using an obscure functional programming language to limit the young hackers’ advantage. Most students with prior coding experience learned a procedural programming paradigm, so forcing all students to struggle with learning a new, functional language helps restore meritocracy.
In the blog comments, Kite recounts hir experience with an intro CS course:
While I think my course was pretty sucky, one good thing it did was to knock the wind out of the sails of those guys who’d been programming for ages – by starting us on an obscure functional programming language called Miranda (oh did it ever raise a whole lotta grumbles from the boasters). Only after that did we do procedural stuff like C, and then onto C++. Mind you, the whole course seemed determined to be as academic and un-real-world as possible, so C++ was probably the most career-relevant thing we got out of it! […]
The grumblers grumbled because they could not take advantage of their prior programming experience.
Another benefit of a functional language is noted in John’s response to Kite:
A well-known UK university did that for a while, using ML as the introductory programming language, specifically to wipe out the bad habits people learn by teaching themselves using BASIC etc.
If obscure functional languages become common in intro CS courses, it is reasonable to expect that young hackers will try to game the system for grades by learning functional languages in preparation. However, functional languages can be very different from each other, and there is still logic programming and possibly other viable programming paradigms to exploit.
In any case, basing an introductory CS course on an obscure programming language and an “academic” programming paradigm is a clever equity hack.
Additional comment guidelines: Resist the urge to talk about what programming languages you personally know. You can talk about programming languages, but try to connect it to the post topic, or say something that people may find interesting even if they don’t care about you personally. If your introductory CS programming course taught a non-procedural programming paradigm, you can talk about that.
Geek Feminism Blog 
Oh, I definitely agree with this! When I started programming I took an intro class that used Scheme. I had no programming experience at all, and the class was honors level, so it was full of d00ds who had experience in other language and generally thought they were super hackers. But even with no experience, I ended up at the top of the class, because using Scheme leveled the playing field a bit.
Hmm.
OTOH, it seems like this approach caters to people who want to look at programming as an abstract art in the realm of pure thought – who get excited about the program itself, who see the program is its own justification. On the other end are people who get excited about what can be accomplished with the program, and it seems like they’d likely be discouraged if what they’re learning seems useful only for solving abstract problems in the course, disconnected from real-world applications. I’ve seen it claimed that women are more likely to be the latter type of thinker.
Anyway, I definitely see the point in not letting swaggerers suck all the oxygen out of the room, but it seems like the same end could be accomplished the way Carnegie Mellon did, by giving self-rated beginning programmers a class of their own separate from the self-rated experts.
I’ve seen this claimed as well from a few anecdotes online, but I’m not convinced. I’m female and I’m the former type of thinker. To me, beautiful code is similar to beautifully-constructed sentences in English. I like arts and humanities, and programming-as-an-art is in the same category for me, an aesthetic creation.
OTOH, it seems like this approach caters to people who want to look at programming as an abstract art in the realm of pure thought – who get excited about the program itself, who see the program is its own justification. On the other end are people who get excited about what can be accomplished with the program, and it seems like they’d likely be discouraged if what they’re learning seems useful only for solving abstract problems in the course, disconnected from real-world applications. I’ve seen it claimed that women are more likely to be the latter type of thinker.
I find those claims hard to believe, because math is so much more gender-balanced than CS and engineering are, especially at the undergraduate level. (NSF report from 2008: 43.9% of U.S. math and statistics bachelor’s degrees were awarded to women, while only 17.7% of CS bachelor’s degrees and 18.5% of engineering bachelor’s degrees were.)
It’s for that reason that I think that emphasizing the more abstract and theoretical aspects of CS might be a good way to get more women involved. The field needs more awesome theoreticians — maybe some of those women majoring in math can be tempted to join us. (Of course, the field needs more awesome hands-on folks, too.)
I’m not speaking for anyone else, but I remain primarily a practical sort of person (I think I have a great deal of S in my INTP) so for me the big attraction is the practical aspect. Physics was very practical at school, but when I got to uni, it was strictly theoretical, and I was bored, and programming seemed much more practical/useful/immediate to me. The theoretical-based CS course was hence not my ideal (I’d probably be more open to it now, I was quite …distracted at the time). I still entirely approve of starting with Miranda. Now I come to think of it, I do seem to remember a disproportionately high amount of post-grad women though in the department, so it seems there was a great attraction to the theoretical for women.
(Skud, did you do a post-grad at Unimelb? I have a memory saying yes but I’m not sure if that’s true.)
By the way, is everyone on moderation now, or just me?
Seems everyone’s on moderation now, at least overnight. Sorry, I was worried that losing it at some douchewad on a previous post had gotten me on watch.
Yes, I’m putting everyone in moderation now for this post.
YES. This was my experience exactly. My passion for programming had sprung up from the practical side (having a problem I wanted to solve using code), but my intro to CS course in university was all theory and I hated it. Scheme, which was taught in the same way C had been (ie. fully theoretical) was only an endless, meaningless set of parentheses to me. I sucked on tests because my explanations of the theories were never good enough and it was hard to remember names of procedures and functions that — on computer — I would just look up when necessary. I failed at doing sorts because I didn’t get the formulas behind the theories (the O(n^2) stuff). And taking that course made me believe for years afterward that I sucked at programming and shouldn’t pursue it as a career (well, that and the fact that I have problems doing certain forms of algebra, which was one of the driving reasons I failed the co-req calculus class).
Despite teaching myself PHP and SQL to integrate into my webpages, it wasn’t until I came to my current school and was taught coding from a practical (versus theoretical) perspective that I realized I was a good enough programmer to make a living off of it if I so chose.
My background in programming helped (ie. I’m not refuting the point of this post or the one that originated it), but the approach of my current school versus my university helped even more. So, yeah, I definitely think that it’s important to level the playing field, but I believe that also entails re-thinking the way in which universities look at and teach CS courses and/or the way we look at and treat IT schools that go for a more practical, hands-on approach.
I think you are highlighting the difference between computer SCIENCE and software ENGINEERING courses. I did a weird smoosh of both at uni, and my first course in computer SCIENCE was Miranda. The reason they taught this was to level the playing field, remove syntax from learning basic programming theory (Miranda is almost syntax less) for things like recursion and searching, and while I hated it at the time, looking back I am really glad I had all that drummed into my head first before I went into the realms of different languages and their uses for solving (lol or creating) problems.
For context, the course was at the university of melbourne in 1995.
OMG that was when I did it. We did the same course together! Why did we not meet each other!?
Theory is a turnoff for most people.
While I am grateful for the introduction to functional programming and the theoretical side of CS, my former university produced scores of graduates that couldn’t program, which pretty much meant they didn’t understand how to actually apply all that theory they had learned.
There is a lot of value to a more hands-on approach, but when you cut out the theory and the abstract stuff, it stops being CS. CS is a science, not a programming certification, it’s a shame how often it is treated that way.
I very much sympathise with this POV. One of the reasons that I have never learned to program is that it takes SUCH a long time to actually do something useful.
Learning an abstracty woo-woo language might appeal to those who like “beautiful” code or whatever, but for those of us who like to make things work, doing such a course would be frustrating in the extreme.
Obviously if you’re doing a CS course with a programming focus, then a course in non-procedural languages should be part of it. But to me it’s more the kind of thing you’d do if you want to delve more into the theory of something – like studying linguistics when your major is German.
A few thoughts, not necessarily consistent:
— No programming language used widely in introductory CS courses will remain obscure. Recent CS grads will push to use it in their projects (due to familiarity) and people will write textbooks for the new market and in ten years it will be a popular and widely used language. Even sooner than that, AP CS courses will start to teach the new standard and high school students with designs on a CS degree will learn it early in preparation. Your hack is not stable against people who find and pursue their path early… which was the whole problem you were trying to address in the first place.
— If you want to use a functional language for the purpose of breaking students of their bad habits (which is a good idea in and of itself, aside from meritocratic considerations), why not Scheme? It’s the basis for what, IMO, is the best introductory computer programming textbook ever written (The Stucture and Analysis of Computer Programs; Abelson, Sussman & Sussman) and there’s plenty of good tools and references out there for it. It’s also pretty damn obscure among younger folks, at least IME. I learned it before I learned C, but that’s because I’m weird… and also not really a programmer (although I do seem to do an awful lot of it).
— A college education is a huge investment of time and money; forcing students to spend part of their major hours learning a language that is deliberately chosen to have as little commercial applicability as possible strikes me as a bit of a dirty trick. It’s different than core humanities curriculum, because that’s required in order to provide the seasoning and worldliness that a college graduate ought to have.
I love Scheme! It’s beautiful.
However, the hack isn’t about a specific obscure language. The idea is that what counts as obscure changes over time, and there will be a moving wall of obscure languages. The obscure language could even vary from lecturer to lecturer, depending on her preference.
I’m not sure that teaching a language like Scheme is a waste of time and money. It’s something that programmers should be learning anyway to expand their mind.
(Anyway, Scheme has some commercial applications. I was once offered a position as a Scheme developer, but the place was too far away.)
I realize Scheme and its relatives have commercial applications; that’s a bit of the reason I suggested it but I ended up editing it out in the name of making my comment a bit less verbose.
My dirty trick comment was more aimed at the idea of teaching a language that doesn’t really have existing commercial applications, like Miranda or Eiffel.
I don’t really like the idea of ‘everyone use a different language’, because I think that inhibits the development of really good tools, teaching aids, and textbooks for intro CS. It’s a tough problem, isn’t it?
No programming language used widely in introductory CS courses will remain obscure
Then pick a new one every couple years. There are so many decent obscure languages that this shouldn’t be a problem.
That’s what my course did after a couple of years.
Purely functional languages such as Haskell (or its predecessor Miranda) will remain obscure enough, they just aren’t capable of being popular.
When a programmer first tries Haskell, a language that doesn’t allow side-effects in regular code (such as reading from a file or database, interacting with the user, setting or reading from mutable variables), the first reaction is to find it absurd that any software could be written this way. Been there. It takes some effort find out that you can write practical software this way, and it will change the way you think about the structure of your programs.
This makes learning Haskell is not only one of the most mind-bending and mind-expanding learning experiences a programmer can make, even if you never use a functional programming language again, it also makes it a much more powerful tool for breaking imperative habits than impure functional languages like Scheme could ever be.
However, the more academic functional languages such as Haskell (or ML, to a lesser degree) are quite frustrating when you are more interested in making a program work than in thinking about that program. These languages are strictly “think first, program later”. This is a turn-off for many and problematic, as it inhibits a “learning by doing” approach, at least until the student “gets” the language, which takes a while.
Any institution that teaches CS as a science with theory and everything should consider teaching functional languages (which does include Scheme), it is not a waste of time, even if you never use the language again.
Your post really clarified why I’m wary of the idea presented here – it’s exactly because I’m a “learning by doing” person.
There are a lot of ways to define “learning by doing”. I think it really depends what you’re interested in. If you’re interested in being able to try things on a small scale and immediately get feedback, I think that the functional-versus-procedural question is less important than choosing a language with a REPL, or interactive environment. Languages with REPLs include a lot of languages that are typically thought of as procedural, as well as a lot languages that are typically thought of as functional. (For those who learn by example, here’s a Ruby REPL that you can try right now in your browser.)
(Languages like C, C++, and Java don’t have a built-in REPL. Some folks have come up with clever hacks to try to bring REPL goodness to those languages, but it’s not the same.)
I love Haskell, but it requires much more learning before doing than other languages.
In most languages, it is good to just dump some unstructured source code into a file and fiddle with it until it works. That kind of code would never type-check in Haskell, where making code run requires knowledge of both the type system and the structure of your own code.
Haskell has a REPL though.
That’s also a good point- I love Ruby and Python for that reason.
I wouldn’t say it’s a dirty trick; if done properly, it should help students to learn not a specific language, but how to learn languages. Some schools seem to be turning out graduates with just one language (almost always Java) who seem to afraid to learn other languages. But teaching a language which helps you understand the underlying principles helps you to learn other languages.
Perhaps Scheme should be in the core humanities curriculum :-) (Ha ha only serious… study of current culture can no longer ignore the presence of CS.)
This can be a useful hack — for the been-programming-forever students to get out of established mental habits as much as for leveling the playing field — but it’s definitely not a new one. MIT famously (or notoriously) used Scheme for their intro class from 1980 to 2008, and a big list of other schools followed suit.
More generally, I’d agree that any intro that makes students face problems from a different angle rather than using preexisting knowledge is good pedagogy as well as a potential privilege hack. But I’m not as convinced that changing the language is an automatic win; it’s still possible for the new challenge to be put in terms of “those of you who already program will see….” which leads right back to the starting problem.
I can’t speak for other people, but learning a relatively obscure functional language as my first programming language in college turned out to be a wonderful, life-changing experience for me. I was talking about it with one of my professors from undergrad some time ago, and I’ll quote what he said:
Having said that, though, I would be wary of deciding to teach anything just because it’s obscure. Choosing obscurity for its own sake seems pedagogically unsound to me. I usually advocate for functional programming languages in intro CS classes because I believe that there are additional benefits beyond the leveling effect. In fact, I’m saddened by the idea that the handful of students who learn functional programming before they get to college might be thought to be “gaming the system for grades”. It’s not “gaming the system” if real learning is taking place.
“In fact, I’m saddened by the idea that the handful of students who learn functional programming before they get to college might be thought to be “gaming the system for grades”. It’s not “gaming the system” if real learning is taking place.”
IIRC from the last post thread, part of the issue isn’t so much ‘gaming the system for grades’ as it is the potential for educators to assume a certain level of knowledge of their students. They may consider it a way of ‘weeding out’ the weaker students, but it doesn’t so much weed out weaker students as it does weed out newer students.
I’m not in STEM, but I have a number of classmates who are non-traditional students. The basic computing classes I have to take are boring me to death, but at the same time some of my friends are still trying to learn the basic functions of the programs we’re using. When I was killing recess on the library computers, they were raising kids or deployed overseas. So while I hate that I have to take such a basic class, I can see why it’s needed. (And it’s not like I’m learning nothing, but I used to screw around with PS a lot, so I’m a bit ahead of the curve)
IIRC from the last post thread, part of the issue isn’t so much “gaming the system for grades’ as it is the potential for educators to assume a certain level of knowledge of their students. They may consider it a way of “weeding out’ the weaker students, but it doesn’t so much weed out weaker students as it does weed out newer students.
I think I see what you’re saying: if educators are trying to “weed out” weaker students but end up weeding out newer students instead, students could “game” the flawed weeding process. It’s on the educators, then, to make sure that if they’re going to weed, they should at least weed for the right thing. (And since the “right thing” to be weeding for is potential, rather than experience, and potential is much, much harder to determine given that we don’t have crystal balls, perhaps the best thing to do is to refrain from any attempt at weeding.)
(And since the “right thing” to be weeding for is potential, rather than experience, and potential is much, much harder to determine given that we don’t have crystal balls, perhaps the best thing to do is to refrain from any attempt at weeding.)
Yes! Both CS programs and programming communities in general seem to have this strong need to weed out those who aren’t qualified, but they have no skill at doing it. The duds remain oblivious and stick around, and the people with potential but no confidence think the message is directed at them and flee. After witnessing this behavior for the last ten years I’m firmly convinced that we’d be safer to not attempt to weed out at all, until we get better at both detecting and nurturing potential and knowing how to frame the messaging to the people who really should leave.
We actually had Scheme as first programming language when I began at university. The goal of that course was to teach us basic programming abilities, not to learn a specific language, though. I’m not sure why they choose to teach us Scheme, but in the light of this discussion, I realize it did level things out a bit.
Later I’ve had a whole course called “Programming paradigms” where we used a lot of different languages – also very good, since you were forced to use a specific paradigm for each assignment. This also leveled the playing field.
I like this in principle, but I wonder whether encountering a functional language as an intro might have turned me or other students away from programming. I took a couple of courses that were taught in ML, and really disliked them after I’d started programming in C++! OO and a little bit of procedural stuff were really what made it feel like magic to me, because I could make things that did some of what I wanted fairly quickly. That’s not the experience I had with ML. Maybe it was the way ML was taught or something, I don’t know.
Except for those of us that were interested in that stuff as kids as well. ;-) But yeah, most young hackers stick to just procedural languages, and maybe OO. Hardly any bother with other paradigms. And this:
Absolutely.
And I can only see this as a win-win situation, really, teaching these sorts of languages up-front as the intro language.
Women (and many guys, too) taking beginning CS courses wouldn’t get so many self-confidence issues due to comparing themselves to their hacking-since-8-years-old classmates, and those hacking-since-8-years-old classmates would actually be learning something new and useful in their intro coursework, instead of just being re-taught a bunch of stuff they already know. And they get taught a bit of humility up-front, too, which is good for character building ;-). So everyone wins. Even as a guy, I would love to see this just for my own benefit.
I wish the CS department at Caltech (in 2002) had been more explicit about why they used Scheme in CS1, and then widely publicized what they were trying to do themselves, in the course description in the catalog, rather than leaving student rumors to do their thing. CS1 was, at the time, the only intro CS class and a prerequisite for any other class. Unlike most of the freshman core curriculum, it was not mandatory, so you had to ask around and find out what other people had thought of the class. The overwhelmingly popular view was, “They teach you basic programming in a language that no one uses, so if you want to learn a useful language, you have to take another class after that.” As such, many people, myself included, who would have benefitted from the class but were not planning to be CS majors, skipped the class and, in fact, never took any CS classes. Later, when I was a student member on a curriculum, we discussed why so few people were taking CS1, and the lack of a useful language came up. We recommended to the CS department that they offer their intro-to-various-0ther-language classes without prerequisites for people to take if they just wanted to learn a specific language, say, for their research. I graduated before this was implemented, but I know that my own department was considering offering its own programming class for the language(s) most widely used in earth sciences, and I’m not sure what happened there either.
I regret never taking a CS class. I believed the people who said that learning Scheme was useless, but in retrospect I can see the appeal and I wish they had been very explicit about why they were using it, and its benefits to people who knew nothing about programming, but maybe a little about computers. (A significant percentage of the student body, upon matriculation, would have fallen into that category.) Maybe it should have even been part of the core curriculum with math, physics, chemistry, and biology– after all, in those other core classes, they were explicit in saying you had to take them even if you considered yourself a hotshot freshman coming in already with AP or college classes, and made it very hard/rare to place out of anything because they wanted you to learn it (or be exposed to it anyway….the amount of learning varied by quality of instructor) using the most rigorous approach. Saying the same thing for CS would have fit in, only the difference would have been that far more people would have a level of knowledge from being self-taught rather than having credits they thought should be transferable.
You make an important point. An introductory course is a gateway to the rest of the field, and if it portrays an aspect of the discipline that students find unattractive or not useful, they can make the wrong assumptions about the specialty as a whole. It takes someone with a well-established prior interest or a personal habit of academic masochism to overcome a negative first perception and opt in anyhow.
I think it’s pretty much impossible for an introductory CS course to cover the full range of engaging things the discipline has to offer, but for students who haven’t known since age 5 that they wanted to be programmers, providing some sort of survey is important for providing perspective about the utility of the coursework. People need to have some sense of what’s beyond the gateway, not just the gateway itself, and functional languages are only one chunk of that pie.
While I’m sure that’s a vague possibility, I don’t think that’s significant. The main issue is not to avoid an advantage gained by those who deliberately learn specific skills so as to prepare for a specific curriculum. The main issue is to mitigate the effects of “early exposure to computers” privilege. To that end, you just have to avoid having your language become “the” language that the 13-year-olds with lots of free time spent on decent computer hardware are learning.
And I don’t think functional languages are going to become that. (If MIT using scheme as the first computer language for nearly two decades before finally switching to Python didn’t do it, I doubt anything can) My own experience would suggest that there are age-related cognitive development reasons for that. (without violating the note at the bottom of the top post, let’s just say that different languages work best with different styles of thinking about problems, and my thinking style changed as I matured)
As for languages to choose: sure, there’s Miranda, but the previous post’s comments also introduced me to Reactor, which looks really interesting. If only my day job would let me go learn an obscure functional language for no foreseeable financial benefit…
As a relatively new CS student (have yet to complete my first year) the intro-to-programming course I was in started us out in C, then moved to Java halfway through the semester. This semester I’m taking two programming units, one of which is Java all the way down, and the second of which starts out in C and moves on to a rather restricted Assembly language (the LC-3 emulator). My prior programming experience was all in the context of a diploma in IT about 12 years back which was largely in Pascal (and a brief flirtation with BASIC a further 10 years before that), so while I had some programming knowledge, I wouldn’t have counted myself as an adept programmer before starting the class.
I’ve found working with C and Java much more understandable than working with Pascal was, although this may be because we had a series of lectures about the actual theory we’re implementing at the same time as the practical classes (rather than practicals where no theory was taught at all – we just got told “do this” and left to figure out the rest). A lot of what we’re learning now is about algorithms and planning the program before we start coding, rather than just hacking away and seeing what happens at the end of things – and at least one of the more vocal “coding forever” proponents had a lot of problems with this particular approach.
I’m not sure whether this particular approach would be able to be transferred into a different set of languages or not. I know that working with these well-known languages has given me a lot more confidence in my own abilities as a person capable of writing programs – if I can write in a commercially used language, I’m more of a “real” programmer, even if I’m still a beginner.
I’m in a Masters of Information Science program that required a sort of everything computer course for new students. I’m studying to be a librarian so this was a good course for me.
The programming language we learned was Python along with HTML, XML, and about SQL. There was a very practical approach and most of the more programming oriented people could take a test and not have to take this class. So they were able to really construct it for someone like me, who has some knowledge of computers but not of all the behind the scenes parts.
I like the idea of leveling the playing field as much as possible and found the practical applications the most helpful. I think the hard part is figuring out how to make sure that everyone is learning and not feeling behind or too far ahead, especially in large programs where the range of what people know on entering can be so wide.
there is still logic programming and possibly other viable programming paradigms to exploit.
My graduate intro computational linguistics class (my background is Linguistics, not CS) used Prolog, a logic programming language, and it seemed to have the kind of levelling effect talked about here. Although everyone was a Linguistics graduate student, about half of them were on the Computational Linguistics track and had either industry experience or a BS in CS, while the other half had not ventured much beyond one-line commands for stats in R. Even so, because Prolog is relatively obscure, everyone seemed to be doing fine and understanding the actual content (parsing algorithms mostly).
A couple years later, a someone else was teaching the course and chose to do so in C, and I heard the course was an absolute nightmare for the non-computery linguists who were taking it. Maybe it was the difference in instructor, but everyone I talked to was always going on about having to deal with the language.
The Lisp group of language (e.g. Scheme) do have a big plus for teaching, which follows from making no distinction between code and data. (Other languages may provide some access, but, for example, the parser output data structures in Python don’t look like Python code.)
Along with the core of the languages being pretty simple, it means that students can be shown the whole structure of the interpreter, quite possibly in the space of one lecture, by showing how to write a Scheme interpreter in Scheme. I’ve used this when teaching (to students who already know some other languages) and found they tend to get an “aha” moment when they realize why variable scoping works the way it does, and how parameters and variables are related.
The great thing is that a Scheme interpreter in Scheme isn’t a particularly large Scheme program, and being able to understand it should be a big confidence boost to students, because it lifts them to understanding a language from the inside and shows them that implementing a language isn’t just something for others to do, but is within their own reach.
And, on further reflection, choosing a language that students aren’t particularly like to get jobs using may not be such a bad thing in its own right, because there seem to be plenty of graduates who learn one language and stick to it, so they may learn to be more flexible in the long term if they start with a language that they’ll get less commercial chance to stick to.
I like the proposal in theory, but when I apply it to my own university experience, I don’t think it really solves the problem. Sure, it’s only a personal anecdote, but I remember reading “Unlocking the Clubhouse” and suddenly feeling like the most average female programmer in the world, because it reflected my sentiments so uniformly.
I think back to my first college CS course and the utter terror I felt sitting in that classroom every day, the tears I cried on the occasional night where the damn program just wouldn’t work. And I think back to my exposure to Scheme and ML a few years later, the complete exhausting brainbendedness of completing just a few simple algorithms.
I can only think that in that introductory class, if I had been exposed to Scheme (or another functional language) instead of Java, that terror would have only been amplified. I was always walking that fine line of “Do I stick with this” and I suspect that such an introductory experience would have crossed such a line.
I had enough privilege in my youth to cultivate an interest in CS pre-college, and I brought a small amount of programming experience with me. I still found that the gap between my prior programming experience and that of my classmates was enormous. Even with Java, our course had a “leveling effect” by restraining students from using libraries and all but the basic data types in programming assignments. I was one of the best students in the class with regards to performance, but I nonetheless internalized the messaging my professor was giving to other students when he was trying to bring them down to size. The big-headed, boastful students still had big heads and still talked of themselves as hotshots even if they were doing miserably academically. Similarly, an A on a test wasn’t enough external reinforcement to stop the internal monologue of fear and worry that I didn’t really belong; it took a lot more evidence (read: several more classes) before that terror started to abate.
I continue to find that the experience of witnessing other programmers being brought down several notches doesn’t provide much comfort in regards to my own struggles as a developer.
I get that this post addresses more of the “mastery of the material” aspect of merit, and to that degree, sure, a functional language does absolutely level the playing field. But being able to master material requires an ability to engage with it in the first place, and in that case emotions play a strong role. I think the privilege of growing up hacking provides an emotional advantage as well: you’ve been able to confirm your interest in the discipline, so you’re less likely to challenge your own commitment to the course of study than a student with less experience who doesn’t yet know if CS is right for them. I suspect most students who don’t fit the traditional hacker narrative are keenly aware of their difference from their classmates the moment that they step into the classroom. A universal lack of familiarity with the material isn’t likely to minimize that difference by much: since when does the stereotypical hacker actually reveal that he has no idea what he’s doing?
I also agree with the commenters who have discussed the practical components of this. The unequal playing field has been far more obvious to me in industry than in academia. I don’t think that the CS discipline should turn itself into a developer training program, but at the same time I think it’s terribly unfair (to undergraduates especially) to not incorporate some basic tools with which a CS graduate can use to enter the workforce into the foundational curriculum. It’s disingenuous to, as academia is wont to do, pretend that students aren’t there to advance their career prospects. When CS graduates aren’t prepared to enter the workforce, everybody loses – the graduate, industry itself, the CS programs that need a consistent influx of students to sustain themselves. Students who come in without any languages under their belt aren’t going to get extra points from a functional foundation when they apply for summer internships or otherwise try to immerse themselves in the working world.
Like Catherine, I have read that many female CS students want to see the practical applications of their learning (“Unlocking the Clubhouse” is just one of many texts I’ve read on female CS retention that mention it.) There’s a subset of potential CS students, male and female, who are engaged by what code can do before the code itself, and even without functional languages being taught in introductory courses, I think a lot of CS coursework is still too abstract and theoretical to really connect with these students if they aren’t able to go into this work with some anchor to the real-world applications. This doesn’t mean that these students aren’t capable of being engaged or interested in theory, but they need a bit of perspective before they can dive in deep and immerse themselves. People decide to engage with and stick with CS for all manner of reasons, and we’re wasting potential if we’re only nurturing the people who are here to geek out on theory.
I guess this argument presents the most difficulty for me because it’s just impossible for me to detach the coursework from the emotional rollercoaster that can be one’s first CS courses. This is a time when a lot of students are searching for a sign that this is the right field for them, and I would hate to mislead people who otherwise had great potential. I was ready to engage with and appreciate functional languages when I did so at the end of my college career, but if I’d seen them at the beginning I would have probably ended up misidentifying myself as “not a programmer.” I hate to address the leaky pipeline when we’re talking about establishing true meritocracy here – because I understand they are separate issues – but I see establishing a true meritocracy as something of a subset of the leaky pipeline. Figuratively: I’d hate to increase the outflow from other portions of the pipeline due to my attempts to plug up just one of the holes.
But the obscure functional language idea is for the first programming course, which is completely different from what languages CS graduates would know by the end of their program.
That’s why I also mentioned the efforts to prepare for one’s career during college. Students looking for summer or part-time work will still be selected on their practical skills (with a few exceptions), and a good number of the students who are coming into college without prior programming experience will be unable or unwilling to do the outside work to acquire those extra languages in their initial years.
Maybe that seems like small beans in the big picture, but I know it was a big deal for me. My summer internships were ultimately what made me decide once and for all to become a developer, and if I hadn’t been able to acquire that internship in the first place I’d probably be on a totally different path right now. CS programs are enormously top-heavy, spending the first years drumming in the fundamentals before getting to the really interesting (and practical) stuff. For most of the students at my school, those classes were in their senior years, junior if they were lucky – so if they wanted to acquire work experience to complement what they were learning in the classroom, the fact that they had learned their fundamentals in a commonly used language meant they had more opportunities to acquire work experience using that language.
I also have to reiterate that “they will learn the other languages after the gateway course” assumes that the student won’t self-select themselves out of the CS path due to the nature of the gateway course. Students in gateway courses don’t yet have the knowledge and experience to grasp the “big picture” role that learning the fundamentals with an obscure language would provide them, and I don’t really trust the ability of most CS instructors to provide that insight. More widely-used languages at least provide students an easy means to grasp at a bigger picture – to see practical applications – without the assistance of a professor.
The big-headed, boastful students still had big heads and still talked of themselves as hotshots even if they were doing miserably academically.
As a teacher, this is something that I notice all the time. I’ve noticed that male and female students act differently when they don’t know the answer to a question. The male students who don’t know the answer bluster, make things up, and do their best to sound like they know what they’re talking about. The female students who don’t know the answer say “I don’t know.” (Of course, there are exceptions in each case; nevertheless, I’ve seen a pattern emerge over three semesters of teaching CS.)
Let’s game-theory this: suppose that you’re a female student in a class where all the students are as I’ve described. You’re sitting in class one day. There are five female students and 25 male students, as usual in CS classes. The professor asks a question, and you don’t know the answer. In fact suppose it’s a hard question, and only 20% of the students know the answer — say, one of the women and five of the men.
Then the professor randomly calls on a guy, Jimmy. One of two things happen: Jimmy knows the answer and answers the question correctly, or he doesn’t know the answer and he confidently bullshits. But since you yourself don’t know the answer, you can’t distinguish between the two, so either way, it seems to you like Jimmy knows the answer. It doesn’t occur to you that Jimmy would have just made stuff up, because that’s not part of your worldview; it’s not how you operate.
In fact, if Jimmy doesn’t know the answer, the only people who will realize that will be the 6 students who do know the answer, plus the professor. Alternatively, if the professor calls on you, and you say “I don’t know”, then all 30 people, plus the professor, will know that you don’t know the answer.
Repeat this scenario a few dozen times over the course of the semester. The men and women are always equally likely to know or not know the answer to a question, but every time a woman doesn’t know the answer, everyone sees it, and every time a man doesn’t know the answer, only a select few people see it. By the end, what gender-related conclusions are the students going to draw about one another?
The good news is that as an educator, I can do something to fight this. First, I can loudly discourage students from trying to bullshit, and instead praise the value of an honest “I don’t know”, so that when anyone is confused, everyone realizes it. (I know that some of the female students I’ve had would be astonished if only they realized how confused some of the guys were.) Second, I can nudge people who don’t know the answer toward saying, “I don’t know, but my best guess is…” or “I don’t know, but I know that it isn’t…” — because often, the “I don’t know”-ers actually do have a pretty damn good idea what’s up; they just don’t have an answer on the tip of their tongue.
Really great points. I’ve observed this tendency myself. I was a lab demonstrator for first years for one semester, which I was really too shy, depressed and terrified to do, and never did it again, but I sure did see a lot of men bullshitting their way through any answers I put to them. (They were pretty offensively arrogant towards me too.) The women were earnest and quiet by contrast and needed encouragement to speak, not that I was very good at that.
If I’d continued in the job, I would’ve gotten better at handling the more annoying men, and encouraging the women, I’m sure. And I definitely saw the stats in my course that first year women did better than men, playing out. Though the levels of cheating/copying were on gender parity.
You seem to be saying that when a student makes up an answer to a question the teacher doesn’t say anything. In my CS classes, if someone made up or otherwise flubbed an answer to a hard question, the teacher would indicate that it was wrong or partly wrong and either call on someone else or explain why. Is there a reason why this isn’t enough to deal with people who make stuff up?
You seem to be saying that when a student makes up an answer to a question the teacher doesn’t say anything. In my CS classes, if someone made up or otherwise flubbed an answer to a hard question, the teacher would indicate that it was wrong or partly wrong and either call on someone else or explain why. Is there a reason why this isn’t enough to deal with people who make stuff up?
I think there’s a difference between indicating that a student is wrong and actively discouraging bullshitting. Bullshitting is derailing in nature and I’ve seen many instructors come along for the ride; they may indicate that the student is off-target but then engage with whatever the student decided to throw out anyhow, probably in the hopes of providing some perspective. That’s a lot harder to sort through than an “I don’t know” or a wrong answer without the fluff attached, and you can make an impact on classroom culture if you indicate that you favor an “I don’t know” over a bullshit guess.
Jeff, you’re absolutely right — my contrived example does not take into account the reaction of the professor. The thing is, though, many professors react pretty well to a confidently delivered but wrong answer. They reward confidence and are willing to overlook incorrectness. Even to an answer that’s completely wrong, the professor might say something encouraging, like “That’s a potentially interesting idea, but…” So, in the end, the student isn’t made to look bad in front of their peers. Meanwhile, if a student the kind of person who doesn’t like to say anything unless they’re sure they have it right, which is a tendency I notice particularly among women, the professor will react negatively to their “I don’t know” answers.
The great irony I notice is that a lot of the guys want to say “I don’t know” but they feel like it would be wimpy to not try to come up with some fancy answer. There seems to be a taboo among the guys against admitting that you don’t know, just like there’s a taboo among the girls against giving an answer when you’re less than 100% certain. And both of these get in the way of learning.
Lindsey, you captured my experience exactly. I never provided answers for the instructor (the material was too fresh for me to engage with it that way – I have to sit with it for awhile), and the ability to discern the “correctness” of the students who did was lost on me. I only had a sense of people who were over-eager or people who were bringing up irrelevant points, not a sense of people who were making things up. That sense seems to come with experience.
Reading this has made me think back to when I was teaching small-group tutorials at a university. I found a teaching style that seemed to work, and now I’m hoping I didn’t terrify any less-confident students.
One of the main parts of my technique was to keep track of what each student knew, and use this to (a) explain the next thing that they hadn’t grasped in terms of what they had got, and (b) keep the group at roughly the same level, which sometimes involved getting one of the first ones to understand something to explain it to the others (which would also help the students to learn to teach each other, as well as being better able to fit in with the lectures which they were attending but I wasn’t).
The groups were small enough that I could make sure that everyone was answering questions; I could simply pick a student by name to answer each question.
I’d also use my understanding of what each student had understood, to teach them by asking questions that were too hard for them, and then prompting them in the right direction after each wrong answer, so that they’d arrive at the right answer in stages, and hence understand why it was the right answer, and also get more of a feeling of having derived it themselves, than if I’d just told them the information as a fact rather than through a question. (This is the bit where I’m now worrying whether I might have been too scary for an unconfident student, although I think I would have noticed at the time.) In terms of what Addie relates, this means that the students would hear that they were all getting wrong answers. And as I pitched my questions to suit each student’s ability, the more capable students would get much harder questions, and would actually get more wrong answers on the way to the right answer — might this even be encouraging to others who might have been awed by them?
I think that in effect you can probably implicitly call people on any bullshitting by asking them to explain in more detail, or to give their reasoning.
I’d be interested to hear how the approach I used would come across to the less confident students. (I was teaching at a university with a very high intake standard, and the path to get there probably instilled academic confidence on the way.)
I’m reminded of the Joel on Software article on the subject:
http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html
I have to agree with most of what Joel says. No matter what your background is, your intro class to Computer Science, Software Engineering or Computer Engineering should cover at least some hard programming concepts.
That being said there are a number of catches to the idea of using a functional language as the first programming class. What about non-majors who need to apply their skills right away, like the electrical engineers who take CSC 101 at my university so that they can program micro-controllers? What about the rest of the curriculum that assumes that you already know C so that they can introduce you to the underlying architecture? I can see why CSC 101 is in C, at least at my university and the functional programming is saved for much later.
The folks who have been ‘hacking since 8’ and really know everything that a good intro course is supposed to teach should have the option of challenging the course. They have no interest in sitting through a course that teaches what they already know. That would be boring and a waste of time to them, and to everyone else.
There is also the issue of non-programming knowledge. If you were the IT guy or gal in high school, you are going to have a significant advantage in doing everyday things like copying files to and from your department’s UNIX accounts and learning to use some of the new tools that programmers use. Learning to use the tools can be almost as much of a burden as programming, to those with no experience. You are going to have disparities of these kinds of skills no matter HOW you split up the programming classes.
No problem at my uni. The electrical engineers went straight into C, because they needed it for a practical application. (As opposed to the Comp Sci stream/major, where ‘practical application’ was a foreign term. :) )
@lbef:
If you are truly confident that you are innately talented in programming, then the idea of limiting the advantage of prior experience should not threaten you. If you are a hacking-since-age-8 student taking an intro programming CS course to learn instead of to game the system for grades, then you should be happy that you are learning something new instead of something you already know.
I agree it’s a very good idea to teach fundamental computer science in a functional language, I thought that was the way every uni did it. I have actually never encountered one that didn’t start that way. Either using LISP or SCHEME. It’s computer science, not applied programming.
However, I feel this is yet another attempt to stick it to the white man. Where is the complaint about sports scholarships? Is it fair that some people get their tuition fully paid just because they happen to be athletically gifted? Where is the meritocracy in that?
Removing the special privileges of white men is not sticking it to the white man, just as women’s right to vote is not a form misandry.
My school did not have sports scholarships.
@ Eternal wonderer:
No, focusing on the privileges of white men is indicative of interest in racial and gender equality. See Robert Jensen’s article on white privilege.
I live in Canada, and also in Ontario, so sports scholarships are virtually non-existent here. Thus, I don’t really care about discussing cultural particularities specific to the United States that don’t apply to my country.