
All Programmers Are Self-Taught - jgn
http://jgneuf.wordpress.com/2011/12/20/all-programmers-are-self-taught/
======
hammerdr
College is an interesting beast. It is a great tool to mature bright teenagers
into contributing adults for society. It does this in several ways: throws you
into a small space full of diverse people, challenges you mentally to an
almost breaking point and forges you into the mold of a person you will be for
the rest of your life. Oh, and you'll learn some professional skills, as well.

For high tech industries, this is even more pronounced. I apply very little of
what I learned in college to my everyday activities (though I do love a good
compilers or garbage collection nerd-out). This is okay with me: I know that
without college I wouldn't be who I am today and probably not as prepared to
make my mark on the world.

The more cynic of us will say that CS programs teach for one thing: post-
graduate courses. This is, to a degree, true. However, the VIM trick that I
picked up at work today is NOT the sort of thing I would have been happy with
a professor 'challenging' me on during my courses.

How you become a good programmer is through: experience, lots of boring little
things that add up and _working with good programmers_ (which almost
categorically disqualifies professors and fellow students).

Want to learn to program? Work up! Always be the worst person on the team.
Find people better than you and _listen_.

Edit: Also, good programmers: part of your job is to make people around you
better. Don't shoo away the wide-eyed and eager of us (me).

~~~
intenex
There are far more cost-effective ways to mature bright teenagers into
contributing adults for society. Arguably more effective ways at large as
well.

~~~
83457
Please argue for one as an example.

~~~
intenex
Alright, I'll speak for myself as that's the path I'm still walking and the
one I know best. I'm 19, matriculated into Harvard for one semester, then
dropped out and took on the Thiel Fellowship. Under the Thiel Fellowship,
we're granted $100k (pegged around college ed prices) for two years to pursue
an entrepreneurial project.

In the past year since leaving school, I've had more opportunity for maturity
than I ever did in college. I've had the freedom to explore, and I've used
that to travel to all 7 continents and broaden my internal horizons of the
world. I've had the freedom to discover, and now I'm fortunate enough to have
found a passion I can pursue with my full attention. I never had luxury of
doing that in school - there's no time to step back and wonder why you're
doing what you're doing as you're too busy being pushed through the grind of
'doing'.

I've had the freedom to become personally responsible. Being devoid of
extrinsic pressures (must get good grades, build resume, get job, etc.) for
the first time in my life means that I've had to replace those driving forces
with intrinsic drive and accountability.

I've been living on my own in SF since June, and that's been a wild ride of
being liable for every aspect of my own survival and well-being :). Being an
entrepreneur means I have to account for a 24 hours each day on my own, as I
don't even have an employer to provide a cover story for 8-9 hours every day.
I'm not saying I account for all those hours nearly as well as I could and in
fact I certainly don't (case in point), but this is offering me the
opportunity to _learn to be accountable_ , and that's exactly the point.

College is a pseudo-diverse atmosphere. Sure, people might be differently
colored or have exotic accents, but everyone's there for the same purpose, is
the same age, and has more or less the same mindset, or at the most one of a
select few mindsets. Real diversity is living in a strange juxtaposition of
homeless crackheads and billionaire tech entrepreneurs (woohoo San
Francisco!), or seeing firsthand definitive proof that polio has in fact not
been eradicated and is still alive and well in the marginalized corners of the
world.

Even if we see these things in college, chances are likely our mindsets have
been so tunnel-visioned that their full impact doesn't register on us. The
insular bubble of college is pretty hard to penetrate.

Challenge-wise, being an entrepreneur is far harder than being a college
student. And thanks to the cost of college, so many of us might never have the
opportunity to take the entrepreneurial path (or any of a number of other
paths) unless we take it in lieu of the college path.

And yes - college might very well be a mold that shapes you into the person
you'll be, but it's a cookie-cutter mold, and it's not unique to you. Life is
a variable endeavor, and the experiences we use as a mold with which to shape
ourselves should similarly be variable. College is probably a wonderful mold
for some. For others like myself, there are almost certainly better molds out
there waiting for us to find them.

