Salvatore Iovene

After claim­ing that most pro­gram­mers just can’t pro­gram, and actu­ally address­ing most of the prob­lems to the lack of pas­sion of peo­ple who decide to start a career as a pro­gram­mer, I would also like to express my point of view on a tightly related sub­ject: what can be done to improve the sit­u­a­tion? The prob­lem that I was try­ing to bring up in the spot­lights, is that a lot of peo­ple just start (or wish to start) a career in the IT for no par­tic­u­lar rea­sons. Those are the ones who don’t love and don’t loathe pro­gram­ming, and they just see it as some­thing that pays their bills. Well, maybe the first ques­tion that I should address, actu­ally is: why is this bad? Sure there are so many jobs which don’t require pas­sion at all, and peo­ple just do them because a job is just a job, and don’t really care. In my opin­ion, being a pro­gram­mer is different.

There are many peo­ple, espe­cially the ones who sit high in the hier­ar­chy of a com­pany, who see pro­gram­mers as the last and least impor­tant step of a lad­der. They often think that pro­gram­ming is quite of an auto­mated and repet­i­tive task, and it could basi­cally be done by any­one, with just a lit­tle train­ing. Unsur­pris­ingly, this seems to be the opin­ion of most com­mon peo­ple, who ignore what pro­gram­ming really is. I wouldn’t want to dis­crim­i­nate among dif­fer­ent types of pro­gram­ming, or dif­fer­ent pro­gram­ming lan­guages, but it’s obvi­ous to me that pro­gram­ming, to some extent, actu­ally can become an auto­mated an repet­i­tive task. That’s quite the minor­ity of cases, though, so I will sim­ply ignore them, and focus on the rest.

As any­body who’s a pro­gram­mer knows, pro­gram­ming is a highly cre­ative task, that requires good imag­i­na­tion and great prob­lem solv­ing skills. Every­body else might just see it as “typ­ing stuff on a com­puter”, and believe me, there’s a whole lot of edu­cated peo­ple who think that pro­gram­ming is a mon­key mat­ter. Hence the term “code mon­key”. This term has his­tor­i­cally been abused a lot, by even pro­gram­mers them­selves. A “code mon­key” is said to per­form a pro­gram­ming task so easy that even a mon­key could do, as the image sug­gests. There are two truths about this phe­nom­e­non: first of all, luck­ily, pro­gram­ming requires far more skills than it’s usu­ally believed; sec­ondly, and sadly, the major­ity of peo­ple just ignore it.

The prob­lem with lousy pro­gram­mer is kind of sim­i­lar to a medal: it’s dou­ble faced. You could actu­ally call it a dog try­ing to bite its own tail: as pro­gram­ming is believed to be an eas­ier and eas­ier task, more pro­gram­mers are needed; as more and more pro­gram­mers are needed, more peo­ple will jump on the field; as more and more peo­ple try to become pro­gram­mers, the lousier the aver­age qual­ity of pro­gram­mers gets. Unfor­tu­nately, what aver­age non-programming peo­ple miss to under­stand is that although it doesn’t really take a hard train­ing to become a lousy pro­gram­mer, it takes a damn hard one to excel in the art of pro­gram­ming. More­over, most peo­ple just lack the innate logic mech­a­nisms that make you a poten­tial pro­gram­mers. Such mech­a­nisms are devel­oped in your mind when you’re very young, and it’s quite rare to develop them after your twenty-somethings. With this, though, I’m not deny­ing that there are a lot of peo­ple who actu­ally do develop those mech­a­nisms in advanced age. I’m just try­ing to think of the big num­bers, here.

So, get­ting to the point, what went wrong and how can it be fixed? I don’t think it would be wise to say that what’s wrong is that there’s too much need of pro­gram­mers, ergo the aver­age qual­ity was inevitably doomed to lower and lower over the time. I rather think that the prob­lem is with edu­ca­tion. Of course I can’t speak for all the uni­ver­si­ties and col­leges in the world, but I can at least try and speak for the one I’ve known per­son­ally, or through peo­ple who have stud­ied there. It seems that, as more and more peo­ple apply to Com­puter Sci­ence or related depart­ments, the eas­ier it gets to get in (sorry for the pun), and to get through with it, i.e. to graduate.

