Strange late night observation:
- I learned TI BASIC from the reference manual included with my TI-99/4A.
- I learned LOGO from the help files.
- I learned TMS 9900 assembler from the Editor/Assembler reference manual.
- I learned Amiga E from the help files, samples and some experimentation.
- I learned Motorola 68k assembler from various random documents I could get my hands on because I couldn't obtain a copy of the chip reference manual.
- I learned C from the Dice C reference manual (and filled in the gaps later).
- I learned x86 assembler from the chip reference manual.
- I learned C++ from the language specification and by reading the STL code (filled in the gaps with Stroustrop's C++ book and Plauger's STL book).
- I learned Java from the language specification.
- I learned Scheme because it was obvious.
- I learned Tcl from the reference documentation.
- I learned Self interactively in the runtime environment.
- I learned C# from the language specification.
- I learned Python from the language specification.
- I learned Ruby from the online tutorial. (What language specification? Grrr!)
This list is by no means exhaustive. I've skipped all sorts of things, particularly declarative, scripting and domain specific languages. Some of them I'd rather forget in favour of INTERCAL.
Anyways, I wrote up this list because I noticed something interesting about my learning style. With few exceptions I've tended towards authoritative source material. I've found myself unaccountably frustrated (or bored) when I needed to rely upon anecdotal source material such as tutorials or reverse-engineering. I have never learned a language by taking a course or by rote memorization of examples. I am very selective about the books I purchase. (They are almost always structured as reference manuals or multi-part formal specifications. My most common complaint is the lack of phone-directory style indexing in the upper corners of the pages.)
However, C++ stands out as the language I probably spent the most time ever learning. I used to bury my head in the language specification for hours at a time grappling with subtle ambiguities. It took me a couple of years to grok it in fullness by which time I was reading draft proposals for C++ extensions. It was entertaining to see just how tortuous each new extension made the language by tossing in half a dozen new rules here or there. When I used C++ every day, I knew all sorts of ways to use and abuse each feature. The funny thing is, I don't feel that same level of confidence with the screwball corner cases of any of dozen languages I use regularly today. Perhaps that just means they're better! (When was the last time you needed something like a 'typename' keyword in your favourite language?)
What were your experiences?