Snyk’s annual Capture the Flag event, Fetch the Flag 2025, is back! Hosted by Snyk and John Hammond, the event will take place on February 27, 2025, from 9am ET to 9pm ET. Engage in 20+ real-world security challenges, enhance your professional development & earn CPE credits.

Hi ,

Welcome to a brand new issue of ProgrammingPro.

In today’sExpert Insight, we bring you an excerpt from the recently published book, Software Architecture with Kotlin, which discusses the You Ain’t Gonna Need It (YAGNI) principle, emphasizing minimalism, avoiding over-engineering, and adapting to change by implementing only necessary features.

News Highlights: React deprecates Create React App due to React 19 issues; Apiiro launches PRevent, a PR scanner for malicious code; Meta introduces ACH, an LLM-powered mutation testing tool; and Google introduces Gen AI Toolbox for Databases.

My top 5 picks from today’s learning resources:

But there’s more, so dive right in.

Stay Awesome!

Divya Anne Selvaraj

Editor-in-Chief

🚀 Three days. 20+ expert talks. Live Q&A. Interactive sessions. Join the global C++ community from anywhere—no travel, no hassle, just top-tier learning.

🎓 What’s in store?
✅ Workshops (24th Feb – 7th Mar) – Master embedded systems, concurrency, coroutines, and more. Includes free main conference access.
✅ Main Conference (26th – 28th Feb, 12:00 – 22:00 UTC) – Live talks, lightning sessions, interactive posters, and open community discussions.
✅ Exclusive Features – Build your own agenda, access slides, join meetups, and network in an interactive virtual venue.

💰 Exclusive Offer: ProgrammingPro readers get 15% off the main conference pass with code PACKT2025_15.

Sign Up|Advertise

Here’s an excerpt from “Chapter 2: Principles of Software Architecture" in the book, Software Architecture with Kotlin, by Jason (Tsz Shun) Chow, published in December 2024.

You Ain’t Gonna Need It(YAGNI) is a principle that states that functionalities should not be implemented until they are needed. This principle came fromExtreme Programming(XP) as an approach to improve software quality and respond to changing business

requirements.

This principle is also related to the idea of minimalism in software development, which states that we should avoid unnecessary code and complexity in exchange for clean, easy-to-understand, andextensible software.

Another way to describe YAGNI is as the imperative to do the simplest thing that works. This is by no means an incomplete design or unfulfilled user requirement. It still promotes complete and functional software that satisfies user requirements with the simplestdesign available.

YAGNI aims at a few practices:

There is also an opposite idea though:future-proof architecture. It aims at creating systems that are unlikely to be obsolete or to fail in the future. This sounds very appealing. If we can build a system that can fulfill future requirements, we will have saved time and effort that would otherwise be spent continuouslyevolving it.

However, there is an assumption behind this. You need to predict the new requirements and you need to be right. That is equivalent to knowing the future. Itrarely happens.

If you are certain about requiring a feature in the future, then it is neither a prediction nor a future requirement. It is simply arequirement now.

This does not mean that we should build systems based on short-term objectives or take shortcuts. Instead, we should build systems that are ready to adapt to new requirements but not havethese implemented.

Capacity planningshould not be mistaken for future-proof architecture. Capacity planning is an operational concern related to deployment and physical resources. For instance, building a road to handle twice the current traffic is different from building a branch of the road that goes nowhere. Leaving headroom for expansion, extra volume, and extra traffic is part of the readiness for evolution. Capacity planning is an NFR, not a future requirement. We would not want the system to run on edges that may collapse in response to a fluctuation in the volumeof requests.

This mindset leads to a few outcomes. The software architecture aims for modular, extensible, and flexible components that are ready to make changes when theybecome necessary.

It implies that each component is highly cohesive but loosely coupled. It means that interfaces are small and specific. It also means that interactions among components are based on abstract interfaces and not concrete implementations. It further means that subclasses conform to the behaviors of their superclasses and are ready to be extended. Furthermore, it means that each component has only one reason to change. It also means that modifying a component does not require recompiling the entire system. It also means that concerns are separated so that when we want to adjust system quality attributes, we can address the particular concernin isolation.

Software Architecture with Kotlinwas published in December 2024. Packt library subscribers can continue reading the entire book for free or you can buy the book here!

That’s all for today.

We have an entire range of newsletters with focused content for tech pros. Subscribe to the ones you find the most usefulhere.

If your company is interested in reaching an audience of developers, software engineers, and tech decision makers, you may want toadvertise with us.

If you have any suggestions or feedback, or would like us to find you a learning resource on a particular subject, just respond to this email!