Even the best of us have our off-days and make poor decisions at work. Programming mistakes are only to be expected when you’re starting out in your field, and that’s okay; that’s why processes like code review are in place, to catch errors before they do any damage. However, there are a few “unforgivable” programming mistakes that go beyond simple coding errors, and could cost you your reputation and your job.
Here are the most common mistakes that can get developers fired on the spot:
As we said, mistakes happen, and they can happen to anyone. But there’s a difference between an honest programming mistake that comes from lack of experience, and an error caused by negligence, arrogance or bad practices.
Negligence is “a lack of diligence or care”, and it can have far-reaching effects. For example, if you deploy code without testing it or checking it for bugs, it could impact important data (such as customer billing data). As a programmer, you would be fired for putting the erroneous code into production without doing your due diligence and testing it first.
Failure to back up your data consistently is also considered extremely negligent. You may not be fired for simply deleting or losing data, but you certainly could be dismissed for losing it irretrievably because you haven’t been consistent with backups.
Lying & Cover-Ups
Let’s be honest, admitting to a mistake can be really embarrassing. However, hiding a mistake or attempting to fix it yourself, instead of escalating the issue correctly, will land you in a world of trouble. Employers are far more willing to forgive a mistake if you take accountability and handle it correctly – they are far less likely to forgive a lie.
One senior developer shares his personal experience: “I pulled a 36 hour shift with no sleep because of data warehouse production on call support rotation. I had gone into the office the following morning to clean up everything after being up all night. I had three instances of SQL Plus running on UNIX and I truncated the data out of what I thought was a development table, which turned out to be a production table. I was terribly embarrassed, but I immediately told my manager what I had done.”
Thanks to his immediate escalation and willingness to own up to his programming mistake, the issue was resolved quickly and painlessly. “It took the DBA about 15 minutes to restore the table and I was teased by co-workers for about a week. Had I lied about it I would have been fired. From that point on I set up environment variables so that I always knew immediately whether I was in development or production.”
Misuse of Company Resources
It’s not unusual for developers to take on side projects and freelance clients outside of their day job. This is something that’s normally accepted by employers, depending on the restraint of trade clauses in the developer’s contract. Where it becomes an issue is when developers begin to use company time and resources to complete projects for outside clients. Employers typically consider this to be theft (i.e. theft of the time you’re contractually obligated to dedicate to company work).
Developers are often in a position to be trusted with sensitive data, closed source code and copyrighted information. Unfortunately, some individuals abuse this trust, sharing, leaking or even selling confidential data.
Sharing intellectual property with a competitor will certainly get you fired, and could even lead to you being arrested and charged with fraud.
Personal Accountability vs Company Responsibility
While a programming error made by an individual can cost the whole organisation dearly, it can also highlight an underlying issue with the company’s structure or processes. One recent example is that of an unfortunate junior developer whose copy-and-paste error accidentally erased all data from the company’s production database – their very first day on the job!
After being immediately fired, the poor rookie shared their tale of woe online. The development community rallied around them in support, agreeing that while they made one mistake, their ex-employer made several. First, the company didn’t back up their database. They had sloppy system organisation and poor security measures in place. And rather than recognising and rectifying those issues, they fired the person who inadvertently revealed them.
Just as it’s important to do your due diligence as a developer, employers need to do their own by ensuring they have the proper processes and practices in place.
John Byrd, CEO of Gigantic Software, says: “I don’t fire programmers for one-off technical mistakes. If one mistyped command destroys production or development, then your process has failed, not the employee. If you have a programmer that is constantly making expensive mistakes, your hiring process is broken.”
Instead, Byrd listed lying, theft, harassment, use of illegal substances, and misuse of company intellectual property as fire-able offenses. This behaviour is, of course, not limited to the development industry, and is considered unacceptable across the board.
In short, the best way to prevent programming mistakes from derailing your career is to cultivate a combination of technical know-how, good practices, and ethical integrity. A mentor-led online coding course will help you to develop this unique and valuable skill set.