[Event] JManc 2025

I had the opportunity to attend JManc again this year—and once more, it was fabulous. The sessions were organic, deeply technical, and full of insights shared by developers across different domains. Here's my wrap-up from the day, highlighting a few memorable sessions and conversations.

1 Tony Wilson, Manchester

30 Years of Java — Jim Gough’s Retrospective

Jim Gough delivered a fantastic keynote on the evolution of Java over three decades. As a Java Champion, his perspective mixed historical insight with a touch of humor and lived experience. Here are some of the milestones he covered:

  • Applets & Early UI: Java’s original fame came from applets—tiny applications that ran inside web browsers. 
  • AWT & Swing: Early GUI development in Java involved the AWT toolkit, later replaced by the more versatile Swing.
  • JavaFX: The modern Java UI framework that succeeded Swing. It was eventually removed from the JDK and spun out as an open-source project. While less commonly used in modern web-first development, JavaFX remains powerful for rich desktop applications.
  • Collections API: Java didn’t always have the familiar List, Map, and Set interfaces. The collections framework demonstrates Java's characteristic of Object Oriented Design.
  • Generics: Added in Java 5, generics brought compile-time type safety to the language.
  • Date/Time APIs: The original Date and Calendar classes were messy and mutable. Java 8’s LocalDateTime and related classes (from JSR-310) finally gave Java a clean, immutable time API.
  • Lambdas & Streams: Java 8 also introduced lambdas, allowing functional programming and vastly simplifying code for iteration, filtering, and transformation.

Jim also asked audience members to share their Java stories. I shared:

“My first Java program was in 2002, working with JCA for encryption and decryption. Even now, I still find JCA reliable. I also used Servlets and JSP—technologies that may be seen as legacy now, but I still find them elegant in their simplicity. I'm hopeful for future UI innovations in Java, especially in areas like JavaFX or beyond.”

Selfie with Jim Gough

Session 1: Quarkus vs Spring

This session compared two popular choices for building backend applications in Java. The discussion was grounded in real-world experience and focused on trade-offs.

Quarkus

  • Designed for cloud-native workloads and microservices
  • Emphasizes fast startup times and low memory usage—ideal for containers, serverless, and Kubernetes deployments
  • Lightweight, developer-friendly with hot reload
  • Lacks the breadth of built-in libraries and abstraction layers that Spring provides

Spring

  • Complete and mature ecosystem (Spring Boot, Spring Security, Spring Data, etc.)
  • Extensive support for dependency injection, configuration, and modularity
  • XML-based configuration was noted as both flexible and hard to test
  • Rich in community tooling and documentation

To wrap up, Spring offers completeness and convenience, especially for enterprise systems. Quarkus is leaner and optimised for performance-critical, containerised deployments.

Breakfast

Cappuccino

Session 2: What is TDD?

We started with a simple question: What is Test-Driven Development (TDD)?

The discussion opened up several threads:
  • TDD isn’t about testing, but about designing with feedback. Writing tests first helps shape APIs and logic with clarity.
  • Working with legacy code that wasn’t built with TDD in mind is difficult. Often, these systems are tightly coupled and require significant refactoring before becoming testable.
  • TDD encourages modular design, which makes code more adaptable.
  • Cultural factors are just as important—communication and team mindset are crucial for successful TDD adoption.
  • We also explored the difference between TDD (writing tests before code) and BDD (writing specs that describe behavior).
“TDD is not about coding tests—it’s about teamwork, communication and designing cleaner, more reliable systems from the ground up.”

Session 3: Event-Driven Architecture and Apache Kafka

In this session, we explored the principles of event-driven systems, focusing on Apache Kafka.

Key points discussed:

  • Kafka promotes loose coupling between producers and consumers
  • It provides durability and scalability, but introduces challenges:
  • No ordering guarantee across partitions
  • Possibility of duplicate events
  • Systems built on Kafka are often stateless, requiring thoughtful design for consistency and orchestration
  • Event-driven design is powerful for decoupling systems but requires careful thinking around delivery guarantees and idempotency


Hallway Conversations

As always, some of the best insights came outside the sessions.

AI in DevOps

In a conversation with Waqas, we explored ideas around using AI in CI/CD pipelines. I shared that AI could:

  • Detect flaky or failing tests based on patterns
  • Recommend release rollbacks or retries
  • Even automate state-driven workflows, such as those involving Stripe payments

Data Pipeline with Apache projects

With Lorenzo, we dived into data integration stacks in addition to Apache Kafka:


JManc 2025 Marketplace

Final Thoughts

Big thanks to the Manchester Java Community helpers for organising such a smooth and welcoming event, and to Autotrader, who generously hosted us in a modern, comfortable space.

The JManc covered a wide range of technical and strategic topics. What stood out for me most was how grounded and honest the discussions were—whether we were talking about Quarkus, TDD, or event-driven architecture. All were just about developers sharing, our experiences, our problems, our ideas.

Java is 30 years old and still evolving—and so are we. 


Comments

Popular posts from this blog

Love of the Phantom

Bookcrossing

Women's Day