Ask a Lille Dev: What Java Developers Really Think About Quality, Frameworks, Communities, and Careers

Author: Vincent Vauban

Original post on Foojay: Read More

During the DevLille 2026 conference in Lille, I interviewed several Java developers and tech professionals with one simple goal: collecting authentic and spontaneous insights from the Java ecosystem. ☕🎤

The result became “Ask a Lille Dev”, a mini podcast made of short interviews recorded directly during the conference. Instead of long talks or polished marketing speeches, the idea was simple: ask practical questions to people working in tech every day.

The questions covered architecture, developer experience, tech communities, Java frameworks, onboarding, IntelliJ IDEA, DevOps collaboration, and software quality.

Interestingly, despite different backgrounds and technologies, several common themes appeared repeatedly: simplicity, collaboration, curiosity, learning, and strong communities.

You can also watch the video playlist here:
https://www.youtube.com/playlist?list=PL4VxEEmdGealwvizViYdrk3lvMwrbavYo

You may also enjoy these related Foojay topics:

• Java and cloud-native development

• Developer experience in modern Java

• Community-driven software engineering

• JVM ecosystem evolution

---

Quality in Development: Simplicity Still Wins

One topic came back constantly during the interviews: software quality.

However, developers did not only speak about unit tests or static analysis. Instead, they emphasized engineering culture and technical understanding.

Several developers mentioned the importance of keeping applications simple. The famous KISS principle — Keep It Simple, Stupid — remains highly relevant in modern Java applications.

Frameworks are useful. Nevertheless, developers also stressed the importance of understanding the fundamentals:

• the language itself,

• the runtime,

• the framework internals,

• and the root cause of production problems.

According to several interviewees, quality comes from understanding why something works or fails.

Additionally, many practical engineering practices were mentioned:

• pair programming,

• mob programming,

• continuous delivery,

• pull request reviews,

• strong CI pipelines,

• and automated quality checks.

One speaker explained that pair programming acts as a “live review system,” while another highlighted the importance of delivering almost every day to validate business assumptions quickly.

Monitoring also appeared as a key subject. Developers explained that technical quality must integrate:

• observability,

• security,

• functional monitoring,

• and operational collaboration from the start.

Therefore, software quality is not a final validation step. Instead, it becomes a continuous engineering process shared by developers, architects, and Ops teams.

---

Favorite Java Framework: Spring Boot vs Quarkus

Another major topic was the favorite Java framework.

Interestingly, two frameworks dominated the discussions: Spring Boot and Quarkus.

Why Developers Still Love Spring Boot

Many interviewees described Spring Boot as:

• mature,

• battle-tested,

• reliable,

• and production-ready.

Several developers explained that Spring Boot allows teams to:

• create projects quickly,

• manage deployments easily,

• deploy to containers or cloud platforms,

• and integrate modern technologies such as GraalVM.

Moreover, developers appreciated the ecosystem maturity and the confidence it provides in enterprise environments.

One recurring idea was simple: Spring Boot allows developers to focus more on business problems and less on infrastructure complexity.

Why Quarkus Generates Excitement

At the same time, Quarkus generated strong enthusiasm among developers focused on cloud-native systems.

The reasons appeared repeatedly:

• fast startup time,

• low memory usage,

• native compilation,

• cloud optimization,

• and developer experience.

Several speakers also praised the readability of Quarkus internals. Unlike some frameworks where abstractions become difficult to debug, Quarkus was described as more direct and understandable.

Developers additionally appreciated:

• local testing support,

• container friendliness,

• Kafka integrations,

• and native compilation support out of the box.

Finally, the Quarkus community itself received a lot of praise. Multiple interviewees described it as extremely welcoming and helpful.

---

Welcoming Girls in Tech: Inclusion Through Everyday Actions

Another important question concerned welcoming women into tech teams.

Most interviewees agreed on one central idea: women should simply be welcomed as full team members, with the same respect, support, and opportunities as everyone else.

However, several speakers also highlighted the importance of remaining aware of unconscious bias and meeting dynamics.

One interviewee proposed a very interesting exercise:

Count how many times a woman gets interrupted during a meeting.

That observation opened a broader discussion about giving people space to express ideas fully.

Developers suggested several concrete actions:

• reinforce ideas publicly,

• avoid interrupting,

• organize pair programming,

• create onboarding moments,

• invite new teammates to social activities,

• and use retrospectives to improve team dynamics.

Another strong point emerged repeatedly: diversity improves technical discussions.

Different perspectives often produce better ideas, better architecture decisions, and more inclusive engineering cultures.

---

Best Thing About Tech Communities

One of the strongest themes across all interviews was the importance of tech communities.

Developers described communities as places where people:

• learn faster,

• meet mentors,

