Sustainability and responsible computing

When we talk about sustainability in computing, the conversation often stops at datacenters, power usage effectiveness, and renewable energy sources. Those things matter, of course. But sustainability doesn’t start in a power plant or a cooling system. It starts much earlier, at the moment we design software.

Responsible computing also means asking how much we actually need.

Less CPU cycles.
Less memory pressure.
Less data moved, stored, replicated, forgotten.

All of that translates, very directly, into less energy consumed and a smaller carbon footprint. Not as an abstract goal, but as a practical outcome of thoughtful engineering.

This doesn’t mean going back to COBOL on monolithic systems, nor does it mean rejecting modern tools outright. It’s not a nostalgia exercise. Modern languages and ecosystems absolutely have their place. Rust, for example, makes a lot of sense where safety and performance truly matter. But the question isn’t whether a tool is modern. The question is whether it is appropriate.

Too often we assemble software stacks by default rather than by design. We add layers, frameworks, plugins, and services because they are fashionable or convenient, not because the problem demands them. Sometimes an older, simpler approach would do the job just as well, with a fraction of the footprint. A well-structured batch job instead of a constantly running service. A compiled binary instead of a heavy runtime. Even an “old” language like Pascal, Perl, or COBOL might be perfectly adequate for a clearly bounded task.

Architecture choices matter more than syntax ever will.

The same applies to hardware. As ARM and RISC-V mature, they offer real opportunities to reduce energy consumption for many workloads. Not everything needs a power-hungry x86 server. Sometimes smaller, simpler, and slower is not a compromise, but the correct choice.

Bandwidth is another blind spot. We live in a world of abundant connectivity, even at home, and we behave as if moving data is free. It isn’t. Transferring, replicating, and storing massive amounts of data has a cost, even if we no longer see it directly. When I hear about companies proudly announcing multi-petabyte data lakes, I can’t help but wonder how much of that data is actually used, and how much is simply there because deleting, curating, or rethinking it feels harder than keeping it.

With memory prices rising, consumer hardware quietly disappearing, and entire supply chains bending toward AI workloads, the cost of inefficiency is becoming visible again. Scarcity has a way of reminding us why restraint mattered in the first place.

Responsible computing asks uncomfortable questions:

Do we need this data?
Do we need it now?
Do we need it forever?
Do we need it online?

Sometimes the most sustainable decision is not to optimise further, but to step back and simplify. A system or a piece of software doesn’t need to be fashionable to be effective. It needs to be reliable, understandable, and designed with the long term in mind.

There is also a quieter aspect of responsibility that rarely gets discussed: engineering that doesn’t require constant churn. Software that doesn’t need updates every second because it was thought through from the beginning. Data models designed intentionally. Execution paths reasoned about before they are shipped.

This isn’t about premature optimisation. It’s about planning. About respecting data, instructions, and the systems that will have to carry them for years. Too often we celebrate shipping an MVP as fast as possible, deferring structure and care to “later”, a later that rarely comes. The cost is paid in complexity, fragility, and waste.

For me, this way of thinking is deeply connected to digital sovereignty. Systems that are smaller, more intentional, and easier to understand are also easier to control, to operate locally, and to keep alive without constant external dependency. They empower people and organisations instead of locking them into endless growth cycles.

Sustainability, in the end, is not only about carbon. It’s about restraint, care, and engineering with intention.

Responsible computing is also choosing enough and choosing to build things that last.