Programming became a lot easier when you could just type a question into Google and it would find that someone asked the same question in some forum or newsgroup. In 2003 Google would always include results in a site called Experts' Exchange, which was basically an earlier version of Stack Overflow.
What was different, though, before Google, was that when I got stuck, I often spent a lot of time inventing (or guessing,) a workaround, and my workaround was often incorrect, fragile, slow, ect. In today's world, I'll often see the workaround show up on Stack Overflow first, and then a better answer show up, and then a better answer.
(edit) Another difference is that documentation is essentially annotated today. If the documentation is confusing or misleading, it's usually clarified in a stack overflow or some other forum. Before Google, if documentation was confusing, you were stuck guessing or hacking. That was very time consuming.(/edit)
So basically, before Stack Overflow / Google, there was no globally searchable database of questions and answers. You would get stuck on simple things for a long time, and move much slower.
Expert Sex Change was garbage, though. If it hadn't been as terrible as it was throughout its life, Stack Overflow wouldn't have taken off nearly as easily or as well as it did. I mean, I like to grouse as much as the next graybeard over how SO has gone downhill - and it has - but it's still miles and miles better than the metaphorical and deeply unmourned Superfund site that predeceased it.
The topic-specific SE sites are often better; Emacs.SE, just off the top, is consistently of very high quality, with maintainers of several high-profile packages and Emacs itself regularly active there. But I abandoned any attempt to participate on SO proper years ago, and rarely even check there except on the off chance that some weird exception has an obvious cause that'll save me a source dive on a library or some similar large investment of time.
>First google result
Probably SO should have weighted question upvotes at least as high as an answer upvote. Now it would take stronger medicine: e.g. pushing questions by people with low rep down the list.
What to do about it, I've no idea. I have the rep for most mod powers, but the Augean stables lack appeal. Beyond that, I wouldn't presume to venture a suggestion.
I used to answer questions on SO, but got so tired of arguing with idiots that I decided it wasn't worth my time anymore. It's too bad, too, because I strongly believe in "giving back" where I can and SO was a way to do that. No more. I still google for answers on there all the time, though.
You may want to edit...
Edit: Well; that explains why the service didn't take off
(Edit to your edit: It did take off! It was the best we had for years. That best was just very, very bad.)
Edit: It was a site that sold pens; I think the alternative pronunciation of their domain name was unintentional.
Edit 2: I think I was wrong. Snopes says they did sell pens but they chose the name intentionally: http://www.snopes.com/business/names/domains.asp. Some other such names from that link: powergenitalia.com, molestationnursery.com, and whorepresents.com.
I was curious about the (presumably) original .com, which is now squatted, and about which there seems no historical information easily to be found.
It's true that horrible PHP forums existed before that, but when google took you there the answer was often buried on page 4 of 7, sandwiched between dozens of the "trying to be helpful" posts instructing you to reinstall windows and reboot.
Oh, and expert-sexchange---hated that site with a passion, until I realized you could just scroll all the way to the bottom. Think that's when I became aware of the term "dark patterns."
And SO still suffers from the same basic problems they all had - "good" answers get stale, information tends to clusters around simple/beginner problems, etc.
Therefore, at no point in time have I been dependent on google, though it was helpful about five to ten years ago. So, my impression is that SO was the bigger innovation, though YMMV of course.
I think overall we are agreeing. USENET and various sites were a huge jump from the state of things before hand, when your available resources really depended on location. SO is a more useful interface on top of that stuff and easier to access, but the real innovation was made decades earlier.
The next version might implement a versioning strategy, say questions/answers get archived every five years or so.
Before that, you'd get books out of the library and get a pad of paper and hand-assemble 6502 code and read Byte magazine and if it took a long time, you learned it very very solidly. So I'd say I got a level of deep understanding from hand-assembling code for 6502 that I (as a fogey) doubt I would ever get from any amount of SO reading. Tho my general work flow once I start typing is to google every thing that I can't instantly fix; weird compiler error, cut and paste into search bar, optionally add "stack" to the end and read.
Agreed. I remember using https://www.codeproject.com/ a lot, back in the day. The quality was often variable, but being able to search for function-names and see them in use was very useful.
Especially when the only alternative was years-old MFC books in the local library.
I would say that one of the reasons why php (the language) took off in the early 2000s was because of its excellent docs pages: each doc page for a specific function had a comment section where you could find the actual examples of said function being used, by actual people. Pretty similar to what one can now find on SO.
Programming became easier with altavista, which was an excellent search engine that supported complex, boolean search operators and respected (((multiple) nested) "parens with quotes") ... and other such complexities.
Google dumbed this down and to this day is very difficult to accurately and precisely use.
There is no effective and consistent "expert mode" with google - even using the "expert" symbols and keys (like allinsite:) result in "related" and other useless results.
I miss altavista every single day.
I'm not sure that this is so much AltaVista versus Google; I remember when Google first came on the scene (or when I first became aware of it?), I found its 'expert' options better than AltaVista's. They have, as you say, become much, much less effective over time, but it seems sadly plausible that the same would have happened to AltaVista. (It does seem that DDG is doing its best to fill in the "search for techies" gap that Google now leaves open, but I don't remember AV well enough to compare them.)
I find Github to be just as valuable today btw, whenever I search for a problem the top result is a github issue with many comments already on it (and sometimes a workaround)
But, you learned. That's something neither SO-driven nor google-driven development can provide. I firmly believe that every detour I took (mostly FreeBSD userland sources or any port I never installed but fetched and extracted just to read the source) was invaluable to help me become a good programmer.
Don't get me wrong: Being able to scan SO/google results for a solution to a problem is important, it's important enough that if you are unable to do so I won't hire you. But: The time saved by constantly referring to SO or google is effectively education skipped. So. if referring to those sites is your MO, I would not hire you either.
Surely every educational innovation is greeted with this sort of lament? (I'm a teacher, and I know that, if I listen carefully to myself, the "good old ways" whose loss I am bemoaning are the new-fangled ways of a few years ago.) For example, when programming was done by hand translation to assembler, you learned what every line of code was doing, but now with compilers people don't really understand the invocations …. I'm reminded of the XKCD cartoon tracing back through hundreds of years the lament about how people don't write like they used to do.
For what it's worth, that was exactly what I meant. I don't think that anyone says, or even thinks, "grr, these kids and their ways of learning that aren't exactly like mine!"; but rather that one sees these kids and their ways of learning that aren't exactly one's own, and says "grr, these kids aren't really learning!"
This isn't to say that it isn't true, as I'm sure that sometimes it is, but that I think that most of the time it's a reaction that's likely to fade with time. However we learned looked, almost assuredly, like "not really learning" to some of those who came before us. Again, to appeal to my own experience, I have become a lot more relaxed about the use of calculators in math classrooms; I initially felt that they were taking away from students' calculational facility (and have not changed my mind about that …), but now feel more that they are clearing away the computational drudgery to allow more room for conceptual exploration. It is believeable to me that being able to Google the answers to things that are already known is a great way to get as quickly as possible to the things that aren't already known—although, of course, it is a worthwhile argument whether, or how much, preparation it offers to deal with those unknown things upon reaching them.
I started programming when I was 10, in 1976. In those earliest days of consumer-class computers, there wasn't really a developed market for practical programming books. However, the manuals that came with software or OSes were quite well-written. There were a few magazines, too, like BYTE and Dr. Dobbs Journal, that published source code -- always the best way to learn!
It helped, too, that my dad was a programmer. I learned most of the basics about computer architecture, binary logic, algorithms, etc., from talking with him.
There were local user groups, though most of the folks were enthusiasts, not necessarily programmers.
By the early 80s, I was reading the C manual by K&R and other books on practical programming, and trying things on my home CP/M system (Heathkit H89). If I had problems (and I often did), I simply had to experiment, read more, think more, debug more.
I first got online around 1980 -- via dial-up BBSes, then the early Internet (ARPAnet), and USENET. While you generally couldn't search for answers/code the way you can now, you could browse, and you could certainly ask people who knew, or at least could offer suggestions.
Finally, I think it's been an advantage that for most of my programming life, I've used Unix, and most of the versions I used included source, which is always educational.
I also loved all the Beagle Bros software and programming tools, and especially their catalogs and ads. (And NO, they were definitely NOT "Brogrammers", they were freaks!)
I bought a cheap compiler, tried to use one of the standard library functions, couldn't work out why it wasn't working.
Used the debugger to single-step through the 68k machine code it had generated. Still couldn't see why it wasn't working, because what it was doing didn't make sense.
Typed out a letter - dot-matrix printed on paper - and posted it, with an envelope and a stamp and all, to the compiler manufacturer.
Got a letter back - hand-typed on headed note paper and signed with a pen - saying: "Sorry, we haven't implemented that function yet."
Whole cycle took about two weeks.
I prefer having SO, Google and GitHub to work with.
My first missed encounter with programming was when I was a teenager in the 90s. I sort of wanted to do more with these machine but wasn't sure where to start. My parents weren't particularly IT savvy (though we had home computers since the Mac SE) and weren't keen for me to do something else than outdoor activities. I still managed to get them to buy me a copy of code warrior, as I kind of understood this was to create software. Then found myself in front of a white text editor. Had never even heard of C and that was a few years before the internet. Never went beyond that until college.
Kids today are spoiled...
I got into programming in the early 90's by tearing apart the sample HyperCard stacks on our Mac Classic. The UI and the english-like programming language made it super easy for a 8-year-old to learn by copy pasting and re-arranging code. My uncle then noted my interest and gave me a copy of the HyperTalk reference guide which I read cover to cover. The writing in that book was great, the sample code was full of humor that flew way over my head.
I don't think so. My experience was pretty much the same as jslabovitz's, just without the progamming dad.
I started programming in 1984 and pretty much only had books, manuals, and magazines to work from. I only had one friend who had a computer and it wasn't the same as mine (and in the 80s, there were scores of different CPUs and operating systems to choose from) so I was more or less on my own.
I still miss the BYTE magazine with the Robert Tinney covers ...
Also in the early 80s using a computer pretty much meant programming. In the early 90s (my youth) computers all had some form of GUI and lots of shareware, and computer magazine weren't really talking about programming.
Still, I've noticed that the Google/SO approach to troublehooting is, all too often, to collect an exhaustive set of things to try, and begin trying them. If you discover one that works, say yay!, and move on to the next problem. If you're very, very nice, post that it worked so that the solution can be lifted marginally higher in the queue for the next person. My students (who, admittedly are very inexperienced, I suspect this behaviour becomes less prevalent later) seem to spend very little time on what was a critical first step for me: hypothesize about what things could possibly be causing the problem and then come up with an experiment (often involving a simplified program or using only a subset of the system). My initial tests were rarely to isolate the problem: they were to either eliminate or comfirm a class of problems as I successively isolated the specific cause (ok, so it remains if I move it to another block of memory. Maybe it's a race condition? Ok, what if I force this test high, then there won't be any branching in this code block ---that's vaguely recalled from a problem that came down to needing a NOP in one branch path to avoid a fencepost error in some probably over-optimized code). The benefit was that, after a few months of troubleshooting like that, you kmew your system absurdly well. Conversations within the tiny community of fellow travellors (there were about a half-dozen in my high school of more than a thousand students) were heroic tales of bugs run to ground that we all learned from and tried ourselves.
Unfortunately, it's not really possible to learn a system that well any more, they're too complex. But I wonder if the ease of just typing the error message into Google means this generation don't learn the application of the scientific method that good troubleshooting really is. Because, for many of my students, it seems as though if the answer isn't on SO, then it will forever remain a mystery.
This is key. I've worked on dozens of systems, platforms, frameworks, etc., and the common predictor of how well I program in each environment is directly related to how well I understand the mental model of the architecture.
I didn't know if what I was doing had already been done, I struggled and struggled and struggled until I figured out the right answer, learning how other things worked with every failure.
Now, jumping straight to the right answer eliminates all those other things I learned along the way.
I believe I was a more well-rounded and talented programmer when I was 15 than I am now pushing 40.
Anyway, maybe I just miss those years where I had 100 hours a week to teach myself something new and fun. I could never find the time for that now, and so jumping to the right answer is really my only option.
It's the difference between 8 hours, 1 of which is wrestling with dumb broken crap, and 4 hours, 3.5 of which is wrestling with dumb broken crap. The latter is way less fun, very demoralizing, and more mentally draining IMO. But it's almost all one gets to do these days, because you do get done faster with them. A blessing (to productivity) and a curse (to fulfillment/happiness as a developer)
[EDIT] add missing word
I had the manual that came with my computer and a library that archived copies of Byte and Compute! I mostly re-typed in games and messed around with those.
In the 90's I guess computers were pretty normal to me. So when I wanted to make computer games like the ones I was obsessed with I had an idea of what to do. I had a bit of dosh to get some books of my own... mostly tech manuals that came with limited trial versions of Turbo C. I was a teenager and didn't have a lot of money so I learned how to get around that so I could continue making my cheesy space shooters and pizza delivery games.
I also had an account on local BBSs before the Internet came. Many helpful people there. Fido mail. One BBS even had an NNTP and email service... but I didn't really use that as much as the books because the turn-around for an answer was still pretty slow. It was often much faster to just look it up in a book or try taking a stab at it yourself and figuring out your own solution.
I mostly just kept making things. The Internet just brought an audience for those things beyond my limited circles.
I guess mostly you just had to be motivated and a little clever to figure out what you didn't know and solve the problem with good, old thinking and experimentation.
I can't remember how I got hold of sources to study or the tools. I probably downloaded every source example I could find from BBSes and fidonet. I distinctly remember finding a pirated SAS-C copy and that disk also contained a really nice c++ tutorial.
In my professional life, Stevens unix and network books helped me alot. I still have them.
The real turning point came with the Internet, and when I started to use Linux in 94.
Google (of which Stack Overflow is only one of many results) is for when you get stuck on some specific problem and need help. Nowadays we just see Stack Overflow in the search results more often than not. I guess SO means nowadays its easier to find answers to specific questions but I don't see how you could actually learn programming from the bottom up that way. It also encourages blind copy and paste solutions without actually understanding the mechanics of the underlying technical problem.
Stack Overflow is very useful, but you need to take it into context like anything else. Many stack overflow answers are still poor quality, outdated, lacking some context, or just outright wrong. Just because its on the internet and a lot of people have looked at it doesn't mean the right person who really knows the subject matter has not only read the answers but cared enough and had enough free time to produce a good detailed answer.
Wasn't until 1995 that I discovered gcc which led to my discovery of GNU/Linux shortly after. Before that I scrimped and saved and waited for trade shows to pick up new books and versions of MS programming tools for DOS, Win 3.1 and then Windows 95. After that I ran a duel boot system to keep learning Windows and start taking advantage of free software. This was also about the time it became easy and affordable for me to be on the internet regularly and the ldp was a great place to go instead of using dead trees.
Before Linux I could not afford access to any type of UNIX system (except maybe Xenix, saw that a lot at shows, was always tempted but never made the plunge). I did not know about *BSD at the time.
It's worth pointing out that, for a lot of places in the world, there weren't such things. There certainly weren't where I'm from in Australia
I'm from a bit north of Brisbane originally and if there were any in Brisbane around the 80s/early-90s I never knew of them (I guess that's the other thing about the pre-web world, that it was a lot harder to know of what was happening).
Later I got a Spectrum; later still a PC. It was vital that these came with BASIC. Paying for development tools would not have happened. Eventually I acquired pirated copies of Turbo Pascal, Microsoft QuickC, and finally a legitimate but already obsolete copy of Borland Turbo C on seven 5.25" floppy disks.
Eventually I also got a modem and could gain access to such troves as the PC Game Programmer's Encyclopedia.
I think the main difference is that if you came up with a question you had to answer it yourself through research or experimentation. If you weren't very persistent, or weren't given the free time to do the necessary self-directed learning, you wouldn't get very far.
Modern knowledge is streamed to you in small fragments. Back then it came in lumps. Multiple-inch-thick lumps. Most of the books were pretty worthless, although the Peter Norton ones I really learnt stuff from.
It was also viable to set out to read the documentation you had cover-to-cover and go looking for interesting or useful things. These days there's almost too much, and it's certainly not linearly structured.
My knowledge came mostly from the BBC Micro Users guide and Advanced Users Guide initially. Eventually a dead relative, who I will be eternally grateful for their thought, left me a not insignificant amount of cash and I bought a then new BBC Master!
The books in question:
This eventually made way for a PC and eventually in the mid 1990s, Linux and then I discovered my father had a 1st edition copy of "Programming C" stashed away in a junk box somewhere. Oh and O'Reilly books. I had crates of them at one point.
To actually learn C (not ++) I used Bjarne Stroustrup's C all the way. I think it was 150 pages of book with 10 pages of index, not exactly a heavy book, probably no larger than a 13" screen 'ultrabook' and I took it everywhere.
Back then we had attention spans longer than a goldfish, so studying a book that was so concise was the way to go, not to skim search results, copy and paste.
Before then with the BBC Micro again there were just the two manuals, the one it came with and some advanced one. The ZX81 was okay with just the manual it came with.
Computer magazines were actually how you learned new stuff, or at least saw stuff that you wanted to do, even if the reality was typing in hex-dumps.
As for attention spans:
A Microsoft study in 2013 said the attention span of a goldfish is 9 seconds, whereas we had attention spans of 12 seconds in 2000 and 8 seconds in 2013.
There is a lot of 'averages' here, however, we have changed how we expect to learn things. I have no idea whether it is 'needle, haystack' or the other way around for commands I use daily. We just remember where to find stuff on the internets rather than in our own grey matter.
But those were the days. We had to experiment like hell (any of you tried to understand the RWTS routines to read/write on Apple2 floppies ? :-)
The Internet has obviated the need for comprehensive books for the bulk of contemporary programming. I suppose there are obscure enough and/or proprietary platforms that still follow the "comprehensive documentation" approach, but it seems it's possible for widely used tooling to be poorly documented and rely on online forums to fill in the gaps with crowd sourced answers and examples. This makes "mind share" crucial to the usability of a language/platform.
I am sometimes frustrated with the contemporary model, but the old way wasn't a panacea either; just broken differently. If you want a good taste of "what it was like" find the manuals for Turbo C++ 3.0 (1991.) You'll learn things about C/C++ that you've never seen written down anywhere.
Often, three or more books: commonly a library reference (which was just what it says, but with a lot more detail than many packages today have with their low-effort, auto-generated API docs), a programmer's guide (a comprehensive guide to the language supported), and a user's guide (a guide to the tooling provided.)
The web has made finding answers to hard questions quite a bit easier, but it's also made the basics quite a bit harder. Current (to the software version you are using), correct, and clear information covering the majority of things most people would use was a lot easier to find when getting a compiler meant getting books with exactly that information.
Most programming language have manuals, and at least those I've used have been pretty good. People just don't want to read manuals, they just want the answer to their current problem.
Over time, I saved up and bought a Hayes modem and got online. As I read source code I'd try to incorporate techniques I saw into my programs. Some of these turned out to be bad. You knew they were bad when they made your life more complicated without any stated benefit (or when the benefit was paper thin). This wasn't explicitly stated anywhere (as I remember it), but it sorta revealed itself.
But he's probably talking about the cheap eMachines that were sold with rebates along with dial up. They went for something like $300 iirc.
I had a nearly identical experience to the grandparent post, except I would build/upgrade my computers with whatever parts were cheapest. I also remember there were a few services that would mail you a CD or 2 of your favourite distro for $5 which was amazing if you lived somewhere with terrible phone lines/no ISDN.
Of course, back then computers were much simpler and user manuals were much more complete and lower level, so this still feasible, where it wouldn't be today.
The books were of vastly different quality, the food ones always had properly described algorithms in algol or pseudocode of the day.
The RAD ones had plenty of screenshots.
Also the books came with disks containing the described programs.
It was typically some form of BASIC or Pascal.
Advanced Turbo Pascal books had x86 assembly in them. Old advanced C64 BASIC books had 6052 assembly. And sometimes you could get your hands on an Amiga Rexx book or magazine.
From the more advanced books you really learned how dumb the computers are and how they work internally. This is missing nowadays.
There were also pretty decent magazines with ideas and program printouts.
You had to experiment more and rely on the cookbook less.
My pet hypothesis is that puzzle and turn-based strategy games were much more popular back then because average computer user was much nerdier. Age of Wonders III came out in recent years, and while it has very good production qualities and is a much more advanced strategy than Heroes of Might and Magic or first Civilization games, it never reached its popularity.
But back to programming. Monthly magazines were BIG before internet, and some of them taught programming. For example there would be a game or another interactive program written in BASIC in every issue. When you had the entire source code printed in front of you, it was fairly easy to tinker with it to grant extra lives, etc.
I agree with your hypothesis about games. If you have to do some study and learn some magic incantations even to launch a game (insert fond memories of himem.sys and boot disks here), then it stands to reason that those of us who could actually get into games were the type of people who liked a bit of an intellectual challenge.
Magazines were a big thing, definitely. I have a big box of Acorn Users somewhere that I inherited from my dad, and at long intervals I pull them out to read through the articles and old BASIC listings. :)
My childhood self-learning experience is a good example of the importance of:
1. "open source"
2. a fast code-run cycle
QBASIC, being an interpreted, pretty much guaranteed these two conditions inadvertently.
An alternative to the PDP-8 was the one class in writing Cobol on a mainframe. You had to hand write code on a huge ledger sheet, translate that into punched cards, submit a job, and wait a couple days for the result. Most of my coder buddies thought that was a joke.
Instead we stuck with PDP-8. Because the computer was shared by several schools, there was a huge inter-school rivalry. We would hack accounts, and write incendiary messages in the other school's directory, which could only be erased by writing assembly code.
When I went to university, the first computer science courses still used punched cards. The classes were incredibly boring: with PL-1 examples of how to move pieces around a chess board. No AI. In high school, we were already writing chess player programs, multi-user star wars, compression, social engineering, and infinite precision math packages.
So, I was a bit judgmental about the quality of the University courses and missed out on some important lessons. My first language was Basic. So, my code was a meandering mess of spaghetti. It took a years to unlearn that self-inflicted pedagogical brain damage.
Now, with SO + Git, coding feels like assembling flat-packed Ikea furniture.
Luxury! (Monty Python "Four Yorkshiremen" reference)
In 1974 I was (the equivalent of) a junior in high school in South Africa. Back then we called it "Form 4", fwiw.
* Number of computers at high school: Zero
* Number of computers to which we had access: Zero
A friend and I joined the school computer club. I think we were the only members.
We were allowed to sit in on a FORTRAN IV programming course at the local university, and use their IBM 360/50 mainframe via golfball ttys. We were even allowed to write the exam, which we failed spectacularly.
We would have killed for a PDP-8 (if we even knew what that was, frankly). There was no such thing as "online".
"And you tell that to the kids today? They won't believe ya!"
> "Four Yorkshiremen"
Zero computers? Ok, you win.
This is a later version of our computer https://youtu.be/NtAF-WfWyGU
To load the OS, you first had to hand key in a bootstrap loader in octal (base 8) on the front panel. The loader would then read the OS from paper tape into magnetic core.
Our computer was a PDP-8/i. Someone mentioned that the PDP-8/i was about as powerful as a Raspberry Pi. So, imagine a half dozen schools timesharing a Raspberry Pi.
Currently, I'm writing for the Apple Watch, which is more powerful than a Cray-2 -- a supercomputer that cost $16 Million in 1984.
Nice YouTube video, thanks.
> To load the OS, you first had to hand key in a bootstrap loader in octal (base 8) on the front panel.
When I eventually got to university in 1978, we had a PDP-11 of some sort, and I recall entering the boot program by setting the address and data toggle switches and booting from paper tape. I have no idea if it was core memory.
Those were the days :)
For a while I had a Win95 product key memorised, for the frequent reinstalls that were a feature of pre-7 Windows.
I'll ask "how do I do <basic concept> in <framework>", check the SO results for a well documented and thought out response (not just code snippets), and start reading. On the side in a notepad I type up the terms/concepts they talk a lot about in that post that seem necessary to understanding their post (which I do NOT usually fully understand). Then I close that tab and start learning about those concepts.
Sometime's I'll also do that with code from SO - find code that works in a microcosm, and tinker on it to see what it does, look at documentation, APIs, tutorials, etc.
I personally have found this to be very effective, far moreso FOR ME than a book ever could be (even a PDF book w/ searching)
Personally, I have a hard time retaining technical book content unless I'm immediately utilizing what I've read, which is mighty inconvenient. If I stop writing code for the time it takes to flip through a book and find the relevant bits, I've lost my flow. It's much faster to google and flip through blog posts and SO questions.
Some books were useful to me, but they were "diamonds in the rough". Searchable documentation and result-focused tutorials available these days are usually much better. Although I can't understand the people who want to learn from videos.
I think the appeal must be the very low rate of information transmission. Watching someone typing slowly onto the screen, while saying out loud what they're typing, under the guise of presenting a "tutorial" on how to fetch input from the keyboard ("tutorial" being a very grand word for a slowly presented code listing) is something anyone can keep up with (although probably shouldn't bother).
That said, compare those to things like Casey Muratori who manages to push information at a higher rate doing essentially the same thing, except that he isn't just reading out loud what he's typing. Again, the information density and transmission rate thereof cannot begin to compare to a book, but there is something of a range to be found.
Straying from the topic, I've come around to the conclusion that there are a lot of people who want to be able to do things, but really don't know how to learn. To take on large amounts of new information, to think with it and ally it to what you already know and to adapt it to your purposes, and to do this for an extended time, is a skill like any other; it must be acquired, and exercised. If you don't know how to learn, if you aren't practised in it, a decent textbook might be simply unassailable for you and all you can do is inefficiently monkey-see-monkey-do your way around SO until eventually you've put together enough pieces to start actually building your own understanding.
So I suppose I've come to a second answer to the question; before SO, you either didn't learn at all, or you learned with an efficiency that must seem blisteringly powerful to some kid trying to bootstrap himself by trying to find the answer to "Why does it break when I try to store a string in a single char?" without even knowing that's the question to ask.
They still are, and there's a downward pressure on them to be at best mediocre--because that's the audience. I wrote a sample chapter and TOC for a large book publisher a year or so ago and got back feedback from the editor that amounted to "I enjoyed reading this despite not knowing the topic, and I think I have a good grasp on it now, but the prose is too complex for our average reader." (Which implies some really unfortunate stuff about their average reader completely separate from their technical acumen.)
The best books I recall were actually For Dummies books, of all things--well-written, engaging, and conversational. As I recall, Wallace Wang, the author of the ones I remember most vividly, was/is a stand-up comic, and his prose stuck with me twenty years later. About Visual Basic, of all things!
However, one very important aspect of usenet was the curated FAQ document of the newsgroups (e.g., a FAQ for comp.lang.c ).
The document was maintained by the newsgroup maintainers and would be of very high quality, informative and with it's own unique sense of (geek?) humor. I have pored over pages of such documents and have learned a ton and enjoyed doing it.
Interestingly, I remember reading somewhere that stackoverflow.com was developed to eliminate some of the problems associated with maintaining a usenet newsgroup FAQ, e.g., through automatic and community-driven curation, although at this point, it seems like that kind of feature is either not used or not considered super-important. (well, in a way, that's what it's doing, but the final product is access to the answers through google search, not a single FAQ document).
 a tiny list of comp.* newsgroups (https://en.wikipedia.org/wiki/Comp.*_hierarchy)
P.S.: Another important resource (in use in the past as well as in the present): irc.freenode.net chatrooms.
Something like: How do I join two strings in Foo? They list a few answers, including a suggested one alongside caveats/pros/cons of each. There's a lot of Stackoverflow there. And they always seemed to provide code that was less abstract and more practical than say a 'Learn Foo' manual.
This is not an issue in SO – if you write a well-formatted and clear question that may also be beneficial to other people, no one is going to look down on you for having 1 reputation point. You can also find reliable answers to common problems, since these posts become very popular and have strong peer review. An answer at the top with a few hundred upvotes is pretty much "copy-paste safe" :-)
The negative side is that people become too lazy and stop bothering with reading long documentation and articles, which can, IMO, help you build the big picture better, in case you can afford the time.
Now this was back when is as 9 and using Qbasic though.
I was able to write a bunch of questions to ask the senior teachers at high school, but that only led to more questions.
I did eventually get given c++ by a friend, but I was absolutely stuck.
Admittedly though, the lack of books was the sticking point. I believe if I had a few more text books, that it would have been a hell of a lot easier. Not as easy as im-stick-quickly-google as I do now, but a ton easier.
Hmm after typing this out I realise it doesn't really answer your question, bit I'll post it anyway.
But imho learning from. Textbook with no outside resources (which I did later in life), made me come up with some interesting work around a, which later on gave me insights, but to get software out quickly, SO and Google help a lot.
Not very clear I know, sorry but that's my 2 cents.
Imagine my surprise the first time I walked into a Barnes & Noble.
Sometimes, after figuring out the answer, I would want to post it as a new reply to the thread, but then I'd have to register as a new user to a forum which I don't know if I'd ever visit again, or sometimes the thread was archived and didn't allow new replies. Even if I managed to, I'd soon be reprimanded by the moderators for necromancing the thread.
Then we also got a Color Computer 2 which I really liked following the manuals and experimenting with BASIC. That helped a lot. https://www.google.com/url?sa=t&source=web&rct=j&url=http://...
The mindset at the time was "I have this, what can I do with it?" Now it's more like "I need to do this, which of several ways is easiest/quickest/less hassle/etc."
I think things have changed in ways that will make it harder to learn programming from manuals, or from any other compact source. BASIC and Turbo Pascal had what, maybe no more than 20 keywords, and the capabilities of those packages encompassed everything that could be done on a limited platform such as MS-DOS or Apple II. Expectations were lower: A text display and menus were good enough for a lot of apps -- even successful commercial ones.
Today, I think that programming has gotten harder in some ways. The systems that we have to program, and the tools, have utterly sprawled. I don't even know all of the keywords for the languages that I use today, much less the libraries. I think we have to get used to using systems that we don't fully understand, and how to do so without creating a train wreck. That's more like how the rest of the world lives: A chemist doesn't know every possible compound, or reaction. They learn some solid foundations, and how to approach the vast space of possibilities.
plus Perl was king so there weren't any right answers, or an infinite number of right answers I should say.
Unfortunately, I don't have many good EE anecdotes to share... But I'm gonna try to dig my account up to have a good ol' chuckle at my younger, clueless self.
 — EDIT: Gems include accepted answers for 'how to open task manager' and 'website not loading properly' -- perhaps a bit more elementary in those days...
