What happened to my career

There was an early period where I thought I’d have an interesting skill-based career. I had learned all about the hardware and software of the PC’s. I was a ground-breaker in a new area of productive activity (PC-oriented tech). I found a specialization (database) where I gained real expertise. It was creative, productive, and remunerative.

It was in the early years of the development of a new profession (“software engineer”). The work had a certain élan and it was satisfying.

The satisfaction didn’t last long. What happened had to do with the nature of the electronics/software phenomenon.

It’s clear to us now what a zoo it all is. The proliferation, the overwhelm of all the media, communications, “information” . . . a result of combining the human inclination toward “more” with the speed/facility of increasing electronic capacity (it’s the speed of light). Electronics is so fluid. Moore’s Law applies such that there is exponentially more in the way of proliferation and ease of innovation than ever before.

More, Bigger, Farther, Faster is, of course, toxic and ultimately ruinous.

During the 19th century the industrial machinery ramped up “More” by orders of magnitude. What you hear Marx saying in the Communist Manifesto (re: productivity) and what Thoreau was sensing in Walden (“the railroad rides upon us”) is what was dawning circa 1800–1850. The scope of it, the speed of it, the plethora of it. Awesome. Disturbing to some. (It disturbed the peace.)

The electronics revolution during the 20th century further ramped up “More” by further orders of magnitude. The skills that I mastered early in my career (1980–1990) soon were obsolete. I didn’t know it at first, but I had entered the zoo of the world of electronics. Moore’s Law states that, with electronics, capacity doubles every two years. In order to try to keep up with the proliferation and innovation a technician has to be constantly embarking upon new learning curves. In 1985 a person could know all about the hardware and software of a device … a mainframe or a mini or a micro computer. One could set it up, install it, program it, and provide training for productive applications. By 1995 the proliferation was such that the number of different devices, applications, operating systems, networking protocols, etc. necessitated extreme specialization and constant re-learning.

The re-learning is overwhelming. The complexity of any area of hardware or software is such that it would take years for thorough mastery. If it might take five years, well, you never get there because you have to embark upon a new learning curve in three years.

I had mastered COBOL and dBase and Clipper. Then I entered into the world of the zoo of the progression of programming languages.

Computers were invented during the 1940s. At first they were programmed directly by moving around the wiring. Then “assembly” languages were invented. They could be fed into the computer’s memory, but each step in a process needed to be specified. Then simplified “higher level” languages were invented, where a command could invoke a sub-routine collection of steps. By 1960 there were a couple of widely-used, widely-learned higher-level languages: FORTRAN (“Formula Translation”) for scientific applications and COBOL (“Common Business-Oriented Language”) for business applications.

By the 1970s there were minicomputers in addition to the mainframes. They used different languages. And then the microcomputers came in. By 1985, when I began programming, there might have been 20 widely-used languages. But then things blew up:

https://en.wikipedia.org/wiki/List_of_programming_languages_by_type

I tried to learn all the languages, but I failed. There are 486:

