Some thoughts on my years of college

December 2008


In his famous last lecture, Randy Paush star­ted by say­ing that when there’s an elephant in the room, one should start by introducing it. My name is Óscar Pereira, and I’m a Computer Engineer. I’ve spent the last years, from Fall of 2001 to Spring 2007, in Coimbra, get­ting the aforementioned degree. And I’m writing this document as a writ­ten statement of why I think those years were both the single biggest waste of time and resources of my life, and at the same time one of the biggest rip-offs I’ve ever been through (education-wise!).

It has been my intention for a while to write about this. How­ever, I did not want to do so in the after­math of the longest half-decade of my life, lest the recentness of events biased my accuracy on relating them (by fail­ing to see the big pic­ture properly—after all, it was half of a dec­ade). Hence the only start­ing to write now. The last remaining issue in need of some explaining is the la­guage: all the events related here took place in Portugal, among Portuguese people. So it does feel a little strange that I should choose to account for such events in English. The reason is quite simply that despite the “Portuguese nature” of said events, some of the con­clu­sions are import­ant enough to not be restricted to Por­uguese readers.

How it all began

I enrolled in the Depart­ment of Inform­at­ics Engin­eer­ing of the Uni­ver­sity of Coim­bra (Por­tugal), in Octo­ber of 2001. My object­ive in doing so was to learn about computers—that one was obvious—and the know­ledge and tech­no­logy that loiters around them: math­em­at­ics, pro­gram­ming, secur­ity, and inform­a­tion man­age­ment in gen­eral. There are more, but those are the ones that most inter­ested me. And for a while, that was what happened. But the signs of rot star­ted early.

The first one of those was the Java pro­gram­ming lan­guage. It was the lan­guage used to teach the stu­dents how to pro­gram. I had some lim­ited pre­vi­ous exper­i­ence with C (but not C++), and as far as pro­gram­ming lan­guages were con­cerned, that was it. So when we star­ted learn­ing Java, I delved into it. And pretty soon, I star­ted to notice some­thing really weird. In sev­eral assign­ments, after I’d thought out the algorithm and star­ted to code, there were com­piler errors I just could not fix. The teacher would then reply some­thing like: “yeah, I know why this hap­pens, but don’t worry about it, you’ll learn how to deal with that in the next semester, when you learn object ori­ented pro­gram­ming”. If you hap­pen to know Java, you can prob­ably sur­mise where this is going.

By the end of the semester, I had really star­ted to dis­like Java, but I could not pin-point what exactly I didn’t like about it. I mean, of course they should have taught that “object ori­ented” stuff earlier, but other than that, it was just another pro­gram­ming lan­guage. Even­tu­ally things eased out, but I never really quite got what was it about hav­ing Java as one of the first pro­gram­ming lan­guages that caused me so much dis­com­fort. Until, much later, I came across this:

Let us pro­pose the fol­low­ing prin­ciple: The irres­ist­ible beauty of pro­gram­ming con­sists in the reduc­tion of com­plex formal pro­cesses to a very small set of prim­it­ive oper­a­tions. Java, instead of expos­ing this beauty, encour­ages the pro­gram­mer to approach problem-solving like a plumber in a hard­ware store: by rum­ma­ging through a mul­ti­tude of draw­ers (i.e. pack­ages) we will end up find­ing some gad­get (i.e. class) that does roughly what we want. How it does it is not inter­est­ing! The res­ult is a stu­dent who knows how to put a simple pro­gram together, but does not know how to program.

Some­times, the best things you can read are those that tell you what you already know. For some­thing like this to hap­pen, in place where pro­gram­ming is sup­pose to be taught, is noth­ing short of unac­cept­able. Recently (one year and half ago, I think) they star­ted teach­ing Python as a first pro­gram­ming lan­guage. I think that was a very good decision. Why did it took them so long? I’ve no idea… (I don’t mean why did it took them so long to change to Python, I mean why did it took them so long to change it, period! Even C would have been bet­ter…) I can only sur­mise that they were try­ing to give the (Por­tuguese) soft­ware industry what it wanted (Java web developers). Which, by the way, is not what an uni­ver­sity should do with its alumni. But that’s another story

