How does a fresher with a clean slate turn into a good programmer? [closed]

Question

As a graduate fresh out of college with a clean slate, how can one go about being a good programmer who writes good maintainable code? How does one learn good coding practices and apply them? Can one get these skills by reading any specific books on Software development or is it something that comes purely from experience? (I don't like to believe that it's purely experience based since I see people here complaining about bright co-workers with years of experience writing bad code). What are some suggestions on getting good at writing clean code?

Passion and ability are assumed.

Answer 1

If nothing else, learn to write lots and lots of good unit tests. If you can prove that your code (good or bad) does what it's supposed to, you're 90% of the way there. Tests document what you code is supposed to be doing. Moreover, they allow you to safely refactor your code when you discover a better way to do the same thing. The tests will show that you didn't actually screw things up.

So start learning about unit testing in whatever language you'll be coding in.

You should probably take a look at Code Complete as well.

Answer 2

You've got to have the desire to write really good code. If you have that desire, it will come with experience. I think the key is to surround yourself with other good programmers. If you're lucky, you'll find a job that has the sort of programmers you want to become yourself. If not, be active in a programming community (SO, USENET newsgroups, local SIGs, etc).

Most importantly, make sure other people see your code. If you work in a company, ask senior developers whom you respect to do code reviews. Also, work on an open source project or create one yourself. When you write a line of code knowing that many smart people will read it, it can act as an incentive to write better code.

Finally, don't equate "clever" with "good". Really good programmers rarely write clever code. The goal is to write code that a) works, and b) is as understandable as possible. "clever" usually runs counter to that second point, so don't try to show off with fancy bit manipulations or obscure constructs, or saving an extra byte or two in a data structure. Stick to the fundamentals and write code any good programmer can read.

Answer 3

In addition to what others already suggested, though quite unpopular: work, at least partially, on maintenance tasks, if that is an option. And yes, that's maintenance for code written by someone else. Often no fun, but quite an experience. There you see why and how things done by smart programmers go wrong, don't scale, whatever. You'll get to see those parts of the code which are actually run in the real world at customer sites and which need improvement and you may get the opportunity for direct customer contact.

It is my experience that colleagues who come from university/college and start immediately in development projects without working on maintenance task quite often write code which can not be reasonably maintained.

Answer 4

The #1 thing either you have it or you don't have it, and that's brains.

The #2 thing also either you have it or you don't have it, and that's passion.

The rest are in no particular order:

• Work together with experienced people
• Find books widely acknowledged as good and read them
• Experiment with programming on your spare time (comes with passion)
• Do not let girls, drugs, alcohol, and generally 'being cool' distract you.

(Well, I take back the thing about the girls.)

EDIT I just thought of one more thing to write, which addresses the issue of writing clean code in a more direct way than my other recommendations; who knows, it might appease our anonymous downvoter, in case their downvote was for being off-topic.

Try to write software systems whose complexity lies not within the code, but within the design. What do I mean by this: any program represents a solution to a problem. The complexity of the solution usually (granted, not always, but usually) depends on the complexity of the problem. An overly complicated solution would constitute overengineering, but an overly simple solution would be inadequate. (As Einstein said, things should be as simple as possible; but not simpler.)

Now, there are two ways of putting all the necessary complexity into a program: you can either have a monolithic (very simple) design which "just does it" with lots of complex code and tricks and hacks, or you can have an elaborate (complex) design which closely models the problem and consists of lots of bits of very simple, very straightforward, I could even say boring, code. Always prefer the second. That's what we call clean. (This was just an elaboration on @BryanOakley's statement about clever != good.)

Answer 5

Learn how to listen, communicate, learn, and keep learning.

The reasons why many intelligent programmers write bad code are legion (misunderstood requirements, misunderstood technology, poor focus, just having a bad day, ...).

The best way to learn how to be a good programmer is to be able to listen to others, communicate back to them to learn from the experience and not stop learning.

Now, some of the things you need to learn are technical, but many will not be technical but softer skills about how to deal with peers, customers, marketing, and managers (etc. etc.).