Are we there yet?
Not quite, but we’ll get there. As much as we’ve been working in order to make our software better, we only ever work on one thing at a time. Never do we stop and think how we could combine everything we’ve learned through years of education into a single process that we can reuse to write great software consistently. Well, today we will create a recipe for success.
We’ve all got lots of techniques and ideas tot create good software, but rarely do we ever use them together. We should all learn how to take all the individual things that we know how to do and creating a recipe that we can reuse so that we can tackle even the trickiest of software problems that we could ever encounter.
Create a features list
Features list help you understand what your software is supposed to do. Remember that features reflect functionality, so they will come in handy once you get your hands into creating actual code.
Use case diagrams
These will let you have a better sense of how your software will actually be used, even if you don’t have all the small details. They reflect usage, so they will help you find and fix errors and bugs before you hand in your project.
Break up your big problem into several small ones
Up until now, if you’re a student, you’ve probably only encountered small problems, but what happens when you find a big one? Well, you break it down. This way, although you will have lots of problems, they are now small enough to be manageable. It’s a good idea to check your features list to know where to categorise each small piece of functionality.
Get your requirements straight
You can’t begin to build something without knowing what you need, so it’s not a bad idea to keep track of those necessary things. These things are called requirements, and they’re things that are either essential for the functionality of your program, or design decisions that the client already made for you.
“If it’s your decision, it’s design; if not, it’s a requirement” -Alistair Cockburn.
Do a proper domain analysis
You’re not always going to know how to solve the problem that’s in front of you. In fact, that will rarely ever be the case, so you are almost definitely going to need to do some research, so you might as well learn how to. Learn how to do something, and then do it, not the other way around.
Don’t underestimate design
This is maybe the step that we programmers underestimate the most. It’s not rare to see how developers design while they implement. While this often gets the job done, it wastes too much time. Although creating a design is not as fun as programming, it makes it so much easier that we might as well do it. Design is based on how our system will be used, and it gives us a better overview of what we’re trying to solve and how we want to solve it, so instead of trying and failing, why not just get it right from the very first time?
Finally, we get to code
We’ve got everything we could want to help us create good software, so it’s time to use these tools to create actual software. With help of our features list, use cases, requirements, newly-acquired knowledge and design diagrams, coding will be so much easier that you will wonder why the hell you haven’t followed this recipe from the very beginning.
That’s it, you’re done. Well, no, not really, but you can now deliver your system to your client. It’s time to start again and make your system better and better, but before you do that, congratulate yourself, grab something to eat and something to drink, play some videogames or whatever. Give your brain a chance to rest before you start working again. Iterations will make things easier on you and your team, since you’re not doing everything from the very beginning, but instead you start small and grow with each iteration.
With this recipe, you’re almost guaranteed to make great software each and every time you start a new project.
