
How Much Does an Experienced Programmer Use Google? - kilimchoi
http://two-wrongs.com/how-much-does-an-experienced-programmer-use-google
======
trcollinson
I'm probably about to date myself, but here goes. When I started programming,
there was no Google. There wasn't a search engine yet. There were BBS's (which
were slow), books (which were expensive), and magazines (which were
infrequent). More junior programmers often ask, "Did you look things up? How
did you search for things without Google? It must have been so hard!"

Well, from my perspective, it was! It was a horrible pain! Sometimes you'd
spend way too much time debugging a simple error or looking up in some
magazine that you are sure you read somewhere a statement that you are pretty
sure would help you out in this particular scenario. Oh, it was tedious.

On the up side, at the time I didn't use nearly as many complex technologies
as I use today. Quite literally today I have written in Java, a bit of Ruby, a
bit of Perl, and some bash. If we expand out to this week we can add in HTML,
CSS, Javascript, and SQL. Back when I started I used Basic for long stints, or
C for long stints, and that was it!

Google (or in my case DuckDuckGo), StackOverflow, and the like are AMAZING. I
am grateful every time I get to use one of them to help me quickly solve a
problem and move on to the exciting part, which for me is making working
software.

~~~
nothis
Having grown up with google, I still sometimes look at code (that I just got
to work after an exhausting search on Stackoverflow) and think, "man, future
generations of coders must figure out something more practical" and I'll
probably get to tell them, "yep, that's how tedious it was" stories as well.
What strikes me the most is how often code repeats, how often mistakes repeat.
You can google a quite specific problem and more or less _always_ find a
result, likely a Stackoverflow article with tens of thousands of views. While
it's great that we now have a collective knowledge tool to fight this, it also
illustrates how much programming is still running in circles. We take pride in
expertise and skill, but how much of this is memorizing workarounds and exotic
quirks that shouldn't even be necessary?

What will be the next google? The next Stackoverflow? I doubt it will
literally just be a better version of either. It will probably be better IDEs
and debuggers. Heck, I doubt we'll continue to type as much as we do...

~~~
fao_
I wonder if there is (or could be) a program that collates the most common
bugs for X programming language from SO. So you run it as a sort of
preprocessor, and it picks up stuff that the compiler either doesn't or can't.

