Hacker News new | past | comments | ask | show | jobs | submit login
What was it like to self-learn programming before Stack Overflow? (2016) (quora.com)
260 points by janeboo on May 15, 2017 | hide | past | favorite | 285 comments

It's really not Stack Overflow that we should be asking about, it's Google.

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.

> Experts' Exchange, which was basically an earlier version of Stack Overflow

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.

What's your problem with the current state of SO?

It's full of people who can't be bothered to do even the most trivial investigation into their own damn bugs - the same trivial "I didn't configure it lol" and "I have no idea what I'm doing, nor interest in developing one, fix my thing for me plz" bugs that the site already has a dozen answers for. It stays that way because volunteer moderators don't want to wade through sewage all day. So it goes.

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.

There are also many questions that I asked myself or googled and that I found shot down by overzealous SO moderators before someone could bring some element of response.

"Just google it"

>First google result

Fair, but that's the point of upvoting questions, no? As someone who uses SO through google searches 95% of the time, I mostly see high quality discussions.

The best discussions are usually marked off topic or 'no good fit" or "not of use for future readers"

And that's OK because discussions tend to lean in different direction, very often, and before you know it you are talking about something completely different. If you are sticking to the topic and have something really important to add, don't worry, moderators won't get in the way.

Yea - that's my biggest beef with SO currently, what I thought OP would say when I asked him.

On SO I pride(d) myself on asking good questions. That is formulating the question clearly and precisely was itself a kind of investigation. Often, the question never go finished, because the work of writing it up caused me to solve my original problem.

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.

I feel like you should still ask the question, and then answer yourself shortly afterwards. It'll help others in similar situations, and you might just get a better answer from someone else.

Same. I think I've asked one question ever on SO, and it got no answers - fair enough; I didn't have one, either.

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.

You could do a blog of your own to capture whatever it is you found out.

One problem is that the correct answers have to change over time and SO does not account for that except by having drive-by downvotes from dweebies who have no business even answering questions.

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.

so sorry to see you go.

> Expert Sex Change

You may want to edit...

Edit: Well; that explains why the service didn't take off

And I may not. That was the constant nickname back in the day, occasioned by the fact that their original domain was "expertsexchange.com". They later moved to one with a hyphen, but by then the damage was done.

(Edit to your edit: It did take off! It was the best we had for years. That best was just very, very bad.)

Remember joking with colleagues back then about sourceexchange.com and how that sounded out loud.

penisland was another famous site from the time with this property.

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.

Did it ever actually sell pens? I always understood it to be a joke; if it's been anything else, I'd love to know more.

Snopes talks about penisland.net, which is still up now and clearly a joke - a rather disappointing effort, in fact, with a few rather broad double entendres and nothing further to offer.

I was curious about the (presumably) original .com, which is now squatted, and about which there seems no historical information easily to be found.

don't know about the website, but "Pen Island" is/was a small shop on Regents Street in London (not far from Picadilly Circus tube station) that sold high end fountain pens, mechanical pencils, etc. Don't know if it's still there, but it was list time i was in the UK (2007)

Pen island? What was it supposed to be?

A joke - a "domain hack" avant la lettre.

penis land

Here's Peter Norvig explaining this stuff: https://youtu.be/yvDCzhbjYWs?t=24m37s

true . Other such nameswere therapistfinder -> The Rapist Finder Whorepresent -> Whore Present

Not exactly. The innovation of SO was to allow folks to upvote the best answers to bring them to the top, saving a lot of time.

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

They are right - SO is a better version, but the majority of impact came from having the information globally searchable at all. Heck, even searchable USENET indices had a huge impact, pre Web.

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.

There were programmer sites/mailing lists before that where knowledgeable people gathered, and today you can search directly on SO, or use DDG as I do. Also, I used AltaVista before google, and often got answers there, though success was less frequent.

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 hate to think what it would mean to be dependent on SO.

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.

Yes, though the "cat is out of the bag" now with SO, so it could be replaced if/when it falters.

The next version might implement a versioning strategy, say questions/answers get archived every five years or so.

The nice thing about Usenet is that you had access to real experts. If your question was good enough, you could get an answer from someone that wrote the drivers for the OS you were struggling with or whatever.

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.

Yes. There is a lot more information out there now, but the average quality is a lot lower. This isn't unreasonable given the growth of the industry, and the number of people who do at least some programming as part of their job but are mostly doing glue programming. These days that's the majority of a much larger group, thought it used to be much smaller.

> There were programmer sites/mailing lists before that where knowledgeable people gathered

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.

The total number of posts used to be so low, the "social" aspects wouldn't have mattered much. Not everyone used to use the internet for that sort of thing (manuals and books), and there are far more people writing software now.

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

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.

It's like when they say "X dev's are too lazy a new language". More likely, your documentation is garbage.

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

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.

> Google dumbed this down and to this day is very difficult to accurately and precisely use.

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

Of course google is trying to help ordinary perple - the sort who type a few words into the search box, get zero results, then add some more search terms assuming that being more specific will help the search engine find what they are looking for. So, default AND becomes default OR along with other 'improvements' but to the detriment of self-declared power users...

yep, google had a better indexing of the net and also had exact string search. Altavista only had exact string search (which was better than yahoo). Since then, google no longer reliably gives you exact string searches.

I've noticed Google is pretty good about finding exact matches when you put the search terms in quotes.

Used to be better.

Pretty much this, before stack overflow forums were very popular for asking questions, so you would traverse forums finding someone who's asked the same question as you. Although half the time their question wouldn't be answered.

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)

