I have been coding for a while now and am confortable with a few programming languages but now feel that I need to improve my problem solving or program design technique.
What skills do I need have to be able to design a program as a solution to a problem?
More: The question is about how to design a solution rather than how to code better.
For Starters I would suggest reading Steve McConnell's book "Code Complete, 2nd Edition"
Keep a list of all the issues you or others have extending or maintaining your code.
Regularly go through that list and sort it by the amount of difficulty. Then, create or find practices that minimize the difficulties and make those into your ever-evolving list of "best practices".
There are many different approaches/tips.
Books. The design by patterns, elegant design, etc, some apply to software others to how engineering problems where solved in general.
Code code code. Code for fun, code just for the sake of coding, take a problem that has ABSOLUTELY nothing to do with work, and just code at it (on your own time of course). You will end up solving the same problem in multiple ways, and hopefully start to look at problems differently. Or we could say "thinking outside the box".
Rise to the challenge. When you come across a problem that the only solution you can come up with is "ugly" or "dirty". Rise to the challenge of finding an elegant solution. Elegant solutions are 90% obsessive compulsive, 10% sadistic, at least when you start out.
Don't be shy to ask questions. I think you may have this one down. So just keep asking questions.
For problem solving technique, look at how other people have solved problems. I recommend The Algorithm Design Manual and Algorithms in a Nutshell. Both of these books take you from a problem statement through several iterations of solutions to show you the thought process, rather than going directly to the final solution.
The most effective solution I've found is to find a problem and attack it. Start with small problems and work your way up. If neccessary, create problems (though not at work, and certainly not on a primary branch).
Once you understand the problem, try to figure it out yourself. If you fail, Google the sh*t out of it. Even if the first hit on Google fixes your problem, look at the other ones anyway. it will help provide you with an understanding of the problem-solving process and how peoples' minds work.
Talking about books, I suggest this great one, by Martin Fowler
Read about data structures and algorithms. I put data structures first because the longer I'm in the software business, the more I realise it's really about data structures. Show me your data structures and I can probably guess your algorithms anyway. You need to understand how selecting the right data structures can make or break a system, and how to decide between them. I suggest reading about algorithms because some algorithms are very counter-intuitive, and you're unlikely to discover them for yourself when just noodling around with a problem. Sedgewick's algorithm books are quite good, if they're still in print.
Code complete is an excellent book (worth the price for the chapter on optimization - "code tuning" - alone), but for design... I'm not so sure. The second edition may be better on this, I only have the first... and its getting very dog-eared by now :-)
I am amazed at how many people suggest code complete or other books. In my experience people make bigger leaps/gain skills by working with other more experienced developers. A mentor/apprentice model works great here. The two work together with the mentor guiding decisions, but working through all the issues to help the junior person understand.
Seeing a master in action and how they work and what they think about is a great way to learn. Additionally, if people have different ways of working or thinking they get to see other viewpoints/aspects of doing the job/work.
IMO nothing can match the mentor model. Doing lots of coding and designing is also a way to get it, but you don't get that help that is so crucial to standing on the shoulders of others.
In my opinion the best way from intermediate to advanced level is:
Read good code written by other people.
You need to have a grasp of the basic theory first, of course. But there's a point you can't get past by just reading theory. Moving on from there requires a lot of work, and that means practical experience reading and writing code.
Start playing around in languages different from the one you are using now. And with that I don't mean to start using Java as a .Net developer.
Pick a language that you would not consider using in a production environment. A language that works totally different and has for some reason a devote following. Lisp comes in mind here.
The idea here is that you start using a language that will change your way of thinking. Sometimes you need to hit your rusty gears with a big sledgehammer to get them turning again. A weird language might turn out to be this hammer.
Find a mentor - someone who has worked in your particular problem domain many years - and learn from them.
My best code comes from peer reviews, formal and informal. Reading books and learning about design patterns is great - but the best feedback is when someone can point directly at the code you're working on and say "You need to change this, this and that."
Specific, constructive feedback from your peers is immediately useful.
Reading and talking about it will help. Experience is great too (assuming that your not just re-enforcing bad habits).
A mentor is best.
In absence of that, write something, then delete it. Then write is again a couple of days later.
Sounds weird, but the second time around, you'll do a much better job :-) Like ants, we our lines get straighter the more we travel over the same path.
Paul.
I think you will enjoy Programming Pearls. It's very readable, chock-full of tips, and gave me a lot of insight on how to approach problems.
Also practicing on a class of problems repeatedly until you begin to recognize its patterns and characteristics. Online judges such as SPOJ are good for this.
I was also required to take an introduction to design and analysis of algorithms course in university. Like others have mentioned, having somebody more knowledgable like a mentor can save you a look of time and grief when you get stuck. But for me just being able to discuss and my thoughts with people like my classmates forced me to think more carefully.
Now if only I knew what that Donald Knuth guy is smoking....
use the great library of open source projects like source forge or google code. try to implement a piece of one of those projects and then compare. figure what is better in each design. learning is investigation that leads to discovery.
sorry acccidently send a duplicate answer, haven't figured out how to delete
use the great library of open source projects like source forge or google code. try to implement a piece of one of those projects and then compare. figure what is better in each design. learning is investigation that leads to discovery.
1) Read as many books as you can.
2) Study as much open source code as you can.
3) Code, code review and do pair programming as much as you can.
good luck :)