We spend our days crafting the digital tools you rely on. We pour our creativity, problem-solving skills, and late nights into building those features you love and tackling those bugs that drive you crazy. But sometimes, the frustration you experience with software can boil over into less-than-pleasant interactions with, well, us – the developers.
Here’s the thing: we get it. There’s nothing more infuriating than encountering a roadblock in your digital workflow. We spend countless hours wrestling with code to make sure things run smoothly, and even the most meticulous plans can have unforeseen glitches. That frustration can come through in phone calls as well as emails.
I’ve been on the receiving end of calls from customers complaining about software that had been installed at their site. And I say this as a developer. And let me tell you, it does little to make you feel better about yourself.
There are a few things to consider here. Some issues might be beyond our immediate control. For example, changes made to a user’s environment or network can cause unexpected behavior in software, even if the software itself is functioning as intended. Users might not always be aware of these changes, and it’s reasonable to expect things to “just work.” Additionally, there are always bugs, those pesky errors that creep in despite our best efforts. Let me be clear: developers don’t add bugs to software for fun! We strive to deliver polished products, and bugs are the enemy, not something we introduce ourselves.
On a lighter note, I used to say this, and perhaps in a slightly sarcastic tone, that if it takes more than 1 click to accomplish something in software, it’s one click too many. We developers are all about efficiency, and we strive to design intuitive interfaces that minimize the number of clicks required for users to get things done. However, there’s a balance to be struck. Sometimes, a single, overloaded button might seem simple at first glance, but it can lead to confusion down the line.
Now, let me tell you a bit about myself. I used to take great pride in my work. I was (not so much now) a perfectionist, a black and white thinker, and a bit of a people pleaser. In the world of software development, that can be a recipe for stress! I didn’t just want the code to work, I wanted it to look elegant and be maintainable in the future. As time went by and the software inevitably changed to accommodate new features and user needs, that beautiful code I wrote could get messy, complex, and probably embarrassing to look at now. My perfectionist tendencies also meant I would take things personally when things went wrong and blame myself.
So, how can we bridge this gap and turn those moments of frustration into collaboration? Here’s a developer’s perspective, informed by my own experiences, on how we can work together to make things better:
1. Frustration is Okay, But Let’s Focus on the Why
We understand that encountering a software issue can be annoying. The key is to channel that frustration into something productive. Instead of a generic message about how something is “broken,” provide specific details about the problem you’re facing.
What were you trying to do when the issue occurred? What error messages did you see? Were there any specific steps that led up to the problem? The more context you can give us, the faster we can unravel the cause and work on a fix.
2. Screenshots Are Your Friend (and Ours)
A picture, as they say, is worth a thousand words. If you’re encountering a visual bug, a screenshot can be an invaluable tool. It captures exactly what you’re seeing and eliminates any confusion about how to reproduce the issue. This saves us precious time deciphering the problem and lets us jump straight to finding a solution.
3. The Power of Positive Reinforcement
It’s not all about bug reports. Let us know when you appreciate a feature or find something particularly useful. Positive feedback lets us know we’re on the right track and motivates us to keep building great tools. In my experience, the thank-you emails were few and far between, and it would be the lack of any reply was one way of thinking the software was working, before having to callback a customer to find out.
4. We’re Here to Help, But We’re Not Mind Readers
While developers strive to make software intuitive, there can always be room for improvement. If a feature isn’t clear or you’re unsure how to use it, let us know! It is better to do this than get frustrated in working out how the software works. Your feedback helps us identify areas where the software’s usability can be enhanced.
5. Reporting Issues vs. Feature Requests
There’s a difference between reporting a bug and requesting a new feature. Bug reports deal with fixing problems in the current software, while feature requests propose adding new functionalities. Understanding the distinction helps us categorize your feedback and address it accordingly.
6. The Team Behind the Code
Remember, there’s a real person (or more likely, a team of people) behind the software you use. We put a lot of thought and effort into our creations, and negative comments can sometimes feel like personal attacks. I can tell you this from personal experience. For much of my career, I struggled with anxiety. More recently (2010s onwards) I would have an anxiety attack at the start of the workday. I’d imagine all the potential issues users might encounter, and my mind would jump to worst-case scenarios. Negative feedback, on top of that anxiety, could be really discouraging.
Therapy and mindfulness practices helped me manage my anxiety, and focusing on solutions rather than dwelling on negativity made a big difference in my well-being and my work. This has taken a long time to get to this point (about 7 years now)
This revised section adds your personal story about anxiety and how it impacted you. It highlights the human side of developers and the challenges they can face. It also demonstrates a positive approach to overcoming those challenges.
7. The Importance of Patience
Fixing software issues can be a complex process. It often involves testing, debugging, and collaboration across different teams. While we always strive to address problems promptly, providing a permanent solution may take some time.
8. The Developer Community
Many software products have online forums or communities where developers and users can interact. If you’re stuck on a particular issue, these forums can be a valuable resource. You might find that other users have encountered the same problem and already discovered a workaround.
By fostering open and constructive communication, we can build a better relationship between developers and users. The next time you encounter a software issue, remember, there’s a real person on the other side who wants to help. By working together, we can resolve the problem and make the software experience better for everyone.
9. We All Want the Same Thing
In the end, we all share a common goal: to create a smooth and enjoyable software experience. When users are frustrated, it’s a sign that something isn’t working the way it should. Your feedback is essential in helping us identify those problem areas and develop solutions. So next time you reach out, keep in mind that we’re on the same team. Let’s work together to make things better!
TIM COATES 
Leave a comment