The real difference: When you found a crappy workaround, you learned. You were frustrated, felt stupid but you learned. You made the same experience every child has to make once: Dont', just fscking don't, touch the hot plate.

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.

> The real difference: When you found a crappy workaround, you learned. You were frustrated, felt stupid but you learned. You made the same experience every child has to make once: Dont', just fscking don't, touch the hot plate.

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.

Uhm. No. I am not lamenting an "educational innovation", I am saying that being presented a solution is not education at all. Education for me means understanding, understanding requires thinking, thinking requires time and taking wrong turns (because we only understand that the turn was wrong after exploring it).

> I am not lamenting an "educational innovation", I am saying that being presented a solution is not education at all.

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.

Reference books, MSDN CD's, newsgroups, etc. That's what was really alluring about Amazon in the early days: they had the latest computer books. I have a bookshelf that's over 6' high full of old computer books. Probably $5K easy.

I remember downloading open source projects that I found online and combing through their source code to find out how they did something. Back in the mid 2000's I was working on a video game and I would spend hours looking through the games on pygame.org for examples. Painful process.

I miss those simple naive days of the unhyphenated internet, when you could find the answers to difficult questions on ExpertsExchange.com, and order tools that were mightier than the sword from small bodies of land surrounded by water on PenIsland.com.

I'm self-taught, and now in my 50s.

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 loved Dr. Dobb's Journal too, and I also really looked forward to each delicious issue of Creative Computing as a kid! Like so many others, I read the Adventure source code and typed in the Star Trek source code.

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




Dear Lazyweb, if someone comes across the "Dr. Dobb's Developer Library DVD" please donate a copy to the Internet Archive. I contacted the new owners of Dr. Dobbs (UBM) and they actually sold the last version they had. No backup. Weren't interested in selling any more copies.


+1 Creative Computing

+1 for typing in the Star Trek. Typing in source code is slower than downloading some PyPi thing but it lets you learn faster. At least at first.

Also of similar vintage. True story about learning C on an Atari ST:

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.

I think they key is your dad being a programmer.

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

If I had been dumped in front of a C compiler, I wouldn't have made it anywhere either...

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 think they key is your dad being a programmer.

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

But somehow someone must have pointed you in the direction of these books and magazines. I wasn't even aware there were programming magazines then.

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.

Yeah, it was me who pointed me in the direction of those books and magazines. You would probably not believe the number of computer related magazines in the 80s. Even my computer (the not-too-popular TRS-80 Color Computer) had like four magazines devoted to it.

I was born in 71 and my dad got us an Apple II in 1980. He wasn't a programmer, but the Apple II came with a full set of hardware and software manuals. We also had a Byte subscription. I taught myself Applesoft Basic, then 6502 assembly. I distinctly remember having printouts of assembly listings spanning dozens of pages spread across the floor which I annotated.

I'm of similar vintage, although my father was a mainframe technician, so I had some significant on-site expertise to draw on, even over the 6502 and Z-80 boards in our basement. One thing I've noted, now that I teach programming to the Stack Overflow generation is that we had to be much, much better at troubleshooting. Now, we had the advantage of dealing with pretty primitive systems -- 'troubleshooting' often involved an oscilloscope (or the poor kids version: a latch accessorized with an LED and resistor) and an 'upgrade' like as not would involve a soldering iron---but my systems were simple enough that I had a pretty accurate mental model of how the whole system worked, and the number of subsystems that could interact to produce an effect was very limited. On modern systems with complex multiprocessing, multithreading, dozens of peripherals, operating systems providing shared services to hundreds of process and every program connected to a fault-tolerant network stack to effectively imfinite other computers that may or may not be standards compliant or even malicious. My childhood mental model of "well this address line should be going high if the data is being sent to ..." is almost quaint in the face of that.

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.

i'm firmly in the SO generation. self/on-the-job -taught. web dev. i enjoy and take the journey of grokking problems, but many of my peers don't. slows me down a bit at first, but then i'm a local expert. feels like these people weren't taught how to think critically, or weren't able to apply that skill to code.

> [...] my systems were simple enough that I had a pretty accurate mental model of how the whole system worked [...]

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 can echo most of that as well (also almost 50). Books, magazines, and good old trial-n-error methods.

Personally, I don't find learning to program new things as much fun as I did when I was 13-20. I would learn assembly, c++, basic, etc, all from books I got from Hastings or the local computer store.

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 think it's 3rd party libraries/tools/SaaS, all sitting on top of a much more complicated stack, causing most of the problems. They provided enough of a boost to productivity that you can't justify avoiding them, but mean you swap thinking about and fixing real problems for googling obscure broken shit in these almost-always-terrible libraries et c.

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

This has been exactly my experience. The only difference is I got books from the local library. I have the same nostalgia for working through Pascal and assembly language books while hunched over an old 386 as a teen. Now, it's much more about how fast I can generate value. Probably speaks equally well to the process of growing up as it does to how learning programming has changed.

I find looking up Java or similar answers to be almost universally unsatisfying, usually its just "use this library in this way and don't worry about behind the scenes", but then looking up answers to C questions I have to understand the logic of the solution so its much more worthwhile.

Who or what is Hastings?

A (defunct) U.S. book, movie, music, and game retailer, as well as video rental store.

I started in the late 80s. Around the final wave of the "every child must be taught BASIC and programming so they don't get left behind" movement. Sound familiar?

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'm probably around the same age, and was learning c++ in the early 90s.

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.

