
Self-Taught Developers: Are You Missing Your Foundation? - nikosmar
http://www.javacodegeeks.com/2012/09/self-taught-developers-are-you-missing.html
======
crazygringo
You know, in years and years and years of programming, of applications and web
and back-end and front-end etc etc, I have never had a real-life use case for
Big-O notation, except in interviews. Nor had a real-life use case for caring
about sort algorithms. I mean, not _once_.

I'd say the true foundation needed is entirely different. Avoiding spaghetti
code, good refactoring practices, understanding when more architecture is
needed, avoiding premature optimization or over-architecture, concepts like
technical debt, writing code designed to be readable, how to establish
practices and standards and make sure they're communicated properly... These
are the kinds of things that actually matter in most projects.

(Obviously, if you're writing video codecs or kernel code, it's a whole
different story...)

~~~
fghh45sdfhr3
_I have never had a real-life use case for Big-O notation, except in
interviews. Nor had a real-life use case for caring about sort algorithms. I
mean, not once._

That is frightening. I can't think of any function I write without taking a
second to think about what the Big-O would be.

And I don't even know how I could do things like parse input without knowing
how to structure it so that look-ups never take more than log N time. And I
don't know how I could do that without knowing sorting algorithms intimately.

And I am not writing codecs or kernel code, mostly it has been high
performance and some soft real time, but I've also worked in back end web
development.

Everything in your second paragraph I fully endorse, but your first paragraph
is terrifying. I'm terrified I'll run into someone like you some day, clearly
smart, clearly experienced and without a clue as to why I'm concerned about
the Big-O of his implementation of something.

~~~
colkassad
Some people know the computational complexity of something they write without
knowing it in terms of Big O. Before my CS degree, I understood that looping
through a list and for each item, looping through the same list again was not
optimal. And someone only needs to write an O(n^3) algorithm once to realize
that it's a very bad idea for any but the smallest amounts of data. Knowing
about Big O is nice though, if only to understand documentation (realizing
that O(nlogn) is better than O(n^2)).

------
halgari
I've been programming professionally for about 8 years, and I'm self-taught.

To be honest, I've found that my degree carrying co-workers fall way short in
the basics. Perhaps it's just me, but my background in languages went
something like this: GW-BASIC -> QBASIC -> ASM -> C -> C++ -> PHP -> JS -->
Python -> Erlang -> Ruby -> C# -> Clojure. So for me, programming in C meant
that I had to understand linked lists and sort algorithms.

I've sat in in interviews before and asked candidates (with degrees and
experience) the difference between a dictionary, a hash-set and a list, and I
just get blank stares.

So no, I think it's more about the desire to learn. If you have a true
interest in Software Engineering, you'll teach these basics to yourself. If
not, then not even college will help you.

~~~
SamuelMulder
This.

I think most folks who truly master this stuff are self-taught, whether they
went to University or not. I got all the degrees, but I can honestly say that
I learned a lot more exploring on my own than I did sitting in class.

------
plinkplonk
What stops a self taught developer from also 'self teaching' the fundamentals?

Books and lectures (from OCW etc) have been available for years now. These
days you can go one step further by taking online courses with assignments,
exams etc from Coursera. All you need is motivation, and self taught devs
often have that in spades.

