I’ve been programming since 1975 and, boy, are my arms tired 🙂
Throughout these times, I’ve seen numerous developments that have made programming easier or harder. Consider this:
I first started programming when I was 15 years old. This was on a Univac 1108 running an interactive BASIC interpreter. As this was my first development environment, I thought it was great. I wrote a cool football game. Call the score +1.
The following year, I took a Fortran class where we had to punch card decks and wait several days for our output to be returned. Life without a “backspace” key is very painful. Running score: -5.
My first “microcomputer” was a Scelbi 8H (Intel 8008) computer. I had to enter machine language programs (hand assembled) using front panel switches in a very, very, primitive way (even more so than on the Altair or PDP 8 or other front panel computers). Running score: -20.
The arrival of the Altair 8800 greatly improved things. I used Microsoft BASIC and was able to store programs on big 8″ floppy disks instead of unreliable cassette tape. Running score: +10.
In college, it was back to punched cards on an IBM 360. At least we got to prepare our “virtual card decks” on a 370 running VM/CMS and we got back our results in an hour or two. Life is much better with a backspace key. Running score: +5.
Worked on an Apple II running UCSD Pascal. Color graphics, a cool IDE and the first incarnation of “DLLs” (Pascal packages). Running score: +20.
Went to work at HP. First used HP3000 to cross-compile Pascal to x86, but then started using IBM PCs and Lattice C compiler. Used Microsoft “debug” program at first and then Microsoft CodeView. Great stuff. Running score: +50.
Got a job at Microsoft. Started writing C++ code using cfront based compiler. Lots of multiple inheritance, virtual inheritance, templated classes. A one-line C++ constructor call turns into a 75 line C statement with about 120 comma operators. Program takes 7 hours to build. Writing Windows applications requires message loops and wndprocs not to mention dealing with near, medium and far pointers. Running score: +25.
We (I was in the Developer Tools group) deliver QuickC for Windows and Visual C++ 2.0 for Windows NT. We say goodbye to 16-bit applications. We deliver MFC and we facilitate “visual programming” in order to make Windows programming easier. Running score: +40.
Everything goes OLE/COM. The ATL library is released to help with COM. Running score: +25.
I leave Microsoft. Microsoft releases C# and .NET. Writing Windows applications is really, really, easy now. The .NET interop stuff makes COM a little easier, too. Not having to worry about memory overwrites and leaks: priceless. Running score: +40.
I start Likewise Software (Centeris, back then). Microsoft releases .NET 2.0 and MMC 3.0. It becomes ridiculously easy to write complicated applications that combine Winforms applications, web services, database access, LDAP access and just about anything else that you can think of. Running score: +100.
At the risk of sounding like a crusty old programmer, today’s programmers don’t know how good they have it. It’s rare for me to find a developer who can code an insert-into-a-sorted-singly-linked-list function without screwing up a corner condition or two. This isn’t surprising – who cares about data structures and standard algorithms anymore when you can declare a List<string> and then call the List.Sort() function? Who cares whether the sort is amortized on the insert or performed repeatedly every time you call Sort()! CPU cycles are cheap and plentiful.
There has been no better time to be a software developer. It is possible to develop insanely complicated applications by building on top of existing components. Todays compilers, editors, debuggers and run-time libraries are a joy to use compared to their predecessors.
By the way, unless you worked at Borland or in the Developer Tools group of Microsoft you probably don’t know that a lot of praise is due to one particular person who’s made a lot of this goodness happen. In the 1980s, Anders Hejlsberg developed Turbo Pascal. Turbo Pascal took everything that UCSD Pascal had done earlier and did it much better. It provided an IDE that integrated an editor and an extremely fast compiler. Beyond this, however, Turbo Pascal provided a run-time library that was the work of genius. Instead of having to call into the operating system or manipulate the hardware directly, 9 times out of 10, the library had exactly the functionality you were looking for.
At the time, I was working in the Developer Tools group at Microsoft and Borland was our arch enemy. Borland released Turbo C – a great product on its own – but we were lucky that Anders never turned his attentions to C. While Microsoft eventually won the C++ battle (mostly, through the introduction of Visual C++ and MFC), Anders turned his attentions to Delphi. Delphi did some extremely clever things to make forms-oriented Windows programming easier.
Microsoft ultimately hired just about everyone from Borland: Brad Silverberg, Paul Gross and Sin Lew, for example. A couple of years later, at considerable cost, Microsoft finally hired Anders. Anders became the architect of C# and a key contributor to the .NET initiative. If the ACM would bother to look beyond academia, Anders would be a prime candidate for a Turing.