C++ development has come a long way. Even the influx of new languages hasn’t really affected the popularity of this cross-platform language, which gives developers a high level of control over system resources and memory. Unfortunately, even C++ development has its fair share of flaws. This article will cover the pains C++ developers have personally shared with our product experts, along with proven and tested ways to eliminate most of them.
C++ programmers are often active decision-making stakeholders when it comes to implementing third-party solutions and trying out new tech. They usually work on single computers/laptops with a predefined amount of computing power and don’t always get to enjoy top-notch devOps pipelines, amongst other issues.
Here are the top 8 pain points of the C++ developer today:
1 – “Let’s grab some coffee…”
Slow build and compilation task times
This is probably the most common line heard around developers’ desks today. Slow build and compilation times simply mean that the developers have to sit around and drink more coffee, or sacrifice the quality of their work due to Context Switching. Slow build times essentially lead to low iteration frequency.
C++17/C++20 include some changes aimed to promote productivity, but they don’t always translate to compilation times. Templates are a great example, as they cause increased compilation times. C++ modules should decrease compilation time drastically, but it will probably take time for companies to migrate.
2 – “I didn’t know about this feature!”
C++ language complexity and hidden features
C++, arguably the most popular full-stack language, is a complex language. It directly supports higher kinded types, dimensional analysis (for example, boost units) and other functional paradigms. On the low end, C++17 includes standard library support for finding the CPU cache-line size.
It’s not surprising to see relatively experienced developers still learning about hidden features and discovering new ways to optimize their development.
Related: Free Guide: C++ Under the Hood
3 – “Who broke this build?”
CI/CD implementation hiccups
DevOps is based on four main pillars – Continuous Integration, Continuous Testing, Continuous Delivery, and Continuous Monitoring, which helps provide enhanced visibility with actionable insights. However, when things happen slowly, there are frequent cases of server bottleneck and other pipeline complications.
To make matters worse, there isn’t enough testing being done to the slow iterations and releases. Not only do things become complicated, developers also have a hard time pin-pointing where the issue is, which is already harder to do in C++. A coding error in one area can often cause issues later in the pipeline.
This inability to manually locate code issues eventually results in cross-team friction and communication problems between the various stakeholders.
4 – “I’m tired of these extra procedures.”
Poor productivity due to third-party solution management
Even capable solutions that require maintenance on a daily basis eventually lose their appeal. This is before we take into consideration that these solutions require training and onboarding, which in themselves are seen as stressful and cumbersome tasks by the developers. Unhappy developers = Poor results.
5 – “Your overtime starts now.”
Buggy products that require post-release patches/fixes
As explained above, ineffective and clumsy development processes lead to buggy products that are often released due to tight deadlines (i.s – new games before the holiday season). Unfortunately, post release work on patches and fixes (extra work for developers) is becoming more and more common across all sectors.
A research by CISQ found that poor quality software cost US-based companies $2.8 trillion in 2018, 18.22% of which was cost accrued from technical debt alone.
6 – “What’s going on with the testing results?”
Slow feedback cycle from the release and QA teams
The ideal scenario for C++ developers is fast iterations with faster testing and results. This helps them launch remediation activities faster for more effective development time, which eventually leads to faster time to market and also enables better planning and design. Unfortunately, this is not always the case.
Long build times result in fewer iterations, which either means less testing (compromising on testing coverage with flaky testing practices) or slower time to market (when testing is done properly, but slowly). To make matters worse, unit tests are harder to apply on existing or legacy projects.
7 – “My machine is stuck!”
Machine clogging and hardware maintenance issues
The typical development pipeline can contain thousands of Lines of Code (LoCs) that can overwhelm even strong personal workstations. This machine clogging can be eliminated by harnessing the power of your local network’s free CPUs, without harming the performance of other machines in any way or form.
Big builds and compilations can literally lead to the choking of developers’ machines, even if they are well configured. Besides the obvious frustration that developers feel on a daily basis, they are forced to engage the IT manager, who often fails to provide a solution to the problem.
8 – “What am I supposed to do tomorrow?”
Lackluster product design and poor planning
The aftermath of a poor development life cycle also has serious implications when it comes to product design and planning ahead. With all stakeholders constantly busy with damage control and fixing issues at the last minute, very little time (if at all) is left to collect insightful data and focus on improving quality.
The best pain killers for C++ developers
There are many ways to get rid of the aforementioned pain points. Here are 3 effective ones that are being implemented by more and more organizations.
1 – Write code with readable comments
As explained earlier, coding in C++ can be quite a complex task. With multiple teams working (often remotely) on thousands of LoCs, making sense of what’s going on can be a daunting task. Commenting is the “art” of describing what your program is going to do in “high level” English statements.
Commenting is best done before actually writing the code for your C++ code. Comments should be useful “high level” descriptions of what the program is doing and not restate obvious things. By using appropriate variable names, much of a program can be (almost) as easy to read as English.
especially when projects are re-opened or after new devs need to familiarize themselves with the product.
2 – Invest in an automated DevOps pipeline
In a nutshell, automation drives innovation. This also empowers C++ developers to concentrate on the real thing they really enjoy doing, which is coding and feature branching. Automation and orchestration are becoming an integral part of the modern development pipeline. This is not a coincidence.
Faster development means that server bottleneck and other pipeline complications are eradicated. It also becomes easier to detect and remediate additional DevOps issues such as configuration drifts, accidental overrides, and cross-team conflicts with improved levels of testing and code analysis.
3 – Create an accelerated development cycle
Plug-and-play distributed processing solutions, such as Incredibuild harness the power of idle CPUs in your network or the public cloud, effectively transforming every workstation into a supercomputer with hundreds of cores to help with task execution. Also, minimal maintenance means significantly lower IT overhead costs.
Incredibuild introduces quite a few benefits. They include:
- Faster build and compilation times – Fast build and compilation times simply mean that you don’t have to be dragged into Context Switching, nor sacrifice quality. Added build and testing iterations mean that the development cycle is clicking like a Swiss watch with extra focus on quality.
- Free up time for more important tasks – Shorter build times lead to more free time on each iteration, which means there is more time for the tests you never had time for. Some examples include end to end, performance, and stress testing, with more manual cycles if needed.
- Zero hardware issues – With all free CPUs running tasks in parallel, machine clogging can be eliminated, enabling C++ devs to concentrate on what really matters – writing code. This problem can be mitigated even in companies with limited resources by scaling up to the cloud.
Summing it up…
Developing in C++ with enhanced visibility and transparency is no longer a fantasy. It’s now possible delve deep into the development pipeline to watch, analyze, and monitor your build’s progress to detect errors, find bottlenecks, and fix issues in real-time for optimal product quality.
Furthermore, peak times and tight deadlines can become quite demanding on your organization’s IT infrastructure. You can now harness the power of thousands of cores and machines in the public cloud to ramp up development, even with multiple remote teams working on the same project.
The pains mentioned in this article are still very common, but they don’t have to be a part of your daily life anymore. A proactive approach is all you need.