~~~
reagency
Google's Tricorder
[http://research.google.com/pubs/pub43322.html](http://research.google.com/pubs/pub43322.html)

------
kyberias
Google usually finds StackOverflow answers which is great.

I once found an answer to my question from SO, tried to upvote it but SO
didn't let me because it was my own answer to the problem written over a year
ago.

It seems StackOverflow works well for seniles as well.

~~~
vangale
I'm embarrassed to say, but this has happened to me too. More than once!

~~~
sanderjd
Why is this embarrassing? You moved something from local memory to remote disk
and found it when you needed it again using a sophisticated index. Seems like
a well-functioning system to me!

~~~
austinjp
A.k.a. "coping mechanism".

------
aidos
Almost 20 years in and I still use stackoverflow (via google) most days.

There are just so many weird things that take too much digging through other
people's src to figure out while you're busy trying to solve another issue.

Something as simple as (last week) - why is my unicode printing ok in the
terminal but not when running from upstart? You debug to that level and then
you want to know the right way of configuring things. I normally read a bit
more than I need to so I'm better armed for other scenarios.

------
tetraodonpuffer
I miss the days when I was developing in mostly only one language (C) and
mostly only one environment (X11/Motif), all the searching I needed to do
could be done on my bookshelf that was filled by the awesome O'Reilly
'Definitive guides to the X11 system' series and other related books (like the
great 'Software portability with Imake', for example)

It was so nice to have all the knowledge I needed at my fingertips and I was
always sure to visit any technical bookstore if I was abroad to see if there
were other O'Reilly books I didn't own; I remember when I went on vacation in
England feeling so bad about not being able to buy all the books I wanted in
London because I didn't have enough space in my luggage...

Nowadays having to switch at a moment's notice between perl, python, C and
java, as well as many, many, many related environments/libraries I don't think
I could function without google, there is just too much information available
and it changes way too fast.

It's not like it's any more complicated than it used to be (I think at one
point I ended up subclassing the XmText widget to support rectangular
selections, which took a while to get working) it's just the volume that makes
it difficult to keep more than a couple of environments fresh in your brain
without having to be online to refresh your memory.

------
on_and_off
I am considered a senior engineer in my specialization and I still Google a
lot of things.

There are still many things that I don't know, some things on the tip of my
tongue that I almost remember and some things I use once or twice a year and
forget in the meantime.

However, the more I mature as a developer, the faster I can detect horrible
StackOverflow answers which technically answer the question but cause a couple
of more or less sneaky issues.

~~~
sanderjd
Yep, the good/bad pattern-matching is the important and hard (impossible?) to
teach part.

~~~
austinjp
If it's pattern matching then the most effective teaching method is probably
exposure to patterns plus feedback on attempts at detecting/emulating those
patterns.

~~~
sanderjd
Agreed. Interestingly, this is how gaining experience works – you become
exposed to patterns by needing to search for them, and get feedback from
interpreters, compilers, and code reviews from teammates on how well you have
picked out the right approach. Presumably that process could be sped up with a
more formal approach.

------
athoik
Using Google is ok, but mastering Google is art!

Although sometimes you are the first that hit an issue.

Solving the issue and sharing the results is the next greatest thing one could
do. Reporting the issue is great too.

~~~
akyu
[https://xkcd.com/979/](https://xkcd.com/979/)

------
planetjones
This post is a good example of why fact based interview questions are not
useful. It's how information is gathered and applied which separates the wheat
from the chaff.

Einstein puts it best:

 _One of Einstein 's colleagues asked him for his telephone number one day.
Einstein reached for a telephone directory and looked it up. "You don't
remember your own number?" the man asked, startled. "No," Einstein answered.
"Why should I memorize something I can so easily get from a book?"_

~~~
thesimpsons1022
anytime I hear an Einstein story I assume it's made up.

~~~
danieltillett
This is my rule too. I actually use the stronger rule which is anything
attributed to anyone famous was not ever said by them.

------
thetruthseeker1
I can't agree with this article more. It's like the author read my mind. I
have programmed in perl, C, C++ in linux, VC++ & COM, python, JAVA, JS, VB,
assembly language, Prolog, Lex, Yacc. I am sure I missed a few in this list. I
think of problems in abstractions and when I think of syntax/semantics its
almost a vague haze a mix of libraries of various languages. Dont get me
wrong, once I start programming in a particular language, I am in the "zone"
so to speak. But I think I need Google too often.

------
Osmium
All I can say is that I've never regretted spending too much time looking for
more information, on the web or otherwise, but I've _frequently_ regretted not
spending enough time after re-implementing someone else's mistakes for the
past several hours/weeks/whatever. It's the lesson that keeps on giving.

[Not that I'd call myself an experienced programmer, but I'd say the same is
true of scientific research and many other things.]

------
leesalminen
Sometimes I force myself to think for ~5 seconds to recall a functions name. I
usually end up feeling that it would've been quicker to just google it.

~~~
rqebmm
When I was first learning, I googled everything.

When I grew comfortable, I took pride in my ability to look up the reference
docs myself and figure out the correct solution.

When I grew comfortable with that, I googled everything because it was a lot
faster.

~~~
aurelianito
Me too, but I have decided to never cease to learn, so I am stuck in step (1)
:D.

------
ThatGeoGuy
Perhaps I am in a minority because I am currently involved in research /
academia, but I find I am using Google less and less as time goes on. This is
not meant specifically to be a dig at Google, nor am I saying I go without;
however, it really isn't as useful to me now as it was when I first started
programming.

The reason for this, I believe, is that I am less and less interested in the
broad range of answers Google often returns. Sure, you can easily find an
answer on StackOverflow as to why Visual Studio is giving you a LNKxxxx error
at compile time, but this has limited utility (in my experience). As time has
gone on, I find myself searching Github, API documentation / wiki's, and most
importantly, my University library. I vastly prefer reading real code
alongside documentation than to just get an answer. Sure, I memorize the easy
things, like how to get the length of an array in Javascript or which library
to import to access vector-fold in Scheme, and that's fine if you're able to
do it (if you Google this information, you likely work with more than 3
languages per day or per week). Instead, I find myself searching for answers
in 1) other implementations 2) documentation of that implementation, and 3) in
the original work documenting the theory or concept (papers, journal articles,
textbooks).

