The tale of a seasoned developer — Part I

I received my first salary in the “software industry” as a software developer at the beginning of April 1988, that is 30-something years ago. I guess it might be interesting–at least just for myself–to go through some of these years and see what I’ve done and what I’ve learned.

This is the first part of this series. You might want to read the second part after this one.

I’ve decided to split this story into two parts: the first covers the 80s and 90s and the second one will do it for the 00s and 10s.

The 80s

Like a lot of people of my generation, my first encounter with a computer was by the means of the glorious Commodore 64.

Before getting it, I was reading everything about the Amstrad, MSX, ZX81, Apple ][, Spectrum and all the other little marvels that were establishing this all-new revolution called home computing.

My father noticed that I was spending almost all of my allowance on computer magazines, and thinking that such a passion of mine would have probably led to something important in my life (thanks dad!), he took me to the store and bought me the Commodore 64. At that time (1984) he paid the equivalent of 300€ for it.

Unfortunately, I didn’t do anything spectacularly noticeable with the C64. Yes, I wrote a lot of small BASIC programs. Yes, I even bought a book about programming in Assembler for the 6510 and I knew everything about peek, poke and sys 49152 but apart from moving some silly sprites with a joystick, nothing really creative came out of these days.

Oh, I regret that. Really feels like a superb missed occasion to me. Maybe lack of mentorship? I was living in a small town in Tuscany and all my “real life” (what else?) experience sharing at that time was with a friend with a Spectrum (and we were of course trolling each other every other day about which one was the best computer).

My biggest achievement in those days was creating management software for an insurance company branch in my town (and I was 17…). Lots and a lot of code, hours spent writing a boring software which was never released, in the end. And why wasn’t it released? Because I hit an insurmountable roadblock: printing reports. As it turned out, not being able to print some reports made the whole software useless (no kidding). And since I didn’t own a printer, not to mention not having the slightest idea how to actually render on print a report coming out of the software I was creating, we decided to kill the experiment. So, at 17 and a bit disappointed, I went back to playing games (oh, Seven Cities of Gold).

In 1986 I got out of high school and started the University: Pisa, Computer Science. I didn’t get too far though: one day my father asked me if I wanted to write my first résumé because he knew someone who could have been interested in hiring me. A job! Surprise! Yes!

I wrote that résumé, I faked the knowledge of C (which was a requirement for that position), I (luckily) interviewed with a non-technical person and I got the internship. On April 1st, 1988, I rang the bell of that office in Florence for the first time. I actually have a vivid image of that very moment.

I believe that I was very lucky during the next few months. The company at that time was predominantly employing people to work in COBOL as contractors for a bank. I started instead as part of a very small team (3 people in total), who were working on an innovative project using a relatively new operating system and tools: it was Windows 2, its own SDK and the MSC 5.1 C compiler.

I really didn’t know C and I’ve never used Windows. The first couple of months were just about reading manuals, trying to wrap my mind around an “SDK”–one that had a manual consisting of at least 10 volumes–and writing small programs from “hello world” to “your own phonebook”.

The toolchain of those days was composed of the already mentioned MSC 5.1–which was the underdog, while Borland TurboC was certainly the most used one–, microemacs as the text editor and an Atari game console used as the remote console for debugging over a serial cable (that one was really a seriously cool hack).

The project itself was a document management system. The idea was to acquire documents via a SCSI scanner, pass them through an OCR system and then store everything on some sort of (very expensive) external storage, laser video discs. Quite interesting, but I don’t remember if we ended up delivering it or not, at the end. For sure I learned a lot: it was my own bootstrap, and software development really got under my skin, while the vast majority of my colleagues were typing numbers and capital letters on a green terminal attached to a mainframe, I was using some of the most interesting technologies at that time.

The 90s

I served in the military from the very end of 1988 to the early 1990 (15 months in total). My “computer knowledge” was considered very valuable even in that context, and after a short period of “military school,” I spent a lot of days writing software on the bulky 286 of the station. Those months, quite unexpectedly, turned out to be very profitable in terms of experience.

When I was back I got hired full-time by the company where I started the internship. I was assigned to a team that was, again, working on something very interesting. We were building the first ATM system for Poste Italiane. The project was huge and we were only a small part of it. Nonetheless, we worked directly with the hardware of the ATM, writing the logic behind reading the card, getting the user input, giving the money, printing the receipt and everything else up to designing the screens of the (touch) user interface.

Everything was still in C, this time with no Windows attached. We were working directly with MS-DOS (which had the “real-time”, synchronous scheduling required by the hardware) plus another “extension” which gave the system virtual memory access from DOS and the ability to have background processes running (not like the “standard” DOS TSRs, but something more like an extension to the operative system called Olivetti PB).

If I remember correctly that system–developed by Olivetti–wanted a 386 to run and we were using some Olivetti M380 for that purpose (Intel 80386DX-20 MHz (32-bit)).

Those were the days when I also started going around Italy to work on the project. Mostly Ivrea (in Olivetti, where I was working on the C driver for the card reader), Milano and Roma (Poste Italiane, which also was our base).

That experience gave me full control of the C language and a lot of fun interfacing hardware over serial and parallel interfaces.

When the project ended, I returned to Florence to start on some minor, internal projects. It was at that time when the Internet started to be “a thing”. For a couple of years before that (at the very beginning of the 90s) I was using a 286DX as my home computer. I also bought for it a Usrobotics modem (28.8K) and I was using it to access the BBS. Nothing special, again: the importance of being “online” was crashing spectacularly with the phone bills and the need to share the phone with all the other members of my family.

In the mid-90s, the office owned a couple of computers wired to the internet (I guess via ISDN). This is how it started for me: sneaking in that colleague’s office and searching Altavista for things. Unfortunately, it didn’t come to my mind at that time the idea to buy some interesting domains or start reading some important newsgroups where some of the most interesting technology of the future were about to be announced. Nope. Nothing. Too late to the party.

Instead of hacking my future on the internet on cool technologies, at home I was writing another management software: Costico, an acronym for a system intended to be the management system for a not-so-small farm. It took me (and my client) quite a lot of time to close this deal, but we finished it. I even bought my first laptop to work on it while on business trips.

Costico was written in what everybody was using at that time to write (small) management software, that is Clipper (DB3). It was basically a scripting language and a “compiler” around a database. An “SQL” also gave you a way to write user interfaces, dialog boxes, form validation and a lot of other utilities. Maybe not cool, but very, very effective.

My text editor of choice at that time was Brief. I loved Brief, and it stayed with me for a long period of time, until I had to start using Visual Basic. Sometimes I (rarely) alternated it with SPFPC.

I finally got Internet at home too. Still using the phone, paying for access–with a 56K modem– but it was definitely there. And you can imagine for what: porn and chat (PowWow), mostly, but when my parents were getting curious, there you go: museums home pages and art pictures. Very impressive.

I worked a couple of years with Visual Basic 6 and I don’t remember those years with plenty of joy. Truth be told, it was really a game changer: writing software has never been that easy. Drag and drop a button, add a function for the “click” and voilà. People with basically any experience were given a month or two to “understand the concepts” of VB, and then they were sold for 200€ a day as outsourced contractors. Oh, boy.

I also spent some time working with Windows NT 3.51 and of course, mister OS/2‎ Warp. Very respectable systems, I’d say.

The second part of the ’90 saw me in Roma, where I was working with Banca d’Italia writing a very big management system for the (gigantic) real estate patrimony of the bank. The system was written in COBOL, using the IMS operative system (on an IBM mainframe). The database was the beautiful and rock-solid IBM DB2 and the editor was of course ISPF.

Those were the moments where I started writing what in the end has proven to be one of my biggest “successes”. Writing code for CICS and IMS in COBOL was a tedious job, and for many aspects, it resembles what we do nowadays with a classic web application. There is a server (the mainframe) that sends a form (a map) to a client (the terminal). You can see the analogy with a script page on a web server sending an HTML form to the browser.

The map, sent to the terminal, was written using a specific language, called BMS. Everybody was editing those maps manually and you can imagine how heavy was that job if you know that BMS has only absolute positioning (x,y on an 80x24 grid) of any element of the map and no “layout” concept whatsoever. Do you want to add an input field after another one? You need to know the exact position of the first one, add the physical length of it, maybe a space or two and then you have the starting coordinates of the second one. Guess what happens when a map containing 10 fields needed another field in the middle of all the others. A lot of fun. Not.

This is why I created MDF (Map Designers’ Facility). If adding numbers and calculating coordinates is very tedious and error-prone for a human being, this is basically what a computer wants to do. MDF was an editor, a visual editor (although text only, 80x24, which was enough given the expected output). You could wander around the screen in total freedom, with the mouse or the keyboard, move, copy, create fields or text labels and then export the final result in BMS (or, lately, in IMF) format. MDF was of course also able to import a BMS. In the end, all my colleagues (and the company, which also rewarded me for this “extra” job) were more than happy to use it. Should I have started a company and sold that program instead of giving it for “free” as a pet project to my company? Probably.

The last big task of the decade for me was of course related to Y2k and the Lira/EURO migration. I was put in charge of a small team that had to convert and port a big product of a bank: its whole credit card management system. The system was based on the CICS operating system (IBM3270), with a DB2 database and ISAM files.

What we needed to do was this: get all those COBOL files and maps (hundreds), pass them through an automated system that would find and automatically fix the Y2K issues, and then go through each one of the files and make sure they were compilable, manually convert the reference to Lira to EURO, compile again and test them. There were no “unit tests” or “automated tests”. Everything was manual, maybe even taking notes in a paper notebook.

It was, literally, a run against the clock. January 2000 was a deadline that you could not simply miss, push or postpone. Nope. It was the definition of the word "deadline". The mother of all the deadlines to come.

We made it, but at which cost? I still remember that on December 1999 I worked more than 14 hours on average a day. We spent several nights in the office and the last couple of nights we literally put in production, live, some programs that have been only automatically converted and never compiled even once. Horrific bugs came through during the next weeks (we were still contractors, basically, and we were expected to do our job and the client was not extraordinarily happy), and I vividly remember those months as the worst I have been through in all my life. If we made it, it was for Simone that at that time was in his 20s and now is not with us anymore. I will never forget you.

During those long months, I had a lot of fun playing in the office with Back Orifice (you still have heard about the cult, don’t you?).

The end of the 90s was also the moment when I came in contact with GNU/Linux and the Free Software movement/ideology. It was for me a turning point. Where I have been writing software for all those years because it was interesting and it paid my salary, the Free Software movement opened my eyes to a much bigger picture: writing software is also an important and socially relevant activity. Writing free software and advocating it, started to be the real reason for me to turn on the computer in the morning.

Follow me on Instagram (claudiocicali) or Twitter (@caludio)

Written on April 24, 2016 by Claudio Cicali.

Originally published on Medium