The Top Five Signs You Might Not be Working with Professional Developers
Are you working with professional developers?
Automation Guild, an online conference dedicated to automation testing, is coming January 9th. We have a great lineup of hands-on automation craftsmen that are going to show us some actionable automation awesomeness.
One of those speakers is Scott Nimrod who will be presenting from a developer’s, or SDET’s, perspective.
I wish all the developers I work with had Scott’s passion and dedication — not just for programming but to the true craft of test-driven development. I think all developers need those attributes in order to be successful in creating high quality applications.
So do you work with professional developers or debuggers? Not sure?
This following is a quick excerpt from Scott’s Automation Guild session. They are his five signs that you may not be working with professional developers.
Your Developers Don’t Scrutinize their Code
How do you rate yourself in regards to being a professional developer? Do you consider yourself good? Do you consider yourself professional?
Think about professionals in other industries — dentists, doctors, mechanics pilots, etc. Think about factories and the quality assurance processes that they have, the checklists that they go through, the automation that they leverage.
Professionals maintain records. They scrutinize. They challenge. They continuously poke holes in the subjects to qualify them as industrial-grade services and products.
Do you build industrial-grade software? Has your software been thoroughly tested and proven? Translate it. I’m not talking about QA, I’m talking about you. Are you a professional developer?
Do you scrutinize your code as a professional developer? Do you have the ability to prove your code works without having to manually launch the entire system, test the UI, go through the debugger and step through code?
Your Developers Manually Test their Code
You write programs, right? You’re a professional developer and programmer. Why are you manually testing your code? If you’re a programmer, shouldn’t you be writing a program to check your program?
Again: Are you a professional developer?
Your Developers Don’t View their Job as their Own Personal Practice
I think it’s something we should all ask ourselves. We should take time to reflect on who we are and what we do and hold ourselves accountable rather than our employers.
Do you view your job as your own personal practice? Are you like some people that believe that the company you work for is responsible for teaching you how to be a professional developer?
If you work in an IT space at delivery company, and build desktop or internal applications, is it up to the company to train you? Is it their responsibility to teach you how to be a professional developer so that you can build software for them?
Would you hire somebody to fix your sink if you have to train them how to do the repairs on your time? Or do you expect the person you hire to hold themselves accountable and already have that skills necessary to do the job? The answer, of course, is that they should come prepared.
Your Developers Don’t Test their Code
Let’s talk about testing. If you test your code and know how to prove it programmatically, than you more than likely do it through “unit tests.”
You may think you’re pretty good. You write “happy path” tests. You right “sad path” tests. You’re in love with the work flow of red/green refactoring.
In general, you always know where you’re at regarding the status of your work because as professional developers by the time we get to code we’ve already nailed down the requirements.
You’re pretty certain that you didn’t inject any breaking changes, but if you find out that you did — even though all your tests are green — then you identify there is an anomaly that was introduced as a result of new or modified code within the system.
As a professional developer, I know you do this.
Your Developers Spend More Time Debugging than Coding
If you can prove that it’s business logic rather than integration logic, then you write another test to ensure that it never happens again.
This is beautiful because we don’t spin our wheels. We’re professional developers. We spend the majority of our time building — constructing the Tower of Babel, so to speak. You spend more time developing, not necessarily debugging.
The bottom line is that we should strive to be professional developers rather than professional debuggers.
Property-Based Testing Can Help!
One technique that can help your developers become true professionals is property-based testing, which is what Scott’s hands-on Automation Guild demo is going to be all about.
You won’t want to miss it. Be sure to leave your email address now, and once registration is open you’ll be one of the first to know.