Many people write code, but not everyone that codes considers themselves to be a professional programmer. What does it take to be a professional? This article lists the practices you undertake when you are a software development pro. From my experience, many of these practices are not taught in coding schools, but they are essential to delivering quality software to customers.
Before covering the practices, let’s first briefly consider different classes of those who write code.
A programmer becomes an amateur instead of a tinkerer when the programmer starts writing software or web sites for others, especially when the programmer is compensated for her/his work. Amateur programmers often create good software and write code well. But to be considered professional, there are several practices a programmer will follow.
The following list represents what I believe are practices that every professional software developer will follow. As in all things, there may be some cases where it makes sense that one or two of these practices is not performed by a professional; but I believe most would agree that professionals follow all of these practices most of the time.
- Use version control
- Back up everything off site
- Track the changes, fixes, and enhancements in each release
- Keep the source code related to each deployed version that is in use
- Keep a copy of your software in escrow
- Use automated builds
- Schedule builds
- Write regression unit tests
- Use a bug tracking system
- Use a system to track tasks and features being developed
- Keep customers informed about the progress of the software development
- Keep third party software used updated regularly
- Understand the security risks
- Ensure proper compliance with industry standards such as PCI, HIPAA, SOX, and PII
- Educate yourself continuously
- Invest in your development tools
- Properly license development tools and software
- Write documentation about the software
- Keep a journal of your activity
1. Use Version Control
A version control system should be used by all professional software developers. It is difficult to imagine a solution for which version control would not apply. Today, most developers use GIT, but many also use Subversion (SVN). The version control system used should have the following features:
- Allow people to add comments explaining each check in, and track who checked it in
- Allow people to view a history of changes checked in for each file
- Allow people to revert to earlier versions of the software
- Allow people to compare the code changes made across check ins
Zipping up the files that are part of each product release or check in, instead of using a version control system, is a sign of an amateur programmer.
2. Back Up Everything Off Site
A professional programmer will make sure that all of the code she/he writes is backed up regularly, and that back up needs to be an offsite location to prevent loss of all of the source code in the event of a fire, flood, theft, or some other event. Given the ubiquity of the Internet today, this is usually easily achieved. Simply using an online repository like github or bitbucket for version control almost fully meets this practice in most cases. Along with the backups of the source code, a professional will make sure that the scripts and commands for the tools and processes used to build the software is also backed up remotely. A professional programmer should be able to start from nothing, acquire a new computer, and reconstruct everything needed to continue developing the software by recovering all of the software from the off site backup.
3. Track the Changes, Fixes, and Enhancements in Each Release
A software professional provides more than software to their clients, they also provide a list of all the new features included in the latest version. Of course, there should also be a comprehensive list of the contents of the initial version. In addition, a list of bugs fixed and other changes such as noticeable enhancements to performance and security should be provided. A software professional tracks the reason behind every code change made during a release. This is often helpful when clients are looking for a feature or fix because you can tell them they need to upgrade to a specific version to get it.
4. Keep the Source Code Related to Each Deployed Version That is in Use
Modern version control software allows us to see how the code looked at any point in time. A professional should be able to easily and quickly see how the code looked for any version of the software that any client currently has implemented. This helps the developer resolve issues reported by clients more quickly, and to create a fix for the software.
5. Keep a Copy of Your Software in Escrow
No one likes to ponder the possibility of their own demise, but as a software professional, you should consider this possibility and take steps to ensure that your clients can continue to use your software if something unfortunate happens to you. Make sure that someone besides yourself can obtain access to your source code and all the artifacts and processes needed to build and support it if the need arises.
6. Use Automated Builds
Building software takes us from the source code to the final output that is deployed to a client or to a production system. While builds often start out simple, they can evolve to become more complicated. For this reason, a professional developer will set up an automated build process that compiles and combines all the source code to a package ready to deploy. Minor tasks that can be automated so that they are not forgotten include flagging the code as a release build so that the compiler will optimize the output, or minimize it, or obfuscate it as needed. Automated builds often update version numbers and also often perform several steps in a specific sequence. Build processes can be automated initially with simple batch/command files; but many professional use tools specifically designed for building software products.
7. Schedule Builds
Scheduling a build is just the next step, and hopefully a minor step, after a professional has created an automated build. Many developers schedule a build to automatically run once or twice a day. This is especially advantageous when multiple developers are contributing to the code. Some developers even configure the version control system to start a build every time code is checked in. Frequent builds help developers identify bugs more quickly if an artifact necessary for the build was excluded from their repository checkins, or if code they checked in adversely affected code in another part of the system.
8. Write Regression Unit Tests
I’ll admit that there may be a few cases where it does not make sense to write unit tests for your software. But I believe that in almost all cases, even for old languages like Cobol and Visual Basic, a developer will write unit tests to validate important logic in the software runs correctly and is not inadvertently altered by a new enhancement or related bug fix. Getting a unit test framework up and running takes a few hours or even a few days for someone not familiar with unit tests, but once you have it, you find that the tests give you a lot of freedom to make changes and the peace of mind that the changes you make are not breaking existing logic that your customers depend upon.
9. Use a Bug Tracking System
Let’s face it, almost all software has bugs, or things that are not working quite as the user desires. Software developers need to track when those bugs were discovered and who discovered them so that they can make a careful fix and provide a patch or fix to the affected systems and users. A bug tracking system can help all customers and users of your software become aware of the bug and sometimes the way to workaround a bug until a fix is applied. It also can let your customers know that they just need to upgrade to your latest version to obtain the fix for the bug. In addition, it helps you keep track of when and where you made the fix so that you can manage related issues with the fix, follow up issues, or just to reminder yourself that you already fixed this bug.
10. Use a System to Track Tasks and Features Being Developed
Software professionals understand that delivering quality software includes keeping track of a lot of details. A system and place to keep track of all of the things that need to be done is very valuable. Your system could be something as simple as a Trello board. Ideally, you will have a list of everything yet to be completed and everything yet to be done. Most tasks boards use at least three columns: To Do, Doing, and Done. Even when you think a task is done, you may decide it is not really done if you have not written the documentation related to the feature, or altered your install package to include a dependency for the feature. The system also helps you remember the status of items and share the status, or share the work to be done, with others.
11. Keep Customers Informed About the Progress of the Software Development
In most software development projects, frequent interaction with the end user, aka ‘the customer’ greatly increases the chance that the software you create meets their needs. Frequent communication also helps you manage your customer’s expectations about when features will be delivered to them and how those features will behave. Although the waterfall method of software development describes collecting all of the requirements up front, it is extremely rare that you really can gather all of the details as well as you can if you keep the customer involved as you develop and can show them the product as it evolves. Professional software developers will not leave their customers in the dark for weeks or months before giving them an update about the progress of the software.
12. Keep Third Party Software Used Updated Regularly
Most developers rely on some third party software to decrease the time it takes to produce the software their clients want. For web developers, this may include frameworks like Microsoft .NET, Angular, React, JQuery, and Java. But security flaws and performance problems, and other bugs occasionally get discovered in these frameworks, therefore a software professional regularly updates to the latest version of the frameworks in order to obtain the security patches and fixes to improve the security and performance of the software they pass on to their client.
I recommend you keep a list of all the third party software used by your software and your software development processes, and that you review the list at least twice a year in order to update each dependency to the latest version.
13. Understand the Security Risks
Professional software developers understand that they generally have more knowledge of software development than the customers that have hired them to write code. Thus they understand that writing secure code, code that can’t be easily abused by hackers, is their responsibility. A software developer creating web applications probably needs to address more security risks than a developer writing embedded drivers for an IOT device, but each needs to assess the different ways the software is vulnerable to abuse and take steps to eliminate or mitigate those risks.
Although it may be impossible to guarantee that any software is immune to an attack, professional developers will take the time to learn and understand the vulnerabilities that could exist in their software, and then take the subsequent steps to reduce the risk that their software is vulnerable. Protecting your software from security risks usually includes both static analysis tools and processes to reduce the introduction of security errors, but it primarily relies upon educating those writing the code.
OWASP (https://owasp.org) is a good resource for developers to learn about possible vulnerabilities and ways to mitigate those vulnerabilities.
14. Ensure Proper Compliance with Industry Standards such as PCI, HIPAA, SOX, and PII
Writing software that complies with industry regulations is also a responsibility of a software professional. It is the responsibility of the customer asking for the software to tell the developer that they need the software to meet specific regulations such as HIPAA, GDPR, PCI, SOX, or PII. But it is the responsibility of the software professional to understand how those regulations affect the software and software development processes. A customer may suggest to the developer what impact the regulation has on the code, but if you are a software professional, you will refer to the regulation directly and clarify your own interpretation of the document.
15. Educate Yourself Continuously
Technology continually changes thus professionals will continually learn new tools, techniques, and software languages in order to improve their efficiency and write software that lasts longer. Even developers that have been programming in the same language and environment for a decade may discover that there are new tools and processes that can help them write better code. Perhaps need static code analysis tools can help you find bugs in your code, or perhaps you can learn to write better code by switching from a waterfall methodology to an Agile approach. Developers writing Visual Basic 6 code may realize they can begin writing more modular code and use classes to facilitate a possible rewrite to Java that is coming, but is still years away. If you aren’t occasionally doing some research to find ways to improve, I don’t think you can consider yourself to be a professional software developer. (If you are reading this article, you probably are a professional or planning to be one!)
16. Invest in Your Development Tools
A good carpenter doesn’t use a cheap saw, and a good software developer doesn’t just use the cheapest tools and equipment. Luckily for software developers, many really good tools are free to use. Some tools do cost a little bit of money, but the productivity improvement gained by paying for them is often well worth the price.
Besides software tools, developers sitting at computers writing code day after day probably benefit from having good hardware. A computer with a lot of RAM and a fast hard drive and Internet connection may spare you waiting minutes or even hours each day. Multiple monitors, a comfortable keyboard, mouse, and chair can contribute to your ability to write code a little more effectively each day. Take time to invest in the small things that can improve your productivity, even if it is just by a small amount.
17. Properly License Development Tools and Software
Customers expect people they hire to work ethically. Well, perhaps unethical customers don’t expect ethical behavior or are willing to turn a blind eye, but if you declare yourself to be a professional software developer, I believe you are also declaring that you do things ethically, and part of being ethical is paying for the resources you use to develop the software solution. This means that you will pay the correct price and licensing fees for the tools you use for development. It also means that you won’t use the free or community version of tools to develop professional solutions that clearly don’t qualify for the rules of use for that version of the development product. Just as you are probably making a living writing software for your customers, those people and companies that created the tools you are using to enhance your productivity are trying to make a living by writing their software too.
18. Write documentation about the software
Professionals write documentation about the software to assist future developers that may need to take over maintenance and enhancements of the code. Sometimes, that future developer could be yourself. System diagrams, flow diagrams, use case diagrams, and comments in code explaining the complicated bits all go a long way toward helping future developers maintain the software if you are not around to do so.
19. Keep a journal of your activity
Professionals often keep notes of their activities during software development. The notes can serve several purposes, but most often they benefit yourself. Perhaps you record why you chose one approach over another. Perhaps you list expected benefits or drawbacks of a decision. Perhaps you keep track of how often you perform IT maintenance or how you fixed some problems. You may keep track of interactions with others and a record of tasks and responsibilities. Professionals also use these notes to help explain where they spent their time and to explain why development is behind schedule, for those times when that happens.
I wrote this for people that are new to software development, particularly those who have completed a program in writing software and hope to embark on a career as a professional. Most of the items covered in the article are not covered by formal software education programs, but are an essential aspect of writing good quality software. Individuals writing software for a living on their own probably want to implement all of these practices in order to give current and potential clients confidence in the quality and professionalism of their work.
Please let me know if you feel something important is missing from this list so that we may improve this article as a good reference for developers.
And please check back for a future article where I cover those practices that make a software development “team” a team of professionals.