I'm not sure why this is even a question, nobody can learn a subject only from a Q&A tool. You learn programming by reading a comprehensive tutorial(s) or book(s) for the foundations. Then you practice on real problems and research the advanced tools and APIs as needed. If you've got more experienced human mentors you go to them for help. You follow blogs / news articles and watch tech conferences. You get enough experience and solve enough hard problems until you know your tools and how to use them effectively.

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.

Books. Lots and lots of books. And computer shows where you could pick up boxed software (OS, compilers, etc.) for anywhere from 50 - 90% off.

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.


> And computer shows...

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

Yeah, I guess I should have stated that my experience was in the US. And I grew up in a large city as well so I can imagine the experience for someone living in a rural part of the US was more like yours than mine.

There were a few regular computer fairs in Sydney in the mid 90s but anywhere outside of the main cities...

Or prior to then - or at least I'd imagine the further you go back from then the fewer of them there were.

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

In the early 1980s I was a starving artist in Denver, Colorado. I was trying to simultaneously finish a physics degree, work a full-time job, learn martial arts, write and perform avant-garde electronic pop music, and help my girlfriend raise a small child.

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

I learnt back in the BBC Micro era, when I could get books out of the local library. What I didn't have at that time was a computer - my very first programming had to be done on paper until I could get time on the computers at school.

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.

Similar story here. Although the only way I could get my hands on the school computers was intentionally swearing at the dinner ladies and being sent inside to sit in "the boring computer room" because the school had a strict policy of anti-technology in all subjects. They never worked my tactic out and thought I was just disruptive.

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.

Borland Turbo C - how I loved that program!

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.

Similar story with an additional twist. In mid 80's, I was 12 years old. At that age the problem was to realize that documentation existed. I had only access to libraries and a few bookshop. There were very few magazines etc. But to have the real knowledge, I had to understand that my books had to be in english, coming from other countries. At my age, that was somehow hard to realize. Knowledge was there but not easily reachable and, in any case, very expensive. My dad helped me a bit but even at 12 y.o. I was further than him so he couldn't help me efficiently (and well, at that time, 12 year old asking to code in assembly language was, well, so unexpected that he may not have known how to help :-))

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

Manuals. Compilers came with comprehensive manuals. When you paid for things like Turbo C++ or Paradox or MS Cobol you got a well edited, indexed and quality printed book that covered the entire language and tools comprehensively. From there you wade into existing code bases, learn by maintaining the work of others, and eventually you originate new work. Along the way you dog-eared the manuals.

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.

> Compilers came with comprehensive manuals. When you paid for things like Turbo C++ or Paradox or MS Cobol you got a well edited, indexed and quality printed book that covered the entire language and tools comprehensively.

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.

Note that, FWIW, Free Pascal today comes with the same manuals - a user's guide (telling you how to install and use the compiler, the IDE and the various tools), a programmer's guide (telling you implementation details for the language), a language reference (explaining the language itself, in theory you can make your own compiler from that), a runtime library reference (what the name implies) and a framework reference (reference for the extra libraries that usually come with FPC). Also there is a reference for the documentation generator in case you need to write docs yourself.


I started with PHP3, and spend so much time ready the manual. It was/is pretty good, well written and the comments can be pretty helpful.

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.

I still have my Turbo C++ 3.1 books. Oh the memories! I Ki of miss the visual style of that RAD GUI prototyper they had.

The first six months or so that I used Linux (1998), I only had a winmodem for my parent's cheap tower (333Mhz Celeron I think; the kind you got for free if you signed a 3 year dialup contract). I taught myself to program based on examples from a book and documentation that was included with man pages, program source code, and long-form documentation (often found in -doc packages). The book was good for basic syntax and a couple working examples. Source rpms (my first system was Caldera OpenLinux) provided working example code. The doc packages (and sometimes man pages) had more detailed manuals. I spent a decent amount of time downloading early TLDP (I think LDP at the time) manuals and various zine issues onto floppies at my school. I wrote a ton of really bad code. My local libraries didn't really help much as they mostly contained documentation on Windows/Office/DOS and languages that assumed those (being in middle school, I didn't know anyone at a college/university).

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.

I may be mixing up the years but in '98 I think a 333Mhz Celeron wasn't necessarily cheap. Not top of the line for sure, but also not your average dumpster find.

I remember the CPU itself was like $35 USD and could easily overclock to 415MHz. It and the Celeron 300a were some of the best bargains ever in computing due to a binning oddity on Intel's part.

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.

Yes, it was an eMachines. I think the promo we were on was for Prodigy dialup and was like $29.99/month for 3 years. If you agreed to that, you could get a $400? instant rebate at Best Buy/Circuit City/etc on any random PC. The base model eMachines were conveniently priced exactly the same as the rebate.

Before StackOverflow? Not too bad. Without internet access, though? Much, much harder, or rather, slower - a similar level of information could be obtained but it took phone calls, bus trips to a reference library, etc. Other than that, you just had to figure everything out yourself from the user manuals and experimentation.

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.

What we did here in Poland (Internet became available to the public in 1996 and then expensive) was to check the library and book shops then buy the worthwhile books. And as usual, run through all examples and then modify and extend them for fun and experiment.

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.

I disagree computers were much simpler. If you wanted to play games, you had to struggle with IRQ, DMA, extended memory mode, smartdrive, config.sys, autoexec.bat, commandline ARJ, zip, rar, floppies or tapes, and so on. If you had Linux, you also had to regularly recompile kernel to make something work (for example a device driver).

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.

Computer interfaces were lower level, and less friendly. Computers themselves are now mindbogglingly more complex than they were back then (and a good deal of that complexity goes towards making them easier to build and use!)

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

+1 for the magazine mention. A lot of what I learned from tinkering with computers back then came from magazine and the floppies (and later CDs) of shareware they tended to include.

oh yeah, who remembers installing slackware from 14 floppies & praying no kernel panic after recompile. oh and neverending rootshell exploits.

Google was a major step up, even when it had less than a billion pages indexed. I remember trying to find programming information on Alta Vista. It was possible but there was a lot of clicking "next page".

The QBASIC help "file" was really good for its time. That's basically how I learned. That plus a collection of QBASIC programs the nerds at my school passed around and would occasionally add to. Basically, I would open one of those programs up, run it in QBASIC, and if it is awesome, I would try to figure out how it worked. If I came across something I didn't understand, I would pull up the help from QBASIC.

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.

Oh, man. QBASIC's manuals were fantastic and they set an expectation for documentation when I was, like, 7 that would rapidly be disappointed by basically everything that I touched for years afterwards.

If I'm remembering correctly, QB 1.1's manual was good, and QB 4.5's was amazing, with deeper explanations, example code, and such.

I was lucky. Our high school system shared a DEC PDP-8. This was in 1974. Each year, Digital equipment would publish a manual. Some years were better than others. Somewhat like a vintage wine. The choice of languages for the PDP-8 were Basic, Fortran, and Focal. It also had a user group called Decus, which shared code - somewhat akin to GitHub. But, I didn't use much of that code, as it usually meant hand entering the source into a teletype. The storage medium was paper tape.

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

> I was lucky. Our high school system shared a DEC PDP-8. This was in 1974.

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!"

And yet here we are. It appears that all roads lead to hacker news.

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

> This is a later version of our computer...

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

All these stories are reminding me of m first encounter with programming. My Grandpa gave me his $600 Visual Basic (5?) book + software when I was 13 (~15 years ago). He didn't have the registration key, but I naively thought I could get lucky with a 16+ digit code. The first code I tried failed, but I tried changing the last digit and after a couple of tries got it. I didn't know what it was called at the time, but I instinctively guessed it could be a checksum, and somehow, that's how Microsoft protected their $600 product in 2002. Anyway, my Grandpa passed before I went to college but I think we would have had a lot of fun talking programming, because I was much more interested in pure math in HS when he died. That first programming book was definitely what got me interested though.

I seem to remember the code just needed to be divisible by seven.

you managed to find a collision?

Probably the codes were simple check-digit systems. Sometimes all zeroes or all ones works: http://opensourcerules.info/oem_key.html

For a while I had a Win95 product key memorised, for the frequent reinstalls that were a feature of pre-7 Windows.

Do people really learn _only_ from SO? I mean sure, it can solve problem at hand but learning a new language or technology? I don't see how it could compete with books in any way

I don't think people learn, but get answers to specific problems. However, I'd say the bulk of your learning throughout your career comes after you "learn" a language.

Actually, I've been recently diving into some frameworks that I've never used before, and some knowledge domains I have no experience with, and I can say that I've definitely used Stack Overflow to "learn". Not in the traditional sense, but almost more like an index.

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)

I think what makes SO more appealing than books to many is that SO questions are usually micro-focused on very specific tasks, and are often asked from an end-goal standpoint rather than a mechanical one. Where traditional reference has a prerequisite of a certain level of knowledge to utilize (mostly the capability to break down problems and know where those lines lay), SO users can simply ask how to accomplish their overarching goal and someone more knowledgeable can supply an answer detailing what the poster actually wants to do, with all the substeps laid out.

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.

Programming language books are and were often very bad. There was a huge industry in giving very detailed step-by-step guides that didn't help the reader to think and had very low information density.

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.

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

> Programming language books are and were often very bad.

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!

A lot of responses have mentioned usenet so I won't repeat.

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.

Borland C++ came with 5 thick books as a reference. It was great. Powerbasic came with a big book, part tutorial, part reference. Schneider CPC had a big programming book with it. So it wasn't bad at all! When you extended your programs with stuff like mouse-support advanced graphics, you read through the readme.txt that was delivered with the library (the libraries could be bought, were freeware, came from your friend or were delivered on magazine-disktettes). Of course, getting help when unexpected problems popped up, was much more difficult without the internet. But then again, you were usually not mangling with a bunch of languages like (HTML5, JavaScript, CSS, Typescript, Angular, React......) but were rather stuck with one programming language that you used for everything. Basic, Turbo Pascal, C, C++... you used one of them for many years as the average guy. So after some time, you got a feeling for it and could work around problems.

Before SO, you had to visit blogs, forums and "programming resources" websites of vastly varying quality. Most of the examples were poorly formatted and not very elaborately explained. Most forums were run by well-knit communities and had a somewhat hostile attitude to newcomers asking a single question.

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.

O'Reilly, did a good line of 'Cookbooks', I think these were a result of many forum questions and answers (most likely iteratively refined) compiled into simple 'recipes'.

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.

For me, shit. I was in rural Australia. What I had to do was pour over the documentation and experiment a lot.

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.

In ~1995 I cut enough grass to buy Visual Basic 4. The manual was pretty thick and, it was hard but, I taught myself to program using it. I bought it from a computer store that didn't sell programming books.

Imagine my surprise the first time I walked into a Barnes & Noble.

You would visit the relevant bullet board, then post a question and get a response like RTFM. Then spend the afternoon staring into space

RTFM is why we have stackoverflow's people who answer. BUM!

Oh never mind, I solved it, thanks! <end of thread>

and of course that was the only hit on Google for your error message.

Google? No such thing. AltaVista maybe.

That reminds me of that one XKCD strip.

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.