As an end note, I add the fol­low­ing: I’m not say­ing one should not learn Java, end of story. The authors of the afore­men­tioned art­icle name two reas­ons to learn Java viz., reflex­ion and the rel­at­ively friendly way of using threads. What I (and the authors) say, it that using Java to teach how to pro­gram is a very ill-devised strategy, and one that will pro­duce mediocre pro­gram­mers at best. The fol­low­ing quote, also cited in the art­icle, from Bjarne Strous­trup, the cre­ator of the C++ lan­guage, should prove insightful:

It [Texas A&M] did [teach Java as the first lan­guage]. Then I star­ted teach­ing C++ to the elec­trical engin­eers and when the EE stu­dents star­ted to out-program the CS stu­dents, the CS depart­ment switched to C++.

The Engin­eer­ing phase

The remainder of the first year, Java aside, is essen­tially math (and a puny class of phys­ics). The next year, is when things really start to get inter­est­ing. It is also when the heavy work­load really starts to kick in, but for all the stuff we were learn­ing, I thought it worth­while. Sadly, that’s the first and last year about which some­thing like that could be said.

From the third year onwards, things star­ted to go very wrong very fast. First of all, the work­load, heavy as it was, increased at least threefold! Some­time near the end of that year, one teacher would tell me that “who­ever can put up with the third year, can put up with any­thing” (free trans­la­tion). !!! I heard a dif­fer­ent form of the same bull­shit next year, when a teacher said (shortly after the begin­ning of the semester, when he gave the class the toughest assign­ment of that semester): “it is my object­ive to put you under stress, and see what you can pro­duce under those con­di­tions” (again free trans­la­tion). That would actu­ally have been a very inter­est­ing chal­lenge, if it had not las­ted the entire semester!! You can’t sprint for the whole length of the mara­thon! Well you can try, but it is bound to yield a bad res­ult

Besides still retain­ing the focus on the tech­nical aspects, most of the classes from third year onward start push­ing in increas­ingly high dosages of man­age­ment related tasks (viz. devel­op­ment meth­od­o­logy, doc­u­ment­a­tion galore, …). This was mad­ness. One thing is to teach, another is to make stu­dents do the work as if they were work­ing in a soft­ware com­pany. The reason why such a thing is mad­ness, is not because it isn’t a good idea, but rather because most of the stu­dents can’t afford the resources to mimic such an envir­on­ment. If the col­lege can’t afford those either, as it is often the case, the stu­dents are left with an unsolv­able riddle. They know they can’t do things right, so they are stuck with try­ing to per­form as less badly as they can. This usu­ally has one of two out­comes: the slack­ers will do things at their own (usu­ally rather relaxed) pace, and accept that whatever will be, will be. The hard-working stu­dents, in turn, will try to do as “good” as they can, and end up over-stressed because their work will seem like an under-achievement, no mat­ter how much effort they put into it. You’re wel­come to try to decide which out­come is worse (and for whom). As an example of the afore­men­tioned lack of resources, some of those pro­jects involved more than four stu­dents. As very few can afford to hold meet­ings in their houses, they’re stuck with the rooms avail­able for that use on campus—which usu­ally are over-crammed and noisy, and not at all setup for a meet­ing to be held. The last resort is to meet in somebody’s house and, no mat­ter how uncom­fort­able, try to get some work done. I’ve had dir­ect exper­i­ence of this—and so has almost every­one of my col­leagues back then.

So in the end, you just end up doing the same work you would do if you were employed in a soft­ware com­pany, hav­ing to learn (most of) the stuff on your own, but without the pay. As a mat­ter of fact, to make this ordeal even worse, you’re the one actu­ally pay­ing tuition!, if not a ren­ted room and other expenses from “going away” to col­lege. You’d prob­ably be bet­ter off work­ing in a real com­pany, learn­ing as you go. The pay would be like crap in the begin­ning, but chances are that you’d learn faster than you do in col­lege, and after five years, exper­i­ence would more than com­pensate for the lack of formal “edu­ca­tion”. Also, chances are you would get only one pro­ject, where you could focus, instead of the five or six classes per semester, each lec­tured as if it was the only the stu­dents were enrolled in for that semester (I remem­ber one teacher acknow­ledging that he had no idea what­so­ever of the other classes his stu­dents also had to work on that semester)! Mad­ness indeed. Would it not be a bet­ter altern­at­ive instead, to reg­u­larly send the stu­dents for Sum­mer intern­ships, in soft­ware com­pan­ies, where they could see how real­ity works? But this is just a sug­ges­tion, and I admit the pos­sib­il­ity that there might be some reason for such an altern­at­ive to be unfeas­ible. I hope that by now, how­ever, I’ve made it clear, bey­ond the shadow of a doubt, why the approach fol­lowed is an ill-devised and mis­guided one, that will do more to hurt stu­dents than to help them.

