Coder Legion - Recent posts tagged green-software

Green Software in Action: Building a Universal, Driverless OBD-II Interface

Wed, 14 Jan 2026 15:35:55 +0000

I wanted to prove that the modern web is a first-class citizen for low-level automotive diagnostics.
I built Gnoke-OBD2 to bridge the gap between complex vehicle protocols and the accessibility of a browser.

The Engineering Challenge

Interfacing with an ECU (Engine Control Unit) requires more than just sending commands; it requires a deep understanding of the ELM327 protocol stack. To make this work universally, I had to architect a Sequential Kernel in JavaScript.

Key Technical Hurdles:

Asynchronous Queueing: Managing the "request-response" dance via Web Serial/Bluetooth without overflowing the hardware buffer.
Protocol Abstraction: Designing a modular system where different diagnostic "plugins" (Emissions, Live Gauges, DTC Readers) all feed off a centralized, stable data stream.
Timing Sensitivity: Implementing 150ms anti-congestion delays to ensure compatibility with both high-end and budget-friendly adapters.

The Competitive Edge: Why the Web?

By leveraging the Web Serial and Web Bluetooth APIs, I’ve created a zero-install, cross-platform diagnostic suite. While native apps have existed for years, a web-based universal interface offers advantages they can't match:

Feature	Native Apps (e.g., AndrOBD)	Gnoke-OBD2 (Web)
Accessibility	Limited to Android / Google Play	Any OS (Windows, Mac, Linux, Android)
Installation	Requires download & permissions	Zero-install (Instant via URL)
Updates	Manual via App Store	Instant (Always latest version)
Architecture	Often monolithic	Modular Kernel (Plugin-ready)

️ Built for the "Conceptuous" Brain

This project isn't just about reading car data; it's about architectural freedom. No proprietary apps or platform-specific drivers—just a secure URL and the open standard.

By focusing on a universal interface, Gnoke-OBD2 is ready to handle the edge cases of various vehicle makes and models through a single, clean code base.

Explore the Architecture

Gnoke-OBD2 is open-source (GPLv3) and currently in Alpha.

Live Demo: https://edmundsparrow.github.io/Gnoke-OBD2/
Source Code: edmundsparrow/Gnoke-OBD2

I No Longer See Software as “Just Software”

Fri, 09 Jan 2026 15:32:32 +0000

How research and green software engineering changed the way I see code

For a long time, I thought software engineering was only about features, performance, and shipping products.

Today, I realize it’s much deeper than that.

A small shift in perspective

I used to measure good software by how fast it runs, how clean the UI looks, and how many users it serves.

But after working on topics like GNSS-based traffic modeling and green software engineering, something changed.

I started asking different questions:

• How much energy does this system consume?

• What invisible resources are being wasted?

• Who is affected by the decisions we make in code?

That’s when software stopped being “just software” to me.

Software writes real-world consequences

When you model traffic data, you’re not just optimizing routes — you’re influencing pollution, time, safety, and city behavior.

When you analyze software energy consumption, you’re not just profiling code — you’re touching sustainability, infrastructure load, and environmental impact.

Code doesn’t stay on the screen.
It moves into streets, servers, electricity grids, and human lives.

⚙️ Engineering is no longer neutral

Every design choice has a cost.

• One inefficient loop multiplied by millions of users

• One always-on service running 24/7

• One poorly planned system scaled too fast

Software engineers are now part of global systems, not isolated applications.

And whether we notice it or not, we are shaping:

• energy consumption

• digital behavior

• economic decisions

• and even environmental outcomes

What this changed for me

Today, when I write or analyze software, I don’t only think about:

✔️ “Does it work?”

✔️ “Is it fast?”

I also think about:

✔️ “Is it responsible?”

✔️ “Is it efficient beyond performance?”

✔️ “Is it solving the right problem?”

Final thought

Software engineering is no longer just about building products.

It’s about designing systems that live inside the real world.

And once you truly see that —you can’t unsee it.

What questions do you have about responsible software? Drop a thought below — I’d love to hear your take.

You can find me on GitHub: https://github.com/fadydesoky

Green Software Engineering: Measuring Energy, Not Just Performance

Wed, 07 Jan 2026 20:56:20 +0000

This article was originally published on dev.to: https://dev.to/fadydesokysaeedabdelaziz/green-software-engineering-measuring-energy-not-just-performance-3i00

We measure speed, but what about the energy?

Most software engineers measure success using performance metrics. We optimize for speed, latency, and throughput, assuming that faster software automatically means better software. However, in 2026, an equally important question is often overlooked: how much energy does our software actually consume?

Faster software does not always mean more energy-efficient software. High CPU utilization, excessive memory usage, and inefficient execution patterns can significantly increase energy consumption, even in systems that appear highly optimized from a performance perspective. Optimizing solely for performance ignores a critical sustainability dimension that modern software systems can no longer afford to overlook.

Green Software Engineering focuses on building software that minimizes energy consumption and resource waste while maintaining acceptable levels of performance. It treats energy as a first-class metric, alongside traditional software quality attributes such as performance, reliability, and scalability. Instead of asking only how fast a system runs, Green Software Engineering encourages engineers to ask how efficiently that system uses computational resources.

Energy consumption is not always directly measurable at the hardware level, especially in cloud-based or shared environments. However, software engineers can still analyze energy-related behavior through indirect indicators such as CPU and memory utilization patterns, execution time, workload characteristics, and resource allocation strategies. These indicators provide valuable insights into how software design and implementation choices impact overall energy usage.

In my recent research work, I focus on analyzing software resource usage and energy consumption to support the development of more sustainable software systems. By combining data analysis with software engineering principles, it becomes possible to design systems that balance performance requirements with energy efficiency goals in a practical and measurable way.

Green Software Engineering is not a passing trend. It represents an essential evolution in how we design, evaluate, and maintain software systems. Understanding and measuring energy consumption today will play a key role in shaping the sustainability of software tomorrow.

Related work and experiments:
https://github.com/Fadydesoky/green-software-energy-analysis