fbpx

Why I love progamming (since then)

Why I love progamming (since then)

Power, immediacy and correctness. As we learned in my Why I love programming (then); those were the three critical ingredients that caused me to fall in love with programming.

It took me a couple of months but I landed my first programming job with Albany Savings Bank and I immediately lost one of the critical ingredients. Yep, back to keypunch. The bank was too afraid of OLPD (On-line Program Development) to allow us to use it. We did it all by keypunch cards, handed them in to an operator who would then run it (eventually) and give us back our output (along with the keypunch cards).

I learned NCR’s (formerly National Cash Register)  mainframe language called NEAT/3 and there was 2 levels to it. Neat/3 Level 1 was like cryptic COBOL with only 8 character names. Level 2 was basically NCR’s assembler.

I used Neat/3 for my first 3 years of programming. For the bank I did mostly report generation, for Victory Markets it was mostly inventory tracking and for Shoney’s South it was mostly General Ledger and Tax Tracking and Payroll. I’ve always enjoyed meeting new people so moving once a year into a new situation was part of the fun.

In each job, I quickly became the main debugging expert because I’ve been doing puzzles since I was in kindergarten and debugging is just puzzle solving. While in Memphis, I also started leaning Basic and I wrote my first little game that allowed to people to play Othello easily. It was crude but fun. I also did some consulting on the side in Memphis (for Peachtree Software, again mostly debugging other people’s programs).

Moving to California and working for Triad Systems; I became the only non-COBOL programmer in a COBOL group. I learned some COBOL but mostly learned Texas Instruments JCL (called “procs”). I ended up becoming a data conversion expert and eventually wiped-out Triad’s field service organization by making installation and maintenance of it’s systems so easily.

I was just starting to get bored with the COBOL and non-COBOL stuff when Unix appeared on the horizon. Unix, Pipes, Awk, Vi, E-mail, Grep; it was all an amazing new way of computing. Shortly thereafter I started hearing about C and realized that was the language I needed to learn.

In my spare time from about 87 to 91 – I decided to learn C on my own and I wrote my first shareware game called Modern Problems. In the middle of that, I switched jobs from Triad Systems to Tandem Computers, working in their TMF QA department. Writing programs to test and break their Transaction Monitoring Facility.

With Modern Problems, I got my first taste of Graphics Programming but it was Dos based and their weren’t a lot of helpful libraries. As much as I resisted the Windows trend, that was the next big paradigm shift for me.

And that’s a good place to get to the point of this blog. There is always something new to learn, especially new languages, new libraries, new paradigms, etc…etc…

And that’s why I’ve continued to love programming for these past 30 years.

I’ll close with a bullet list of things I’ve left out.

  • Direct-X and Full Screen game development.
  • SDL and iWin’s Framework of CastMembers (almost like sprites) running around.
  • Fake C++ (just used as “A Better C”).
  • Real C++
  • Upper Memory DOS (can’t even remember what we called it).
  • MASM
  • Interactive Network’s proprietary C masquerading as Pop-Code/Assembler.
  • The joy of Sockets
  • Creating Mah Jong from scracth.
  • Creating Small Games.
  • Creating larger Casual Games.
  • Designing a complete User Experience.
  • The Joy of creating my own Art – especially the Joys of Bevel in Paint Shop Pro.
  • Front Page 2000
  • Java + Java Beans
  • Word Press
  • Word, Excel, VPN, SVN, CVS, Vim, MKS Toolkit, etc…etc…

I’m sure I’m missing stuff here. On the horizon is Unity, Android, iPhone, iPad or all of the above. Working with real 3-D instead of 2.5D (I will enjoy the day I start doing Camera tricks with real textured surfaces).

Still to come – Why I love programming (now) (only hinted at here) and What have I learned about non-programming business related stuff in the last 30 years.

 

 

4 Comments

  1. Phillip Stanhope says:

    As Joe says, NCR was a cryptic COBOL. This was because NCR designed the Century series – 100, 200, 300 and later 75 and cut-down 101 so as to run COBOL efficiently.
    LEVEL 1 was the basic assembler, with Table-handling macros.
    LEVEL 2 allowed the use of additional assembler commands, which were 1-to-1 with the machine code.
    LEVEL 3 also allowed direct I/O, and indirect addressing (mode 1, 2, & 3 (don’t ask – one was repetitive ad infinitum!).
    They were all options to the compiler, “USE >EXEC.LEVELn”. Any restrictions were those imposed by management.
    If I recall correctly:
    LEVEL 1 – MOVE A,B – Moved data in A to B, data length as defined by B. One machine code if length < 256
    LEVEL 2 – MVAR A,B – Same, 8-bit char by char from Right to left, 4 chars at a time.
    – MVAL A,B – Same, but Left to right, might seem the same but different effects if A.B overlapping!
    Could override length MVAR A, B,22
    e,g. – COBOL: MOVE SPACES to PRINTLINE (length 132).
    L2: MVAR (4 spaces), PL,4 – sets first 4 chars to spaces
    + MVAR PL, PL+4, 128 – ripples the 4 spaces forward!
    L2, allowed you to dynamically create code by patching the following code!
    Great fun, but not easy to maintain!
    Met a number of programmers who insisted MVAR was quicker to excute than MOVE. Had they looked at the code generated by the NEAT/3 compiler they would have seen the same op code "64" for both!
    Another example – once wrote a complex module in COBOL68 (much easier to maintain and understand! )The prog manager was annoyed as he wanted it in NEAT/3 LEVEL 2 as this was supposedly much faster. Not sure if he ever accepted that the compiled code was exactly one machine code half-command longer ( 4 bytes) – because of how the COBOL 68 compiler handled "IF's"!
    Happy memories indeed!

    • joe says:

      I loved the fall-through architecture of the instruction loop.
      Can’t remember specifics….something like QA TB
      Where Q was “Q-Code” and “T” was the length….or something else…and
      if you didn’t specify a new TB….it kept the prior one….which let
      you do some slick stuff….when indexing through a table.

      Also….the compiler listing had the actual assembly code (on the right)….so it
      was a great way to see what was really happening.

      Lot’s of fun….used it for 3 years….before moving on.
      (Bank, Grocery Store Chain, Restaurant Chain). (1 year each).

  2. Tim Jannsen says:

    NEAT/3 also had a Level 3, which was known as “Captain Midnight Code”. It was at the operating system level and handled devices, interrupt processing and the like. As I recall, you had to have been granted special privileges to assemble and run Level 3 code.

Leave a Reply

Your email address will not be published. Required fields are marked *