Another funny (in the not so funny sense of the word…) thing that happened in the third year, were the two classes about data­base man­age­ment. Judging by the name, I was hop­ing to learn about data­base engines, and their applic­a­tions. And that’s what happened, well sort of. As I said there were two classes, one in the first semester, and one in the second. The idea was to learn about data­base applic­a­tions in the first semester, and about data­base engines in the second. Now, what’s the most com­mon applic­a­tion of data­bases today (and back then as well)? Web­sites! So we were told, do a web­site like this and that, and put a data­base engine behind it. End res­ult: we spent the BULK of the time ded­ic­ated to that pro­ject try­ing to put up a decent web­site, and the data­base was just the final touch! The second semester was essen­tially more of the same, with per­haps a change in scale: in order to apply the more hard­core stuff about we’d learned about DB engines, the site had to be pre­pared to with­stand a heav­ier load. In prac­tice what happened is that we learned a lot about web­site design, and a whole lot less about data­bases. Two final notes about the DB classes’ ana­chron­ism: first, remem­ber this is the third year. The first class where we are sup­posed to learn about build­ing web­sites (HTML, CSS, Javas­cript, and so on), is on the first semester of the fourth year! (remem­ber what I wrote before about the teacher that had no idea of what other classes were lec­tured in that semester… that wasn’t an isol­ated case) The second note is that, because of this wretched state of affairs, I really got a bad thing for data­bases. A couple of years would go by before I would real­ize that work­ing with data­bases proper, can actu­ally yield quite inter­est­ing pro­jects (but this real­iz­a­tion only took place after I star­ted working).

By this time, I was com­pletely aware that I was not learn­ing any­thing (well not any­thing use­ful), because even for those few classes I thought were worth the effort, the global sched­ule was so insane that I ended up ded­ic­at­ing the min­imum strictly neces­sary to each class, try­ing to get a passing grade for as many classes as I could—and learn­ing zero or close to it in the pro­cess. My teach­ers kept say­ing that the more know­ledge, the bet­ter it will be for our CV’s and pro­fes­sional lives. How utterly wrong they were (and are still, for what I hear!). The reason why they, des­pite well-meaning, are non­ethe­less com­pletely wrong, is well worth under­stand­ing: and that’s the sub­ject of the next section.

Col­lege “High School”

In 2001, in his third year as a vis­it­ing pro­fessor at IST, MIT pro­fessor Michael Ath­ans wrote a paper titled “Por­tuguese Research Uni­ver­sit­ies: why not the best?”, in which he points some things that should be improved or cor­rec­ted in order to improve the qual­ity of the over­all Por­tuguese higher edu­ca­tion sys­tem. I strongly recom­mend read­ing this paper, spe­cially to any­one related to engin­eer­ing fields. In the paper, he makes sev­eral sug­ges­tions regard­ing fac­ulty, rela­tion with gov­ern­ment and industry, under­gradu­ates, and some more. My focus here will be, obvi­ously, undergrads.

Here’s a com­par­ison of MIT and IST under­grads, in Pro­fessor Ath­ans’ own words (emphasis added):

(1). IST stu­dents are just as intel­lec­tu­ally gif­ted and hard-working as their MIT counterparts

(2). In 5 years IST stu­dents have been taught almost twice as many tech­nical sub­jects as com­pared to those of an aver­age MIT stu­dent in a 4 year engin­eer­ing curriculum.

(3). The depth of tech­nical know­ledge of MIT stu­dents is super­ior to that of their IST counterparts

(4). MIT stu­dents excel in inde­pend­ent think­ing and problem-solving, while IST stu­dents are “spoon-fed”

(5). MIT stu­dents have more expos­ure to, and appre­ci­ation of, indus­trial issues and are far more soph­ist­ic­ated about the nature of the engin­eer­ing research pro­cess than their IST counterparts

And there you have it, the cause for the lousy state of affairs I’ve described in the last para­graph of the last sec­tion! But don’t take my word for it; quot­ing again:

In my opin­ion, while IST engin­eer­ing stu­dents have a far greater expos­ure to a vari­ety of sci­ence and engin­eer­ing sub­jects, their skills in deeply under­stand­ing and apply­ing fun­da­mental con­cepts, in con­duct­ing inde­pend­ent study, and execut­ing com­plex problem- solv­ing are inferior to those of their MIT coun­ter­parts. This state of affairs appears to be the con­sequence of treat­ing under­gradu­ate engin­eer­ing edu­ca­tion, learn­ing and test­ing, as an exten­sion of Por­tuguese high-school prac­tices(+). Thus, although both IST and MIT under­gradu­ate stu­dents start with the same intel­lec­tual cre­den­tials, IST stu­dents simply do not have the time for deep under­stand­ing and true mas­tery of the very large volume of the tech­nical mater­ial that they have been taught.

(+) An example is the com­mon prac­tice to offer (non-hardware) “labor­at­ory sub­jects” where prob­lems are solved by the instructor. This rep­res­ents, in my opin­ion, a time-wasteful pro­cess, rein­forces an inferior mech­an­ism for learn­ing, and is rep­res­ent­at­ive of the “spoon-feeding” men­tal­ity. Por­tuguese stu­dents deserve better.

Of all the reas­ons why this is wrong, the most blatantly shock­ing of all is that this learn-all-you-can-as-fast-as-you-can men­tal­ity, while yield­ing stu­dents that essen­tially learn noth­ing, or close to it, neg­lects to teach them the most valu­able les­son of all: learn to learn. Actu­ally this is not quite so, because due to the afore­men­tioned hec­tic organ­iz­a­tion of the dif­fer­ent classes each semester and each year, whatever you happened to pick up in col­lege, was most likely self taught. But given the facts that a) you’re the one pay­ing tuition, sup­posedly for get­ting an edu­ca­tion, and b) most engin­eer­ing fields are char­ac­ter­ized by fast-paced change, that learn to learn stuff should be THE VERY LAST THING you should have to pick up on your own. Con­fused? Well Pro­fessor Ath­ans explains it bet­ter than me (again emphasis added):

In sci­ence and tech­no­logy, and espe­cially in engin­eer­ing, tech­nical obsol­es­cence can occur in as little as 10 years. To safe­guard against such tech­nical obsol­es­cence, under­gradu­ate stu­dents must “learn how to learn” and “learn how to think” so that they are pre­pared for the inev­it­able life-long continuing-education require­ments. It is far bet­ter to learn fun­da­ment­als well and in depth, rather than to fire-hose the stu­dents with a myriad of tech­nical details, many of which may well become obsol­ete by the time the stu­dent gradu­ates. In short, stop the cur­rent prac­tice of hav­ing under­gradu­ate engin­eer­ing edu­ca­tion mimic that of high-school; it only encour­ages mediocrity.

I can’t stress how urgent I think it is for any­one related to sci­ence or engin­eer­ing activ­it­ies in Por­tugal to read and spread this paper. Des­pite slightly dated, it is still one of the best accounts of what’s wrong with Por­tuguese uni­ver­sit­ies, and how can some of those wrongs begin to be set right. I do not know why it is almost still unknown, but I do hope that changes, if for noth­ing else, at least for the stu­dents to come—they deserve bet­ter, and heck, the coun­try deserves better!

The full art­icle can be read here, or using the local copy.

The End

Most of what I have told here, I was already aware of by the time I got to the end of the third year (though not with enough clar­ity to put in writ­ing). Look­ing back with hind­sight, I now see that I should have quit col­lege then, and gone to work. I knew enough to start as a full time pro­gram­mer (and truth be told, the com­ing years added very little to that), and by now I’d have a lot more exper­i­ence, together with know­ledge (and per­haps salary, but for more on this see the next sec­tion). But, for my eternal shame, I did not quit: rather, I endured it until gradu­ation. I say “with hind­sight” because, what I thought back then was that, des­pite all this, I had already been through so much, I might as well hang a couple of years and get a degree. What I did not know (and could not know), was that the worse was yet to come. Some­times you really should listen to your gut rather than your brain.

But I was a ration­al­ist (some will argue that I still am, but let’s not dwell on that, lest we digress), and so of course, I stayed and went on to get the dip­loma (which, by the way, was requested—and payed!—when I gradu­ated (Feb­ru­ary 2007), but at the time of writ­ing (Decem­ber 2008), is still to arrive).

