After going through my undergrad, I have noticed that over time you get a good feel on how strong a programmer the other students around your are. The brilliant ones are easy to pick out, they seem to do their own things, answer questions with responses that are usually full of jargon and tend to not worry about programing assignments. The latter is obviously the clueless programmer, they tend to ask pretty much nothing, usually always ask what the better programmers do, and usually have very limited understanding of what they're trying to code. Obviously there is a lot of people out there that fall in between the two, which brings us to the topic of this post. I've just kinda made this up but hopefully you'll be able to follow my thought process.
So how do you know how strong your programming kung foo is? Well, this is a hard question to answer so in order to answer it in the form of some sort of metric. I'll break it down to certain skills that I think make strong programmers.
Effectively Communicate Concepts and Ideas
- This is a big one, if you can't explain what you want to do to some one else, then there is little chance that you actually understand what your doing
- The benefits to being able to communicate well, I'd hope are obvious, but lets just go over a few reasons just for the heck of it.
- Helps when dealing with collaborative groups, that way everyone is on the same page
- Makes sure that you really understand what your talking about
- Helps you explain concepts to other would be programmers
- Communication is vague, so be able to explain your concepts and ideas verbally, syntactically, and is some cases graphically.
Debugging
- All great programmers, soon to be or otherwise must be strong in this "style of the programming art" in order to be successful.
- At some point in time as a programmer your going to make a mistake, actually who am I kidding your gonna make A LOT of mistakes and not all of them will be obvious so being able to debug not only teaches you to think through your code more often, it makes you learn from your mistakes, quite a concept huh?
- Bottom line is that most programmers do this intuitively with their code at the beginning usually with print statements or something. This will only work for a time, but true masters of the art use debuggers, such as ddd or GNU debugger for all of you GCC fans or the Visual Studio Debugger for all of you windows programmers. The ability to use these tools effectively reflect, your understanding of your code and the ability to gain a better understanding of what happens under the hood.
- "The path of the Debugging master is through patients and breakpoints."
Knowing your Structures and Classes
- I've tied these concepts together since, their both important to understand but most modern programming and development uses classes heavily
- You'll need them, USE THEM, but know why first
- Know the difference between the two, and when their used, in most cases when dealing with modern projects you'll be dealing with classes
- There is tons of literature on Classes and such so I'm just gonna say that you should do your homework on them so you know just how powerful they are
Understanding Pointers
- This one of the most straight forward concepts in programming and should be one of the easiest to learn but still leaves initial programmers in a frustrated state of uneasiness.
- When dealing with pointers you just need to think, " Am I dealing with a value or an address?". If you thought strays from that, then your not talking pointers any more.
Buffers
- Know why you need them and when to use them.
- Keep in mind, though buffers are generally a good idea they can be expensive if over used.
- Remember buffer overflows are one of the most common ways to break code, its sad but we live in an in secure world
Using Regular Expressions
- If you can't logically think out your logic then you've definitely lost your way.
- As a developer you'll be responsible for the back-end logic in your applications, just make sure that it evaluates out to what you think.
- Don't forget some times its okay to go simple, its never okay to go stupid.
- Don't forget it al boils down to TRUE or FALSE
- Just remember that FALSE isn't always 0 and TRUE isn't always 1
Testing
- Understand that testing and debugging are closely related but its worth noting since, not all testing deals with basic use and functionality.
- Testing is essentially the next step in debugging, essentially its finding and fixing bugs you don't know about yet. This gives a developer a good idea on how strong their design is and what can/could have been done to improve it.
- Remember this portion is often overlooked because of time constraints, both in the professional and educational world, so don't forget it's not enough to know that there is a problem but you'll need to make sure you have time to fix it.
Tips
* Know your tools ( Take the time to learn about how to effectively use your development environment, it'll save you lots of time in the long run)
* Tools don't do all the work for you, they're there to save you time
* Comment your code, I know it sucks but trust me its worth it in the long run and helps in maintenance. On that note, make sure that the comments are useful, try commenting about how your code segment relates to the big picture.
* Code defensively, expect the worst and try to a count for future problems and you'll spend less time wondering what happened (If done properly you'll know what caused your problem)
* Re-using code, this will save you time just remember with cut and paste that trouble usually follows, especially when its done blindly.
* Coding try not to get frustrated when dealing with problems, this usually what makes and breaks most would be developers. be patient you'll get it just give it time and avoid going in circles with your thoughts; they tend to be unproductive thoughts.
