While many of you are great software developers, you can always use a boost in speed! Here are some tips that I try and instill in my software development team.
Learn the Keyboard Shortcuts
The mouse was one of the greatest inventions to come out of Palo Alto, however, it has made some of us a little too dependent on this great little invention. How many times are you moving it around to find the file menu, or the tools menu, then moving along to find something else? All this time can be saved by using the keyboard shortcuts. Depending on your development environment, you should really make an effort to learn to do everything with your keyboard.
One way to do this, is set aside an hour when you will only use the keyboard to do your development. This means no mouse movements or help from your little friend at all. If you can train yourself to use your keyboard for most things and your mouse less, you will become extremely fast at development, and will be labeled the keyboard cowboy at your office.
Remove Unnecessary Dependencies
As your software expands and grows, the build process will start taking longer and longer. This will start affecting your productivity by making you sit there and wait for things to finish. A large part of this process is caused by dependencies that are not needed. Make sure you clean them up. There are a lot of great tools to help you with this process, suggesting and guiding you along the way.
Make sure you research these tools, but at the end of the day, just make sure you keep things clean on your own. By removing these unwanted and unused dependencies, you will notice a huge improvement in speed of build, and even the overall software application.
Setup a Continuous Integration Build Environment
This tip will speed up your development time astonishingly! One of the areas that always takes the longest is the code integration between different pieces of code, and different developers. Software developers go and develop some great pieces of the software, time comes to put out a new version of the software, or a patch, and everyone scrambles to give the build master their new code files.
Poor build master tries the build, and everything fails. The software development team then spends the rest of their time for a week making sure everything works well together, and compiles. Then come all the bugs, and it’s just a bad situation all around. Setup a continuous integration build environment and enjoy the process of builds!
Put Source Control in Place
Source control is extremely important to any project, without it, you are going to develop slowly. Period. I’ve talked about this before, because it is extremely important. It’s the foundation to your project. Even if you are coding a small project, make sure it’s in source control. Source Control will enable you to have a history, a journal, of you project.
Let’s say at some point someone wanted to roll back a certain screen to a previous design, or worse yet, a huge bug was found with the current version. What do you do? Well if you don’t have source control, you are in big trouble.
Write Unit Tests
By adding test cases to your software development, you will speed yourself up by not allowing things to be changed. In a future article I will explain the best way to create these unit tests, but here are some of the basics for those of you that have heard about unit tests, but haven’t had time to implement them into your software development lifecycle.
There are a few common types of unit tests you will want to start with: Validation, Bad Input, and Code Path unit tests. The main idea here is you will be writing these automates tests, that will run every time you check in new code, thanks to our source control and automated build environment combination we setup in the previous steps.
Remember the golden rules: If it’s broken, fix it! If it passed, and it still broke, create the unit test. If it’s hard to write the unit test, make your code easier to work with. If you need to do setup before executing the test, do not copy paste from the application.
Use Code Coverage Tools
Code coverage tools are fantastic and go hand in hand with unit tests. If you want to know how much code your tests really exercise, or want to ensure that the outsourced code is tested, code coverage tools are for you. Code coverage tools will allow you to understand what parts of your application are well tested and what is not tested. Some of the best tools out there not only measure line coverage, but also measure branch & statement, and methods.
Become One with the Debugger
Becoming a debugger master will really speed things up for you. I’m not going to spend a lot of time on this as its very basic, but it is far to important to not mention. Learn all the basic and advanced features that are available to you in your debugger. Breakpoints, Watches, and Stepping will save you countless amounts of time.
Write Reusable Code
When you are writing code, don’t just write code for the problem at hand. Write code for thinking about the future! Create classes, and put things together into reusable custom frameworks and libraries. How to write reusable code is another article, however just make sure that each of your classes or methods does one thing. Try and reduce the coupling in your code. Lastly, make sure you are always thinking “modular”.
Take Advantage of Frameworks
There are hundreds of thousands of frameworks out there for you to use. Pick one that suites your needs, and use it. The main reason for the creation of software development frameworks is to allow software developers to focus on the software requirements, and less time on the low level details. There are a slew of excellent frameworks out there, pick the area you need, select a framework, and you are off to the races.
Ensure Proper Testing and Quality Control
Do you have bug tracking software? Do you have a process that works for finding bugs, reporting user issues, logging all feature enhancements? If you don’t, chances are you will be spending a lot of your time trying to keep track of all of these times. Set yourself up for success. Invest in some great bug tracking software. Some of my favorites are Joel Spolsky’s FogBugz, and Axosoft OnTime.
I love tools, and over the next few weeks I will start sharing with you some of the tools that we use to make our developers fly through the software development lifecycle. Stay tuned.