The real problem is that in most enterprise swshops/codebases, knowing (say)
algorithmic complexity is not very valued in terms of reward structure (though
it should be - I've fixed my share of O(k^n) horrors) and lots of people
_choose_ to go through life writing simple apps and stitching APIs together
(which is perfectly ok as a career choice if that's what floats your boat).

(Due Disclosure: I worked as an enterprise dev for a decade before I shifted
fields. I work on fairly large machine learning systems these days and let me
assure you that knowing algorithmic complexity analysis - and other things
like statistics and linear algebra - is a _basic_ required skill in this
world. Fwiw I am entirely self taught. My degree is in Industrial Engineering)

~~~
fghh45sdfhr3
_What stops a self taught developer from also 'self teaching' the
fundamentals?_

Just read through the many comments here the gist of which is: _Why would I
care about the difference between a list and a hash table._

A lot of people tend to assume hostile bias against knowledge simply because
they've been successful without it for a while.

~~~
columbo
> Why would I care about the difference between a list and a hash table.

> A lot of people tend to assume hostile bias against knowledge simply because
> they've been successful without it for a while.

I don't necessarily see it like that. My opinion is more along these lines:

> Why would I care TO STORE IN LONG TERM MEMORY the difference between a list
> and a hash table.

There are plenty of things I know I know, things I know I don't know and
things I don't know I don't know. The vast majority of my programming
knowledge resides in short-term memory; in six months ask me about Linked
Lists vs Array Lists and I will have forgotten the primary differences (fast
iterate vs fast insert or something like that)... I only vaguely know that
today because I was researching something.

The biggest challenge I see as a self-taught developer is I see everything on
equal footing. That means the basics (map, set, list) and the trivial (apache
config settings, tomcat's web.xml) tend to reside in the same heap and if I
don't think about one element for awhile it tends to get GC'ed. Since all of
my knowledge came from 14 years of on-the-job-training nothing was given
particular precedence, everything was important to the task at hand.

I believe that's really what frustrates self-taught developers. It isn't that
I don't know the answer, or that I'm hostile to learning new things (far from
it) it is simply that I never burned these fundamentals into my permament
memory. I've tried, but I tend to miss bits and pieces, for example, I needed
to refresh myself on autoboxing just a few weeks ago because I just haven't
_thought_ about it.

------
j45
Having a "formal" CS education, the only thing that keeps me current,
relevant, is being perpetually self-taught and self-directed.

Having and building this discipline is the single master skill that unlocks
everything else.

As soon as we think we're done, arrived, or have a "foundation", we're dead.
What we know today will be relevant in a different way tomorrow.

It's true there are intangible skills like design, usability and architecture,
but it only comes from building lots of small and larger software projects,
not in the classroom, textbooks, projects, or theories.

Algorithms are important, but I contest that the majority of web/mobile apps
don't even come close to needing premature optimization.

I wouldn't think twice at hiring someone who's self-taught and self-directed
over someone with a CS degree.

Why? Self-taught people seem to have more of a track record of things they've
built, instead of school projects on a resume. Self-taught programmers also
tend to like to build things customers like and focus on the customer a lot
more instead of optimizing their own world and tools.

I would definitely argue that the only thing that gets in the way of my
learning is my "education"

One handicap my CS education gave me until I realized it was the "start fresh"
syndrome. In CS you start pretty much everything from scratch, and think
that's normal. Get into the post-graduate world and scrapping existing
codebases isn't exactly normal, nor is always starting from scratch.

------
edw519
If "foundation" means:

    
    
      - learning many technologies, even the ones I'll never use
      - learning 100% of the syntax (10x what I'll ever need) 
      - being able to solve the same problem 5 different ways
      - learning slick stuff I'll never need
      - being able to scale to levels I'll never encounter
      - winning brogrammer arguments in on-line forums
    

then, yes, I'm missing my foundation.

If, OTOH, foundation means:

    
    
      - seeking solutions for problems, not problems for solutions
      - being able to learn whatever I need
      - being able to solve most problems with few tools
      - favoring action over status
      - living in the real world, using academia as a resource
      - having learned what really does and does not work
      - having raving customers who don't care what's under the hood
      - satisfying 100% of customers with 75% solutions
    
    

Then, yes, I think I'm just fine.

~~~
logn
What about being able to analyze efficiency (Big O), understanding compilers,
full understanding of computer architecture, realizing how the CPU executes
code, knowledge of advanced algorithms, knowledge of the OS workings, and AI
fundamentals? That's generally what I see self-taught people lacking, i.e.,
deep understanding of anything outside of languages.

~~~
mahyarm
You realize these pet topics are only 5 university courses. It would be a
intense 4 month semester, but it's workable.

    
    
      1. full understanding of computer architecture, realizing how the CPU executes code
      2. analyze efficiency (Big O) (a few hours), knowledge of advanced algorithms
      3. understanding compilers
      4. knowledge of the OS workings (often self taught out of necessity) 
      5. AI fundamentals (Admittedly a specialized topic)

------
afxjzs
For me, I think absolutely. Sometimes to the point where I don't consider
myself a 'real' programmer and feel like a faker any time I'm talking with
someone more skilled than myself. I've always been much better at just getting
things done than learning an entire catalog. Maybe it's because I spend half
my time in the design space, where I also have no training and also feel like
a 'faker'.

I've looked in various apprenticeships like thoughtbot's and others, but at my
age (30) I am not their usual target demo.

It's why I'm so grateful for hackernews. i learn a lot of great stuff here
from the 'real' developers that I can then apply in my day-to-day.

~~~
indiecore
>Sometimes to the point where I don't consider myself a 'real' programmer and
feel like a faker any time I'm talking with someone more skilled than myself.

<http://en.wikipedia.org/wiki/Impostor_syndrome>

<http://www.inc.com/magazine/20060901/handson-leadership.html>

~~~
hoka
interesting! As one of the top performers in my major as a senior, I think I
self-inflict this a little bit to keep myself sharp / hungry. Kids call me
crazy and say I've had all kinds of success, but I don't compare myself to the
apathy I see around me and putting a chip on my shoulder compared to 'elite'
devs has worked for me.

~~~
indiecore
Privately I think most people have this but don't want to admit it because
they think someone would call them out on it. From what I see/experience it
seems like the world mostly runs on people trying to impress other people
because that's the only validation for our own skills we get.

------
jeffreybaird
Self-taught developer here, I think the foundation is incredibly important if
you desire to advance in your career as a developer.

That being said, you don't need to know all that to get started. I probably
would have hated a CS program if I had tried it in college. Now, however, I am
completely fascinated by things that would have terrified me before.

There is a lot to be said for Just in Time learning as opposed to front-
loading your knowledge Just in case you need it down the road.

~~~
thedufer
Just In Time learning is perfectly fine, but there is a minimum of foundation
for you to even realize there's something you need to learn. I think this
article covers that pretty well.

------
gautamkumar
I consider myself a self-taught developer even though I hold a CS degree. The
reason is, what is taught in college is not always up the standard required by
the industry.

The only thing I learnt from college was the list of topics that needed to be
studied. I spent time learning those things practically on my own.

That was the thing that helped me land a job immediately after college.

So I would say that a college CS degree is really a subjective, It depends on
the person and the college.

Any self-taught developer who has the interest to improve him/her self can and
will learn the foundations eventually.

~~~
Evbn
The goal of a college education is to learn how to learn, so you can stop
paying people to teach you. Becoming an independent learners isn't in spite of
college, it is the goal.

~~~
gautamkumar
I wish they told me that in college ! :-)

------
oacgnol
I'm a (mostly) self taught developer but I have taken some software related
courses (assembly, C, data structures), so I have some semblance of a
foundation. Still, I constantly feel 'behind' in my foundational knowledge
compared to my peers because I majored in something other than CS/SWE.

That's why the rise of edtech startups have been of interest to me: online
courses like Algorithms: Design and Analysis from Coursera have been a
godsend, at least when I have the time and energy to do it. It's not easy
playing catchup with a full-time job, but there's even less time (and money)
for me to go back and get a degree in CS.

~~~
TheCowboy
"but there's even less time (and money) for me to go back and get a degree in
CS."

It seems like many don't understand that not having pursued a CS degree is
often a pragmatic one dealing with _money_ , not because self-taught people
are too lazy or unwilling to learn at a university level.

They have already obtained their degree and invested a lot of time and money.
Or they're far enough along in life where they're giving up a lot more than a
teenager or person in their early 20s if they take 4 years off to pursue a
degree full-time.

I think these are articles are useful for people who are learning on their
own, or who come from that direction. But if you're starting out at a self-
taught person, from my experience, no one seems to care if you understand
algorithms. You're better off building real things, and it doesn't seem close.

------
don_draper
Developers should know CS fundamentals

Developers should know security

Developers should know testing

Developers should know the business

Developers should understand marketing and SEO

Developers should should should. Everybody's different. Do what you need to
do. No one is going to be perfect at everything.

Here's my 'should advise': Developers should stop listening and executing
everyone else's ideas and execute their own.

------
RivieraKid
I'm about 90% self-taught, including the foundation. To be honest, university
is a waste of time for me. When I learn by myself, it's about 10x faster and
more effective. What is most important is experience and practical knowledge.
The good thing about university is that 1) I have lots of time 2) I find out
about stuff like boolean function minimization or state machines.

------
nyan_sandwich
At first I found the article kind of condescending. I was expecting something
I didn't know, instead:

>hey self-taught developers, here's all this totally elementary stuff that you
probably don't know.

I'm self taught, but I have a very solid computer science foundation because I
found that stuff interesting when I was learning. Looking at the other
comments here, I guess that's not the default...

~~~
JasonFruit
We're in the same happy boat. I think there are probably more in it, too, but
a lot of us have stopped thinking of ourselves as self-taught, because we've
been working at a higher level for a while. I'd bet that those who are less
interested in fundamental topics have shorter lifespans in the profession.

------
rickmb
As a self-taught programmer who started in the '80s, I definitely missed a lot
of foundation I had to pick up over the years. However, this was mostly on the
architectural level. As far as the more technical stuff is concerned, I was
lucky enough to start with C at a time where we still had to code a lot of
stuff by hand which is now taken for granted.

But realistically, this knowledge is rarely needed in most modern day
application-level programming. Many decent developers can not only get by, but
produce great applications without it. It's mostly a matter of the right
skills for the right job. And as always, just getting stuff done is the #1
skill.

------
agentultra
I learned everything I know from the streets.

Read the Hacker Ethic. As long as one is curious the information is there. Set
theory? Probability? Algebraic lattices and convergent data structures?
Monotonic functions? Cache registers and word alignment on some rare
architecture you've never encountered before? Need to know how to write a
compiler? I've learned some of this stuff and more on Usenet, web forums, IRC
chats, books; from github, bitbucket, CPAN, PyPI, quicklisp; and by going to
conferences, meetups, and even on the job. Academia is not the bastion of
Computer Science fundamentals.

As long as one is curious and has the intellectual tenacity to be critical
then there's nothing that the ivory tower can offer that isn't available on
the web, at your local library, and right on your damn computer.

We don't live in the dark ages. Why do so many Computer Science people insist
that only they know the true knowledge?

------
GFKjunior
Seems like these "missing foundations" can easily be remedied by reading a
couple of algorithm books.

~~~
sgtnotorious
You're right. You probably won't need to take any courses to learn all this
stuff - this stuff can be easily accessed online. It's definitely crucial for
all software developers to have this sort of CS background.

------
geebee
I'm somewhat "self-taught". I majored in straightforward "pure" math, with
emphasis on real analysis and abstract algebra, but I did take graph theory,
numerical analysis, and so forth - and the professors did include a lab
component that involved writing substantial amounts of code... so I'm not
completely self-taught.

That said, I feel that there is a gap because I didn't major in CS.

Although I had to read a textbook on Data Structures and Algorithms on my own,
I don't feel like this is a particularly glaring gap. Interestingly, my math
coursework _did_ cover a lot of the stuff at the _end_ of the algorithms book,
since I'd taken graph theory, linear and non-linear optimization, numerical
analysis. But I had to learn the basic data structures (trees, hashes, lists)
on my own. While it took some work to learn this, it came naturally enough,
because I consider data structures and algorithms to be very similar to math.
You could study this stuff without a computer and get a decent understanding
of it.

The big gap in my knowledge is more around compilers, operating systems, and
that elusive border between software and hardware. I never took compiler
design, and I think that languages are still a dark art to me because of it. I
think I also would have benefitted from doing some very low level programming
(when I was in college, "C" was still considered a "high level" language, but
at least I had to struggle with memory management). Also, a lot of data
structures that are optimized to interact with memory or hardware are still
pretty much a mystery to me. Obviously, without this knowledge, my
understanding of operating systems is going to be pretty limited.

~~~
textminer
Right on the same page with you. Mathematician by training, programmer by
youthful joy of building games and ELIZAs in QBasic, with some MATLAB/Python
in college. Lucky both things caught my interest when they did, it's made
breaking into Machine Learning awfully accessible as a post-university career.

(I still think there are dragons inside the CPU.)

------
cjdentra
Its a great question. I believe IMHO that ultimately it boils down to the
application; does it require computer science, some deep scientific
understanding, or does it require basic knowledge of a language? Are you
writing real-time Bayesian Learning algorithms for use on big data feeds for
example or a sign-up form for a web site? Do you need to have fine control
over where data is placed in memory so you can optimize performance
(C/C++...assembly even?) or do you not need to know anything at all about
memory management - and don't want to? There is a raft of questions like this.

Self taught programmers can write well but may be missing some of the nuance
for why things are done one way over another or maybe be missing some tricks
that save a lot of time. These limitations can be overcome by somebody
committed to writing good quality code.

------
robertjflong
I'm new to this site, but hopefully I can give some insight. I'm in Ireland
and I'm in my fourth year of CS, but I've also worked at some startups because
they frankly aren't mutually exclusive. I've had the pleasure of working with
both self-taught and formally-educated programmers, and when it comes down to
the daily grind of work the lines between us are pretty blurry.

What I'd _miss_ if I dropped out isn't any notion of a foundation, I'd be able
to get it all from the resources mentioned on this page. What I'd _miss_ (as
in, it's absence would sadden me) is being able to discuss compiler design and
other areas that may not be of interest to most working programmers with
respective experts in the field. I'd also miss the impact the piece of paper
would have on any potential greencard application but that's another story.

------
leothekim
A CS degree can differentiate you from someone who cargo-cults their way
through a software project. Sure cargo-culting can make the plane land once in
a while, but wouldn't you some day want to know why?

I started programming for a living before I got a CS degree. After I got the
degree, the biggest difference I found (aside from the really cool knowledge I
gained) was that I had a common language to use to talk to other people with
CS degrees and an understanding of common methods that I used to take for
granted.

Also, I appreciate the rigor behind a lot of CS fundamentals, and I believe
I'm able to teach myself new CS-y things more easily and do my job better as a
result. I don't think the CS degree is necessary, but I really really really
believe it helps you in ways you may not realize until you get one.

------
prpatel
These developers hit a wall quickly, and have to work harder (or just write
poorly thought-out/designed code) over time. That does not mean they are less
capable than classicly trained CS programmers; it just means they have to
overcome certain learning curves at a steeper incline. Saying this tho -
personality, drive, etc makes a huge difference and overshadows this argument.
Want to know how to optimize your website for a high-latency 3G mobile
connection? I bet that having eaten some TCP/IP 7 layer burrito will help you
in some way.

------
zmanian
What many self taught software engineers lack is the shibboleths of the
computer science community. The interview process at many large organization's
like Google and some startup's seem to use many of these factors like obscure
algorithim tricks to screen potential applicants. It is possible to pick these
things up on one's own but it makes to it more difficult to transition between
organizations.

------
flexxaeon
Agree. A lot of us self taught developers get started because there may be
something simple we want to do that requires a program, and can hack or
reverse engineer our way through it. But if/when we progress past hacks to
actually building applications, it becomes obvious (to the ones who care)
where a good understanding of the foundation is crucial.

The part about dismissing boolean logic really rang true.

------
dreamdu5t
No. What is up with college students thinking that Big O is some complicated
secret concept that only college graduates know about.

~~~
pheon
its the secret handshake that only CS grads know. If you cant` recite the CS
pledge then you must be lame..

------
pearkes
One of the biggest traps self-taught developers fall into is not recognizing
(seemingly) complex problems have likely been solved before.

A simple example in Python:

    
    
      for dog in dogs:
          print dogs.index(dog)
          calculate_dog = something_complex(dog)
    

vs.

    
    
      for i, dog in enumerate(dogs):
           print i
           calculate_dog = something_complex(dog)

~~~
sateesh
I don't see your example as a trap a self-taught developer would fall into.
The non-usage of enumerate just indicates that it is a code from some one who
has started with python and any self taught developer who groks pydocs would
eventually discover enumerate.

~~~
pearkes
I guess that's kind of my point - there's no motivation to grok pydocs,
because you don't realize there's a better way.

------
rsobers
Maybe. But 18 years in, it hasn't mattered yet.

------
CeRRuTiTo
If you are careful enough to learn the basics good and practice what you have
learned, there is not really anything that can get in your way. So it depends
on the person, but definitely working with more advanced developer can improve
your learning curve. ;)

------
EGreg
I think most developers are self-taught. Those college classes were okay for
comp sci theory perhaps. But for accomplishing real world tasks, I think I got
more from books and the internet and actual knowledge, than paying for a
course.

------
nomo17k
People forget the saying "school if what you make of." School is just a place
for facilitating the self-study of people by providing a guide devised by
people who have already gone through the joy and pain of learning.

------
boothead
IMHO (as someone with no programming qualifications at all) there's no such
thing as a developer who's _not_ self-taught.

You don't get taught anything (especially programming) you get out there and
you fucking LEARN it!

~~~
owenjones
In this context self-taught obviously means: didn't pursue computers in
secondary education. I've learned way more about development post college, but
I wouldn't call myself "self taught."

~~~
boothead
self-learned? :-)

------
gearoidoc
I'd choose to work with product developers than software developers anyday.

~~~
miahi
Can you give your definition for both these roles? I thought they are
different jobs.

~~~
gearoidoc
Software developers are concerned with making things "the right way" - eg. in
the article the writer speaks about choosing the right data structure,
algorithms etc.

Users couldn't care less about a perfect domain model, dependency injection or
asynchronous yada yada.

They care if it works and Product Developers know this.

~~~
fghh45sdfhr3
Imagine you have a web startup and as soon as people visiting your website
start coming with reasonably large data sets, your website becomes noticeably
sluggish.

And then a competitor pops up and they are dealing with the same sized data
blazingly fast, instantly from the user's perspective.

And you look into it and they are using the same technology stack you are
using.

It's at that point that you might start to care about the difference between a
linked list and a hash table.

~~~
mcantor
And at exactly that point (but rarely before), a good "product developer" puts
on his "software developer" hat, and executes his finely-tuned JIT learning
subroutine. He Googles "[framework] profiling", spends a week collecting
information, tracks down the bottleneck, makes a fix, tests it, evaluates the
new output, then calls it a day or repeats from step 1 until the issue is
resolved.

~~~
fghh45sdfhr3
Or a if you already know the difference you take a minute to look at the APIs
you are using and switch to the one which is implemented with a hash table
instead of a linked list. One minute vs. a week. A week here and a week there
adds up.

------
rjzzleep
no we don't, when I started programming in high school in my late i had a copy
of the dragon book that a RE friend told me about.

ops question would be better addressed if it addressed it's audience
correctly:

"Self-Taught Web-Developers: Are You Missing Your Foundation" - and again the
answer would be no. Since it's essentially a form of text processing we're
talking about. Entirely different audience/target/whatever.

There's also many many many algorithms books around these days. The average
web developer doesn't read them, and why would he?

Long story short:

Any headline which ends in a question mark can be answered by the word 'no'".

<http://en.wikipedia.org/wiki/Betteridge%27s_Law_of_Headlines>