------
apaitch
I'm not sure I can fully agree with the idea that programmers are self-taught
in the sense of writing good code. I'm a student at the University of
Waterloo, and in the courses in 1st and 2nd year a sizeable chunk of the marks
depends on readability/documentation and such. We have coding guidelines and
we lose marks for not following them. Needless to say, this doesn't mean most
students at Waterloo write good, well-documented, readable code. Most of them
are focused on getting the program to work, sprinkling in obvious comments
(i.e. "//setting width to 60" ) and debugging when the tests fail. When they
get marks off for poor documentation/readability they either complain or brush
it off, claiming that since their program worked the rest isn't a big deal.

Bottom line: in my experience, the reason most programmers are self-taught
with regard to writing good code is not that no one tries to teach them. It's
that most of them don't think they NEED to know (i.e. don't place enough
importance on it) and are willing to lose marks for it until they get to a job
and they have no to choice but to, you guessed it, teach themselves. There are
people who try to make the best out of their education, and these can be very
good coders who learned by making the best of their education.

(Note: obviously this is a generalization - there are plenty of students who
try to write good code.)

~~~
lukev
No personal reflection, but what "good code" means in a professional context
is quite a bit removed from student assignments.

There are just some things you'll never learn, for example, until you have to
interact daily with code you wrote a year ago.

~~~
evilduck
Student assignments also rarely operate in the _sheer magnitude_ of real world
programs.

In university, I think the longest assignment I had was in the ballpark of a
couple thousand lines of code and you could pretty readily keep it all your
head as you solved the problem, there's not too much abstraction or delegation
of responsibilities, no interfacing with 3rd parties, few library
dependencies, it's all written in a single language, etc, etc. And you wrote
it all from scratch by yourself or in a small team with (likely) equally
inexperienced peers, so you know all the clever tricks that were employed.

On the job, I deal with company's code base that's over a million lines of
code and uses a very messy database, maintained by dozens of people or varying
skill levels over the last decade, wrought from an unholy amalgamation of 3
different programming languages spread over several servers and reliant on a
half dozen "support utilities" to keep applying band-aids to bugs that "aren't
cost effective to fix".

Writing good code the interacts with bad code is one of my hardest
professional endeavors.

------
richardburton
I have been trying to learn to code for about 3 years. Recently - I succeeded
(in getting started!).

I had been on courses, bought books, read tutorials etc. but at the end of
each forced exercise I still could not build a decent rails app. Then, after
coming back from the US 6 months ago, I decided I wanted a GroupMe clone for
the UK. So I built one.

<http://bit.ly/groupmeclone>

The SMS is disabled on that version as I have no intention of subsidising
peoples' group-messages but the fact is it WORKS and _finally learnt to code_.

The controller is fat, the model is thin, there are no tests, there are lots
of lengthy if-else statements, there are lots of bugs but I do not care
because _I finally learnt to code_.