I think in the 90's there was a growth in what I call career programmers: people who chose to get into programming because it was "the thing to do", though they didn't have the natural skills or passion for the work. They just worked really hard to learn and found a nitch to fit into...before moving on to management (or getting fired). A lot of these people were the foundation for classroom training and certifications.
I think millennials are a combination of natural skill and passion, but in many cases lack the background of computer science so they do great and terrible things all at once.
I'm mostly self-taught, but having Google and Stack Overflow are really amazing tools. Except when you're asking the wrong question (Google lacks context). Then you need something else, which doesn't exist. Yet.
Writing code these days is SUPER easy. Write stuff, run or compile it, get an error, search Google for said error, click on SO link, find answer, implement answer, move on with your life.
As in any branch of science or engineering, learning to work from primary sources is an absolutely core skill. Resources like StackOverflow are a crutch at best, and counter-productive if not outright dangerous at their worst.
At the very least, I always recommend people at least try to correlate the cookbook answers they find against the standard references.
I find too often the "it's on SO" responses end up being circular, and people point various descriptions of different problems to the same single answer, which aren't applicable. Just spent way too much time last night dealing with CORS stuff, and kept linking to the same handful of SO threads/answers which were not the problem at all, but at some point in the google/search world, so many things have similar enough keywords that they all congeal together, making it harder to find the 'real' solutions.
no idea why that works, but it usually does
Ugh.. Trial and error via compiler is one (arguably inefficient) way to learn to write code. Actual "writing code" is more like around 1% "getting it to compile".
At the same time, language APIs have exploded. In 1998, you could literally memorize all of a language like ColdFusion. External libraries existed, but weren't as depended on like gems or node modules are today.
However, I think your statement is very true for certain classes of applications. For example, many Rails apps are very much gluing things together. Michael Hartl in his popular tutorial even describes "Googling the error" as an actual technique.
Programming these days is hard, too. The amount of stuff you have to learn seems to continually get bigger and bigger. Like learning to program in pure Java vs. learning Android development. Writing programs in Java feels like programming to me. Writing programs for Android feels like remembering formulas without understanding how they work.
And googling for answers often takes you down the wrong path, or there simply is no answer when you get deep enough into the codez.
For me at least, there was a certain level of aptitude I needed before I was able to productively seek out knowledge on my own. The range of possible things-to-learn in the programming world is so vast and daunting that I needed some hand-holding at the outset, until I had enough knowledge to reasonably separate things I needed/wanted to learn about from things I could confidently disregard.
If I were learning from scratch today, I think it's fairly likely I would still need something similar, even with the existence of SO.
Stackoverflow definitely saves a lot of time, but it doesn't compare to the personalized help from those gurus on IRC. Unfortunately, much harder to find these days.
Alex Suraci If you're reading this, thank you.
But the technology has evolved in more ways than just stack exchange. There was the availability of compilers in general- today, it's a search and a 1 minute download to get your compiler. And pick your quirky tutorial of choice. Back in the day as a kid, it was mowing lawns and paying for boxes of disks, paying for thick books(hope you bought the right $40 book!), nobody to verbally speak with, and staring at obtuse example code for hours late night while you were supposed to be sleeping.
It was bad as hell with PHP (which in turn led the PHP core developers to provide backwards-compatibility for ages), but in the JS world which evolves waaaay faster and especially believes that "backwards compatibility" is the devil I will not buy any kind of JS dev book - and also the reason why I shifted from JS frontend work to backend, server ops and security. Stuff there evolves fast (and is plagued by security considerations), too, just look at Docker - but at least you are out of the "I just reasonably understood framework X, version Y but now version Z is out and I can throw everything I learned into the bin" loop which is bound to destroy you sooner or later.
StackOverflow, in contrast, attracts a massive load of users so you're way more likely to find a working example - and usually if it's outdated you'll find someone in the comments mentioning that it's outdated and in most cases even an updated response. What I don't know, however, is if StackOverflow's success is based on the hyper-evolution in the JS scene or if the evolution would not be possible without SO - because there would be no way to distribute the knowledge fast enough.
so yes, nearly always learned and traversed bugs in my code the hard way...but i don't recall it being that hard. Mostly it was just awesome.
but here's the thing: then i was coding in BASIC then C from lyceum, university, and the first few years of my professional career and most of the time i was working. While working in C for instance, i recall most of the time i got stuck it was something having to do with memory management--allocating it, reallocating it, recycling it, and re-pointing it. I got stuck, but not in a subject i didn't already know quite well.
today, it's a much different story: i'm at risk of drowning in DSLs (never called that, often "frameworks)--new ones pop up constantly and others disappear.
so when i get stuck today (or for most of the last decade) quite often it's because i need a different kind of assistance--like the kind a noob needs, because quite often i'm starting at some code from a DSL that i don't need to re-factor or debug, but that i need to interact with, and i've never seen this DSL before.
Not having access to the internet (let alone Stack Overflow) really forced you into a mindset where you were on your own, so you had to take a scientific approach to finding bugs: trying hypotheses, comparing code that worked and code that didn't, reverting changes to a known working state, and so on. I wish it had made me better at writing easily debuggable code, but I was still too young back then, so it mostly made me very good at debugging ugly code (this, and my four-year stint as a programming TA means that my most effective debugging method is staring very hard at code for a minute).
After a while, I managed to get a connection to the internet. I suddenly gained access to a lot more tutorials and online resources. I spent a little while on IRC and on the Gamedev.net forums, but by then it was a lot faster for me to solve my own problems than to post them somewhere and wait for an answer. What I needed then was to unlearn all the bad habits that came from coding on my own, and it took a while (and a few team projects). I was this kind of weird creature who knew the C++ standard by heart and could find subtle errors just by reading C++ code, but who was completely unable to work in a team where everyone wasn't a C++ language lawyer. I got better.
As a ten-year-old armed with thousands of hours of spare time, I devoured this manual in pursuit of making games and drawing pretty pictures. I don't even really remember many details of the process; I just know that I spent a lot of time engaged in trial and error (guided by the manual, without which I would not have even tried).
(I've still got most of those books, and the papers are largely in boxes, and while many of them are kind of quaint, like the early Unix, Mac and Windows manuals, much of the material is still relevant and worth re-reading).
For learning programming: Read textbooks (e.g., K&R) and do the example exercises. Read kernel, compiler and editor source code for good examples. Find a mentor, ideally a hardass who won't let you get away with even tiny mistakes.
I was thinking earlier today that a lot of the reason why systems are so complicated these days is that we can get away with it because of resources like SO and Google, and in a sense we're creating "complexity we can't lift", but on a global scale now, and at some point this approach won't scale. You need to pretty good at searching for issues and triaging bad advice, and this is only going to get worse.
That's where I bought huge numbers of programming and theory books in the early 90's working in SV. Better than the Stanford Bookstore. The old store even smelled nice, like a very old library. I so enjoyed spending an hour once a week or so just sampling books.
Anyway, I started out learning basic on a (borrowed) sinclair about 1980, and then learned fortran on a mainframe at GaTech. The way you were taught fortran was to be given lectures on numerical analysis, and then you implemented the algorithms using the fortran manual as a guide (no help from the class). The asocial grumpy nerd behind the counter might occasionally answer a question at 2AM. When Newton's method converged the first time... I was in heaven. We had a fabulous co-op program, and so I learned basic (again, much better) on an HP-9845. Though it was state-of-the-art hardware, the real advantage was that it had a full set of HP manuals, and I got to use it almost full time for a whole summer. And they paid me!
Then next came a PC about 1986. I spent about 15% of my total income for that machine, and never regretted it. What that enabled was a platform for Turbo Pascal, and a little later Turbo C. As others have noted, those were heavenly development environments, with outstanding documentation. I think one of the authors of the documentation was kinda famous for his literary style, but I have forgotten his name. I also in about '88 spent $600 for an 80MB HD. This was about 5% of my then income as a math grad student. Never regretted that either. All of this investment in money and effort might have been entirely wasted, but instead I got my dream job in '89.
> And finally, there was "reading code."
This is what I did. A lot. And typed-in the code (found in magazines) I didn't understand. The reading code bit is I one of the two* important skill that I don't see exercised/exhibited by a lot of folks who are learning now. Reading lots of different styles of code found in the "wild" i think helps you appreciate more the underlying concepts a lot better instead of focusing on the particular style of you language of choice
* The second is the basic concepts behind "relational algebra" which I also learned by doing using Quattro Pro 2 (long before i knew the name of it) back in the day. I'm not talking about the syntax of SQL but more the modeling of objects/tables and their relationships to each other. Knowing when things should be 1-to-1, 1-to-many or many-to-many seems to be a lost concept sometimes. </rant>)
Edit: Quattro Pro 2 is probably not right.. it was a DOS based relational database package similar in features to Microsoft Access. You designed your schema with DOS based forms but could make links and queries between forms using a foreign-key concept.
Also, one big reason I think PHP was my go-to was the easiness of the manual (http://php.net/function_name_here)
I honestly don't know if it helped move web development forwards or held it back!
Even these days if i'm having a poke around somebody else's work, one of the first things i do is to pop open the dev tools and start seeing which libraries they're running and what their custom namespaces are.
A lot of things were simpler since there were no external libraries, no network updates, even no real choice of language. You just keep reading and experimenting and building your skills. I kept a 3-ring binder of notes, things I'd written down or photocopied from books.
My next computer was a Commodore 128. This had a better version of BASIC, more memory, and a CP/M option. You could also program directly in assembly or compile down to it, so I learned to read and write 8-bit assembly too. People are still learning new tricks with the old Commodore computers but by and large, you could still learn this machine inside-out in a way that's really impossible with today's more complicated, constantly updated systems.
After that I went to university and had both teachers and internet access, and programming has never been the same since...
But that's not learning programming. That's an occasional source for a neat trick, or a function I didn't know about. I probably try SO a couple of times a week, and generally it's not to learn anything so much as to save myself five minutes digging through a reference manual. For proper learning I just sit down and grind through a book while reimplementing The Secret of Monkey Island in whatever language/style I'm trying to learn.
So for at least some of us, self-learning programming before SO was pretty much the same as now.
A well structured book with bite-sized chapters should be very approachable even for today's attention deficit generations.
(Looks as though a few people have put it online: http://qzx.com/pc-gpe/)
This is more of a factor of how tech moves fast today, but still. It wasn't impossible to write programs.
SO does not teach you how to program. It gives you upvoted answers to specific questions people have.
Would you try to become a doctor by reading common questions and upvoted answers to medical issues? Of course not. Sure, after you were a doctor, such game-playing might be useful -- but only as something extra, not as the skill itself.
I was just leading a team two hours ago through some group coding, and we ran into a problem. "Let's Google it!" we all said, and sure enough, other people had the same problem.
But the top three results? They were bogus. The authors didn't understand the error, so the questions they posed were vague and out-of-context. The people answering the problem were just as bad, only some of these wrong answers to wrong questions got quite a few votes! And why not? The internet is a game you play for points.
I was fortunate that I knew the answer before we started. I was just curious to see how it played out.
It did not play out well.
You learn to program by somehow climbing inside of somebody else's head and learning to think like they do while they program There are various ways to do this: read lots of books, watch videos, spend time pairing up in a computer lab on campus. None of them involve playing hit-and-miss Q&A with the internet. Sure, it's fun, and yes, it gives you a bunch of answers to specific problems you didn't have before. But it's got jack shit to do with programming.
Remember those old haunted house games from the 90s? Where you had to thrash around until you finally came up with the magic phrase? Something like "pick up the lamp from the corner". Once you got the phrase right, you could proceed.
Lotta folks think programming is like that. It is not.
In fact, when I look at a lot of the crap that passes for programming, most of it is due to coders on a time budget thrashing around online, copying and pasting whatever they think might work. And they never come back to clean anything up.
Why refactor if your idea of programming is simply making the compiler work and something half-way acceptable appearing in the results? I'd argue that the majority, perhaps the vast majority, of people claiming to be programmers today are, in fact, people who aren't afraid of the machine and know how to Google. (And what usually happens to these folks if they are successful is that they end up in corporate jobs where they do less and less programming and become more and more afraid of breaking anything)
I'm very glad that learning programming is much easier these days (especially at my job where I can just google most issues now :)).
So then StackOverflow came around and none of us have looked back since.
I was surprised to find that someone made a web version out of it:
My first source of information were the computer provided manuals, with them I got to learn Basic and overall computer architecture.
Then back on those days there were lots of books targeted to get kids to learn programming. With them I got to improve my Basic skills, learn Z80 Assembly and enjoy typing Assembly via hexdumps.
Later I started reading the Input magazine, which had code to type for all major 8 bit platforms.
At the same time I was getting MicroHobby, MicroMania and the newspaper A Capital with its computer section on Friday's.
Then when my English skills improved, Crash and Your Sinclair became part of my magazine collection.
Later I got into the PC and Amiga worlds, then I was reading Spooler, Amiga Format, PC Techniques, Dr. Dobb's Journal, The C User's Journal which became The C/C++ User's Journal, C++ Report, Microsoft Systems Journal, Game Developers Magazine. After having devoured all the programming manuals that came with all Borland products I was using.
During my GNU/Linux FOSS zealot phase I was also a regular buyer of Linux Journal and Linux Format.
Parallel to all those magazines, regular trips to the local library, getting some books when travelling to Lisbon or Porto.
Access to BBS were out of my budget back then, so I only got to access them when I got into the university.
So I started to access BBS, shortly followed by Gopher sites and USENET, before the Web got any meaningful meaning.
Also given that the university had a huge collection of CS books and research papers, all the way back to the foundations of computer science, I also got to visit it regularly.
Other than that there were the computer clubs and demoscene meetings to get to exchange knowledge between persons that shared the same interests about programming.
There was a series of disassembled and commented ROM and OS series named "Journey to the center of the ROM" for the TRS80 family and that was very instructive for me. Sort of like "Lions Commentary on UNIX" but a decade later for Z80 rather than unix v6.
Something to realize is back in the old days even the old timers only had like two years of experience writing Z80 code. And you were limited by memory enough that scalability problems were not an issue. And people with more than 2 years of experience perhaps writing IBM360 assembler were making so much money they had little interest in these Z80 6809 6502 things.
I eventually bought it, more due to nostalgia than anything else.
Horace Goes Skiing definitely brings back memories.
I remember back in 2001 I'd been self-taught PHP for about 3 years and was able to be productive, build some stuff that I needed built and was generally comfortable with how things worked. As far as I was concerned I "knew PHP". One day I was stuck on a problem so I actually went to B&N and bought a big PHP book because it looked like it had what I needed in it.
Sat down, found that answer and noticed something else that I didn't know. Was shocked that I'd been programming so long without knowing that thing. Ended up binge reading the entire 600 page book over the course of a week and became a better programmer for it.
Ever since, I force myself to read a book on any language I plan to actually do more than tinker with because that comprehensive information is so much more valuable.
So yea...Barnes and Noble.
Are you talking about "Advanced PHP Programming?" I bought that book when I wasn't even as tall as the checkout counter at b&n. The cashier was very confused. I remember learning the fundamentals of object oriented programming from that book, sitting poolside on a Florida vacation. People must have thought I was some sort of super nerd child prodigy.
My method of learning was to save web pages to a USB flash drive on an internet-connected computer, and study them, or copy them, or modify them on my computer until I understood and was able to create my own documents. Learning PHP was a similar exercise, augmented by a downloaded copy of PHP's documentation manual.
Stackoverflow definitely made answering questions much quicker, but I also think that it made it so easy to quickly get things working that I lost the practice of having to understand and fix things through deep study.
I came to America and I was surprised by the poor computer literacy here, well, at least in my middle school. That was 2003. School were using Mac (first time, I have never seen one in HK, so I thought they were really cool looking), but the teachers would just teach us how to use the outdated Mac Word (whatever it was called back, Apple's own version). I think we did learn one or two lesson of basic HTML, but that was it. Computer class in my middle school was seen as a time break for students. Nothing exciting, teacher would just walk around and check if the student followed what she typed. I also had a single technology class in 9th grade and again teacher didn't care much and we just spent our time watching YouTube (yes, that's around 2005, 2006) or playing GTA on the computer.
I never took AP Computer Science, but I was already learning to use phpBB and started to do some light programming here and there. I don't know if I ever came across SO, but I know I used to just rely on Google search and look at either forums or blog posts. The rise of SO and convenience of Google search meant I didn't have to dig so deep on my own, but I enjoy learning the crust on my own whenever possible.
I am now 25. Although I can't do front-end development, I still believe I am a lucky person having exposed to a good CS education early on.
The abbreviated answer, for me:
A book open on the desk, another one open on my lap. I spent a lot more time reading programming books cover to cover than I do now, and I spent a lot of time in the programming bookstores that no longer exist, like SoftPro. In fact SoftPro was sort of like dessert when I went out for lunch.
At any rate, that machine also had EDLIN and BASICA, and that was the start of my programming career. I didn't have any books on BASIC, and the manual was pretty scant when it came to information about BASIC. But I did have a friend who was into BASIC, and he pointed me in the right direction a few times.
I would bring a notebook and pen so I could hand-copy passages out of O'Reilly books and Dr. Dobbs. Then I'd walk back home and try them out.
This was circa '90-'93. I was in middle school, and had no internet access.
There weren't as many technologies around, so you could really invest your time into one or two technologies that were the core of your competency. Spending a lot of time figuring out a problem was an investment in your career because you were certainly committed to using that technology.
Today, it seems like there is a new technology on every project. Frameworks last 2, maybe 3 years unless they hit it big. If you spend a lot of time investing in a technology that quickly loses favor, you've really wasted your time, so cut-and-paste from StackOverflow / Google now makes up the difference.
Things went a little slower back then. In some respects, I think that was better. You could find decent quality code in magazines and books to learn by. Books stayed up to date longer. I still have a copy of PC Intern that I used when I moved to the PC platform. It had a lot of really good information in it.
But, really, it was more about trying and failing than anything else. Sadly, I've even gotten away from this because it's too easy to reach out to another dev for help. I think this makes learning more superficial. But, then, with how fast everything moves now, you kind of have to pick what you want to learn in depth and just accept the superficial learning for everything else.
I also learned Python in ~2000 or ~2001 using their offline documentation and the occasional online session (didn't have internet at home at the time, but wasn't completely offline either).
My first real job as a developer was in C and then C++. I had good college textbooks that I reference and Stroustrap's The C++ Programming Language.
But even as early as 1992 I had access to Usenet and various comp.lang.* groups.
Today, usually I get by with PluralSight videos, MSDN articles, and Google where I put the obtuse error message in and usually Stack Overflow is the first link.
Unlike the bad old days where it use to be Expertsexchange.
this model of gluing together several large undocumented packages just wouldn't work - because you couldn't debug by just typing error messages and pathologies into google
I know, I'm dating myself here, but man was it a good time to be a kid and learn how to program.
Later: Borland Pascal came with a glorious full bookshelf of printed documention, and instant-access context sensitive help within the (console mode) IDE.
As someone else said, Google was the big game changer for learning new languages or skills.
What Stack Overflow has done has made it much easier to find answers to specific problems or questions. I don't feel like you can browse SO and come away learning Swift. But if you do run into a very specific issue you can Google it and quite probably find a solution that's on SO.
I now use use books, duck duck go, IRC, email, mailing lists, Twitter, whatsapp, slack, and stack overflow.
ISPs also used to give you free website hosting and once I'd learnt enough playing with that, I remember doing a website for a family friend's business and ordering my first ever .com domain (from Network Solutions iirc) for something silly like $70 via fax :)
It's worth noting that in the pre-web era the proliferation rate of new frameworks/languages/platforms was a lot lower, so once you had mastered a toolset you could stay relevant a lot longer than is the case today.
One thing to consider: before Stack Overflow (and the internet in general), it was harder to learn about fringe languages but it was also therefore harder for fringe languages to get the kind of business toe-hold that made learning them a financially-valuable expenditure of time.
Try to imagine Ruby on Rails getting the traction it did in the time it did in the absence of a global community that could teach itself Ruby on Rails.
So the short answer is: exactly the same way you self-learn programming now (reading good books & code, practice, and hopefully finding a good mentor or two).
We could just barely afford computers for myself so I am eternally grateful to my mom for working nights while I seemingly played around with Linux and scripting in my room.
Before the Internet took off it was a much different situation. You'd read many books of course, and to fill in the missing gaps you could read magazines or talk to other people at conferences. IT conferences in those days did make much more sense than they do now, imo.
For many Dr. Dobb's (http://www.drdobbs.com) was the only real source of programming information they had. Those with more of an academic background had access to the books by Knuth and others, but those were hard to come by in those days. Bookstores didn't carry them, libraries didn't have them, and Amazon didn't exist so you couldn't buy them special-order even if you wanted to.
I learned C from a book and open-source software I could hack away on that was also written in C. I learned C++ from the Borland manuals that came with their compiler. I learned Perl from of the first O'Reilly books ever made. Newsgroups were only so useful, you'd have trouble getting answers to basic questions in a timely manner. Most were more interested in more high-level discussions like how to evolve the language.
If you wanted mentoring you could take your chances on IRC. Most of the time you'd have to endure an unofficial hazing ritual where they'd ignore you, then ridicule you, then finally, if you hadn't run off in disgust, begrudgingly answer some of your questions. Getting a straight answer to a basic problem was pretty much a social engineering problem.
It was only in the late 1990s that programming-specific sites like Perl Monks (http://perlmonks.org) popped up and filled that niche. That was the precursor to sites like Stack Overflow. I'm extremely glad to have been a part of that community where even the dumbest question would be given a straight-forward, non-judgemental answer, in some cases by the guy who literally wrote the book on Perl.
Books were everything! Sometimes even the computer access was rare, so you better hit your books in order to get a rolling start when you get the access to one - writing code on paper!
I learned a lot of lower level Unix programming from those Sun documents.
Later (mid-teens), I taught myself C doing the same thing (on an Amiga.)
I also downloaded sample code from BBSes and the early Internet (pre-WWW.)
You tended to learn more broadly rather than zeroing in on a specific task. Now you can execute a Google search after learning to "rails new" and get the precise answer, for better or worse.
It was clumsier, but it worked.
I also believe that until sometime in the 90s most programmers genuinely were interested in computers and didn't just do it to have a good job. So you didn't have to deal with a lot of zealots or clueless people like there are around today.
it's also a sign of a thriving developer base with lots of people interested, but i still want a moment of crankyness about basic questions of "how do I _X_ in _Y_?" where Y's documentation is crap
It was slow, and like learning chess with your sibling.
You didn't know how much you didn't know.
"Before Google" is probably what you really mean.
For me: Early on (age 7-14) it was how-to/text/learn-X-Y-days books + man pages and lots of playing with Batch files, GW-BASIC, QBASIC & ASM.
Later on in highschool I was lucky my school had AP programming classes (and a small C-S dept!). So that helped me move from BASIC to VBasic/C/C++. Along the way I picked up vbscript as an sysadm intern and bash playing with early desktop Linux.
When I started college, even though stackoverflow didn't exist, you could certainly now Google things, but results were often not as good and often paywalled. During this time using the same methods above + college classes I picked up: Java/Haskell/Scheme/Prolog.
Later on now firmly in the stackoverflow era I picked up C#/Perl/Go while working, but I did this more like I always had done than the "on-line academy/tutorial" ways people seem to do it now days.
My most recent languages are Go (I have been programming fulltime professionally in it since Go 0.8) and Rust (still learning), but I still have eschewed the "on-line academy/tutorial" way of learning. I guess I don't appreciate a highly curated learning path (when I used text books I tended up use them more as references when stuck or for learning theory).
Stackoverflow is of course something has a full time programmer I might use once or twice a month... but it really only shines (IMHO) for the most superficial of issues (glitches in toolchains etc), if you are going their to learn theory your mileage may vary.. all my opinion of course.
IMO in pre-web days it was a far more tedious and frustrating experience.
The remaining results being archives of that first one.
(I continued this general strategy of doing way too much stuff and getting way too little sleep all the time until it all came crashing down on me in 2004, and my life changed drastically and permanently.)
Apple released the Mac, and I fiddled around with it. I really loved MacPaint, but there was no way I could possibly scrape together enough money for a Mac. They were twenty-five hundred dollars. It might as well have been a million. Some years my annual income didn't break $5,000.
Nevertheless, my newfound fascination with digital painting led me to start reading everything I could find about programming, mostly in books and hobbyist magazines. There was a plethora of geeky computing magazines in the middle of the 1980s.
Eventually, with my girlfriend's help, I scraped together enough money to buy a bargain-basement Commodore 128. It wasn't a Mac, but it had a BASIC interpreter built in and it could display graphics. They were 8-bit color graphics with huge, fat pixels on a 320x240 screen, but they were graphics.
I started buying COMPUTE! Magazine. Each issue shipped with a piece of software in it, in the form of a BASIC program printed in a column in the magazine. You could type it into the Commodore and presto! You had a new piece of software!
The transformative event for me was typing in an assembler written in BASIC. After that I could write programs in assembly language. I bought a big fat book that documented the Commodore memory map, listing everything in the machine's memory along with all the addresses. It listed the entry-points for all the built-in BASIC subroutines. I could write machine-language programs that used the built-in BASIC graphics routines!
I wrote a crappy little paint program that I called "ChocolatePaint". It was horrible. Trying to write MacPaint for an 8-bit 320x240 screen and a cheap joystick is a terrible idea. However, I also discovered Conway's Life and got sucked into a black hole of cellular automata.
I spent months on successive versions of a 2D cellular automata program that ran several sets of rules simultaneously on the same grid. There were N sets of rules. Each cell of the grid obeyed all N sets of rules at the same time. The color and text-character displayed at each cell depended on the ruleset that caused it to be considered alive (all dead cells were rendered as empty black squares).
I would stay up too late at night fiddling with my cellular automaton, then fall into bed thinking about ways to improve it until I fell asleep, leaving the thing running overnight. I would get up too early in the morning and rush in to see what the program had produced. Sometimes it was a black wasteland with maybe a few live cells here and there. Sometimes it was a riot of color as some ruleset had mostly taken over, occasionally providing fertile habitats for secondary rulesets to thrive in.
One day, when I was juggling work on a graduate degree in psychology, songwriting, working in a bookstore, and this cellular automata craziness, while exploiting the bookstore job to read every book and magazine title that had anything whatsoever to do with programming, I learned that my girlfriend was going to have my child. Uh-oh. Sub-$10K income looked even less attractive than before.
My mother, a member of Mensa, sent me an ad from the Mensa Bulletin asking for people to apply to Apple Computer to work as technical writers. I said to myself, "why not?" And sent in my application.
To my complete astonishment, Apple flew me out to Cupertino to interview, then made me a job offer that would multiply my income by a factor around ten, and that would represent a whole number multiple of the most money I had ever made in a year in my life. To work with and on programming systems for Apple products!
I said, "sure!"
I officially started work in Cupertino on January 1, 1988, but that was a Friday. I don't remember for sure, but I imagine I didn't really start until the following Monday.
Apple drastically accelerated my self-education in programming. It had several resources that were like heaven for me:
- the Internet
Apple had one of the earliest domain names assigned, and a great big chunk of IP addresses. It had a dialup network for employees that bridged to the Internet. It supported uucp. Woohoo! Apple had connections to everybody on the net and repositories of all the software anywhere that anybody thought was interesting. Oaklisp! Smalltalk-80! AT&T CFront! Eiffel! Icon! FigFORTH! MIT Scheme! Minix! GNU! I promptly downloaded every free compiler and interpreter and OS I could find and set about learning all I could about them.
- the technical library
Apple had a robust library of technical books for any employee to check out. In order to ensure that its library was the best it could possibly be, it had a policy that I took full advantage of: if you went looking for a book there and they didn't have it, you could file a request for them to get it. Not only would they order a copy of the title for the library, they would order an extra copy and give it to the employee who had requested it. I spent hours in there. My collection of technical books on programming and computer science ballooned in size.
- the software library
Apple had a software library with policies similar to those of the library of books, except that you couldn't go in and browse the stacks and they wouldn't give you a free copy of the software you requested (a lot of software was pretty expensive). It would, however order enough copies to ensure that you could check one out, and it would allow you to renew your checkout indefinitely. It also had archives of every piece of software that Apple had ever shipped, or that it had ever released internally. My collection of working software ballooned in size. I requested and checked out every compiler and interpreter I could find. I had old versions of Apple Smalltalk and Fabrik and everything else I could find.
- the competitive intelligence library
This was Apple's library of actual computing hardware. You couldn't check out the hardware and take it home, but you could reserve time on it. If the machine was connected to the internal network you could get an account on it. They had everything. I spent hours fooling with a Xerox Star. I learned Lisp and Emacs using a Unicos account on Apple's Cray Y-MP. Later I talked someone in ATG into letting me borrow his Symbolics machine. I rolled it into my office, where it stayed for about two years until he decided he missed it and came back and got it.
That, plus lots of conversations and cooperative projects with other programmers working at Apple, is how I did it before Stack Overflow.