I received my first salary in the “software industry” as a software developer at the beginning of April 1988, which was 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 many people of my generation, my first encounter with a computer was through the glorious Commodore 64.

Before getting it, I read everything about the Amstrad, MSX, ZX81, Apple ][, Spectrum, and other little marvels that were part of the home computing revolution.

My father noticed that I was spending almost all of my allowance on computer magazines, and, recognizing that my passion for computing could lead to something important in my life, 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 particularly noteworthy with the C64. I wrote many small BASIC programs and even bought a book about programming in assembler for the 6510. I knew everything about peek, poke, and sys 49152, but apart from moving some basic sprites with a joystick, nothing truly creative came from those days.

I regret that missed opportunity, and I wonder if a lack of mentorship contributed to it. I lived in a small town in Tuscany and had only one friend with a Spectrum who I could share my experiences with (and we were always arguing about which computer was better).

My biggest accomplishment during that time was creating management software for an insurance company branch in my town, even though I was only 17. I spent hours writing a tedious software program that was never 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 project. So, at 17, a bit disappointed, I returned to playing games (like Seven Cities of Gold)."

Back in 1986, I graduated from high school and started studying Computer Science at the University of Pisa. However, I didn't get very far before my dad dropped a bombshell on me. He asked if I wanted to apply for an internship, which he heard about through his connections. A job opportunity? Surprise, surprise!

I quickly put together my first resume and even faked some knowledge of C programming (which was a requirement for the position). Luckily, I interviewed with a non-technical person, and to my surprise, I got the internship! On April 1st, 1988, I showed up at the company's office in Florence for my first day on the job. I still remember that moment like it was yesterday.

As it turns out, I lucked out with this internship. The company was mostly hiring people to work in COBOL as contractors for a bank, but I ended up being part of a small team of just three people working on an innovative project. We were using a relatively new operating system and tools - Microsoft Windows 2.0, its own SDK, and the MSC 5.1 C compiler.

The catch? I didn't know C, and I'd never even used Windows before! So, for the first couple of months, I spent all my time reading manuals, trying to wrap my head around the SDK (which had a manual that was at least 10 volumes thick), and writing small programs, from the classic "Hello world" to my own personal phonebook.

Let me tell you about the tech scene back in the day. The toolchain that we used for programming was quite poor for modern standard, but yet state-of-the-art. We had MSC 5.1, which was the underdog, and Borland TurboC, which was the most popular choice at the time if you needed a C compiler; the almighty make was doing the rest and now that I think about it that program is probably one of the few that I have been using during all my career. As for the text editor, we used Microemacs, and we even used an Atari game console as a remote console for debugging over a serial cable. It was a seriously cool hack!

We were working on a document management system project, which was quite innovative for its time. We had to acquire documents via a SCSI scanner, pass them through an OCR system, and store everything on external storage, laser video discs. Although I don't remember if we delivered it at the end, I definitely learned a lot from that project. It was my own bootstrap, and software development really got under my skin. While 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 returned to civilian life, I was fortunate enough to be hired full-time by the same company where I had started my internship. This time, I was assigned to a team working on something even more exciting: building the first ATM system for Poste Italiane, the Italian postal service. The project was massive and we were only a small part of it, but we worked directly with the hardware of the ATM, designing everything from the logic behind reading the card to the touch user interface. It was a challenging project, but I learned a lot from it and it was great to be a part of something that would ultimately benefit so many people.

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 personal 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 (huge) 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, personal 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 (called "a map") to a client (the dumb terminal). The user enters data in the form and then the form and its data are sent back to the mainframe for processing. Pretty much as you do with an HTML <form>.

The map, sent to the terminal, is 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 him.

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.