
Codeacademy for competent programmers? - eluos
Where can a good programmer learn to be a great programmer? How does one go from a builder to a polyglot expert in design patterns, someone who makes beautiful, modular, maintainable code? A coder's coder.
======
nostrademons
Work with other great programmers. When you outgrow your current company, move
to a better one. When you outgrow your current team, move to a better one.

(BTW, "beautiful, modular, maintainable code" is _one_ skillset necessary to
be a great programmer, and a relatively minor one at that. Much more important
is knowing _when_ to write beautiful, modular, maintainable code, and when to
bang out a piece of shit that nobody will ever want to look at again, but will
quickly prove or disprove a hypothesis and let you know whether an idea is
worth pursuing.)

~~~
larsberg
> When you outgrow your current company, move to a better one

Preferably one with a formal, rewarded mentoring system in place that is
outside the management structure.

I'm sure they have this sort of thing at Google/Facebook/Apple, etc. as well,
but at MSFT I spent a bunch of my time finding technical mentors --- mostly
outside of my organization --- for my direct reports. Finding them is easy for
people with < 7 years of experience, but once you have > 13 years of IC work
(as more than five of my directs did!), it takes serious effort to both help
you identify a direction that it would be worthwhile to grow in and then find
somebody who can actually help with it.

------
adolfopa
While this is nothing new (it has been said a thousand times by now) you'll
have to:

1\. Read a ton of (good) books: this will expose you to new (and old) ideas
and techniques.

2\. Read a lot of code: this will expose you to good, bad and awful code. As
you suffer other people's bad ideas, you'll learn to recognize and avoid them.

3\. Practice, practice, practice.

About the #1 point, it's very important to read not only fashionable books or
things related to your immediate work. Try to be broad: read the classics,
even if their ideas seem outdated to you. Read about the history of the field
and the old programming languages and systems (you'll notice that things
haven't changed that much).

Also, try to learn a couple of languages that are really different from each
other. If you know Java, learning C# won't give you anything. Good languages
to expand your mind are: Racket/Scheme/CommonLisp/Clojure (DSLs,
metaprogramming, FP, OO, almost anything ...), Haskell/Scala/ML ("real" static
typing and FP), Smalltalk (like Java but fun!), Factor/Forth ...; explore a
couple of them and pick the ones that make you feel "weird": those are the
ones you'll learn interesting things from.

And don't rush: becoming a good programmer will take your whole life; but it's
fun and extremely rewarding.

~~~
phleet
Care to suggest some books for 1.?

~~~
adolfopa
For beginners, these are good:

\- How to design programs (<http://htdp.org>)

\- The Little/Seasoned/Reasoned Schemer.

\- Code: The Hidden Language of Computer Hardware and Software by Petzold

\- Coders at work by Peter Seibel

\- The Pragmatic Programmer by Hunt and Thomas

\- Code Complete by McConnell

For intermediate/experienced people:

\- Structure and Interpretation of computer programs
(<http://mitpress.mit.edu/sicp/full-text/book/book.html>)

\- Software Tools in Pascal by Kernighan and Plauger.

\- Programming Pearls by Bentley

\- Smalltalk 80: The Language and Its Implementation by Adele Goldberg.

\- Paradigms of Artificial Intelligence Programming by Norvig

\- A Discipline of Programming by Dijkstra

While I've ommited some important language specific books, and ignored
essential areas (algorithms, discrete math, hw arquitecture), I think this is
a good starting point.

------
exDM69
Quite simple: write more code. Go outside your comfort zone and do a project
that is unlike anything you've done before. Write an interpreter or a compiler
or an operating system skeleton or something else you've never done before.

And if you don't come up with an interesting learning project, you can always
learn new programming languages. I've found that the best learning experiences
have been the languages that least resemble what I use daily. I'm a C
programmer but for learning purposes I recommend learning a Lisp, ML or
Haskell and Prolog. An alternative to Prolog is going through the logic
programming chapter of SICP and writing your own Lisp-based logic programming
language and having fun with that (I actually used Haskell + Parsec to
implement a logic language).

------
abecedarius
Just one resource, but Peter Norvig's course
<http://www.udacity.com/view#Course/cs212> aims at this sort of thing. (I
helped a bit in preparing it.)

------
aniketpant
This is one of the worst kind of questions one can come up with.

It's absolutely impossible to turn an average coder into a great coder.
Because the things about code you mention in the question -

1\. Beautiful 2\. Modular 3\. Modular 4\. Maintainable

All of the four things above do not come by direct learning. They come with
experience and a _lot_ of practice.

I agree with the fact that you can make a platform to provide the user with
questions that will challenge him but still there will be a part where you
will give him some hints. And that will just spoil the entire working.

~~~
steam
Don't see why one would call it a bad question.

A bad question is one to which everyone knows the answer to (or everyone knows
that no one knows the answer to).

"It's absolutely impossible to turn an average coder into a great coder." -
Sorry all great coders were average at some point. No one is born great.

~~~
klibertp
I think what he meant is that it's impossible to "make" someone a great
programmer, as in "transform him by applying external force". If so, then I
agree - it's impossible to "teach" or "convince" someone to write for example
readable code, one must learn on his own through practice.

~~~
cloverich
I think you can turn an average coder into a good one. Just not a average /
good one into a great one.

------
SudarshanP
github. Write code that others would love to clone ;-). Fork other projects
and improve them to grok awesome ideas and practices. OSS in general not just
github...

~~~
nnythm
This is good advice. Another good tool to better yourself is reading code.
This lets you think about why people have written code the way they have, and
whether you agree with how they did it.

------
Jemm
I love that not one comment mentioned post graduate university as an option.

~~~
geofft
Why would it be? Grad school is great for learning to be a better researcher,
to understand problems better, and to write a bunch of crappy code that nobody
else will ever use that you yourself want to never touch again after your
paper gets submitted.

In other words, grad school will help a good scientist become a great
scientist, but it will not help a good programmer become a great programmer.
In other fields the same is true -- it will help a good architect become a
great architect, but it will not help a good bricklayer become a great
bricklayer.

~~~
Jemm
Interesting.

------
geofft
Find some good-quality open-source project and get involved in it.

This has two benefits, and the primary one is that it gets you _reading_ good
code. The second benefit is that, if the project is any quality, it forces you
to write good code, both because of the project's standards and because the
software is well-designed enough that the easiest thing to do is to make new
features match that good design.

------
gersh
Read good code, and think about how they've done it. Read all the major open
source projects. Really try to understand how different people organize
different types of projects. Learn different programming languages, and learn
how to code in different styles.

~~~
eluos
I feel like higher level organizational stuff could be taught in a codeacademy
like format. Just simple lessons for different design patterns:

"This is the delegation pattern, we use it to _________" "This is a singleton
method, it's best used for ____"

"Create an MVC structure using the strategies we discussed"

~~~
klibertp
Singleton method? I'm admittedly not a DP geek, could you please tell me what
it is used for and point to example reification(s)?

~~~
wsc981
Just yesterday used a singleton in Objective-C due to a webservice that worked
with a challenge-response system. Whenever I perform a request, I receive a
code. The code is required in the next request to retrieve the data. The issue
I was having, was sending lots of requests in different threads; this could
cause a code retrieved in a previous request to become invalid, making an
older request for data fail.

I figured that by creating a singleton class responsible for executing
requests sequentially, this problem would be fixed (and it did). This
singleton class internally uses a FIFO-queue to execute all requests
sequentially. I think it was an appropriate solution, especially since this
singleton class is used internally, not exposed through interfaces to other
classes interacting with my 'framework'.

~~~
klibertp
I have nothing against singletons! (I'm referring to your somewhat defensive
"I think it was an appropriate solution, especially since this singleton class
is used internally,...")

I was just curious about what 'singleton _method_ ' meant, as opposed to
'singleton object'. Sadly, it seems that it would be very hard to implement
something similar in Python (my main language at the moment) without creating
a metaclass. But I certainly saw this pattern in Smalltalk before, just didn't
know how it's called.

------
ludicast
As far as online stuff goes, I can't recommend codeschool enough. Really
kicking myself that I didn't contribute to their IOS Kickstarter (good excuse
- I planned to yesterday but I forgot I was having surgery :)).

