Holly Cummins gave a keynote at Goto Copenhagen where she urged developers to care about overlooked issues that shape their work. She warned of unintended consequences of design decisions, promoted systems thinking and statistical literacy, stressed mastering concurrency as hardware evolves beyond Moore’s Law, and mentioned the impact of AI on the job market.
As software developers, we have some unique challenges, because we have to work with both computers and people. But many of our challenges are common to a whole bunch of fields, as Cummins explained:
How can we make decisions in a complex world? How can we be sure that well-intentioned decisions won’t have unintended consequences?
Cummins mentioned the cobra problem. The colonial Indian government decided the cobra population should be reduced, and decided the solution was to pay a generous bounty for every cobra carcass it received. What the government hadn’t anticipated was that some enterprising individuals would start breeding cobras, because cobras were now lucrative. This was bad, but what happened next was worse – the government cancelled the program, and everyone who’d been breeding cobras suddenly had no incentive to keep the snakes, so all the captive cobras were released into the wild.
For most of us, our design decisions are unlikely to result in a cobra explosion, but there can still be unexpected consequences, Cummins mentioned:
For example, the yaml designers’ decision to parse “no” into “false” works well … as long as the yaml document doesn’t mention Norway. The country code for Norway, “no”, gets auto-converted into “false”.
Cummins mentioned that systems thinking is part of the solution. Nothing exists in isolation, and when considering technical solutions, we must consider how changes in one part of a system might produce unexpected effects in another. But systems thinking can be time-consuming, so we sometimes need to be more reductionist in our analysis, she said. How can we make fast decisions based on math? This is where statistics come in, Cummins said:
Statistics is the foundation of data science, and data science is a critical underpinning for modern artificial intelligence systems. The output of large language models is based on statistical analysis of the training data, and the likelihood of various word combinations in a given context.
Cummins argued that those of us (like her) who ignored statistics in university should probably do some catching up. She suggested doing an online course, such as data science courses offered by MIT. For a smaller time-commitment, there are books and articles:
Its focus is Bayesian statistics, but I found Everything is Predictable a useful refresher on classical statistics, too. Although her focus is parenting, not IT, I also learned a lot from Emily Oster’s explanations of statistics-gone-wrong, such as her explanation of residual confounding (it’s a lot more exciting than it sounds!).
The end of Moore’s law means that modern computers are growing sideways, rather than up, Cummins said. The power is coming from more cores, rather than more transistors on the same chip. To take advantage of these cores, programs need to do parallel execution at the hardware level. That means concurrency in the programming model:
Even on single-core chips, where parallelism isn’t possible, concurrent programming was important for some kinds of workloads, such as I/O-heavy ones. But now concurrency is important for all kinds of workloads. This is awkward because writing concurrent code can be notoriously hard.
Our industry is stepping up with more powerful abstractions and libraries, Cummins mentioned. In the Java space, we’re seeing existing libraries such as Netty adding powerful concurrency features, and new frameworks such as Quarkus and Micronaut building on that to offer developer-friendly concurrency. There are also some great new language-level features being released, such as virtual threads and structured concurrency, she concluded.
InfoQ interviewed Holly Cummins about things software developers might need to know.
InfoQ: How does probability work in detecting spam?
Holly Cummins: Spam detection is about evaluating how likely a message is to be spam – that is, the probability. The probability that an email is spam is called its “spamicity”, which I find delightful.
Many modern spam filters are built on Bayesian analysis, which is a form of probability theory. Rather than just using a list of “bad” words to screen emails, the filters look at each word in the email. Some words turn up regularly in spam emails, but are rare in good (“ham”) emails. If one of those words is present, the probability that the email is spam notches up. The opposite is true as well; some words just don’t end up in spam email but even though they’re common in normal communication. If the filter sees one of those words, it bumps the spamicity down.
InfoQ: What impact does AI have on the software developer job market?
Cummins: It’s unwise to try and predict the future, but I can make some observations based on the past. Jevon’s paradox tells us that efficiency improvements can lead to increased consumption. Over the past seventy years, the process of writing software has become more and more efficient. Think about the leap in productivity between assembler and higher-level languages, or how open source frameworks act as accelerators. But over those same seventy years, the number of software developers has grown exponentially.
Personally, I think the demand for software will continue to rise, partly as a consequence of the efficiency increases we’re currently experiencing.