I have built little scripts for managing my kindle
(<https://gist.github.com/1404068>) and scripts to get my Instragram pics
(<https://gist.github.com/1399696>) and _I love it_.

I feel like I can finally call myself a rank amateur nuby Hacker. It feels
good.

~~~
jerfelix
>> The SMS is disabled on that version as I have no intention of subsidising
peoples' group-messages

If you are interested in advancing that project, you may want to consider
sending the SMS messages via email, which would be free. Each user would need
to define their gateway when they set up their account. Many carriers have SMS
gateways, and an easy way to translate a phone number into an email address
that delivers by SMS.

See: <http://en.wikipedia.org/wiki/List_of_SMS_gateways>

~~~
richardburton
Oh that is very cool. I would definitely invest the time if I was still
interested in the project but I have finally found something I want to focus
all my attention on. Thanks!

------
fab13n
Having spent some time in the academia, the main reason why most TAs and
professors don't teach you how to code is that most of them don't know how to
code for themselves.

That skill is neither expected nor rewarded in academic careers. So unless
they moonlighted as hackers or in a company, they never learned to code as
students, and certainly won't as staff. They certainly won't teach it.

~~~
araneae
It depends on what branch of CS you're in.

Just like computer science is not about computers, it's also not really about
programming. Certainly there's overlap. I have a pH.D. student friend who
works on proving the correctness of programs. He doesn't write code, he writes
proofs. Of course he'd be more rusty in C than a full time C dev.

But I also have pH.D. students that build proof-of-concept software. Yeah,
they're not optimized in the way that live software is optimized, but they can
certainly _code._

And I really have to wonder where you went to school if "most" of the TAs and
profs "can't code" and what kind of standard you have. That was not my
experience at all when I went to school.

~~~
fab13n
Sure there are some researchers who can and do code, but their coding skills
rarely do much good to their career. I bet that's why you delegate PoC
software development to PhD grunts :) Moreover, it seems to me that most
academic coders don't have enough occasions to collaborate on long-lived code
bases; I don't think you can call yourself a developer if you can't deal with
code decay and team collaboration.

Finally, I didn't realize how many teachers and TAs couldn't code while I was
a student--although I had serious doubt about some of them; I fully realized
it when I was a PhD and TA, with a background as a start-up developer.

I don't see it as a huge issue, though: as the article points out, many
developers successfully learn to develop on the go. In my opinion, school is
there to teach you the foundations which would be very hard to learn on the
fly as a junior developer: maths, formal reasoning, hardware architecture,
algorithms, maybe a bit of formal semantics. As I recall, those happened to be
the most interesting lectures, given by the most awesome professors; it's
probably no coincidence.

------
makecheck
Programming is unusually accessible compared to other skills. If I wanted to
learn how to raise farm animals, where would I start? A person needs only a
few common things to try programming: an off-the-shelf computer, maybe a book,
and these days an Internet connection. After that, they require only the
traits common to any other hobby, such as _free time_ and enough imagination
to figure out what is going to be built. (I'm glazing over a few details of
course, such as the fact that knowing how to type would certainly speed things
up.)

Programming is also an unusually marketable hobby skill. With many hobbies you
can invest a lot of time and effort and produce beautiful things, but that's
liable to only gain you praise; in programming, it can gain you a really good
job. This is a pretty smart investment: for a modest expenditure yourself you
might net a high income so it should not be surprising if people often teach
themselves.

Besides, when I hire someone I _like_ seeing evidence of side projects that
reveal a certain passion for doing good software work. I wouldn't hire an
artist or designer without seeing a portfolio either, and software has a lot
of things in common with art and design.

------
tdavis
There are two classes of programmers: the taught and the self-propelled. You
can certainly _teach_ someone to program--what they do after that defines the
rest of their career. No CS curriculum will give all the information one needs
to be a _great_ programmer, but it's certainly possible to have a long and
mediocre career as a _taught_ programmer.

I would wager a majority of the best programmers are _also_ self-taught,
though. Not because College is a bad experience or sets you up for failure,
but because it's really internal motivation and curiosity that makes a
programmer grow, not something they learned in a CS course once upon a time.
And you've got to be pretty damn curious to make a career of programming
without any formal introduction or education.

~~~
ntkachov
I would argue that a good CS curriculum makes you a good Computer Scientist. I
started really programming my senior year of high school. My code has been
steadily improving since then. However if it was not for my CS courses I
would't be able to tell the difference between a binary tree and a stack.

Programmers are artists. You can't teach art. Computer scientists are
mathematics. Math must be learned.

The two together are Engineers.

~~~
digitailor
I'm a self-taught programmer who went to art school and I love this thought-
provoking comment.

There's one thing I'd like to point out. You _can_ teach the _techniques_ of
art, which are used for creating art. You _can_ teach the _techniques_ of
programming, which are used for creating software. You _can't_ teach how to
_create something that's never been created before_.

That goes for creating ground-breaking art, as well as ground-breaking
software.

Often, it's a set of disparate and interdisciplinary techniques, seemingly
unrelated, that are used together to create the cutting-edge.

~~~
narag
_You can teach the techniques of programming, which are used for creating
software._

I completely agree. The article might be right that it doesn't usually happen.
But we should ask what the causes are, not simply accepting the "it can't be
taught".

------
devuatl
Programming is a trade of great skill and requires enormous amounts of
knowledge. Whereas one has to be self-taught it doesn't mean one is alone. It
is something I found out when I got my first job.

I joined a small team at a startup. Those guys did their best to make me
produce quality code as soon as possible. They were reviewing my code several
times a day, and teaching me what to do to, to make it efficent, easy to
understand and well designed. Early on they even made me read the "Clean code"
and I am eternally grateful for this.

Now I think part of being self-taught is actually having to find teachers on
your own. Software Engineering is always about knowledge - whenever you code,
you're probably solving a problem, which hasn't been solved before. Otherwise
you'd just use some library to do the trick. It means that programming is
about inventing new stuff, and so when you tell someone about your code,
you're actually teaching them about it. Whenever you join a new project,
someone has to teach you how to work with their system. If you're independent
contractor building software for your client, you have to learn their ways of
doing business.

High tech jobs are all about knowledge transfer, this way or another.

During my college I didn't learn that much from my professors, when it comes
to software engineering in the trenches. I did learn a lot during college
though. It was a time of meeting other people who were passionate for
technology. We could exchange our insights, and do college projects our way.
We would give each other feedback on our work, and so we were actually
teaching each other.

I think above applies to meetup groups, code retreats and similiar
initiatives. Programmers gather together to learn. Software engineering is all
about knowledge transfer, and you have to want to learn, but it doesn't mean
there's nobody to teach you. You just have to find your teachers on your own.

You are self-taught, but never alone!

~~~
babebridou
This is my feeling, too. I never took any serious CS course during my studies,
not more than maybe an hour a week at best on Mathlab, Caml, Prolog or Pascal,
a tiny bit of assembler or LOGO, and these courses were almost always tied to
other scientific disciplines, using the computer as a tool in the exact same
way as we would use a ruler, an erlenmeyer or a LED.

I learned programming at work. I was working in a startup that I joined
shortly after the internet bubble burst, in 2002, as their first employee. I
was taught, beyond syntax and flow, to find my own "Way of the Programming
Fist", as I like to name it, and more importantly to keep an open mind for
other ways of programming. The key, and possibly the only lesson that is still
relevant today:

"When in doubt, remember that your Way of Programming is complete, which means
you can eventually build anything with it, anything. Whether you want to
display a barchart from a static printer spool log or light up a bulb with a
handclap, your Way of Programming can eventually do it. For every goal, there
are probably faster, stronger or easier Ways, but these are never 100% better:
there's always a tradeoff. For that reason you don't need to learn the other
Ways - but make sure you acknowledge their existence, learn and remember these
pros & cons your whole life."

You're talking about "Quality Code" - I didn't get it through people looking
at my code, but through me looking at other people's code. My brains designed
some abstract "compiler" of sorts, used in my very mind to parse an alien
piece of source. For me, "Quality" in that domain is the amount of work I need
to do to be understand the "Way of the Programming Fist" of the coder, and use
it in turn for my own programs. It has a lot to do with conventions, design
patterns, formatting, naming and of course the programming language's
"family", whether it's procedural, functional, object-oriented or whatever.

A decade later, it feels like it's still only the beginning, but I'm now
proficient enough to understand the pros and the cons of some of the various
conventions, design patterns, algorithms or programming languages I've met
along the way, the way they fit with various goals and requirements, I'm
mature enough to make my own choices, and I actually have my own programming
business.

I would absolutely describe myself as a self-taught programmer, but like the
above poster said, I would have gone absolutely nowhere on my own. Programming
is all about knowledge transfer - "Here's what I use to do this, and here are
the benefits, here are the tradeoffs" should be every programmer's favourite
sentence.

------
j_baker
_if my program compiled and my unit tests demonstrated correctness, that was
enough._

...

Your professors taught you unit testing? In terms of learning the "practical"
side of programming, I think that right there gives you a leg up on most CS
students.

------
wvenable
I mostly had the same experience as the author in university, with the sole
exception of the C++ class. That class was brutal -- you had the match the
style guide exactly, have good variable names, good comments, const-
correctness, etc.

When I've taught programming to beginners, I try and demonstrate good code and
when I see ugly code I point them in a better direction. I have, however, had
students be stubbornly focused on the output of their code and ignore all my
advice. No matter how ugly and hard to debug their code was, they refused to
believe it mattered.

------
vph
Programming needs lots of training, for which self motivation, self teaching
is important.

But to say that all programmers are self-taught is a little short sighted.
Beyond the basic syntax, there are difficult concepts and idioms in many
languages or programming paradigms that can be quite hard for a person (who is
not familiar with such concepts, idioms, paradigms) to discover by
him/herself. These things include pointers in C, reasoning about correctness
of programs, recursive techniques (dynamic programming, etc.), and many
functional programming concepts. Good teachers can make these things a lot
easier to learn.

------
geebee
Interesting... I had a professor who spent a ton of time looking at my code. I
almost didn't like asking him a question, because before he'd answer it, he'd
insist on reviewing at my code and making me refactor it, and it was always at
least a half hour, often well over an hour, before we'd actually get to my
question. It was good for me, though, and I knew it - I did ask him to be my
senior thesis advisor.

Interestingly, this guy was a math professor, not a CS professor. But he was
very particular about code.

------
bguthrie
I sympathize with the author's experience, but all programmers are absolutely
not self-taught. There are all sorts of ways to learn programming that don't
involve homework assignments or even college classes; pair programming and
mentorship with a skilled craftsperson comes to mind as one perfectly nice
alternative.

Besides, even after college I learned a tremendous amount about programming
from my colleagues and peers over the years; programming isn't one of those
things you learn, and then you're done learning it. It sounds like in this
case, college didn't adequately cover the basics, and the author decided (to
their credit!) to drive their own learning; but I promise there's a great big
crowd of helpful peers and teachers out there when you're ready for them.

