Our next-gen architecture is built to help you make sense of your ever-growing data. Watch a 4-min demo video!

Top 3 Time-Consuming Annoyances for Developers

  • Amir Raz
  • April 13, 2017
Share article
things developers hate

Developers, Data Scientists, and Software Engineers alike have a lot in common when it comes to their jobs. They are in high demand, get paid well, and are amongst the most respected in the companies they work for. On the flip side, they also share many of the same annoyances.

The annoyances I’m referring to has nothing to do with sitting all day, unrealistic expectations, or people not understanding exactly what it is that they do. I’m talking about bigger things. Things like trying to make sense of poor documentation, or other people breaking their code.

Three of the biggest offenders (in terms of being time-consuming annoyances) are definitely troubleshooting/debugging; ricochets from customers; and scaling clusters.

Troubleshooting and Debugging

ariel assaraf quote

It’s only natural and expected for bugs to pop up here and there, and Developers know to devote some time each day to track down and fix the defects. In some cases, bugs can be found and squashed in a matter of minutes. Oftentimes however, coders end up extremely frustrated as they spend many hours of development time trying to find the issues. The counterproductive feeling that stems from the extensive time lost gets very disheartening. Sometimes, Developers even end up going so deep into debugging, that they forget what the original bug even was.

Then there are the times that Developers don’t even know where to start looking. According to Yaniv Levin of Panoply, it can even be seen as “A bottomless pit, an abyss, the void… If the system is slow, just about anything could be the problem. It could be poor data modeling, improper indexing, network issues, storage hardware — basically anything.

Ricochets from Customers

Despite tireless attempts by teams to unleash perfect products to their customers- that doesn’t always quite end up being the case. Bugs have a way of slipping through the cracks, and making their way into production. That leads to endless ricochets from customers (who figure it might just be a quick fix.)

dev ninja

The constant correspondence and repeating of oneself has a way of bogging down Developers that are trying to iron issues out with minimal distractions. The main thing most people forget to keep in mind is that it takes a lot of time to publish new versions of software, even with the slightest fixes.  

Scaling Clusters

Multiple data scans are required to achieve convergence for scaling clusters. That may not seem like a big deal for smaller databases, but it’s a whole different ballgame for the larger ones. There is also the added risk of what may come to be for under-provisioned resources. Aside from obviously being far more expensive of a process, it also becomes far more time-consuming and cumbersome, especially for data scientists.

In the case of relational database management systems that need scaling, additional proprietary is required- when then opens up another can of worms for Devs to deal with. The annoyances in this case include extensive downtime, and additional configurations that would be needed to make changes.

The Solution: Continuous Delivery!

With continuous delivery, reaction times to internal and external stimuli are quicker. This is a major plus for companies that rely on their release infrastructure on a daily basis, as deficiencies are uncovered and resolved in a surprisingly efficient manner. This saves companies and their Developers weeks (or even months) of grief. A DevOps culture is an enabler for versions of the product to be sent to production at high quality and speed.

We weren’t kidding when we previously wrote about how machine learning is revolutionizing log analytics. It saves time, money, resources, and yes- sanity. Although continuous delivery and DevOps methodologies tend to be a harder sell for companies that lean towards dated traditional methods, it’s absolutely worth it once you can overcome the barriers to adoption, for the sake of efficiency at the very least.

With continuous delivery by their side, Developers can go back to doing what they do best. Creating and enhancing awesomeness.

Where Modern Observability
and Financial Savvy Meet.