You really would do well to subscribe, bang through their
javascript/coffeescript/git stuff and if rails/ruby intrigues you stay a
while. Otherwise cancel your subscription (they are very rails-centric so
there will be a continued focus on that I believe) and just go forth from
there.

Not to throw conspiracies out there, but I think they are suspiciously un-
emphasized here a lot because they are competitors of codecademy with a better
product...

~~~
ludicast
and obviously, it wouldn't hurt to get a short-term programming gig to get
going with stuff.

------
TheMiller
Lots of ways to learn. Aside from what others have already mentioned, work on
a lot of existing code. This can be others' code, or code you wrote yourself
months or years ago. Whether you're fixing a bug, or adding an enhancement, or
just trying to clean it up and make it better, stop and ask yourself
occasionally: What made this difficult to understand or modify? How could it
have been organized better? The other sources (books, courses, etc.) provide
starting points for answering those questions but you need to apply that
knowledge to real code, to test it and learn where it does and does not apply.

------
ozne
I think you should pick a technology you want to learn, get a book or two, and
create actual solutions using those technology's.

<http://www.safaribooksonline.com/> This site is awesome for computing
information, its about $10 per month and you can read 5 books per month. Books
in general give you a more comprehensive understanding of the subject.

Amazon top sellers lists for programming category's are also worth looking at:

<http://goo.gl/L0lZ3> <http://goo.gl/ptZCN>

------
douglascalhoun
I'll throw in another one: screencasts.

Peep Code, Destroy All Software, Railscasts... It's like watching over the
shoulders of some of the best programmers in the world as they teach you
everything they know.

------
redsquirrel
My advice to a good programmer who wants to be great is to spend as much time
with great programmers as possible. Consider an apprenticeship program, or
create your own apprenticeship with mentors, conferences, tons of practice,
and tons of reading. If you're already good, everything you need to be great
is accessible and cheap, you simply need to focus your efforts and work hard
at learning to be great.

------
kellros
Practice!

------
davidjnelson
Write failing tests first. You will be amazed by the quality and lean nature
of the code you create to make the tests pass.