Certainly, I think it's okay to Google something, or just search in general.
But as time has gone on, the value of my University's library, as well as
specific documentation and the availability of open-source implementations of
most general purpose materials / paradigms has made my life infinitely easier
(and hell, possible). While I value what's possible to find on today's search
engines, often times dedicated resources really are the best way to go over
the much more broad search engine Google provides.

Note though, that despite this, I do realise that much of these "specialized
resources" were discovered through Google, so perhaps I am in circles on this
one.

------
LukeB_UK
If you mainly look up documentation, DevDocs[0] is a great app to use. It's
browser based, but you can make it offline.

[0]: [http://devdocs.io/](http://devdocs.io/)

~~~
jdright
Very nice, thanks!

------
narrator
If I'm using a language and platform that I'm very used to, then not very
often. In that case, I'd only use Google if I hit a weird bug in the platform
that I haven't seen before or wanted to use a new capability.

When I'm just starting out on a new platform I'll Google a lot though. I find
it's good to keep a blog of everything with a new platform that took more than
an hour to figure out.

These days, there's a definite lack of appreciation for rote learning of
frequently used information.

------
Theodores
_More often than Bing?_

In the olden days you had to write a lot more stuff from scratch. This would
be in a language that could be explained in a relatively concise manual. So
everything you would need would be in that manual.

You could learn from things others did with the same manual/hardware by seeing
the end result, but the art required for that result wasn't open source, you
would have to work it out yourself and RTFM as often as needed. Magazines were
as good as it got.

The knowledge to program wasn't easily obtained, for starters computer kit
could cost many thousands. Computers weren't really networked back then
either. Floppy disks were the distribution medium. Also computer screens
actually flickered in glorious 1024 x 768. Plus they were noisy. You read your
code in printouts side by side with the manual, probably hand-writing code
before typing it in.

Back then it must have been possible for someone to actually know a language
such as 'C' (or BASIC, or an 8 bit assembly language) completely as in know
all the commands and understand all the concepts. This would be learning by
rote to a certain extent as the 1-2 manuals would be memorised to all intents
and purposes. I don't know if that sort of mastery of a subject is easier to
obtain today.

------
Aldo_MX
I usually force myself to use the documentation of a
Language/Framework/Library/etc. with a tool like Dash[1], because I don't
always have Internet Access.

I try to restrict myself to use google only for troubleshooting.

[1] [https://kapeli.com/dash](https://kapeli.com/dash)

------
Arnor
On any given day I use any combination of the following languages: Ruby,
Python, JavaScript, CoffeeScript, Haskell, Bash.

If I could remember how each language handled list operations and JSON/Base64
encoding I could probably code much faster, but the real efficiency gain
wouldn't come until I stop reading HN :P

------
joezydeco
I've joked that if I only had a small program that would take my compiler
errors, grab the important part (especially when C++ pukes a mountain of text)
and automatically feed it into Google, my productivity would take a huge jump.

Now I'm wondering if there's a business model for it.

~~~
TheOtherHobbes
Google is obviously missing a trick. Instead of working as a search engine, it
should work as an online compiler and code repository.

Then it could apply machine learning and AI to predict code before it's typed.

Maybe Google Code was an early prototype?

I regularly wonder how much code is repeated effort. I get the impression that
some very non-trivial percentage of global business effort is thousands of
different developers writing their own versions of code that does the same few
things - especially in web land.

For some reason frameworks seem to make this problem worse instead of fixing
it.

~~~
joezydeco
I think it's _all_ repeated code now.

The moment I get an error the first thing that crosses my mind is "someone has
had this problem before, I just need to find the forum where they discussed
it."

------
m0dc
Memorizing documentation and obscure bash tricks is the last thing a developer
should be expected to do.

Even reading the documentation (in its 'raw' form) can sometimes be harmful,
because you miss out on the contextual information that a search engine
provides. Especially if you're new to a language or domain, it's easy to fall
victim to the XY problem [0] - you comb the docs trying to implement your
perceived solution, when a simple Google search or Stack Overflow answer would
give you the solution you're _really_ looking for in seconds.

If something is important to you, you'll absorb it over time anyways.

[0]
[http://www.perlmonks.org/?node=XY+Problem](http://www.perlmonks.org/?node=XY+Problem)

------
mianos
Over 30 years in. My second monitor is for google search when it's not moved
due to multiple putty sessions overflowing the first :) I still have my
original Kernighan and Ritchie. When I went to the bookshop there where two
books, K&R and a Byte book on C. I used to remember many of the pages numbers
of things I looked up a bit. Next I moved on to help files. I made my own CHM
files or scabbed them. Now we have google, why not. I agree with the point. I
use python all day now but still do a bit of JS and use google for the same
things, size, len, .len(), .size, len(x).

This is how we rolled:
[https://goo.gl/photos/VRyNYQMyVLxJjYVq7](https://goo.gl/photos/VRyNYQMyVLxJjYVq7)

------
blakecaldwell
I don't even bother committing some easy stuff to memory. Living in a polyglot
environment, there's just too much going on to worry about the little details
that Google and StackExchange can give me in a moment.

~~~
thoman23
I feel the same way. It worries me that it may come back to haunt me in an
interview environment where the fact that you don't have something in RAM
could make you look incompetent, when in fact it's just a conscious choice on
where you are going to store your knowledge.

------
fezz
Grep was my google in the old days.

I kept a library of code I liked or found useful. For example, a bunch of
nicely written code on SGI's that came free by guys like Paul Haeberli was
quite useful say if looking for opengl examples.

------
redwards510
I miss the days where you could become an expert in one language and work
completely offline. Things have changed so much though, with everyone expected
to be "full stack" and have a working knowledge of a wide variety of
constantly changing APIs. Now, having n years experience in one language no
longer seems relevant. Your value comes from your ability to understand
requirements and marry different pieces of technology together. I don't feel
as smart having to constantly look things up.

~~~
icebraining
There are still jobs like that; right now, Indeed.com has 2000 COBOL jobs
offers. I wouldn't trade it, though.

------
thoman23
Well, I'm a Scala developer these days so I certainly don't use the official
documentation. :p That leaves Google/StackOverflow.

~~~
jghn
Not sure what you mean here, I use the official scaladoc constantly

------
pluma
If you never have to look anything up, you're likely not actually getting
better. The last thing a developer can afford is to stagnate for extended
periods of time (i.e. years rather than weeks).

The likelihood that you already know everything there is to know about your
niche and that you will be able to stay in only that niche for your entire
career is extremely low.

------
_nato_
To quote a great hacker, Joe Armstrong, ``The reason we write code is because
we can't find it on Google.''

------
jimmaswell
One thing I appreciate about good autocomplete like Intellisense is that for
problems like the length example, I can guess and confirm with the
autocomplete even faster than going to another window and googling it. Even
lets you know if it's a function or member.

------
minthd
All this raises an interesting question: what tools does Google offer it's
developers ,to search for help and code ? is it better than what we've got ?

Also ,the same goes for tools for patents and engineering knowledge search.

~~~
chubot
You can see a public version running on the Chromium source here [1], which is
pretty nice. Notice that it understands symbols and so forth, which
essentially involves building/compiling all the code. I think it is ahead of
what you'll get elsewhere, at least for C++.

[https://code.google.com/p/chromium/codesearch#/](https://code.google.com/p/chromium/codesearch#/)

------
fredgrott
I develop android apps and use Google to catch device specific bugs ie the
mention of bugs and workarounds that way I only have to pay for one android
device rather than have about 25 devices

------
spiralpolitik
A lot.

Simply because it's impossible to remember everything unless you use it on a
day to day basis. Every useful link I find is tagged and stored in a
repository for future use.

------
krapp
I write PHP and javascript for a living and C# and C++ for fun and school, so
in my experience, a lot.

------
jonathaneunice
Google is my hive-mind.

Stack Overflow* is where I find the most real answers.

* and sister sites like programmers.stackexchange.com

------
jheriko
wasting time remembering the unimportant fine details is a sign of a bad
programmer imo.

good programmers use software to make themselves better and google is a very
reliable alternative to excessive memory (but not understanding, or problem
solving skills)

------
liebknecht
Very rarely. In general, we use DuckDuckGo.

