A List of Cognitive Revolutions in my IT Career

Following on from Oracle Alchemist‘s comments on my Comments on “Putting NoSQL In Its Place”, I realise that I have been through several cognitive revolutions during my IT career.

Use of Library Routines

When I started learning about programming back in the middle 1970’s, the language of choice was Fortran IV. The extensive subroutine libraries that were available astounded me. Programming seemed to be just pasting together calls to subroutines.

Unfortunately, my first programming job used COBOL. And I was introduced to the monolithic programs, with the idea of subroutines actively discouraged. The common code was copied directly into the main program, making change control a nightmare.

Use of Random I/O

My next shock was adapting to the idea that data can be accessed directly on a disk drive instead of programming for serial devices such as tape drives, card decks, card punches, line printers, and paper tape devices. All of my training and thinking was developed around the idea that the data is only read once.

Strongly Typed Languages

The use of a strongly typed language, such as Pascal, shocked me because I could be assured that only numbers could be stored in numeric variables. I no longer had to worry about error handling every time I accessed a variable.

Dynamic Memory Allocation

I first encountered dynamic memory allocation in PL/1 and that probably crippled me when I moved to C. Dynamic memory allocation was much simpler in assembly language.

Non-Procedural Languages

The idea that there are languages like SQL and LISP that specified the result should look like, not how to compute it, is a very hard one to digest.

Database Transactions

This was a big one for me. I had to learn to accept that when the COMMIT statement was successful that the data was really saved to disk, and was intact. There was no possibility that there were dangling pointers, or bits were missing. For a long time, I kept writing validation routines just to make sure that the data was really consistent.

Modular Programming

This I really loved because there were no more huge, monolithic programs. I probably went berserk modularisng everything in sight.

Dynamic Linking

It also took me a while to trust dynamic linking of subroutines, because I knew I was safe with static linking. Again, it was a matter of learning to trust.


Modular programming kind of prepared me for this, but it took me some time to get used to hierarchies and message passing.


There are probably shifts in my thinking that has occurred over the years that I had forgotten, or am not willing to admit.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s