I was like 6 or 7 and we had this old Ohio Scientific. I think I was failing to get some really simple BASIC program to run and then started crying and my mom had me call my dad at work.

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 technically started with access to a TRS-80 Level I, but it was the Color Computer that really started me down the path I'm currently on. It helped that it booted into a BASIC interpreter. I eventually got an assembler cartridge for it, and used it mainly to learn 6809 assembly language after quite a few BASIC programs. Somewhere I found a memory map for the machine, and I was off trying to recreate my favorite games. I think I still have the 6809 book I bought back in the day. I remember a lot of trial and error, and a lot of time spent fiddling with the cassette player to load and save programs.

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

One of my high school math teachers decided to offer a course in BASIC programming, I took it, and was hooked for life. It was in the early 80s, and I was also interested in electronics, so I devoured Byte Magazine every month -- especially Ciarcia's Circuit Cellar. My dad read an article in the Wall Street Journal, about this guy who had the audacity to sell a software app for 39 bucks, and got it for my birthday: Turbo Pascal. One of the great things about TP was the manuals, which were comprehensive yet readable. There were corresponding manuals for electronics, such as The Art of Electronics and the IC databooks.

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.

The old software system was mathematics; you could be absolutely certain that the code was correct, in a way mathematics is correct. The new software system is like biology; you have to perform experiments to see what the truth is; reason fails.

I think that's romanticising the old ways far too much. The famous RISKS DIGEST is over 30 years old.

RISKS was entertaining because the mistakes seemed so obvious.

Programming is now integration of large volumes of mediocre code written by others. This is only possible because we can find the problems of that code discussed online. Before that capability, there was more reluctance to reuse existing weakly supported code.

