CodeIsGo.com

TDD approaches—classic (state-focused) and London (interaction-focused) — explained through Kotlin examples using test doubles like stubs and mocks. By Michal Przysucha.

The article demonstrates classic TDD through a property price calculator test, where the system under test (SUT) interacts with a stubbed collaborator (MarketPricesProvider) to return predefined values. Verification occurs via the SUT’s direct output (e.g., calculated price).

For the London school, the example extends to an orchestrator that generates reports and sends emails. Here, interactions between the orchestrator and its collaborators (calculator, templates, email sender) are verified using mocks, ignoring the final state. The author introduces test doubles: stubs (for indirect inputs), mocks (for interactions), fakes (simplified implementations), and spies (tracking invocations).

Two testing strategies emerge: Inside-Out (bottom-up, classic) and Outside-In (top-down, London), each with trade-offs—e.g., mock fragility vs. classic decoupling.

This article provides a clear, practical comparison of TDD schools using Kotlin examples, demystifying test doubles without framework bias. It’s valuable for developers transitioning between TDD styles but doesn’t introduce novel concepts. Its impact lies in clarifying trade-offs, making it a recommended resource for teams refining their testing strategy. Nice one!

PaloAlto Networks strengthens its AI security portfolio by acquiring Portkey, an AI Gateway specialist, to enhance governance and control of autonomous AI agents through integration with its Prisma AIRS platform. By Simply Wall St.

Palo Alto Networks’ $181.08-per-share acquisition of Portkey aims to integrate its AI Gateway technology into Prisma AIRS, offering enterprises enhanced visibility and protection for autonomous AI agents.

For investors watching AI related security, this move suggests that Palo Alto Networks is actively building out its toolset for enterprises deploying autonomous agents. The planned integration of Portkey into Prisma AIRS highlights a focus on governance and control of AI workloads, an area that could become increasingly important as adoption rises across sectors.

The integration could solidify PANW’s market leadership in AI-driven security, though funding for the deal and its impact on future earnings remain key considerations. Interesting news.

The AI “compute‑demand” hype is a mirage built on hyperscaler subsidies; without Amazon, Google and Microsoft’s deep pockets, OpenAI and Anthropic could never have scaled. By Ed Zitron.

Ed Zitron dismantles the “AI compute demand” narrative by exposing how hyperscalers are using their vast resources to prop up startups like Anthropic and OpenAI, creating an illusion of market need. For instance, Amazon and Google’s $65 billion combined investment in Anthropic—despite its $30 billion fundraising—reflects desperation rather than organic demand. Anthropic’s financials, projected to lose $29 billion in 2026 but claim $18 billion in revenue, highlight unsustainable models reliant on hyperscaler subsidies. Similarly, OpenAI’s Azure dependency (80% of Microsoft’s AI revenue) and Amazon’s $12 billion annual spend on Anthropic underscore a closed-loop system where hyperscalers fund their own AI ecosystems.

The article critiques circular financing, such as Google’s TPU sales to Anthropic via SPVs, which recycles capital without generating external revenue. Data center construction, though massive (e.g., 15.2GW under construction by 2027), lacks corresponding revenue streams, requiring $157 billion annually to monetize—far exceeding current AI compute demand estimates. Zitron also notes that non-hyperscaler players struggle to compete, as building AI infrastructure requires expertise and capital beyond most startups. This centralization risks creating systemic weaknesses in smaller cloud providers like CoreWeave, which depend on hyperscaler contracts. Nice one!

Open source powers Europe’s digital economy, contributing €65–95B annually to GDP. From energy (Baltic RCC) to cloud (NUBO), finance (Deutsche Bank), and mobility (EV charging), real-world use cases show how it boosts resilience, innovation, and sovereignty. By Paula Grzegorzewska.

More detailed feedback is provided in the accompanying document, while the key points are summarised as follows:

