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.
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.
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.
This I really loved because there were no more huge, monolithic programs. I probably went berserk modularisng everything in sight.
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.