------
chrismealy
I agree with the premise. However, the whole world runs on sloppy, inelegant,
and downright ugly code. I strive to write pretty code but the truth is it
doesn't matter that much. Just getting it done and out the door counts for so
much more.

~~~
mattdeboard
Just getting it done and out the door counts for so much more _right now_. It
matters far less in a day, week, month or year when you or the next guy has to
maintain it.

Though now that I reflect for a second I have to acknowledge that it's all
that matters to the stakeholders, and not necessarily to the coders (nor
future maintainers).

------
crxpandion
I disagree with this post. There are professors out there who do in fact teach
code style in a very hands on and personal manner. Chris Riesbeck [1] at
Northwestern University has made a great system to teach good coding practices
in a number of languages. Many of my fellow alumni have learned good coding
practices from him. Its an inside joke to talk about "Riesbeck crying" when
messy code is written.

[1] <http://www.cs.northwestern.edu/~riesbeck/critiquing.html>

------
JJMalina
I agree. As a third year undergrad also I've noticed that the focus on the
code itself has diminished to almost zero from CS 101. At least in that course
my professor mentioned a few things about code quality and design like DRY,
loose-coupling, etc. My data structures professor's sample code which he would
give out had single capital letters as variables, single lowercase letter
variables, and awful and inconsistent indentation. I understand that it's data
structures and not an open source project being maintained by the professor,
but there were students in the course who barely had any experience
programming outside of school. My guess is that the professor's neglect for
any sort of code conventions will carry over with those students.

