Hacker News new | comments | show | ask | jobs | submit login
Codeacademy for competent programmers?
51 points by eluos 1706 days ago | hide | past | web | 35 comments | favorite
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.



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


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


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.


Care to suggest some books for 1.?


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.


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


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


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.


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.


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.


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


> They come with experience and a lot of practice.

Couldn't agree more. BTW, that's the reason why, contrary to popular belief, old programmers are often better than young programmers.


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


One of my proudest (and motivating) moments as a programmer was when someone forked one of my repositories.


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.


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


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.


Interesting.


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.


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.


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"


You can get that out of the Gang of Four book.

The problem is that until you're faced with a real-world software system with real-world problems - and in particular, faced with the consequences of your misuse - you'll be tempted to use them in places where they're not the best solution. It's one thing to read something in a textbook. It's another thing to wrestle with a million-line codebase and try to make sense of it.

Singletons, for instance, almost always turn out to be an antipattern in the long run. You're better off injecting your dependencies explicitly, even if you only think there is one in the whole program. Delegation is used all the time, but can also be overused, and it's important to know when you're better off modifying the original class rather than trying to wrap it with something else.


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


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


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.


I use these in objective C, I usually create a data object and stick the networking function in it as well. Some use core data, but I haven't found a need for it yet.

static MySingleton *sharedSingleton;

+ (void)initialize { static BOOL initialized = NO; if(!initialized) { initialized = YES; sharedSingleton = [[MySingleton alloc] init]; } }


+1 Informative. Thanks! :)


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


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


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.


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


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.


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.


Practice!


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




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | DMCA | Apply to YC | Contact

Search: