Improve your Skills as a Programmer
Programming is one of the most versatile skills on the market in this age. From being able to create company websites to knowing how to easily fix a redirecting error, these skills can be invaluable to an employer and yourself in many ways. However, staying the way you are will never let you be the best Programmer you can be, read on to learn how to improve your skills as a programmer.
Steps
- Analyze the problem clearly.
- Think twice about how to solve that problem.
- Gather complete requirements. Take the time to write down what goals the end product needs to achieve, and who your user base will be. Clarity of thought at this stage will save a lot of time down the line.
- Write a thorough implementation plan (or model).
- For something small and self-contained, this might be just a basic flowchart or a simple equation.
- For larger projects, it helps to break the job into modules, and to consider the following:
- What task each module must perform
- How data gets passed between modules
- How the data will be used within each module
- Although gathering and planning requirements can be tedious and much less fun than diving straight into coding, it is even more tedious to spend hours debugging. Take the time to design the flow and structure of your program correctly up front, and you may even spot more efficient ways of accomplishing your goals before you write the first line of code!
- Comment your code liberally. If you think that your code might need explanation, comment it. Each function should be preceded by 1-2 lines describing the arguments and what it returns. Comments should tell you why more often than what. Remember to update the comments when you update your code!
- Use consistent naming conventions for variables. It will help you keep track of each type of variable, and also what that variable's purpose is. This means more typing than simply x = a + b * c, but it will make your code much easier to debug and maintain. One popular convention is Hungarian notation, where the variable name is prefixed with its type. For example, for integer variables you might use intRowCounter; strings might use strUserName. It doesn't matter what your naming convention is, but be sure that it is consistent and that your variable names are descriptive. (See Warnings below).
- Organize your code. Use visual structures to indicate code structure. For example, indent a code block that sits within a conditional (if,else,...) or a loop (for,while,...) Also try putting spaces between a variable name and an operator such as addition, subtraction, multiplication, division, and even the equal sign (myVariable = 2 + 2). As well as making the code more visually elegant, it makes it much easier to see the program flow at a glance. (See tips on Indentation below).
- Test everything. Start by testing each module on it's own, using inputs and values that you would typically expect. Then try inputs that are possible but less common. This will flush out any hidden bugs. There is an art to testing, and you will gradually build up your skills with practice. Write your tests to include the following cases:
- Extremes: Zero and beyond the expected maximum for positive numeric values, empty string for text values, and null for every parameter.
- Meaningless values. Even if you don't believe your end user would input gibberish, test your software against it anyway.
- Incorrect values. Use zero for a value that will be used in division, or a negative number when positive is expected or when a square root will be calculated. Something that is not a number when the input type is a string, and it will be parsed for numeric value.
- Practice, practice, practice. Programming is not a stagnant discipline. There's always something new to learn, and - perhaps more importantly - always something old to relearn.
- Be prepared for change. In a realistic working environment, requirements change. However, the clearer you are at the start about the requirements, and the clearer your implementation plan is at the outset, the less likely it is that changes will be the result of poor planning or misunderstandings.
- You can take an active role in improving the clarity of the process by presenting your requirements documentation or your implementation plan well before beginning to code. This will help to ensure that what you are planning to create is actually what's been asked for.
- Structure the project as a series of milestones with a demo for each block, and manage the process one milestone at a time. The fewer things you need to think about at any given moment, the more likely it is that you will think clearly.
- Start simple and work towards complexity. When programming something complex, it helps to get the simpler building blocks in place and working properly first. For example, let's say you want to create an evolving shape on screen that follows the mouse direction, and changes shape depending on mouse speed.
- Start by displaying a square and getting it to follow the mouse; i.e., solve movement tracking alone, first.
- Next, make the size of the square relate to mouse speed; i.e., solve speed-to-shape tracking on its own.
- Finally, create the actual shapes you want to work with and put the three components together.
- This approach naturally lends itself to modular code writing, where each component is in its own self-contained block. This is very useful for code reuse (e.g. you want to just use the mouse tracking in a new project), and makes for much easier debugging and maintenance.
Tips
- Use an IDE (Integrated Development Environment). A good IDE will have a colour-coded editor built it, with code hints and code completion functions that make editing faster and less prone to spelling mistakes. It will usually feature debugger, as well.
- Have fellow programmers read your code. They may well know something that you may not have thought of before. Don't know any professional programmers? Find an online forum that's dedicated to your chosen programming language or operating system and join in the conversation.
- If you go down this route, read and observe the forum etiquette. There are a lot of goodhearted experts willing to help out, if asked nicely.
- Remember to be polite, because you're asking for a favour. Don't get frustrated if you don't understand everything at once, and also don't expect them to want to review 10,000 lines of code. Instead, ask simple single-focus questions and post just the relevant 5-10 lines of relate code. You're most likely to get a positive response that way.
- Before you start posting, do a little research. Your question has almost certainly been encountered, considered, and solved already.
- Studying the source code of other programmers is an excellent means of improving your own skills. Work your way through their code, step by step, working out the flow and what happens to the variables. Then try to write your own code to do the same thing (or maybe even improve on it). You'll quickly learn why things need to be written a certain way and you'll also pick up some useful tips on how to write efficiently.
- Customers and bosses aren't concerned with how your program works nearly so much as they are with how well it works. Think bottom line. Clients are intelligent, but busy. They won't care what kind of data structures you're using, but they will care if it noticeably speeds up or slows performance.
- Tutorial sites are an excellent resource as well.
- Make regular backups of your application code onto another hard drive or portable device so that you will have a copy if your computer dies or becomes unavailable. Keep at least one copy in a secure place.
- Keep your code visually elegant, not because it's pretty but because it makes it easier to read. This is essential when you want to make changes six months down the line. Read more about code indenting.
- After each bigger segment of work, take a break, do something unrelated, then review what you have written with a fresh mind. Rethink and rewrite it, making it more effective and elegant by using less code.
- Find an editor that uses color-coded syntax highlighting. It really helps to separate comments, keywords, numbers, strings, etc.
- Change one thing at a time when debugging and then test your corrections before moving on the next item.
- Use version control management. Tools like CVS or SVN make it easier to track code changes and bugs.
- Double check spelling and syntax. Even the slightest of mistakes can cause a great deal of stress.
- Keep archival copies of your past work. It's not only a good point of reference, it also may have bits of code that you can re-use later.
- Use a debugger tool instead of placing statements in your code to display output variables. A debugger tool will let you step through your code line by line so that you can see where it's going wrong.
- Talk to other programmers. People can often be a good resource for information, particularly when starting out. Find out whether there's a group of programmers who meet up locally, and join the group.
- Start small, aim for things that you will most likely be able to achieve, and work your way up.
- Separating (packaging) your reusable code from your application-specific code will, over time, lead to a large, debugged, and reusable library full of handy utilities. This will aid in writing more powerful and stable applications in less time.
- A good way to both save your work often and keep a physically separate backup is to use a versioning tool like git or mercurial and a free hosting service like GitHub or Bitbucket.
Warnings
- Copying and pasting others' code is generally a bad habit, but taking small portions from an open source program can be a good learning experience. Just don't completely copy a program and attempt to take credit for it. Don't copy code from another program unless you have permission or the license permits.
- Save your work frequently as you go along or you risk losing hours and hours of work to a computer crash or lock-up. If you ignore this warning now, it's a lesson you will definitely learn the hard way!
- Hungarian notation (indicating a variable's type as a prefix) should be used with caution. It can lead to inconsistency when edited, or particularly if ported to another language or operating system. It is of most use in 'loosely typed' languages that don't require you to pre-declare the type of a variable.
Things You'll Need
- Computer
- IDE (Integrated Development Environment)
- Reference books or web tutorials
- Advanced API knowledge and/or Simple i86x architecture knowledge
Related Articles
- Add Comments in Visual Basic
- Learn a Programming Language
- Create a Simple Web Page With HTML
- Become a Programmer