My school does offer a class called "Production Quality Software" but it's a
graduate course and if you want to take it as an undergrad you only get 3
credits.

IMO the situation is not good.

------
bgray
I find myself very good at picking up small examples of code. I think the real
challenge in programming isn't learning how if statements, loops, arrays, etc.
work but how to put them together to do what you want. This is the real
challenge and I believe this is a combination of self-teaching (maybe
experiences) and natural ability.

~~~
glimcat
Loops are to software development as spelling is to writing a novel.

------
rileya
Very true. As a current CS student, I couldn't agree more.

From what I've seen thus far, most school assignments are pretty easy to
stumble through without _really_ understanding what you're doing. As much
useful stuff as I've learned in class, it's been personal projects that have
really solidified things and taught me the most valuable lessons.

------
EmilStenstrom
Is this really so different from other disciplines? I find that courses and
theory are good for grasping the basic concepts, not for actually learning how
to use those concepts in the real world. I'm guessing that holds for most
other disciplines too.

I read a course about data structures. It was taught in Java, but it was very
clear that Java was not the point. What did I learn by that? Not to write
linked lists in Java - I've never had to do that again - but to understand the
basics of how to think about storing data in your programs.

For me, courses are great for grasping theory.

------
ww520
That's not true. It depends on the type of classes and the professors. Some
professors and TA would go to great length to show how programming are done,
especially the intro classes. Of course there's always some amount of self-
learning, as in any discipline you can't be spoonfed for all materials without
doing it yourself.

