home | lab | find me | science | publications | software | toolbox | site map


How I became a programmer



Looking back, my first interest in programming sprang from the need to socialize, with the implied purpose of getting laid. In short, I started chatting online. My first chat room was a DOS terminal, over a telnet session to the nescafib.upc.es servers. I had heard of a (DOS) terminal before, but only for doing boring monkey-do tasks such as increasing Windows 3.11 virtual memory, and the like. Chatting was for real; my will was into making chatting a successful experience.

The nescafib 5000 chat client interface had a couple of built-in commands to express emotions, and thus all started with '.e' -all commands started with a dot. One could send private messages to specific users, create chat rooms, move between chat rooms, list their users, and so on, as in most of the currently available chat clients. There was a logic to it all. Communication between humans was happening in a telnet session inside a DOS terminal. On hindsight, such an interface watered my mouth for what was possibly doable with computers (and, specifically, from a command line interface), that I had so far zero clue about. At the time, though, it was just fun to do.

As time moved forward and Windows 95 came out, my next chatting interface was mIRC. A fully graphical chatting interface, which, most likely due to the recent past of chat clients being exclusively inhabitants of, and developed for, terminals, was not so far from it. mIRC was a wannabe terminal inside a neat window with a couple of buttons. Most remarkably, the DALnet network -mIRC's default, which took me a while to figure out I could change (I never read manuals back then)- supported colorful text, whose users abused of with neat artistic ASCII multiliners.

Now colorful multiliners that could be called with a single command word, and the name of the user to insert in it, was a big deal. Not just a feature I had never heard of; rather, a new layer of emotional communication was now possible. Furthermore, within mIRC there was a scripting language and built-in editor for the purpose -the first programming I ever did. Well, to be fair, ten years before that I joined a Summer course of BASIC in a Philips MSX computer. But never again I was exposed to programming until I got the need for it, inside a chat room.

My mIRC times, stuck in DALnet, brought me to meet mostly people from the USA but also westerners spread in distant places such as Letonia, Zimbabwe and Mexico. English chattering exclusively; there were others, but I never came across the Spanish or Catalan channels. Chatters were mostly teenagers and house wives, and university students like myself, with way too much time in our hands.

All my acquaintances over the IRC used scripts, even if only to "slap a big large trout" on each other. Chatters wholeheartedly shared them all over DCC, or in web pages crudely patched together, overloaded with blinking text and annoying javascripts, thankfully now a footnote in WWW history. In a very lispy way, chatting itself was a form of programming: most obviously the character encoding of the message (colors and ASCII figures) and the command-based user targeting, but most interestingly, the contents itself -initially wild, progressively more carefully crafted to grow social ties.

Scripting slowly become the most natural thing, same with entering commands. My experience resembled that of the Unix user, as described by Tim O'Reilly himself:

"On most systems, you need to learn consciously how to program. You must take up the study of one or more programming languages and spend a fair amount of concentrated effort before you can do anything productive. Unix, on the other hand, teaches programming imperceptibly -- it is a slow but steady extension of the work you do simply by interacting with the computer."

Unfortunately, by then I had no idea what a Unix or Linux system was. Much less did I know, that a PC could run anything else other that Windows or its forgettable predecessors.

Soon enough I joined a research lab at the University of Barcelona. There I learned about the Macintosh -which, in their very distinctive PC cases -the colorful iMacs-, positioned themselves in a new class. That was 1998, halfway through my undergraduate studies on biology and genetics.

I remained a Windows and occasional Macintosh user -for lack of any known alternative- until 2001. For these 3 years, I had started web mastering, designing in the NotePad with the -annoying- html tags, and having fun with canned, very slightly customized javascripts. It is praising to javascript's security model and people's good heart that I never managed to damage any computer. Perhaps only the visitor's eyes.

My programming abilities leaped forward tremendously when, by 2001 and while studying at Los Angeles, I completed webmonkey's Thau Javascript Tutorial, and then the advanced follow-up. From if/else to loops, from variables to functions and object-oriented programming in general, Thau's JST was great. Great fun, useful, and source of creative power and pleasure. By then, I had my own website in arkania.org -still here, greatly metamorphosed- and could test any html/javascript code.

That December I bought my first laptop: an ibook. Apple machines had transitioned to MacOSX already, a BSD derivative aiming at ease of use. But with a terminal. The lab I was hosted in used exclusively Macintosh machines, in their versions 7 and 8.6, mostly for imaging, browsing and text editing.

The Macintosh back then was privileged in having a neat little extensible application, the NIH Image, to which I was introduced by Scott Santagata. It was written in Pascal and supported macros. Image had the ability to use image stacks, particularly the weird .PIC stacks obtained from Biorad confocal laser scanning microscopes, and there was a macro for separating and merging color channels. But, such macro could handle only two channels, not three. The first serious program I ever wrote was a macro to handle three channels, written in Pascal.