• discover opportunities,

• and grow beyond their daily project environment.

Several communities were mentioned:

• DevLille,

• ChtiJUG,

• Quarkus communities,

• open-source ecosystems,

• and company guilds.

One interviewee explained that development is not only about writing code behind a desk. Instead, communities help developers:

• exchange ideas,

• challenge assumptions,

• discover technologies,

• and build relationships.

Another recurring idea was that communities break the stereotype of the isolated developer.

Communities also create career opportunities. Several speakers explained that conferences, open source, and community involvement helped them:

• become speakers,

• mentor others,

• gain recognition,

• or even obtain titles such as Google Developer Expert or Docker Captain.

Most importantly, communities create learning environments where developers continuously improve together.

---

Best Java Developer Skill Today: Adaptability

When asked about the most valuable skill for Java developers today, one word came back several times: adaptability.

Java evolved tremendously over the years:

• streams,

• records,

• virtual threads,

• pattern matching,

• cloud-native deployments,

• GraalVM,

• and reactive systems.

Therefore, developers explained that modern engineers must continuously evolve alongside the ecosystem.

Technical expertise still matters. Nevertheless, curiosity and adaptability now play an equally important role.

Several speakers also emphasized soft skills:

• communication,

• collaboration,

• curiosity,

• and positive team behavior.

One interviewee summarized it perfectly:

Great developers are not only technical experts. They also help teams grow.

---

Why Not Java? Kotlin, TypeScript, and Node.js Perspectives

Some interviewees also explained why they sometimes choose technologies other than Java.

Kotlin for the JVM Ecosystem

Kotlin appeared frequently as an alternative language.

Developers appreciated:

• native null safety,

• concise syntax,

• JVM compatibility,

• GraalVM support,

• and modern language features.

Android developers especially explained that Kotlin progressively became the natural standard within the Android ecosystem.

TypeScript and JavaScript

Other developers preferred TypeScript and JavaScript because of their immediacy and flexibility.

Several speakers explained that JavaScript ecosystems often feel:

• more concrete,

• faster to start with,

• and easier to experiment with.

TypeScript additionally brought stronger structure and scalability to large applications.

Nevertheless, most interviewees still respected Java deeply and continued using it for enterprise systems and backend applications.

---

Becoming a Java Architect

Another major question focused on architecture careers.

Most interviewees agreed that becoming a Java architect is a gradual evolution rather than a direct promotion.

Developers recommended:

• working on multiple projects,

• collaborating with different teams,

• learning several technologies,

• and building broad technical culture.

Architecture was also described as much more than framework knowledge.

A good architect should understand:

• optimization,

• security,

• scalability,

• DevOps,

• business constraints,

• and software design principles.

Most importantly, architects should not pursue technology for technology itself.

Instead, architecture should always serve business goals and user needs.

---

IntelliJ IDEA: Still the Favorite IDE

IntelliJ IDEA received overwhelmingly positive feedback.

Developers praised:

• Java integration,

• productivity shortcuts,

• debugging capabilities,

• plugin ecosystems,

• and developer comfort.

Some interviewees combined IntelliJ with VS Code:

• IntelliJ for Java development,

• VS Code for lightweight editing and documentation.

Several developers explained that IntelliJ significantly improves productivity because it helps developers:

• understand complex codebases,

• debug applications faster,

• and navigate large projects efficiently.

Therefore, IntelliJ was repeatedly described as more than an editor. It became a real engineering companion.

---

Working Efficiently With Ops Teams

Finally, many interviewees highlighted the growing importance of DevOps collaboration.

Several developers recommended creating:

• technical guilds,

• shared standards,

• observability frameworks,

• and recurring discussions between developers and Ops teams.

The goal is simple:
stop separating development and operations too early.

Instead, developers and Ops engineers should collaboratively define:

• monitoring,

• deployment standards,

• security,

• infrastructure practices,

• and operational tooling.

This collaborative approach improves software quality while also reducing friction between teams.

---

Final Thoughts

What started as short spontaneous interviews during DevLille 2026 eventually revealed something bigger about the Java ecosystem.

Despite different technologies, frameworks, and backgrounds, most developers shared common values:

• curiosity,

• simplicity,

• collaboration,

• learning,

• and community.

The Java ecosystem continues evolving quickly. However, strong engineering principles remain timeless.

And perhaps that is the real lesson from this “Ask a Lille Dev” experiment:
technology matters, but people and communities matter even more. ☕🚀

If you want to watch the full podcast playlist, you can find it here:
https://www.youtube.com/playlist?list=PL4VxEEmdGealwvizViYdrk3lvMwrbavYo

The post Ask a Lille Dev: What Java Developers Really Think About Quality, Frameworks, Communities, and Careers appeared first on foojay.