You go further with self motivation and self-learning since there're only so
many class hours, and there're a lot more topics in programming.

------
langsamer
I'm not sure I agree. Yes to a certain degree, I think that programmers are
self-taught, but I think like most things in life, most of the learning comes
from your peer group. Working on a project in a small team with other
motivated developers is a much more enriching learning experience than doing
solo class projects or teaching yourself some new technology.

------
th
I think CS departments should offer at least one course that spends a little
time focusing on writing quality code.

The Software Engineering course I took at university was a pretty good
introduction to "programming". One of our required texts for the course was
Code Complete by Steve McConnell. We were required to read all the chapters
that focused on programming style.

------
jeffreymcmanus
Just because most (not all) programmers are self-taught, doesn't mean that's
the natural or optimal state of being.

This is mostly a criticism of academic CS (which aims to produce systems
programmers and researchers). The underlying implication that programming is
somehow unteachable is bogus.

------
demian
There is a difference between "self-taught" and "polishing skills with
experience".

Whatever you study in school, you will never be 100% prepeared to work.

That being said, code/program design IS a very important skill that seems to
be hard to teach in school.

------
richchan
I agree that coding is generally not "taught" in lectures or recitations, but,
like the article says, we learn from other people -- other people's code,
their comments on our code, etc. In fact, I feel like that may be the only way
to learn how to write good code and isn't something that can easily be self-
taught.

Working with and learning from other people is way more effective (than just
writing code) in figuring out how to identify good and bad code. And I think
formal CS education usually gives people the right tools (like algos, design
patterns, data structures, etc.) to understand and work with others.

------
MBlume
Wow. I've been referring to myself as self-taught because, well, I came from a
physics background, taught myself Python using google, and started kibitzing
on a friend's startup. But it occurs to me reading this, that I probably had
more direct instruction than most CS students. We worked together for only a
few months, but it was the two of us in a room every day, I showed him my
code, talked through what I was trying to make work, he'd nudge me towards
best practices, and I got better. I should thank that dude.

------
scott_s
As someone who has taught and TAed many students, I always tried to comment on
coding style, explain what good style is, and why. This becomes more difficult
as the number of students scales.

------
namidark
I disagree, I often see people in the CS program who haven't done a lick of
programming outside assignments and don't bother teaching themselves anything
beyond whats required for class.

~~~
BadassFractal
Regardless, they tend not to go anywhere meaningful professionally.

I wouldn't be surprised if 10-15 years down the line, these mediocre corporate
programmers (they can only survive in a large organization, where you don't
have to pull your weight nearly as much as on a 10 person team) they become
managers from hell.

------
tmcw
Actually, according to this article, "All programmer’s are self-taught."

Unfortunately, some are also self-taught in grammar and punctuation. (I had
to. My snark quota is done for the day.)

~~~
jgn
Sorry about that, fixed now.

------
suprememoocow
Interesting article. I tend to agree with the author. In fact, I would go
further and claim that while I've met many very good programmers who learnt
they're craft at university or college, it's probably safe to say that all the
truly great programmers I've met have done at least 10,000hrs of self-taught
programming before they even left school.

------
henrikschroder
The first thing our teacher said in my introductory course in CS was that the
_only_ difference between a good programmer and a bad programmer is the amount
of code they've seen. And from that follows that the _only_ way to become a
good programmer is to look at a lot of other people's code.

------
angelbob
Carnegie Mellon is quite a stronghold of this. They don't teach much coding --
they hand you the books, give you projects and grade the results. If you
produce workable code, mostly you win :-)

It's telling that CMU is considered such a great tech school. Even the best
don't know how to teach programming (yet?).

~~~
spauka
On the contrary, I don't really think that it is the University's job to teach
"programming". University traditionally focuses around teaching the skills to
do research. Higher level skills such as analysis and problem solving.
Consider learning history. It is expected that you "know" how to write an
essay. You may be critiqued on it, but it is not the primary motivation for
your study of that subject.

