Software Development: Do’s & Don’ts

Software development is an intricate craft; a technological art form that allows creators versed in the subject to effectively type things into existence.

Coders paint with letters and numbers like something out of a sci-fi fever dream, with even writers like William Gibson failing to imagine the wild realities of what development evolved into. Rather than simply calculate, we can now use code to do so, so much more – including coding other tools, allowing others to create as well.

And this tools-creating-tools-creating-tools family tree is almost reminiscent of humankind’s ingenuity with stone – or even, dare I say, a Godlike simulacrum of a creator creating a creator. But with the fanciful dreams of software development’s potential, and the education that brought us here, aside – software developers continue to be humans.

Even with libraries worth of learning behind a coder, they can still fall into the simplest of pitfalls of development. Something that might seem so obvious in hindsight but overlooked in the blind fury of planning and typing. As such, it’s important to remember the various “Dos” and “Dont’s” of development, things easy to miss but sometimes detrimental to forget.

Do: Know Your Audience

With the intricacies of software development, you can get caught up in the wild net of what you’re creating – and you want your software to have it all.

Before going into the design stages, make sure you do market research into the types of people who will be using your software.

A more personal and home-based software might need to be simple with clear buttons, while a specialized software can have more in-depth functions – it helps to scour forums of people who might want to use your product, or literally ask them, for what kind of software they want.

Do: Gather all material before starting the project

If you’re creating this software on a commission, it would behove you to get all of your information in one go.

All your material should be on hand from the beginning; the assets, text, aims – not to mention deadlines and the overall pitch for the product. When creating the brief at the beginning of development, it’ll be useful to create a checklist of everything you need from the client.

Cast your mind back to every piece of software you’ve worked on before, and what it took to complete it all. This will help for future reference and helps cover the specifics of whatever a client might throw your way.

Do: Make Confident Decisions

Much like the last point, it’s imperative that you’re on the same page as everyone involved on the project – this might include your development team, or your client if you’re working on commissioned software.

When in the planning stages of the software, every decision should be your final answer, as it’s often hard to go back and change. You, and everyone else involved, should be at a point where you can confidently answer any question asked about the software. Otherwise, this could lead to confusion and a horrible Frankenstein’s monster of an application.

Decide on a platform for your software – are you all aware if it’s going to be created for a PC, Mac, Android or iOS? The more intricate parts of your software rely on knowing the platform, and the software needs to cater for that. Communication is key when one or more people are working on a product.

Do: Be Patient

As mentioned in the introduction, software development is an art, and art should not be rushed. With coding, you’re bound to run into countless dead ends, or features that simply do not work. This is completely normal, and panicking and trying to patch over this may just make the problem even worse.

Coding requires immense concentration; this is why when most of us think of coders, we imagine them hunched in their chairs, wide-eyed and lit only by their monitor’s glow. This is because coding is about focus and following the process – and jumping the gun could break what you’ve worked for.

Don’t: Create Messy Code

In the heat of wild coding passion, it’s very easy to create an unbroken block of text, each following on from each other with no rhythm or reason – nothing neat or tidy.

You might think you know where everything is after a coding session, but think about when you get back to it the next day – do you really remember where one module ends and another one begins? It’s not only annoying dealing with your own messy code – it’s also time-consuming.

Keep your software code as easy to maintain as you possibly can – it’ll be less stressful for everyone involved, and will be overall more enjoyable to deal with.

Don’t: Forget To Document And Test

It’s important to remember that you’re creating your software to be used by others – and with that comes documentation. As a new user installs and uses your software, they might go into it with a particular aim in mind.

With this, you’ll need to write up everything your software can do, and how to go about achieving it. It doesn’t have to be an in-depth guide, but more of a step-by-step instructional on using your software. There might be something very specific about the installation process itself that users would find helpful.

With the more specialized users who would want to use your software – for example, other developers and system administrators – you should provide a more intricate guide on the specifics.

When it comes to the documentation comes testing itself – testing is so easy to overlook, especially if it’s a very small feature that’s recently been implemented. However, this feature still lives in the heart of your code, connected to everything else – it has the very real possibility of breaking another part of the software.

Rather than manually testing every aspect of your finished code, it can help to create an automated unit test to push the boundaries of what you’ve created. This automated test environment maximizes the efficiency of your development process, and publishing the test results to your users and clients will help them to understand the progress the software is making.

Don’t: Forget To Back Up Code

Document back-up is imperative for not only coders, but for writers, artists and photographers – if you keep all of your work limited to your machine, then all your hard work can be lost as easily as the machine itself.

The benefits of using online hosting and storage for your work is crucial – if the worst happens to the system that you’re working from, you can simply re-access your hard work and get straight back into it.

Backing up and hosting your code can also help you if you air it in a public service – code-hosting sites like GitHub and SourceForge are not only helpful backups for losing your work, but the community aspect can help you take your coding to the next level.

Not only do these platforms have great communities that can help you with dead-ends in your work, but users can subscribe to your software and be up to date with the latest versions, news, mailing list and a full-fledged wiki devoted to your software. You might even find contributors in these public circles to develop certain parts of it for you.

If you’re not interested in having your code open to the public, there are other hosting services that do the same thing, only private – for example, Assembla is a popular private platform for this, and offers use of a full revision history (to return to earlier versions), release tagging and even abilities for branching.