The big responsibility we have as Geeks... And nobody really cares.

People like us are widely misunderstood. We might feel disappointed when people think of computer geeks as practitioners of soulless, mechanical endeavors. We believe that what we do is an art and a craft. Our job is steeped in arcane acronyms and daunting terminology that makes it seem like a form of witchcraft for geniuses.

People enjoy using computers and playing around with the software we develop. When something goes right, they believe we are outstanding people. When something goes wrong, we might be considered the worst people in the world. 

Front-end and Back-end are terms that not many people understand, but for 99% of the people they are the users and we are just the non-social people that make it happen. 

The truth is that we live under constant fear and we worry a lot more than most people do in their offices. Doctors, Engineers, Lawyers, Pilots, and many other people rely on what we do everyday. Making their life easier and safer is not a simple task. We type words they don't understand, we check things hundreds of times, and we sometimes pray that nothing goes wrong. 

If something goes wrong, the best doctor in the world could kill someone, the best pilot with the best plane could crash without knowing it, Engineers might design things that will never work or even risk someones life and many others could mess up something that might change the world for bad. 

“To err is human, but to really foul things up you need a computer.”  –Paul Ehrlich

This simple sentence has been around for decades and people blame it on the people that make those computers or the people that make them work. When something goes wrong you have to blame someone. That someone will always be the people behind stage. 

Over the years there have been lots of real bad incidents caused by mistakes made by computer companies or programmers. I will mention just a few and then we will probably change the way we feel about the people involved in our field of work. 

• 1962: The Mariner 1 rocket with a space probe headed for Venus diverted from its intended flight path shortly after launch and mission control had to destroy the rocket just 293 seconds after liftoff. The whole thing happened because a programmer missed a simple char in the code. That mistake caused faulty corrections that sent the rocket off course. This simple mistake cost NASA (US Government) $18.5 million. 
• 1978: Just a few hours after thousands of fans left the Hartford Coliseum, the steel-latticed roof collapsed under the weight of snow. The mistake was made by the programmer of the CAD software used to design the roof. This mistake cost $70 million. Fortunately people were not inside the coliseum.  

These are just two of many things that have happened because of machine failure or software bugs. 
Software errors cost billions annually in rework, lost productivity and actual damages. We all know software bugs can be annoying, but faulty software can also be expensive, embarrassing, destructive and deadly.The point, again, is that when something goes right we are big heroes and geniuses, but if something goes wrong, we are the bad guys and nothing good will happened to whoever fault it was. We don't always play around with things and sometimes we end up stuck in a milestone of problems. We love what we do, but not everyone really thinks about the big responsibility in our hands. The next time something like this happens you might even read or hear something like this: 

• Oh, I would hate to be the programmer that made this mistake. How heavy must it lie on their conscience.

I still love what I do. I try to make things better for people and for me, too. If I were born again, I would still do what I do today. Mistakes can be prevented and that is part of our jobs, too. 

#geekmae