We're all running other people's code
When we think of a day in the life of a software engineer, we typically think of writing brand new code in a text editor—building a new feature, fixing bugs, etc. But in 2022, the vast majority of software engineers are running other people's code. They're building on top of open source libraries, or reusing code from other parts of their company's codebase or from online tutorials.
Investing in and using open source
To say that open source is popular isn't surprising, but the degree to which open source code is essential to modern codebases is. Almost 90% of the engineers we surveyed view open source code as at least somewhat essential to their day to day. Fewer than 1% said confidently that it's not essential.
How essential is open-source code
Investing in and using open source
Obviously, if you built your app on Node, you're technically using open source code all the time, but the dependency goes deeper than that. More than 80% of developers are actively pulling open source code into their work (via StackOverflow or otherwise) at least once per month, and almost 50% are doing it at least once per week. Those percentages are slightly higher for junior engineers vs. senior ones.
Frequency with which engineers pull open-source code into codebase
Senior and managing engineers
Individual contributors
Engineers actively pulling OSS code into their work
>80%
at least once per month
>50%
at least once per week
Investing in and using open source
The increased reliance on open source software certainly catalyzes development, but it also introduces drawbacks and concerns. Between supply chain security (see this CNCF whitepaper; remember the Log4J vulnerability?) and open questions around compensation, power law contributions, and whose responsibility this stuff actually is, norms around open source have yet to fully catch up to the importance of its role in the software ecosystem today.
The StackOverflow memes are true
These numbers are directional, but the story is clear: developers are copying a lot of code. This isn't all from the internet, of course—it also includes copying internal snippets and reusing code you've already written yourself.
Junior developers are copying more code than senior ones, which aligns with the split around using open source code.
Lines of committed code copied and pasted from other sources throughout the week
Senior and managing engineers
Individual contributors
Wrangling machines is hard
It's no secret that deploying apps has paradoxically gotten more complicated despite the proliferation of tools like Vercel, Netlify, etc. Software is a much larger part of the world than it used to be, and that comes with expectations around uptime and reliability that may not have existed in the past.
Accordingly, we're testing our software a lot more these days. It's now standard practice to have integration tests that take hours to run and are difficult to construct—requiring fake data, mocks, and stubs. We're swimming in different operating systems, dark and light mode, browsers, even different kinds of Mac chips.
Unsurprisingly, software engineers would really prefer to spend less time on testing changes, and this goes for individual contributors and managers alike.
Top things engineers wish they could spend less time on
Waiting on machines
As these build processes get more complex—especially with more tests (which is a good thing!)—software engineers are spending more of their time waiting on machines. SQL queries take a long time to run over large tables, database syncs are slow, and a monolith repo can take 20 minutes to build: all of this cuts into precious time.
Regular significant issues in everyday work
Senior and managing engineers
Individual contributors
Wrangling people is even harder
If life was just writing code, things would be simpler; software engineers in our survey reported that human-driven obstacles, like disruptive shifts in project direction, code review latency, or trying to figure out who owns which piece of code, were some of the biggest frustrations they faced day to day.
38%
of engineers say that waiting on people (e.g., waiting for code review, requirements) is a significant issue in everyday work
Wrangling people is even harder
In particular, it takes nearly an entire week for code to make it from a software engineer's brain into production, a stat that may be correlated with how well your company does.
Amount of time for code to fully ship to customer
Senior and managing engineers
Individual contributors