The Magic Of Getting Started
The hardest part of any endeavor is often the first step. It can be difficult to know where to start, what to work on next, or how to stay motivated. But there are some simple tricks for getting over that initial inertia and starting down the road toward success. We'll discuss them in this informative post, as well as some tips for making progress day after day.
10 Things I Wish I Knew Before Getting Started (or Anywhere for that Matter) and then you can get started on the next thing...
Immediately after your first encounter with something (be it a bug, a feature request, or just a little thing in general), ask yourself:
1. "Is this something that I would enjoy enough to spend a few minutes on?"
2. "Do I have any idea at all what this is intended to accomplish?"
If not, move onto #3. If so, start making notes down what you learn along the way so you can be sure to hit those later.
As you are working, keep in mind that the second rule of programming is to write code that you would be happy to change the next day when you look at it again.
If you're mainly writing production code (where fancy features are not a factor) then this shouldn't be so hard to stick to. If it's starting to become more of an artistic endeavor (which I think most people start out as), then make sure that it's clear what your vision for the future is and what your goals are for each feature.
The biggest mistake I see beginners make is making a lot of changes without ever having thought through their long-term vision or goals. Make sure you know what you're trying to accomplish, otherwise it's just a lot of work for nothing.
When you're done with your first feature, go back and review the original requirements. Are there any other features that serve the same purpose that can be combined? Alternatively, are there some edges cases that don't really make sense now? (You can always fix stuff later if you have time.)
As with the first rule of programming, try to make sure that it's still understandable what was originally intended after all your changes. If not, feel free to refactor it back into shape by adding some documentation or comments explaining what your design decisions were.
Do this every time you finish a feature. If you have time, review the original spec and see if there's anything else it needs or anything that seems extraneous.
If you're like me, and you're usually working on a specific feature with some sort of deadline, then at least try to keep track of the core issues in the area that are preventing you from moving onto your next feature. If you have any time left over after finishing the first one, try to knock out a few of those so that they don't come back when your deadline hits again.
Make sure that every time you take a break (or go to sleep), you save your progress so far to source control. For example, I do this every day in my Rails work. I usually have a directory like "2008/05/30 FeatureList" with a simple YAML file, where I just store all the small things that are still left pending.
Git doesn't like to keep old revisions forever, so after three months you'll need to redo that entire branch from scratch if you want to roll back any older versions. Another way to save and restore older revisions is to use rubocop or part of a git-flow workflow.
I usually use my own personal Git-Flow workflows for every project (Ruby/Rails, PHP, etc.); they really help increase the predictability and reproducibility of frequent builds. After you've gone through the whole workflow once, you'll get familiar with doing each step in a different order than last time, and that makes it easier to get started each time too. If you're just getting started and don't have one already, there are plenty of tutorials out there.
I've written about this before, but I recently saw someone write about this a little more eloquently: http://www.devqueuentreprise.com/blog/2011/04/esquisse-une-methode-de-devops.html
The long and short is that you should have one place where you keep all your code, with multiple repos for each separate feature. It's essentially a little self-contained isolated world, and you can easily roll back to an older version at any time.
For a Ruby project, I recommend using git-flow , while for PHP check out the company I worked for: http://www.wakaleo.com/blog/.
For Rails projects, I recommend using Travis-CI to automate building and testing your code. Of course, this is just a nice way to check your progress if you don't have time to build and test daily. It's easy.
While it might be tempting to work on something that you think (or should) be high priority based on the number of bugs you see, remember that the real reason you're hiring people is so that they can do what they want with the code instead of what you want with it. You should never take the blame for their failures, but when they make things better you should always take credit for their successes.
Remember that no matter how hard you try, you will never understand what the other person is thinking. Try to always keep this in mind when standing in judgment of their work or asking them questions about their progress. Also, if you're having problems understanding something about a particular work item, make sure you ask for clarification as soon as possible before moving onto the next one because it's likely to come back and haunt you later.
As much as possible, try to keep all the code for a particular feature in together in the same folder so that you can easily find everything with one command (e.g., "git status"). If you're working on multiple features at once, that can make this even easier.
If you find yourself in a situation where you don't want to go back to something else in the future, but it's not really part of any feature that's been released yet, then put it in a branch and name it after the feature (e.g. "site_manager"). When ready to merge it into your main branch (and if your dev team isn't too anal about naming things after single-word nouns), run "git checkout master" and merge into master . That way you preserve the build history for that branch and can just merge once instead of doing a bunch of fancy git merges on each of your branches.
Conclusion
I hope you enjoyed reading this. I know it was pretty long, but hopefully the tips and tricks that I have given you here will help you maintain a high level of productivity and make your team look good in the process.
In fact, if you're looking for a team to work with to tackle your next software project, please let me know on my contact page! I'm sure we can find a great fit based on shared goals or our respective experience.
Please feel free to leave comments or ask questions below in the comments section or send me an email at support@devqueuentreprise.com .