My personal opinion is that university is not a place to learn tools (i.e.
programming), but to learn to apply knowledge to form solutions to complex
problems. We learn about algorithms, data structures and techniques because
that is what we need to know to learn to solve hard problems. Programming,
while not separate from this (i.e. you can hardly build anything without
knowing how to use a screwdriver) is something that is assumed knowledge.
Teaching it at university would waste valuable time in courses that are
already too packed to give rigorous treatment of all topics covered.

~~~
thomaslangston
I'd say you're wrong.

I don't think we should assume the students have the knowledge 1) because they
obviously don't have the knowledge and 2) it doesn't match the methodology of
every other applied science. I don't assume that students are competent to
work in a biology lab before college. Why should Computer Science get a free
pass from teaching the lab work techniques that all other applied sciences are
expected to teach?

------
tvorryn
This essay seems quite relevant:
<http://www.lambdassociates.org/blog/hackers.htm>

It compares self-taught and college taught programmers to street fighters and
martial artists.

------
prodikl
I took CS101 twice because I hated it. When i found my passion in web, that's
all I needed. I learned AS3 and LAMP in a relatively short time; it was just a
matter of motivation!

------
blago
My school experience was almost the same with one awkward and notable
exception: writing a cache emulator implementing 3 different strategies for an
Operating Systems class. I still hurt when I remember the TA took points
for... indirection. Apparently an abstract C++ class with 3 subclasses was a
no-no in the OS world.

------
bijolianabhi
Completely true. The Professor can not make you to code.

------
billpatrianakos
The thing about coding is that you _have_ to be self taught. Languages,
techniques, and technology in general moves so fast that by the time you get a
degree everything you've learned as far as coding goes is already being
replaced.

I learned simple HTML when I was 11 and have been self teaching myself ever
since. I'm not in my second year of a degree in CS and what I've found is that
the language and the code itself is not important. What's important are the
concepts. Types, objects, methods, the theories behind programming, and all of
those less tangible things are what's important because that is the basic
foundation of programming.

Programming is different than other skills. It's as much of an art as it is a
science. The science is relatively unchanging but the art does. Your code is
always evolving and there's always the potential for you to make yourself
obsolete if you don't continue to teach yourself. I focus on the web and in
working in web design in particular I'm seeing a trend that speaks to the idea
that you must always be teaching yourself. There are oodles and oodles of web
design/development firms out there that have been around since the late 90's
that you can _tell_ have been around since the late 90's. Their work looks
dated in terms of design and their techniques look like they're right out of
1997! The guys working there used to be young and up on the latest trends but
it's obvious they've stopped learning and young guys are passing them up
easily. Even people with less than half their experience are writing better
code and have prettier output.

I think you can tell who got into programming just to get a job and who got
into it out of passion by looking at their work. If it continually improves
they've got passion, if it plateaus at a certain point then they're just
employed and nothing more.

In the end being self taught is a requirement and never an option in this
field. Once you have the foundational knowledge of programming then everything
else is just a matter of keeping up with new tech and learning some new syntax
every so often.

~~~
sounds
Counterexample?

I'm self-taught. I'm trying to filter for confirmation bias here.

I dated a girl (it was awesome but it didn't last) who was a C.S. grad student
but wasn't the type to "autodidact" at anything. She was also a stunning
musician, an entrepreneur, and an investor.

Ok, basically I'm trying to paint the picture of someone who is clearly my
superior in many areas, and understands C.S., but isn't self taught.

I couldn't pretend to know all the reasons, but she wasn't in it just for the
job or the money. She seemed a genuine hacker but just not in the same sense
as me.

~~~
billpatrianakos
I think you're misunderstanding me. I'm not saying that only self-taught
programmers are good. In fact I think it's extremely important to get that
initial education. I was just commenting on the fact that programming is a
field where you're forced to continually learn new things long after your
training ends. Your example is probably missing a lot of things. While I'm
sure she was a great hacker I'm willing to bet that she continued her
education on her own like all of us do. If you're programming then chances are
that you're learning things you weren't taught in school all the time. Given
that the industry changes noticeably between the time you enter a program of
study and graduate it's inevitable.

I also made another point about how some programmers never try to branch out
beyond what they're comfortable with coming out of the gate (i.e. they stop
learning) which could have made it seem like I was saying something else.