I'm way younger than you and I've felt this way for a long time. The alternatives are to either vet code quality yourself (hard if no good options actually exist) or to implement the functionality yourself (which comes with additional headaches and usually isn't even feasible). I employ a healthy mix of both, but overall I hate dependencies with a passion (cough cough left-pad).

I think the biggest change for me isn't the availability of information on the internet but the decrease in cost. Pretty much any language is available for free now, when I started the only thing you got for free was a BASIC interpreter in the system ROM.

Books, online tutorials, finding solutions to some obscure problems ("connecting to SQL from Borland C++" etc) was a nightmare. For short period just before Stack Overflow, Experts Exchange and W3Schools had dominated Google results related to programming problems. Personally, I think that one of the motivations why SO was created were the shady practices of EE (how they were trying to trick visitors into paid subscription).

Wow, that was a blast of nostalgia! I remember how much I was getting sent to ExpertsExchange from my googling as an intern in an IT department when I was a mid-teen. Luckily, SO had gotten off the ground when my real thirst for programming started.

Unfortunately, I don't have many good EE anecdotes to share[0]... But I'm gonna try to dig my account up to have a good ol' chuckle at my younger, clueless self.

[0] — 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 loved EE's trick of covering content with an easily-removable div.

I would make a joke about how everybody used to read books, but before SO there were forums and before forums there were mailing lists and newsgroups.

plus Perl was king so there weren't any right answers, or an infinite number of right answers I should say.

Learning to code was mostly done by people who naturally gravitated to logic and computers and could solve problems on their own or with the help of a mentor.

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.

it SUCKED. You really had to rtfm (and hope that the fm was good) or depend on google to find the right topic on a given forum (dreamincode, for ex) and hope that that topic didn't devolve into a shouting match over something that had NOTHING to do with your search query. it took much longer to get anything done.

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.

I disagree. As a software person, I'm constantly dismayed by the quality of information in the surface web. Some days it feels like all but the most esoteric search terms yield so much lowest-common-denominator information useful only to the rank beginner.

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 agree with your disagreement.

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.

and half of he time the information you get from StackOverflow (judging by the comments against them) is abstract because it's written by someone who understands what's going on and is being implemented by someone who doesn't. Cut and paste doesn't work when you're trying to take a conceptual piece of code and use it for an actual implementation. You've actually gotta take a minute to understand what it's doing and apply it in real terms.

thats why i always go for the second answer, not the first

no idea why that works, but it usually does

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

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

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

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.

yeah, i could imagine that there is less "SO software dev" amongst C++ developers than Rails or JS developers that practically live on the web. I haven't done C++ dev in a while, but when I did, the libraries were really well documented. whenever i had an issue with win32 dev, i would usually get referred to msdn instead of SO or cplusplus.net for example

(Not sure if being sarcastic...)

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.

i agree that there are n frameworks coming out every day, but the point I was trying to make was that if you run into an error or even a warning that you don't understand, you can now usually find what you're after on SO or even Github Issues given that enough people have used the product unlike the past where you had to do more of your own digging to troubleshoot issues. so even though the volume of new things is bigger, access to info about those things is significantly bigger too, so it kind of evens itself out

I was extremely lucky and stumbled across a particular IRC channel where some kind souls took pity on me and patiently answered my questions and gave me advice. I think it's fairly likely I wouldn't be a professional programmer today if I hadn't found that channel / those people.

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.

This really brings back memories. During my first year of programming there were occasions when I was absolutely desperate for help. A friend introduced me to some programming channels on IRC, and I was amazed at how knowledgeable and helpful those guys were.

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.

Similar for me. When I had near zero programming experience I picked out a boutique PHP CMS to build a relatively fancy blog. The CMS author was up on IRC for hours helping me shoehorn my rediculous project into his CMS and patiently explaining some very basic programming concepts to me.

Alex Suraci If you're reading this, thank you.

Newsgroups and mailing lists were the thing. To me as a kid, the space felt much cozier and more intimidating.

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.

I grew up in the mountains of Southern California. No mentors, nothing other than an 80386 running DOS 5.0 and QBASIC. There was a book on BASIC at the local library which became a staple of my programming education.

I strongly regret that this post most likely won't get enough votes to trigger n-gate.com to generate a summary.

I learned programming by books and the PHP .chm offline manual mostly (and trial-and error with VB6/VBA). The difficulty was and is that a book is likely to be outdated even before the printing plates are engraved.

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.

I started with Hypercard and followed up with Borland C++ Builder. In both cases, there was a reference manual and many examples. SDKs (such as the DirectX one) also came with tutorials and sample code. I also bought a book about C++, but it was a very bad one in retrospect, as well as the OpenGL red book.

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.

Well, we didn't waste as much time arguing about whether or not a question was on-topic or a duplicate of another, so we had a lot more time to just write code and practice.

Also we didn't spend time competing for fake internet points.

i'm 46 and i began programming when i was 11. Obviously no Google or SO. There were some excellent resources even at that time, but i don't recall having legal access to the internet until i was in university (from eastern europe).

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.

I learned to program on an Atari 130XE, which came with a manual that covered basic operation and a full ATARI BASIC reference.

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

Books, and subscriptions to things like the ACM (for papers to read). Before the internet I'd go to the corporate library (at Apple) and photocopy a few dozen papers to read every month. In my office I had a couple large bookcases with a few hundred textbooks. Read manuals from various manufacturers (e.g., processor references, chip docs).

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

Nobody has mentioned Computer Literacy! It even has a wikipedia page.

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.

For me, which was just before stack overflow, it was dodging and weaving through forums and getting grilled on rather it was a homework question or someone copy and pasting the forum FAQ about searching the forum, etc, before posting.

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

From the article:

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

There was this horrible site called experts-exchange.com (note the hyphen) that dominated search results, but IIRC they made you pay to see the answers.

Also from the same era was implausibly popular 'dynamic HTML' site Dynamic Drive, where users could copypaste semi-curated JS, which was responsible for some of the worst code ever to be deployed on the internet.

I honestly don't know if it helped move web development forwards or held it back!

I once argued that the best thing that ever happened to web-development in terms of adoption was "view source" and how easily accessible it was.

Absolutely! That and being able to run code directly in the context of the page through the dev tools console.

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.

You could always scroll down to the bottom of the page where they were uncensored.

IIRC: _can_, not _could_. They only started doing that when Google started punishing them in their search results for not showing others what they showed Google's robots.

Good books were /great/. Local library had some books on Basic, VB (with a Visual Basic 5 CCE), C++ and whatnot. They may not contain the most recent 'best practices' or may even teach some antipatterns, but they get the ol' noggin' rolling and tuned for coding.

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

My father bought us a TI-99/4A in 1981. The manual was quite good, and was essentially a tutorial for BASIC programming since BASIC was the OS. I got through that quickly and then just started trying stuff on my own, more and more complex.

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

I'm still learning how to programme (getting better every year); Stack Overflow is good for quickly discovering class functions I didn't know about (but would have found by drawing my finger down the class reference if I'd gone that way), and suggestions for dealing with annoying bugs or compilation failures. It all has to be carefully filtered, though; I know I really should double-check everything I read there against a more authoritative source, and examine any algorithms etc for applicability.

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.

Sure, there was no SO/Google, and you had to rely on manuals and books. But the signal-to-noise was much lower. If you found a solution to a problem, it was nearly always The Right Solution. Today you look for something and you find 10 solutions, of which 9 are complete shit.

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

Mailing lists an newsgroups were the help centers of the day. Particularly newsgroups and services like DejaNews that let you search them.

Enormously frustrating, if you couldn't afford books. Once I got a modem, I made several breakthroughs thanks to collections of text files, the greatest of which was PCGPE, the PC Games Programmers' Encyclopedia.

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

I hate quibbling with a question's premise, but dang, this one is whack.

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)

Mostly books from the library (or buying them, but that was fairly rare when a teen + broke), experimenting yourself and also being very fortunate to befriend some established programmers who were willing to take me under their wing.

I'm very glad that learning programming is much easier these days (especially at my job where I can just google most issues now :)).

Back in the day, we self-learned programming by buying a box of blank punch cards at the campus bookstore, waiting in line to use the keypunch machine, and then waiting in front of the printer bins for the line printer guy to roll up your output like a newspaper and deliver it. There was lots of down time for reading the manuals very carefully.

Stack Overflow wasn't around for sooo long. I remember after it first came about and everyone jumped onboard and it's hard to remember how we lived without it, but before then we had Expertsexchange and blogs from various evangelists from companies and we also had this acronym to live by RTFM... which we did, rigorously. When we didn't understand something, we pestered our professors, consulted other books, Google'd for it or jumped on IRC and asked other programmers who would always be quick to reply RTFM... until you'd been around long enough to proven yourself not to ask questions that could've easily been answered with some rudimentary reading. Before the internet though, it was all books and hacking to see what you could figure out on your own... and if you couldn't figure it out on your own, you were pretty much done.

So then StackOverflow came around and none of us have looked back since.

There was also a work-alike to StackOverflow in my pre-internet days for Turbo Pascal called 'SWAG'. It had example code snippets for all kinds of questions/problems, sorted by category.

I was surprised to find that someone made a web version out of it:


Does anyone else find quora to be a "fluff" Q&A site? I so much prefer the stackoverflow and friends approach.

I think that is what it is meant to be. Mostly an exchange of opinions and discussions. Stackoverflow happens to be much more formal and precise. So, while a question like "How do I use RxJava primitives with Spring MVC" is better suited for StackOverflow, a question like "Do you believe reactive programming is highly misplaced in most situations" is more quora-ish... or at least that's the way I think of them.

Everytime someone asks what you'd think would be a simple yes or no question, the top answer is a 600-word story about something their mother did on a hippie commune in the 80's, or something. It's bloody irritating, yet I keep on reading. What can I say, it's something to read when you're in a waiting room.

I started coding at the age of 10 in the early 80's, using a Timex 2068.

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.

"learn Z80 Assembly"

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.

There was a ROM disassembly for the 48K Spectrum as well, but as things were on those days, I only got my hands on the book when I was already using a 80386 SX PC and it happened to land on the local library.

I eventually bought it, more due to nostalgia than anything else.

Since you mention "Your Sinclair" you might enjoy this link I posted back a few weeks:


Thanks, it is interesting.

Horace Goes Skiing definitely brings back memories.

Barnes & Noble. That was the go to resource for programming books.

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.

I also read a lot of books from Barnes and Noble. I've still got the bookshelf... some pretty hilarious titles on there. Macromedia Flash 2004 for Dummies, C++ in 30 Days (complete with a Borland compiler install CD)... great memories.

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.

I don't actually have the book anymore but that might be it. It was a big, red Wrox book.

Pretty good post.

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.

I started teaching myself HTML and CSS (and shortly after PHP) in high school, maybe around 2003 or so. At the time I had a computer in my room, but was not allowed to have internet access on it (a wise decision by my parents that I want to implement for my own children to the extent possible these days).

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 was born in Hong Kong and I lived there until I was 12 years old. Around age of 8, 9, when I was in my 3rd, 4th grade, the school installed a computer lab and we had to take compute class every year. This was around 1999, early 2000. We learned the basics of Words (we loved playing with art work) and we also played with HTML using Dreamweaver. There was no SO and Yahoo was our primary search engine at the time, but we as kids didn't know anything about search engine. So the only way we learned was sitting in class mess around, and then go home and mess around more after downloading the free trials. Later I joined the school's newspaper club (I was the founding member) and we used Dreamweaver and Words to create newsletter. I enjoyed it.

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.

My parents' 80286 IBM PS/2 came with MS DOS 4.0 and a manual. I worked my way through the manual, trying every command. One day I tried RESTORE. This ended poorly, since it overwrote the entire contents of the 20MB hard drive. But on the plus side, I learned how to install an operating system that day, as I installed DOS again from the floppies. Fortunately, we still kept all of our files on floppies at the time, so nothing important was lost.

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 haven't used SO that much, so it didn't change much for me. I started in 1990. Best resource was the library. University libraries were best. I learned a ton from typing in those BASIC listings in magazines. When I got a modem, I could find some harder to find info on BBSs, Prodigy, or Compuserve. That was like trying to find a needle in a haystack, though. It took like a year or two for me to find a good reference manual on VGA adapters, for example. Finding a txt file like that was like finding treasure. Now I don't have one main resource. Just Google. The main value I get from SO is debates about best practices on specific topics, e.g. stuff like "fastest way to rip a file into an array of structs in .NET".

Things got faster once a Barnes & Noble opened up in my hometown.

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.

You had to figure things out by yourself. It was tiresome, frustrating, but you really understood what you were doing.

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.

Usenet and Listservs served similar purposes. They just weren't as easy to search or as prolific. I remember spending more time posting posting questions and waiting for replies compared to now where I almost never post something new to Stack Overflow.

Learned on a C=64.

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 career began here in the mid 80s: http://i.ebayimg.com/images/g/iGgAAOSwnHZYmiO0/s-l1600.jpg

My first two programming languages were AppleSoft Basic and 65C02 assembly language. Like the Quora answer, I learned from books. My first was the official AppleSoft Basic programming language book from Apple, then InCider, the library, Beagle Bros books, etc.

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.

Easy. DejaNews was way better than Stack Overflow.

As verbose and annoying to read MSDN and Microsoft documentation in general can be, I learned a lot of visual basic and the win32 API as a kid by reading the offline documentation. If it hadn't been so verbose and annoying, I don't think I would have been able to, as once I got accustomed to it, it provided great detail -- enough that beginner-me could piece everything together and write simple games using GDI and other win32 API stuff.

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

Systems were designed better and documented better back then, and changed less frequently. They had to be, because Stack Overflow didn't exist to make up for language/compiler/runtime developer shortcomings.

also, to a much larger degree than today you could do your job with K&R (or the equivalent for one of the other 3 environments you might use) and man pages. by spending (wasting) a lot of time you eventually figured out the nuances of the systems you were using and that was it.

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 just worked through books (you know the ones with animals on them) and online courses like in school. i don't think stackoverflow is a great place to learn programming, it's only good for looking up specifics.

Back in the day we had books and magazines. Computers used to come with books explaining how they worked and how to use the BASIC that came with them; there were programming books available for sale for skill levels from beginner to professional. Magazines often had program listings printed right in them; you could type them in or send away for a cassette or disk with the programs from that issue on it. There were magazines available for each specific computer type (Apple, Commodore, Tandy, etc.).

I know, I'm dating myself here, but man was it a good time to be a kid and learn how to program.

I literally wrote hand-written letters to IBM asking questions about BASIC.

Later: Borland Pascal came with a glorious full bookshelf of printed documention, and instant-access context sensitive help within the (console mode) IDE.

I used books. Then when I had web access, I used yahoo search and altavista. Then IRC, email, mailing lists, and ICQ.

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

Before SO we had usenet groups, and later forums, so you'd ask those same questions and someone would help, pretty much like SO just on a smaller scale. Also back then we actually RTFM, and manuals usually included source examples so you'd figure out from it how to do the basic stuff and then worked your way from there by trial & error. Borland's Delphi had one of the best manuals I've ever used, to the day. And it was much slower and harder to learn it (but also you'd get broader knowledge than today).

Started my programming in 1975 on a pdp using fortran 4 - used punched cards for storing and running significant programs. Used something called I* to edit binary files. A fluorescent light with "crash" in big letters on it came on from time to time. Could play a few games including moon lander and some star trek game. Then it was RTFM and only a few people were knowledgeable and the run debug cycle was slow - 1 day per iteration - errors printed out on big sheets of paper. Everything seems pretty easy after that...

When I transitioned back into programming from the arts, back in the very early 1990s, it was RTFM, Dr. Dobbs Journal, IRC, and picking the brain of every geek and "Computer Guy" that I met ('cept most of those Netware Certified guys, as that generally ended up in a disappointing exchange between a geek and a guy who got paid to maintain a proprietary network using a cookbook, who usually didn't grok much else, and, if they'd heard of linux, they pronounced it (wrongly) as "Lie-nucks".)

Books, and using your brain. I still hardly ever use Stack Overflow (never asked a question, might check out the answer if it comes up in Google results, but usually it's not very useful).

For a while I had a paid subscription to CIX (https://en.m.wikipedia.org/wiki/CIX), which was pretty handy at times.

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.

IRC, usenet, "view source", local DIY computer fairs (which were quite a big scene in the UK in the middle nineties) and Microsoft developer books were my route in.

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

I read the source code of web pages to learn how to do HTML, then did the same with Javascript. At the time I was learning plenty of people were blogging about how to do things with computers and I couldn't afford any books so I did it all through blogs and web sites. I remember JScript help manual and Netscape documentation showing me how to do OOP with JS back in the day and that really opened the doors up for me.

Books worked great.

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.

I taught myself to program in Atari Basic on an Atari 800 in 1981. I still remember the book and the way it described a for loop as an Oreo cookie. I remember subscribing to Byte magazine and typing in code snippets. Later had a 1050 disk driver, Gemini 10x printer with the Ape Face interface, and a Mips 300 baud modem. It was a glorious time, the dawn of a new age. I loved it.

I was visiting a local library 2-3 times a week and took out books like "The C Language" and SICP and slowly worked my way through them. It involved a lot of tinkering plus trial and error. Learning to program was less spoon-fed compared to today's norm and needed more dedication since gathering information and its synthesis took longer and was harder.

Basically the same, except sometimes you'd accidentally click an ExpertsExchange link in Google and have to hit the back button.

I literally begged my mom to buy a couple of books for me. The Debian sysadmin bible and some mixed programming for linux book that featured bits from many languages like bash, perl, tcl.

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.

NB: Stack Overflow can be a very useful resource to answer a certain limited class of problems you run into while programming. By construction, it's a poor resource to learn how to program.

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 StackOverflow you could still find your information on forums and newsgroups.

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.

There was a time before forums and newsgroups when all you had was magazines.

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.

I'd hoard programming books, magazines, and articles. Now, I just rely on the internets, keeping a file of useful links.

I really miss the days of going to Barns and Nobel and browsing thru programming books for hours to learn a new technology, then buying the best of the books available. It was a different experience that is lost in today's world and it was really only a blink of an eye as far as computing eras go, but it was by far my favorite.

You had to spend many hours reading lots and lots of other people's code. You still do, but many people seem to find that distasteful. I don't know what they're bitching about because it's MUCH easier to find and read other people's code these days than it used to be, with github search and google.

Now I feel old. Stack Overflow was launched the year when I celebrated the year I moved away from professional programming into another realm!

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!

In the Dark Old Days, there was more specialization, so you could (and were expected to) become deeply knowledgeable about a few things, e.g. Cobol programming on OS/360. The computer vendor usually supplied everything, including the OS and the one language you used, and decent manuals were expected.

Our high school got some TRS80s in 1978 (+/- 1 year) for the CS class. I wasn't taking that class, but I borrowed the TRS80 Basic manual and read it in an hour while I was supposed to be paying attention in calculus class. After that, I could just go into the CS room after school and try stuff.

In the 80s we couldn't do the "download code" part. The most interesting code was in books: K&R, Software Tools, Thinking FORTH, SICP, etc. They taught me an implicit lesson that all my code could be that polished and readable; graduating to the working world in the 90s was a shock.

I actually have quite fond memories of the documentation that came with Sun workstations around '90 - a huge amount of documentation and boxes of ring binders to put them in. Later on you even got a complete set of PostScript books for NeWS.

I learned a lot of lower level Unix programming from those Sun documents.

We had a lot of "learn x in y hours/days" books like this one: https://www.amazon.com/Hours-Sams-Teach-Yourself-6th/dp/0672...

I actually learnt a lot from the ground up from first principles, which I was lucky to had time for back in the days (like SQL and markup etc.). Unlike today, where everything has to be completed by the end of the day in agile fashion, where I hastily copy/paste from SO.

I went to the library and checked out books with code you would type in by hand, like this one: https://en.wikipedia.org/wiki/BASIC_Computer_Games

You probably wouldn't believe, but we used to read assembly code in books and magazines and wrote resident programs for MS-DOS, used to load custom bitmap fonts to imitate the Norton Utilities fancy UI and stuff like that. I'm an oldfag, you see.

I started in the 80's. when I was in elementary school. I taught myself BASIC by typing in programs from books (TI/99 and Apple II).

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

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact