What was it like to self-learn programming before Stack Overflow? (2016)

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.

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 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.

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.

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[1] 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.

[1]http://tldp.org/

(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.

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.

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.

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.

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.

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.

[UPDATE] grammar

However, one very important aspect of usenet was the curated FAQ document of the newsgroups (e.g., a FAQ for comp.lang.c [1]).

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).

[1] http://c-faq.com/

[2] 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.

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.

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.

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.

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://... https://www.google.com/url?sa=t&source=web&rct=j&url=http://...

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.

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.

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.

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.

Good times.

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.

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.

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.

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.

Also, one big reason I think PHP was my go-to was the easiness of the manual (http://php.net/function_name_here)

> 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.

A well structured book with bite-sized chapters should be very approachable even for today's attention deficit generations.

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.

This is more of a factor of how tech moves fast today, but still. It wasn't impossible to write programs.

(Looks as though a few people have put it online: http://qzx.com/pc-gpe/)

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:

http://swag.delphidabbler.com

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.

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.

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.

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.

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.

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.

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).

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.

I now use use books, duck duck go, IRC, email, mailing lists, Twitter, whatsapp, slack, and stack overflow.

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.

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 :)

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.

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.

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).

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.

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.

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.