• Open source is a basis of successful business ventures and is widely used across industries, with most modern software built on open source components, whether proprietary or not. It is a diverse ecosystem spanning multiple governance, sustainability, and commercial models, and the Linux Foundation welcomes the Call for Evidences acknowledgment of this reality and its pursuit of pragmatic, evidence-based approaches to strengthen EU competitiveness and technological autonomy.
• Europe should build on and influence the global open source commons rather than pursue isolated notions of European Open Source, as existing global projects already underpin cloud, AI, and emerging digital infrastructure. Strategic upstream investment and participation in these commons - alongside scaling local commercial open source companies through funding instruments, market-access initiatives, and updated procurement practices - offers the most realistic path to technological sovereignty, innovation, and talent retention.
• Critical open source infrastructure should be hosted under neutral governance to ensure balanced decision-making, mitigate single-vendor and lock-in risks, and foster rapid de facto standardisation.

Europe’s commercial open source scale-up pipeline remains underdeveloped, making it difficult to turn strong open source projects into globally competitive product and services companies, as well as retain talented European founders, especially when compared to the US. Good read!

Ubuntu 26.04 LTS (Resolute Raccoon) brings Linux kernel 7.0, GNOME 50, TPM‑encrypted installs, and Rust‑based sudo for a hardened, performance‑focused release. By John Britto.

Ubuntu 26.04 LTS builds on two years of development since the 24.04 cycle, delivering a feature‑rich LTS aimed at desktop users, developers, and server administrators. The kernel jumps to version 7.0, adding native support for Intel Panther Lake (Xe3) processors, NPU optimizations, full Xe2/Arc Battlemage graphics, and NVIDIA Dynamic Boost.

A real‑time kernel is now available in the main archive without Ubuntu Pro. GNOME 50 introduces HDR color management, grouped notifications, improved remote desktop/touch input, and new default apps (Showtime, Resources, Papers) while dropping legacy X11 sessions in favor of a Wayland‑only desktop (XWayland provides backward compatibility). The installer gains better wireless (Wi‑Fi 7, Bluetooth 5.4) handling and automated TPM encryption setup; dracut replaces initramfs‑tools, and APT 3.1 ships a faster dependency resolver.

Security is tightened: AppArmor now prompts for snap access to camera/mic/files, TPM 2.0‑based full‑disk encryption is enabled by default, sudo‑rs replaces the C sudo, and Livepatch extends to ARM64. Systemd moves to v259, removing cgroup v1 support and ending System V init script compatibility. Performance tweaks include optional x86‑64‑v3 packages (AVX2/BMI2/FMA) for Haswell‑plus CPUs, VA‑API video acceleration, and crash dumps enabled by default for better post‑failure diagnostics. Nice one!

In the age of AI-assisted coding, the sharpest Unity C# programmers are the ones who still write, debug, and understand code the old-fashioned way. By Darko Tomic.

Writing for Unity developers at any level, Darko Tomic makes the case that AI tools, while impressive, can erode the foundational skills that distinguish competent programmers from copy-paste operators.

His advice spans six areas: deliberately coding without AI assistance to build mental models, treating every Unity error message as a diagnostic tool rather than noise, making debugging the first resort rather than the last, adopting Git from the very start of a project, memorizing the Unity MonoBehaviour lifecycle execution order, and stepping away from the keyboard when stuck.

Some main ideas mentioned:

• Coding without AI for a few hours each week builds mental models that make you a better developer and a better prompter.
• Treating every Unity error message as a diagnostic story—rather than noise to outsource to an LLM—drastically reduces debugging time.
• Debugging is a core skill, not a fallback; use logs and stepping to verify assumptions before changing code.
• Start every project with Git from day one, learn it in the terminal first, and don’t rely on GUI clients as a crutch.
• Memorize the Unity MonoBehaviour execution order page to eliminate an entire category of initialization bugs.
• Step away from the keyboard when stuck—your brain continues solving problems in the background.
• The differentiator in 2026 is not output speed but the ability to understand, debug, and extend code that AI produced.

The underlying thesis is that AI accelerates output but not understanding, and that the developers who invest in fundamentals now will be the ones called upon when AI-generated code inevitably breaks in ways only human insight can resolve. Good read!

The fifth report in our Meta-sponsored series examines the open source AI opportunity for Canada. Key findings show that despite the country’s early momentum in policy development, funding, and academic excellence, it faces challenges in the commercialization of AI. By Hilary Carter, Anna Hermansen, the Linux Foundation.

