Avoid Designing Yourself Into a Corner: Exploring the Compatibility of Java/Kotlin with Agile Development

⚠️ This article is based on the author's real-world experience and observations, structured and organized with the assistance of OpenAI's AI assistant. As the content includes the author's subjective views, readers are encouraged to evaluate the information for themselves.

🔥 Real Experience: "Argument Addition Hell" in a Java Project

In a certain Java project, I added a single argument to a service method, and it turned out that multiple areas needed modifications, including callers, DTOs, tests, the API layer, and XML configurations, causing the scope of changes to expand far more than anticipated.

At this moment, I strongly realized that if initial design decisions are naive, subsequent specification changes will come with significant costs. As a result of prioritizing "making it work for now" and compromising on design, I experienced the risk of a minor change rippling across dozens of locations.

🧱 Design Remains Crucial Even in Agile

In Agile development, "making it work first" is prioritized, but if you neglect design, it is no longer truly "Agile."

Especially in a static and strict language like Java, initial compromises such as the following become technical debt that impacts future development:

• Ripple risks due to DTO bloat
• Service layers with ambiguous responsibilities
• Frequent breakage of methods created "just for now"

Consequently, I realized that Agile development cannot be sustained without design flexibility.

🧭 Example of Impact Scope When Adding Arguments

The following diagram illustrates the structure where the impact spreads just by adding a single argument.

💣 Why Java Is Not Suited for Agile Development (From a Structural Perspective)

While Java is robust, it has a structure that is somewhat incompatible with Agile development, which involves constant change:

1. Verbose Syntax: Extensive boilerplate code like getters/setters and null checks increases overhead.
2. Strict Signatures: Changing an argument ripples to all callers, making it prone to breaking changes.
3. Heavy Initial Configuration: Dependencies like DI and configuration files make it difficult to start small.
4. Trade-off between Type Safety and Flexibility: While types provide peace of mind, they lack adaptability to design changes.
5. Slow Evolution Pace: Adoption of modern syntax is slow, and its ability to follow the latest development styles is limited.

✅ Characteristics of Languages Suited for Agile Development

Perspective	Necessary Elements
Flexibility	Syntax and design that allow for minor changes
Conciseness	Less code, allowing for lightweight construction
Maintainability	Design that prevents bugs and is easy to modify
Testability	High test affinity due to modularity and readability
Sharability	Syntax that is easy for others to understand

🚀 Is Kotlin Strong for Agile Development?

Kotlin possesses the following characteristics that match Agile development:

• Default Arguments + Named Arguments → Flexible to API changes
• data class / sealed class → Clear and concise model design
• Null-Safe Type System → Prevents NullPointerException in advance
• Extension Functions / Lambda Expressions → Testability and flexible design
• Expressiveness of DSL Syntax → Easy to clarify design intent

🤝 Latest News: Spring × JetBrains Strengthen Kotlin Support

In May 2025, JetBrains officially announced a strategic partnership with the Spring team (VMware), unveiling initiatives to accelerate the integration of Kotlin and Spring.

Key Collaboration Details

• Strengthening Null-Safety Mechanisms in the Spring API
• Expansion of Official Kotlin-based Tutorials and Materials
• Evolution of Bean Definitions via DSL (Bean Registration DSL)
• Reflection Performance Improvements via kotlinx.reflect

Reference: Strengthening Kotlin for Backend Development: A Strategic Partnership With Spring

🧩 Comparison with Other Languages (Author's Perspective)

Language	Flexibility	Dev Speed	Maintainability	Testability	Learning Cost	Comments
Java	○	△	◎	○	○	Stable but weak to design changes
Kotlin	◎	◎	◎	◎	○	Modern and ideal for Agile
Go	○	◎	○	○	◎	Suitable for small-to-mid scale
TypeScript	◎	◎	○	○	△	Standard for Web/Front-end with great affinity ◎

✅ Conclusion

In Agile development, resistance to change is the biggest challenge. While Java is robust, it has a structure where design failures can significantly impact future development. Conversely, Kotlin enables a design that balances flexibility and maintainability, and with its deepening integration with Spring, it is a practical choice in real-world environments.

Language selection is not just about choosing syntax; it is an important decision that includes team culture, developer experience, and preparation for specification changes.

🔚 Afterword

I hope this article helps you find a language that provides the "perfect level of flexibility" for your development environment.