A+
ABAP
ABC, Python’s parent
ABCL/c+
ActionScript
ActionScript 3.0
Actor
Ada
Adobe Graphics Assembly Language (AGAL)[23]
Advanced Boolean Expression Language
Agda
Agora
AIMMS
Aldor
Alef
ALF
ALGOL 58
ALGOL W
Alice
Alma-0
Alphard
Altera Hardware Description Language
AMPL
Analytica
AngelScript
Ant
ANTLR
APL
AppleScript
ARB assembly language (ARB assembly)
Arc
Argus
ARM
AspectJ
Ateji PX — an extension of the Java language for parallelism
ATL
ATS
AutoHotKey
AutoIt
AutoLISP (specific to AutoCAD)
Averest
AWK
Ballerina
Bash
BASIC
bc
BCPL
BeanShell
Beatnik
Beef
Befunge
BETA
BLISS
Blockly
Bluespec
BMDFM
Boo
Brainfuck
C (widely used procedural language)
C#
C+
C++
Caché ObjectScript
CA-IDEAL
CAL
Catrobat
Cecil
Céu
Ceylon
Cg
Ch (Embeddable C/C++ interpreter)
Chapel
Charm
Chef
CHILL
CHIP
ChucK
Cilk — concurrent C for multithreaded parallel programming
CLACL (CLAC-Language)
Claire
Clarion
Clean
CLEO for Leo computers
CLI
Clickteam Fusion
Clipper
CLIPS
CLIST
Clojure (into JVM bytecode)
CLU
CMS EXEC
Co-array Fortran
COBOL
Cobra
Coco/R (EBNF with semantics)
ColdFusion
COMAL
Comet
Common Lisp
Component Pascal
Confluence
Coq (Gallina)
CorVision
CPL (Combined Programming Language)
cpp (the C preprocessor)
Crystal
CSC’s GraphTalk
csh and tcsh
Cuneiform
Curl
Curry
CWIC
Cyclone
Cypher
D (from a reengineering of C++)
D Digital Mars
Dart
Dartmouth BASIC
Darwin Information Typing Architecture (DITA)
DASL
Datalog
dBase
Delphi Object Pascal
DIBOL (a Digital COBOL)
DIGITAL Command Language CLI for VMS (DEC, Compaq, HP)
Distributed Application Specification Language (DASL)
DOS batch language (for IBM PC DOS, pre-Windows)
DRAKON
Drools
Dylan
Es (ensures deadlocks cannot occur)
Easytrieve report generator
eC
ECL
ECLiPSe
ECMAScript
ECMAScript for XML
EEL
EICASLAB
Eiffel
Elan
Elixir
ELLA
Elm
Emacs Lisp
Emerald
Erlang
ESPOL
Esterel
Etoys in Squeak
Euler
EXEC 2
Expect (a Unix automation and test tool)
eXtensible Stylesheet Language Transformations (XSLT)
Ezhil
ezhil (Tamil)
F
F#
Fabrik
Factor
Fantom (functional, object-oriented (class-based))
Fexl
Filetab
fish (a Unix shell)
Fjölnir (Icelandic)
Flix
FOCAL
FOCUS
Forth
FORTRAN
Fortress
Free Pascal (FPC)
FreeMat
Fril
F-Script
Futhark
G (used in LabVIEW)
Gambas
Gambit Scheme — using the Termite library
Game Maker Language (GML)
GAMS
GAUSS
GDScript
Gelato Shading Language
Genie
GLSL
GNU bison (FSF’s version of Yacc)
GNU Octave
Go
GOAL
Gosu (into JVM bytecode)
Grasshopper
Gremlin
Groovy
Guile
Hamilton C shell (a C shell for Windows)
Handel-C
Harbour
Hartmann pipelines
Haskell
HDLs for digital circuit design
High-Level Shading Language (HLSL) or DirectX Shader Assembly Language
HLSL
HolyC
Hop
Hope
HyperTalk
IA-32, introduced in the 80386
IBM Informix-4GL
IBM VisualAge
IBM[c]
Icon
IDL
Idris
Impulse C
Impure
Inform (usually story files for Glulx or Z-code)
INTERCAL
Io
IPL-v
ISWIM, the abstract language that introduced the rule
J (functional, imperative, object-oriented (class-based))
Janus
JASS
Java
JavaScript
Jess
Join Java — concurrent language based on Java
Joule
JOVIAL
Joy
jq
jq (C and Go)
JScript
Julia
JVM
Kaleidoscope
Klerer-May System
Kotlin
KRC
ksh (a standard Unix shell)
LabVIEW
Language H
Lasso
Lava
Lean
lex (Lexical Analysis)
LFE
Limbo
LINC 4GL
Lisp
Little b
Little Smalltalk
LiveCode
Logo
Lola
LOLCODE
LPC
Lua
Lucid
Lustre
LZX
M4
Malbolge
Maple
Maple
MAPPER (Unisys/Sperry)
MARK-IV (Sterling/Informatics)
Mathematica (Wolfram language)
MATLAB
Maude system
Max
MAXScript
MCST Elbrus 2000
MEL
Mercury
Mesa
META II (and META I, a subset)
Metal Shading Language (MSL)
MetaOCaml
MetaPost
Microsoft Dynamics AX (X++)
MIPS
Miranda
Miranda, Haskell’s parent
ML
Modelica
Modula
Modula-2
MOFM2T
MOO
MultiLisp
MUMPS
MXML
MyHDL
NATURAL
NELIAC
Nemerle
NetRexx
NewtonScript
Nim
NXT-G
Oberon
Object Pascal
Object REXX
Objective-C
Obliq
Obliq Modula 3 variant
OCaml
Occam
Octave
Opal
Open Object Rexx (ooRexx)
Open Programming Language (OPL)
Open Shading Language (OSL)
OpenCL (extension of C and C++ to use the GPU and parallel extensions of the CPU)
OpenEdge Advanced Business Language (ABL)
OpenGL Shading Language (GLSL or glslang)
OPS5
Orc
Oriel
Orwell
Oxygene
Oz
PALASM
Pascal
Pascal Script
PCASTL
PEG (parsing expression grammar)
Perl
Pharo
PHP
Pico
Pict
Piet
Pike
PILOT
PL/C
PL/I
PL/S
PlayStation Shader Language (PSSL)
Plus
POP-11
Poplog
PostScript
Power ISA
POWER
PowerPC
PowerShell
Programming Language for Business (PL/B)
Prograph
Progress 4GL
Prolog
PROSE
Pure
PureScript
PV-Wave
Python
Q (equational programming language)
QML
Quartz Composer
QVT
Racket
Raku
Rapira
Rc (shell for Plan 9)
RDQL
Reaktor
REBOL
Red
REFAL
RenderMan Shading Language (RSL)
Revolution
Rexx
Ring
ROOP
RPG
RPL
Ruby
Rust
SableCC
SAC
SARL
SAS
SASL
Sather
Scala
Scheme
Scilab
Scratch
sed
Seed7
Self
Seneca — an Oberon variant
SequenceL
SETL
sh (standard Unix shell)
Shakespeare
Signal
Simula
Simulink
SISAL
S-Lang
SMALL a Machine ALGOL
Smalltalk
Snap!
Snobol
Solidity
Soufflé
Source
SPARQL
Speakeasy
Spin
SPIN
SQL
Squeak
Squirrel
SR — research language
Standard ML (SML)
Stateflow
StreamBase
StreamSQL
Subtext
SPARC
SuperCollider
Swift
SYMPL
SystemC
SystemVerilog
TACL (Tandem Advanced Command Language)
TADS
Tcl
Tea
thinBasic scripting language
Thue
ToonTalk
TorqueScript
TRAC
TREEMETA
Turing
TUTOR
TypeScript
Ubercode
Uniface
Unified Parallel C
UNIVAC[c]
Unix shell
UnrealScript
Ur
Vala (GObject type system)
VB.NET
VBScript
VEE
Verilog
Verilog-AMS
VHDL
Vim script
VisSim
Visual Basic
Visual DataFlex
Visual FoxPro
Visual Prolog
VisualWorks
Vvvv
WebDNA
WebMethods Flow
Whitespace
Windows batch language (input for COMMAND.COM or CMD.EXE)
Windows PowerShell (.NET-based CLI)
X++
X10
XAML
XOD
Xojo
XOTcl
XPath
XProc
XQuery
XSLT
yacc (compiler-compiler, from Bell Labs)
YASS
Yorick
Zig
Zilog Z80
ZPL
zsh (a Unix shell)