About the third and fourth years, I’ve said all I wanted to say. I could in fact have lumped those two years together, in what the account I wanted to make of them is con­cerned. Any­way, then along came the fifth (and final) year. The deal is like this: in the first semester, you must choose five sub­jects out of a list of them, and then on the second semester you should per­form a final, semester long, pro­ject. In my case how­ever, I still had one extra dis­cip­line: Data­base Man­age­ment, the second! (second semester) Yes, this one was my true Achilles’ heel.

OK, so first imme­di­ate task at hand: choose optional sub­jects. I did not make much fuss about it, and chose what I thought would be a good trade-off between inter­est­ing and easy—which essen­tially amoun­ted to net­works (three dif­fer­ent sub­jects on net­works), sim­u­la­tion and sys­tems integ­ra­tion. If most of my col­leagues were by this time wor­ry­ing about the choice of the final course pro­ject, I cer­tainly was not. After all, by that time I was abso­lutely fed up with the course, my aca­demic track record was less than bril­liant (and even that’s quite pos­sibly an over-statement…), and I was pretty sure the pro­jects I’d find would be more of the same: paper­work, neatly packed rushed code, a final report and a present­a­tion. The first semester came and went, and then the second came and went… earlier than expec­ted. I ended up doing my (then) final pro­ject in a cer­tain CMMI level 3 com­pany in Coim­bra, that des­pite that clas­si­fic­a­tion had one of the most messy chaotic pro­ject man­age­ment sys­tems I have encountered. That together with the fact that I still had Data­base Man­age­ment 2 (along with its “small” pro­ject) to do forced me to quit my final pro­ject, and to ded­ic­ate myself that final data­base course.

Again look­ing back with hind­sight, that res­ult was to be expec­ted. But I’m going besides my point here. I wanted to explain why the course largely sucked at what was sup­posed to be it’s main object­ive, and what happened in the fifth year was more the accu­mu­lated res­ult of what pre­ceded it, rather than faults per se. If you’re inter­ested by the way, I fin­ished DB man­age­ment that semester, and then took another (this time for real) final pro­ject in the fol­low­ing semester (of my “sixth” year), this time in aca­demia instead of cor­por­ate world. And then, a long five and a half years later, I was done.

The After­math

Should I have chosen to not write this final sec­tion, the text could hardly be cri­ti­cized for lack of com­plete­ness. How­ever, I want to address here some cri­ti­cisms that are eas­ily anticipated.

The most blatant of all, is per­haps say­ing that all I’ve described here essen­tially means this: I was in the wrong course, I should have taken math or phys­ics instead. Well, look­ing back with hind­sight yet another time, my retort to this is that: 1) it’s abso­lutely right (and is so for sev­eral dif­fer­ent reas­ons, but I digress), and 2) it does not inval­id­ate any of the cri­ti­cisms I make through­out the doc­u­ment. This last point bears repeat­ing: my account of things is as object­ive as I am cap­able of, and not biased by whether I liked or not of what I was being taught (though, mind you, I often did not).

Another pos­sible cri­ti­cism is that nowadays col­lege is a way to ensure a “good” salary. To put it another way, it’s an assur­ance of a “min­imum” wage that’s higher than the national “min­imum wage”. This is an extremely per­vas­ive argu­ment. Put yet another way, col­lege is becom­ing a de facto part of com­puls­ory edu­ca­tion. This of course applies broadly bey­ond Inform­at­ics. And it’s fatally and hope­lessly wrong, as I explained else­where. In addi­tion, that men­tal­ity of “throw­ing” every­one at col­lege, almost as if by instinct, has in the case of Inform­at­ics, a dis­astrous effect, which a former co-worker described very enga­gingly (Por­tuguese only).

The last pos­sible cri­ti­cism I’ll argue about here is that things have improved, and are no longer as bad. It’s cer­tainly true things are not as bad as they used to be (I’ve talked about the move from Java to Python above), and I heard of sev­eral other changes being made. But the words I’ve used in the beginning,

those [col­lege] years were both the single biggest waste of time and resources of my life, and at the same time one of the biggest rip-offs I’ve ever been through (education-wise!)

still remain sadly accur­ate. I can only hope what I have writ­ten will help to change that, although I don’t expect that change any time soon. And even after said change takes place, I’ll still keep this ref­er­ence, to remind and to keep account of how things once were—lest we for­get. For those who for­get their his­tory, are truly the ones doomed to repeat it.