WingedPanther

One of the things I'm always looking to do is increase my programming skills. What I find interesting is how the focus of that improvement has changed over the years. I'll try to trace through the areas of focus, and why I believe they require a change in perspective for each one.

The most basic level is to learn procedural programming. It doesn't really matter whether it's Java, C, C++, Pascal, or something else, almost everyone is first a procedural programmer. Every method in OOP is procedural. We learn the basics of loops, decision structures, and function calls.

Once that is done, OOP and generic programming become available. Of course, simply wrapping things in classes isn't the heart of OOP, but it gets you started. Functional programming is a different approach, as well. At this point, regardless of which direction you take, it's about learning different ways to look at data and function calls.

These are all basic skills. They deal with structuring valid code to perform obvious calculations and manipulations. The next level is using them well. There are several areas involved.

One key area is algorithms and data structures. This is where code efficiency comes into play. It's not enough to have code that works, it needs to be efficient. In addition, this is where we start looking at creating new types of data that are more powerful than the primitives such as integers, floats, and arrays. It doesn't really matter whether it's wrapped in procedural or object-oriented techniques, it's the start of building more significant types of data.

A different area is focused on how to exploit OOP techniques. Inheritance and polymorphism are the real keys to object-oriented programming, but it isn't always obvious how to exploit them well. Just as data and functions are less efficient than data structures, simple classes are less effective than carefully exploited inheritance and polymorphism. The key, here, is defining an interface and then letting the implementation be highly variable. There are design patterns to exploit this in a variety of ways.

While data structures and design patterns help you to get more out of your language, their is still another level you can go to. Along with being skilled at exploiting your language, you also need to be skilled at exploiting your time. This is where you change yourself. There are a lot of buzzwords that all try to grab this concept; things like Extreme Programming, Refactoring, Pragmatic Programming, Test Driven Development, etc. All of these are describing related concepts: program smarter, not harder. A lot of this involves learning to assume you've made errors, and finding ways to detect those errors quickly, along with working on your code in ways that minimize the likelihood of making those errors in the first place.

In addition to detecting bugs as quickly as possible, it's also important to be able to use your tools effectively and efficiently. Your tools include a variety of things, such as choice of language, choice of editors, and how you generate your code. As an example, when I code in Lazarus, I use both the native editor and jEdit to manipulate the code. They represent two different mechanisms for working with the same information, and each provides different techniques for getting the results I want quickly.

This list represents the path my learning has taken, and the state of it right now. The unfortunate reality is that I don't know what I don't know. I do know that I am limited, and still have things to learn. Everything you do as you learn needs to be focused on becoming a better coder.