I know this hap­pens most likely in any other fac­ul­ties, but see­ing that there are peo­ple who have been study­ing CS for three or more years, and still can’t get through the most sim­ple con­cepts, just doesn’t seem right to me. Yes­ter­day night, I was sit­ting in an IRC chan­nel about the C pro­gram­ming lan­guage, when some­body joined in and asked:

“I just started study­ing struc­tures in C, and I don’t get them. Can any­one explain to me what’s the use for them?”

Ok, I don’t really think there’s any­thing wrong in not get­ting the point of C struc­tures right away, but after a lit­tle chat­ting, it turned out that the guy was in his sec­ond year of Com­puter Sci­ence, and this was the sec­ond time he took the C class. Still that wouldn’t be a rea­son of hatred, of course (not that I have any hatred), but after another small while it turned out that the guy didn’t like pro­gram­ming at all, but he just got him­self into it because he applied to CS since he liked to “fid­dle around with com­put­ers”.

What’s really needed, in my opin­ion, is a harder and less tol­er­ant edu­ca­tional sys­tem, that would be more selec­tive, rather than push­ing every­one for­ward. Peo­ple that find out to be really not made for it, should just give up and move their focus on some­thing less.

I’m actu­ally very well aware that a lot of pro­gram­ming work, nowa­days, is not really rocket sci­ence, still this doesn’t mean that it should be done by com­pletely unqual­i­fied peo­ple. If what Jeff Atwood says in his post about pro­gram­mers who can’t pro­gram is true, and that is that 199 out of 200 appli­cants (not pro­gram­mers, appli­cants) can’t write any code what­so­ever, than it obvi­ously means that some­thing is wrong. Look­ing at the num­bers pro­vided by Joel Spol­sky, it looks like a lot of these basi­cally incom­pe­tent peo­ple are going to end up work­ing on an actual pro­gram­ming job, and maybe their code will end up on The Daily WTF (Paula, are you there?).

Unfor­tu­nately, the edu­ca­tion is not the only one to blame. No mat­ter how much edu­ca­tion will improve, there will always be unqual­i­fied peo­ple who are going to apply for jobs that require a lot of skills, and in the end the odds will help them, so they’ll man­age to get a job as a pro­gram­mer. Is it so bad, con­sid­er­ing that it’s most likely not going to be any crit­i­cal posi­tion, and the only ones that will be dam­aged will be the own­ers of the com­pany that hired them? Well, the point is that this is not true. There’s some­one else who gets dam­aged, in this sce­nario. I’m talk­ing about the com­mu­nity out there, the good pro­gram­mers, who find them­selves com­pet­ing with new­bies who’re happy to earn peanuts. The salaries keep going down, and cus­tomers are not able to dis­tin­guish a good job from a good one.

In a com­ment on the pre­vi­ous post of mine about this sub­ject, Hoowie Good­ell really gets a great point with this paragraph:

“There has been a great effort to indus­tri­al­ize pro­gram­ming, too. Again, there are many good fea­tures, and it’s a field I’m inter­ested in. Build­ing a large pro­gram requires a struc­tured approach. Lan­guage design, libraries, pro­gram­ming frame­works and IDEs can and should incor­po­rate as much exist­ing human knowl­edge as pos­si­ble: com­puter sci­ence, domain knowl­edge, solid pre-written code and human inter­face prin­ci­ples. (Check out Thomas Greene’s “Cog­ni­tive Dimen­sions of Nota­tions” for some of the lat­ter: I think of how pro­gram­ming tools fail to use them on a daily basis!)”

In a way, this sug­gests that the whole sys­tem is not ready yet, as it’s indeed years and years behind sev­eral other engi­neer­ing fields, and that’s a good rea­son, prob­a­bly, to explain why it’s so easy to fail at being a good pro­gram­mer. Let’s just try to get some insight­ful inspec­tion points, in order to build bet­ter gen­er­a­tion of programmers:

1. Bet­ter edu­ca­tion.
   The whole higher edu­ca­tional sys­tem should be improved in sev­eral way. World­wide. Nowa­days, it looks to me that in many coun­tries grad­u­a­tion is just a direct con­se­quence of apply­ing to an Uni­ver­sity. Unfor­tu­nately, this kind of prob­lem must be addressed on a country-basis, to prop­erly iden­tify the spe­cific issues, but still the options that I would like to con­sider are worth men­tion­ing. It all comes down to a sin­gle point: there should be less tol­er­ance towards peo­ple that don’t learn. The thresh­olds for suc­ceed­ing in a course should be raised to greater dif­fi­culty. Cur­rent mod­els of test­ing should be seri­ously revised, so to ensure that stu­dents that really didn’t under­stand the sub­ject are not going to make it.
2. Bet­ter tools.
   Are we try­ing to make pro­gram­ming just like a fac­tory chain or are we not? If we are, as it seems nowa­days, then the tools are not ready yet to sec­ond our inten­tions. Pro­gram­ming is too error prone and too time-consuming.
3. Bet­ter process.
   Soft­ware process that doesn’t con­form to some stan­dards, say ISO-9000 (sorry if it’s inap­pro­pri­ate, I’m not an expert on this kind of stan­dards), shouldn’t be allowed to sell. Qual­ity insur­ance com­mit­tees should be taken more seri­ously as being part of the process. This might be against all prin­ci­ples of lib­er­al­ism, I know, as bad soft­ware, you may say, will not sell any­way. I know many bad soft­ware that did sell well, for greatly dif­fer­ent rea­sons than its (non) good quality.
4. Bet­ter judg­ment when hir­ing.
   I’m not going to try to teach you how to run your com­pany, nor how to hire your crew. But some­times really crazy thing hap­pen (again, is Paula around?). A very inter­est­ing post by Joel Spol­sky (I’m sorry, I can’t find it any­more: does any­body know the link?) talks about only hir­ing “A”-people, where “A” means top class. If you’re ever hir­ing a “B”-person, he’s quite likely to hire a “C”-person, some­day. After that, it’s chaos. I rec­om­mend any­one not to lower their canons of per­fec­tions. Here’s another great arti­cle by Joel, about hir­ing good devel­op­ers, I rec­om­mend it.

Con­clud­ing, improv­ing the qual­ity of pro­gram­mers seems really to be a tough issue, and the whole thing depends on so many fac­tors that track­ing a pre­cise prob­lem is impos­si­ble. Cul­tural and tech­ni­cal dif­fi­cul­ties arise all the time, and get­ting clues is hard. I’ve tried to get around the prob­lem and give some insight­ful opin­ions: what do you peo­ple think?

I’ve been in the IT field long enough to get to know many pro­gram­mers, both expe­ri­enced and just wanna­bies. Dur­ing this time, I’ve real­ized that most of them are just bad pro­gram­mers, sim­ply said. I find myself agree­ing with a bril­liant post by Jeff Atwood, which alleges that pro­gram­mers can’t pro­gram. What are the rea­sons for this? Many. Prob­a­bly, IMHO, the main fault has to be addressed to the lousy edu­ca­tion that peo­ple receive. But then again, the abil­ity of giv­ing edu­ca­tion remains directly pro­por­tional to the abil­ity of get­ting it, and where I see peo­ple com­plain­ing about low qual­ity of edu­ca­tion in Uni­ver­sity, I also see stu­dents with no inter­est in learn­ing. Let’s see some of the rea­sons why pro­gram­mers can’t really program.

1. Young peo­ple study Com­puter Sci­ence just because it’s a trend. It sounds almost unbe­liev­able to me, but I must admit it’s mostly true. The vast major­ity of my old Uni­ver­sity mates just applied to the Com­puter Sci­ence depart­ment because… well: every­body was doing so. They fol­lowed the rest of the sheep.
2. Young peo­ple study Com­puter Sci­ence because they wouldn’t know what else to do. That’s really another strong source of appli­ca­tions to Com­puter Sci­ence. A lot of young peo­ple in their teenage years just don’t know what they want to do as grownups. Com­puter Sci­ence still seems to be a good career oppor­tu­nity, so they just go for it.
3. Young peo­ple study Com­puter Sci­ence because they think it’s a sure way of get­ting a job. 10-something years ago there was a big boom, and if you just knew some HTML, were thought to be a com­puter guru. These types of belief mark a deep foot­print on pop­u­lar say­ings, hence the wave of peo­ple apply­ing to Com­puter Sci­ence just because they can work, is still there.
4. Many of today’s pro­gram­mers, were doing noth­ing else than surf­ing the net or using Word till last year. Espe­cially in small and ver­ti­cal based mar­kets, impro­vi­sa­tion just rules. Peo­ple learn some­thing, and lit­er­ally throw them­selves on the field. Draw­backs for qual­ity of their work are sim­ply inevitable. This is not only a group of illit­er­ate peo­ple that just jumped in to catch the big wave (what big wave, nowa­days?), but peo­ple with no pas­sion what­so­ever. In other words, I don’t think it’s pos­si­ble, nowa­days, to become a great pro­gram­mer if you didn’t start get­ting some inter­est in the field when you were very young, say about 10 years old (with the due excep­tions, of course).
5. Many of today’s Com­puter Sci­ence stu­dents have no inter­est what­so­ever in what they’re force­fully study­ing. Just put together the pre­vi­ous items in this list and what do you get? A bunch of peo­ple who just don’t care, who want to get their piece of paper (the degree) as soon as pos­si­ble, and have absolutely no pas­sion in what they learn. That’s the worst. I strongly believe that pro­gram­ming is not just a job like many oth­ers, but you need pas­sion to get best at it.
6. A lot of pro­gram­mers just don’t like to pro­gram. This goes for 100% of my ex Uni­ver­sity mates! Think of that: 100%. Of course it’s not the whole world but it makes a small statistics.
7. A lot of pro­gram­mers just don’t get it. Not even the easy things. I was asked, few weeks ago, by a friend of mine who’s been study­ing Com­puter Sci­ence for now 4 years, what the dif­fer­ence is between a private and protected method in Java. Appar­ently read­ing the books isn’t enough any­more, nowa­days. Another guy asked me: “I’ve stud­ied point­ers in C, and I think I under­stood them. Still I can’t find any use for them… are they really used at all?”.
8. Basi­cally all of the pro­gram­mers, or wannabe pro­gram­mers, men­tioned above, are miles away from the tech­ni­cal com­mu­nity. These peo­ple will totally ignore the exis­tence of:

   Slash­dot and sim­i­lar
   RSS
   Usenet
   IRC (“Is that like MSN?”)
   SVN and similar

As you can see, a really strong point, in my opin­ion, is the lack of care and pas­sion for the sub­ject of pro­gram­ming itself. Lousy pro­gram­mers are bound to pro­gram to take a wage home; good ones are bound to pro­gram for the sake of pro­gram­ming itself. Or course you can do that but still miss to be a good pro­gram­mer, but all falls down to numbers.

I’ve been hav­ing quite a lot of trou­ble, lately, con­fig­ur­ing irssi to work well with UTF-8. Irssi’s doc­u­men­ta­tion was quite incom­plete, on the mat­ter, or dis­cour­ag­ing, and there wasn’t much on the Inter­net, so, after fig­ur­ing out what the way is, I’ll share it here.

First of all, you’ve got to make sure that your sys­tem is con­fig­ured for UTF-8 locales:

bash-3.1$ locale
LANG=en_GB.utf8
LANGUAGE=en_GB.utf8
LC_CTYPE="en_GB.utf8"
LC_NUMERIC="en_GB.utf8"
LC_TIME="en_GB.utf8"
LC_COLLATE="en_GB.utf8"
LC_MONETARY="en_GB.utf8"
LC_MESSAGES="en_GB.utf8"
LC_PAPER="en_GB.utf8"
LC_NAME="en_GB.utf8"
LC_ADDRESS="en_GB.utf8"
LC_TELEPHONE="en_GB.utf8"
LC_MEASUREMENT="en_GB.utf8"
LC_IDENTIFICATION="en_GB.utf8"
LC_ALL=en_GB.utf8

If the out­put of the locale doesn’t look like that, you want to recon­fig­ure your locales. On Debian, wha you have do is:

sudo dpkg-reconfigure locales

Here’s some scree­nies of what to expect:

Generating locales (this might take a while)...
  en_GB.ISO-8859-1... done
  en_GB.ISO-8859-15... done
  en_GB.UTF-8... done
  en_US.ISO-8859-1... done
  en_US.ISO-8859-15... done
  en_US.UTF-8... done
Generation complete.

Per­fect, now that our sys­tem is con­fig­ured for UTF-8, we want to con­fig­ure our ter­mi­nal emu­la­tor. If you’re using xterm, you can invoke it with the -u8 switch, or just do uxterm, and that’s all that’s needed. If you’re using the gnome-terminal, go to the Ter­mi­nal menu, then choose Set Char­ac­ter Encod­ing and then UTF-8. If UTF-8 doesn’t appear in the list, you may want to try to logout and login again. While you’re at it, in the GDM login man­ager, go to the Lan­guage option and choose UTF-8 there too, so that it will be default.

Now let’s take care of GNU/Screen. In order to enable UTF-8, all you have to do is launch it with the -U switch:

screen -U -S irc

irc is just the name I want to assign to that screen ses­sion. Notice that if you want to switch a liv­ing screen ses­sion to UTF-8, you could do it for each win­dow, using the com­mand CTRL-a : utf8 on.

Once your GNU/Screen is con­fig­ured for UTF-8, you have to finally set up your irssi client. This was, for me, the tricky part, since the doc­u­men­ta­tion is a bit unclear, and I didn’t real­ize that my irssi wasn’t built with recode sup­port. To make sure that your irssi is, fire it up and give the command

/recode

If you get some­thing like

Target                         Character set

then every­thing is alright, oth­er­wise, if you get a No such com­mand error, you will have to rein­stall irssi with recode sup­port.

Irssi UTF-8 sup­port is made so that you are able to recode to dif­fer­ent charsets, depend­ing on the server or chan­nel you’re chat­ting in. First let’s set up some gen­eral options:

/set term_charset UTF-8
/set recode_autodetect_utf8 ON
/set recode_fallback UTF-8
/set recode ON
/set recode_out_default_charset UTF-8
/set recode_transliterate ON

These options will be the default, unless over­rid­den for spe­cific servers or chan­nels. What do they mean?

• term_charset: this is the char­ac­ter set of your ter­mi­nal emulator
• recode_autodetect_utf8: irssi will rec­og­nize UTF-8 input auto­mat­i­cally and treat it consequentially
• recode_fallback: when we get some non-UTF-8 text from a chat peer, the text should be con­verted to this char­ac­ter set
• recode: this enables the whole recode thing
• recode_out_default_charset: this is very impor­tant: this is the default charset that you send out, unless dif­fer­ently spec­i­fied by a server/channel rule (we will see that shortly)
• recode_transliterate: this enables translit­er­a­tion of the clos­est match: i.e. if some­one sends you a char­ac­ter that’s not in your charset, it will be translit­er­ate to the clos­est pos­si­ble one, or with a ques­tion mark, if none found

Now, you prob­a­bly need dif­fer­ent recodes on dif­fer­ent chan­nels, because you may speak dif­fer­ent lan­guages on dif­fer­ent chan­nels. For exam­ple, I send out UTF-8 when typ­ing on Eng­lish speak­ing chan­nels, and ISO-8859–1 or ISO-8859–15 when typ­ing on Finnish or Ital­ian speak­ing chan­nels, so peo­ple on the other end will always get my char­ac­ters right.

You need to add rules with the /recode command:

/recode add ircnet/foo ISO-8859-15
/recode add ircnet/bar ISO-8859-1
/recode add freenode/gee ISO-8859-1

Those com­mand will make you “speak” ISO-8859–15 on #foo on IRC­Net, and ISO-8859–1 on #bar and #gee in freen­ode. Every­where else you will “speak” UTF-8.

And this is what we get: here I’m typ­ing (er… I’m copy-pasting from Wikipedia) some text:

If you con­nect via SSH to a remote machine, where you run irssi inside screen, all you have to do is to set both sys­tems to use UTF-8, as explained in the begin­ning of this arti­cle, and then set the ter­mi­nal of the machine from which you SSH, to use UTF-8, as explained earlier.