While browsing the web for NIH Image macros, I realized the program was obsolete. Wayne Rasband, the author, was now working on ImageJ, a Java-based image processing application. Again, ImageJ supported plugins, written in Java, and about two years afterwards macros as well. The existing built-in tool set and available plugins of ImageJ were impressive. My lab image processing needs were almost fully covered.

Needless to say, from then on I began my journey into the Java programming language. First riping other people's plugins, later aided by Bruce Eckel's book "Thinking in Java", and also from Ben Berman, a computer scientist in the lab who gave me the one and only 2-hour programming course I ever had (while debugging a Java email reader app I had made).

From within ImageJ one could "Compile and run" any plugin, but soon I needed more control. As a biologist, the concept of a programming IDE was absolutely alien to me. But what brought me to NIH Image and then to ImageJ, that is, the usage of Macintosh machines, became an advantage again: hidden in MacOSX Application's folder, under Utilities, there was a Terminal. After 5 years of using computers, I discovered the unleashed power of the command line.

Why did I never ever come across anyone who could show me the GNU/Linux and BSDs operating systems? Do computer scientists and geeks in general think that researchers in other disciplines are not qualified, and thus overlook us as possible users? I have no idea. In any case, finally, I grasped a general idea on how a computer worked and what could be done beyond typing a document in Word.

There are two separate aspects of my personal evolution in computer usage. On the one hand lays the discovery of powerful text editors, from haxial's TextEditor to JEdit to Xemacs to ViM, which I have related earlier. On the other hand, my increasing passion for learning several programming languages.

As I gained a proper understanding of the Java language beyond ImageJ plugins, I also became aware of its shortcomings. Limited memory, the tyranny of the class, slowness in string handling, and the like. Don't take me wrong, in my opinion Java is the most complete integrated language set I have yet to see, regarding it's default library. But I read that people were addressing complains similar to mine by using other programming languages.

Around that time I started reading Stuart Kaufmann's books on boolean networks and complexity, and in a split second I was writing my own network simulation programs in Java (confirming for myself his results: order comes for free when the network interconnectivity is K=2 entering connections per node or lower, or a critical number of nodes are canalized). I could plot the results easily with ImageJ classes and so on. And yet, networks could not be too big -memory limits-, or run too many cycles -too slow. So, again by the hand of Bruce Eckel, and already used to object-oriented programming, I learned how to "think in C++".

To put it plainly, C++ was first very nice and enjoyable, but very soon a pain. Programs are very hard to scale up in C++; destroying objects and freeing memory becomes a real sneaky pain. Not to mention all the ambiguous and blurry concepts such as volatile variables, and the dilemmas presented when deciding to inline or not inline. What do I know, that is the compiler's problem, not the programmer's!

Far worse, I found C++ classical separation of header files and source files utterly ridiculous. I understand such separation obeyed the industry's need to sell commercial libraries, for which undisclosing header files are provided to the buyer. For day to day programming, header files are an unnecessary nuisance. The limitations of the preprocessor and thus the need to do forward declarations, plus the aforementioned memory management hassle, made me dump C++ as a language not worth of any further attention.

C++ though was described as a super set of C. So I learned C, and I still use C today. This time, there was no outstanding book dedicated to the language, but I was acquainted enough with libraries, general Algol-style syntax and work flow, that picking up C was trivial. The C programming language is, as described by Paul Graham, a very neat and extremely powerful little language. In many ways, C is like a *nix-like terminal with pipes; it is no coincidence that the oldest and best *nix-like operating systems are written in C.

To finish the C family languages, I must mention here Objective-C. The ability to use this language without any tinkering came for free with MacOSX, complete with some tutorials, for instance on how to make a GUI temperature converter (a sort of Hello World program for GUIs). What can I say, I'm no mouse-oriented programmer: the interface builder left me first confused, then shocked at how restrictive and error-prone it was (does not free oneself from thinking like a trained programmer), then annoyed at the limitations of interfacing with GUIs through their generated code access routines.

The worst part of programming in Objective-C like MacOSX intends you to, though, is programming in Project Builder (later renamed Xcode). There are no powerful text editing tools (except for some basic emacs bindings, generic to all MacOSX cocoa text widgets), and the amount of clicks to get anything done is comparable to Eclipse, another forgettable IDE. Plus I must mention the collection of puzzling and by all means unnecessary files, and utterly fat at that, created in the "project's directory", even for the simplest of programs. I am aware that hard drive space is orders of magnitude cheaper than programmer's time, but still such setup speaks of carelessness to me.

As for the available Objective-C libraries, sure they are nice and complete, but the function names are like pleasePutThisWindowOverThereAndNotHere long, which renders code unreadable. Plus code is not portable, in a practice very much like that of Microsoft, although not commonly associated with Apple (despite numerous well-known reasons). Objective-C is for me the paradigm of a programming language taken over by Microsoft Word interface lovers. Ironically, the language sponsor is Apple, the source of all coolness.

Of course throughout my journey I never ceased creating web pages. That is, manually, in a text editor, first HTML and javascript, then combined with server-side PHP scripts. I did use Dreamweaver for Windows for a while, but its generated pages just didn't work (Microsoft kept breaking their Explorer, and the numerous coexisting versions differently rendered the same page). Doing web development made me familiar first with FTP, and later with scp and ssh, three (mostly) command line tools fundamental in my day to day computer usage.

My first doodlings with PHP were almost concomitant with my first contact with relational databases, in particular MySQL (and now PostgreSQL). The reason was the discovery of b2, later renamed WordPress, a blog and/or general web content management system (for which I'm thankful to my former girlfriend, that was a leap forward). Tinkering with b2 I learned most of my php, which enabled me to create my own, customized web content management systems.

As a web master and developer, at some point I realized I could host my web pages home, and even in my laptop for ease of development. Doing so in Apple macs was easy, but limited (particularly in Jaguar 10.2.8). So I bought a desktop PC and installed Linux Mandrake 9.2 (now Mandriva) in it. The system was flaky, I bet because of XFree, KDE and Gnome instability at the time (around Summer 2002). So I went for FreeBSD 5.3 with KDE, which worked perfectly, although was rather painful (compiling everything, manually mounting CDs and USB devices, no flash, shitty look and feel for Java GUI widgets).

In any case FreeBSD was very stable and got me started with Apache (and it's powerful perl-style modrewrite module), installing and maintaining databases, understanding DNS servers, domain names and subdomains (why no one ever told me about the command line utility dig!), and in general acquiring an understanding on how the World Wide Web works.

I should mention also perl. I can read perl code (despite being famous for its unreadability). I can tinker with it; I did customize several CGI scripts and even sIRC (a little perl IRC chat client), but I would never use perl for serious undertaking. If anything, because there's nothing I can do in perl that I couldn't in php, which I find way easier to program with.

The next language I learned from scratch and quite in depth was Python. How I got here has to do with ImageJ: from confocal stacks of images I could generate 3D models as meshes, which needed be visualized somewhere: in Blender. Since then (already 3 or 4 years), Blender's python bindings have grown and become faster, easier to user and more complete relative to the on-screen available commands.

About python itself, I find it a rather unreadable language, or at least, a language that asks for absolute attention when reading. This shortcoming is but the other side of its all-powerful flexibility. Python is like mental chewing gum: everything is possible -except multiple class constructors, which is annoying. In many respects python is like PHP and perl (in syntax, and also in being both procedural and object-oriented), but where I find PHP limited, and perl cryptic, python is easy to code in. In addition python trivially wraps C code in modules, enabling an all-powerful combination of low and high level languages. Python can even compile embedded C code on the fly!

Python was and is so attractive for high-level programming that I created a Jython interpreter for ImageJ. Jython is a python language implementation in Java, abusing savagely but most neatly the java.lang.reflect.* classes. Why Java itself does not support dynamic interpretation on its own is beyond me.

To sum up, I am already 6 years (2001 to 2007) into Peter Norvig's plan on Teach Yourself How To Program in 10 Years. To complement my general programming knowledge, and following Norvig's and Paul Graham's writings, I recently started learning how to code in Lisp. It got me started -it forced me, almost- to explore the full capacity of the text editor emacs, which I never did (ViM is my first choice). I have to admit I am impressed. Incremental compilation is fantastic, and the overall functional programming style beautiful, very consistent (I am using functional programming techniques now wherever I see fit). Unfortunately Lisp's GUI libraries are very limited, don't work well across all situations, and rely on the full details of for example GTK, a not-so-simple GUI library. Java for linux relies on GTK as well, but hides all the complex details away from the programmer. I wish Lisp GUI libraries reach such graceful state someday.

So where am I now? I am proficient in using, mantaining and repairing MacOSX systems, but use (and mantain and repair) GNU/Linux (mostly debian and ubuntu) and FreeBSD in my laptop and desktop computers. I have acquired sysadmin skills, although most of my programming is oriented towards 2D and 3D imaging (in Java for ImageJ, and in python and C for Blender) and simulating biological systems (in Java and C).

I must end by noting that none of the above would have been possible without licensing schemes such as the General Public License (a.k.a. GPL) and the Berkeley Software Distribution License (a.k.a. BSD License). Both licenses not only empower me to stand on the shoulders of giants, but also to switch giants at little or no cost, or to stand on many of them when necessary. My appreciation to whoever foresaw the all-powerful development environment that such licenses could generate.



Last updated: 2012-05-08 11:10 Zurich time. Copyright Albert Cardona.