Canada’s AI sector, despite its significant research and investment contributions, faces challenges in AI commercialization and scaling adoption. The article posits that open source AI can help address these issues. Open source can lower barriers to entry, enable model fine-tuning, and provide cost-effective access to technology. It also supports workforce training and data privacy, fostering innovation and public trust.

To leverage this, Canada should strengthen its open source infrastructure, accelerate workforce reskilling, and improve commercialization pathways for startups. This can be achieved by building on existing AI strategies, incentivizing adoption in key sectors, and fostering public trust through transparency. Good read!

The Raspberry Pi’s 15-year journey has been one of evolution and adaptation, from its humble beginnings as an educational tool to its current status as a beloved hobbyist and maker staple. Its success can be attributed to its affordability, extensibility, and the vibrant community that has grown up around it.

However, the single-board computer landscape is shifting, with new competitors vying for market share. Mini PCs, with their more powerful processors, faster storage, and higher RAM capacities, are increasingly popular choices for resource-intensive tasks like homelab projects and media streaming.

These devices, often based on x86 or ARM architectures and featuring solid-state storage, offer more bang for the buck than the Raspberry Pi. At the other end of the spectrum, the ESP32 platform has gained traction for its low cost, low power consumption, and versatility in simple, power-efficient IoT and smart home projects.

While these competitors pose a challenge to the Raspberry Pi, the Pi’s extensive software support, community backing, and historical precedent ensure its continued relevance. Furthermore, older Raspberry Pi models remain compelling budget options, with a wealth of projects and resources tailored to their capabilities.

While the Raspberry Pi’s reign as the king of single-board computers may be waning, its influence and relevance are undeniable. Fortunately, with a dedicated community and a history of overcoming challenges, the Raspberry Pi is well-positioned to remain a staple in the maker and hobbyist communities for years to come. Nice one!

This article explores four distinct methods for running a full graphical Linux environment on Android devices, ranging from popular Termux-based solutions and standalone apps to replacing the Android OS entirely, providing a technical roadmap for developers and power users seeking desktop Linux capabilities on mobile hardware. By Bertel King.

The main topics in spotlight:

• How to run a full Linux desktop on your Android phone
• Termux-based apps
• Other standalone apps
• Replace Android with Fedora
• The Linux Terminal app
• Master of your domain

The article provides a valuable roadmap for a specific, power-user niche. However, the methods presented are largely incremental rather than significant advancements. The most impactful development mentioned—Google’s native Linux Terminal—is currently in the “bleeding edge” phase and not ready for prime time.

Until native support arrives, running Linux on Android remains a domain for the technically adventurous, requiring patience and a tolerance for workflow friction. It solves a real problem for mobile developers, but it is not yet a seamless consumer experience. Good read!

Frontend memory leaks remain alarmingly prevalent in production codebases, with 86% of 500 analyzed repositories containing at least one missing-cleanup pattern that can silently accumulate memory at a rate of approximately 8 KB per navigation cycle. This comprehensive study combines static analysis across React, Vue, and Angular frameworks with controlled benchmark scenarios to quantify both the prevalence and real-world cost of these often-overlooked issues. By Ko-Hsin Liang.

Following topics are discussed:

• What “memory leak” actually means in a garbage-collected runtime
• Part 1: How common are missing-cleanup patterns in the wild?
• Part 2: What does missing cleanup actually cost?
• How scan findings map to benchmarks
• When missing cleanup is acceptable (and when it’s not)
• How to find this in your own codebase
• The fix is almost always one line
• How this study relates to existing approaches
• Caveats and limitations
• What this means for your codebase

This study provides compelling, data-driven evidence that frontend memory leaks are not a theoretical concern but a pervasive, quantifiable reality in production codebases. By combining AST-based static analysis of 500 repositories (714,217 files) with controlled benchmark scenarios, the research establishes two critical findings: first, that 86% of repositories contain at least one missing-cleanup pattern, with 55,864 potential leak instances identified; and second, that each unhandled pattern retains approximately 8 KB of heap growth per navigation cycle, compounding linearly with user interactions. Good read!