From Silent Coder to Respected Leader

Java technical leadership is a journey that transforms developers from focused coders into community contributors. With “silent coder” I mean a person who is focused on writing software but has no intention or interest in sharing what they have learned. Productivity is measured in how much work I as a person can get done. This mirrors Java’s early days when it was a closed-source language, its evolution hidden behind Sun Microsystems’ walls, its growth limited by what a single company could envision.

I still remember the moment everything changed. It was 2014 at JavaOne in San Francisco, which was the biggest and most famous Java conference in the world for decades, and I was watching Venkat Subramaniam present Java 8’s new features. As he transformed traditional for-loops into elegant stream operations, engaging with the audience and making complex concepts approachable, I realized something profound: technical knowledge alone wasn’t enough – how we share that knowledge matters just as much.

This was my first international Java conference, coinciding with one of the most revolutionary changes in Java’s history. The entire community was buzzing with excitement about Java 8’s new direction, with developers eagerly learning and teaching each other about lambda expressions, the Stream API, and the Optional class. The energy was infectious, but what truly changed my perspective was watching Venkat present. Here was Java 8, a complex and transformative update that could have been intimidating, being explained with such clarity and enthusiasm that even skeptics were won over.

We write code for others to read and occasionally for machines to execute

Venkat Subramaniam

I remember going back to my hotel room that evening, my mind racing with possibilities. For the first time, I could envision myself not just learning from speakers, but potentially becoming one. The next morning, I even worked up the courage to approach Venkat after his session on functional programming patterns. To my surprise, he was welcoming and encouraging, spending several minutes discussing how he prepares his presentations. This brief interaction showed me that even renowned speakers in our community are approachable and willing to help others grow.

But my journey to that transformative moment – and beyond it – wasn’t straightforward. I had been working with software development for 25 years, paralleling much of Java’s own journey. Just as Java started as a language meant for embedded systems and television set-top boxes, I began my career focused narrowly on embedded systems and C programming. And like Java, my journey has been one of continuous evolution.

The Silent Years (1990s-2010)

We don’t think you are suited to work in a team, that you are more of a person who wants to sit in a corner working on your own thing

Feedback from first interview

The Early Days

My journey as a developer mirrors Java’s early transformation in fascinating ways. Just as Java began as Oak, a language designed for embedded systems and interactive television, I started my career focused on embedded systems and C programming. And just as Oak’s creators discovered their technology had potential far beyond its original scope, I would eventually learn that my capabilities extended beyond solitary coding.

My journey started with a bachelors degree in electronics with a major in computer engineering. Like Oak’s initial closed development within Sun’s “Green Project,” I was totally focused on the technology and dreading standing in the spotlight. During my education, I was mainly working with embedded systems, assembler and C, and I enjoyed it – much like how Oak was originally designed for embedded consumer devices.

This was the late 1990s, a pivotal time when Java was making its own transition. Just as Java’s team realized that “Write Once, Run Anywhere” could revolutionize general-purpose programming, I got my first taste of Java in a course. But while Java was embracing openness and cross-platform compatibility, I retreated back to C and systems programming, choosing isolation over collaboration – much like how Oak might have remained a niche technology had it not evolved into Java.

The idea of writing software for end users and working in teams didn’t appeal to me – I wanted to focus on the low-level technology, just me and the problem, no other people involved. The irony isn’t lost on me now: while Java was transforming from a closed project into an open, community-driven platform that would connect millions of developers worldwide, I was deliberately choosing paths that would keep me isolated.

I actually got rejected in one of my first job interviews with the feedback, “We don’t think you are suited to work in a team, that you are more of a person who wants to sit in a corner working on your own thing.” Looking back, this feedback perfectly captured where I was in my journey – still focused on the machine level while the industry, led by Java, was moving towards more collaborative, high-level software development. Just as Java had to break free from its initial constraints to reach its full potential, I too would need to step out of my comfort zone to grow.

Action Items:

1. Schedule 15 minutes this week to write down one technical problem you solved recently
2. Share your solution in your team’s Slack/Discord channel or during the next team meeting
3. Find and join your local Java User Group on Meetup.com – even if you just observe the first few meetings
4. Set up a technical blog (e.g., on dev.to or Medium) – write your first draft about that problem you solved

First Steps Toward Community (2000-2010)

While Java developers were building a robust ecosystem of shared libraries and frameworks, I was discovering the power of community in the Linux world – though I remained just a consumer of information, afraid that I had nothing unique to contribute.

Finding My Place in the Linux World

I managed to get a job at a small company working mainly with systems programming and device drivers in Linux. That’s where I first came into contact with a community. While Java developers were building a robust ecosystem of shared libraries and frameworks through the newly-created Java Community Process (JCP), I was discovering the power of community in the Linux world.

But I was still just a consumer of information, not sharing what I knew because I felt that I didn’t know anything that the community didn’t already know. I was also afraid to make mistakes that would make me look incompetent. The sometimes harsh tone in the Linux community – quite different from the more welcoming Java community I would later discover – didn’t help my confidence.

For those who, like me then, are solely consuming community content – take that first step toward participation. Find your local Java User Group (JUG). Even if you just attend one meeting, you’ll be surprised how welcoming these communities are. I wish I had done this sooner in my journey.

The Unexpected Bridge: From Fitness to Speaking

Around 2010, as Java was evolving from its enterprise-focused Java 6 era toward the more modern Java 7, something unexpected happened that would later prove crucial to my transformation. I joined a local gym to address my health issues, and discovered a passion for fitness that would ultimately help me overcome my fear of public speaking.

When the gym needed instructors, I volunteered – a decision that seemed unrelated to my technical career at the time. But leading fitness classes taught me fundamental lessons that would later prove invaluable:

• How to read a room and adjust based on participant feedback
• Breaking down complex movements into digestible steps
• The importance of authenticity over perfection
• Managing energy levels and engagement

These skills would soon find an unexpected application in my technical career. Just as I learned to break down complex workout routines into manageable sets, I would later apply the same principle to explaining intricate Java concepts. The confidence I gained from standing in front of a fitness class would become the foundation for my future technical presentations.

Action Items:

1. List three non-technical activities you enjoy or excel at
2. For each activity, identify one skill that could apply to tech leadership (e.g., teaching music = breaking down complex concepts)
3. Volunteer to lead your next team’s retrospective, applying these transferable skills
4. Ask your manager for a 15-minute meeting to discuss growth opportunities that align with these skills

The Transformation Begins (2010-2014)

As we debated language features and solved practice problems together, I discovered something surprising: each of us, despite working with the same language, brought unique insights and approaches to the table.

Finding Community in Java

When I joined a company building applications for cell phones using Java and Java ME, I found myself naturally applying these presentation skills in team discussions. The same techniques I used to guide people through challenging workouts helped me explain technical concepts to colleagues. During our code reviews, I started noticing how my experience reading the energy of a fitness class translated surprisingly well to gauging team members’ understanding of complex code.

Those study sessions became my first real taste of collaborative learning in the Java ecosystem. As we debated language features and solved practice problems together, I discovered something surprising: each of us, despite working with the same language, brought unique insights and approaches to the table.

This realization was preparing me for that transformative moment at JavaOne, though I didn’t know it yet. Each small step toward community involvement was building the foundation I would need.

If you see yourself in this phase of my journey, start small. Next time your team has a technical solution to discuss, volunteer to present it. Even a 5-minute walkthrough of your code during a team meeting can build your presentation muscles. The key is to begin with an audience that already knows and supports you.

After JavaOne – Putting Inspiration into Action (2014-2022)

If I could lead a room full of people through a challenging workout, surely I could guide fellow developers through a technical topic I knew well.

From Inspiration to Implementation

After returning from JavaOne, inspired by Venkat’s presentation style, I started small. I began with lunch-and-learn sessions about Java 8 features for my colleagues. Just as developers were discovering the elegance of functional programming in Java, I was discovering the joy of helping others learn.

My experience as a fitness instructor proved unexpectedly valuable. The same skills I used to guide people through complex workout routines now helped me explain technical concepts. If I could lead a room full of people through a challenging workout, surely I could guide fellow developers through a technical topic I knew well.

Action Items:

1. Follow three Java community leaders on BlueSky/LinkedIn who inspire you
2. Write down three presentation techniques you admired from recent tech talks you’ve watched
3. Pick one upcoming Java conference (virtual or in-person) and submit a proposal for a lightning talk
4. Record yourself explaining a Java concept for 5 minutes – watch it back and note areas for improvement

The Next Level: Oracle Code One 2022

Just as my JavaOne experience with Venkat had opened my eyes to the power of technical presentation, a session at Oracle Code One 2022 would take my journey to the next level. I attended a session about “Growing beyond senior” with Bruno Souza, memorable for wearing a Brazilian flag as a cape. His message about technical leadership resonated deeply with where I was in my journey.

After that session, I did something that would have been unthinkable to my “silent coder” self – I approached Bruno to continue the conversation. This time, unlike at JavaOne, I wasn’t just seeking inspiration; I was ready to take action. I became his mentee, and that relationship would prove instrumental in preparing me for my biggest challenge yet: presenting at Devoxx Belgium.

Building Bridges in the Community

NCAY – Nobody Cares About You, they care how you can help them solve their problems

Bruno Souza

As I worked with Bruno, I began to see how my various experiences were connecting. The confidence I had gained from fitness instruction, the technical depth from my years of coding, and the inspiration from Venkat’s presentations – all these pieces started fitting together.

My journey to international speaking began with small steps in the local community. I started attending more JUG meetings, not just as a passive listener but as an active participant. Each small interaction built my confidence incrementally.

Finding a mentor transformed my journey, but I had to take the first step by approaching potential mentors. Look for experienced developers in your community who inspire you. Many are happy to provide guidance – they remember their own journey and want to pay it forward.

Through my mentor’s guidance, I learned that technical leadership isn’t just about speaking at conferences or writing blog posts – it’s about identifying opportunities to solve problems and share solutions in ways that benefit the whole team. This lesson proved especially valuable when we faced a significant challenge with application performance monitoring.

Through a beta testing program with a new APM tool, our team discovered how powerful development-time telemetry could be for improving application quality.

By instrumenting our application with OpenTelemetry, we gained insights that transformed how we approached performance and debugging:

Understanding N+1 Query Patterns: One of our most valuable learnings came from analyzing trace data during development. We discovered that a seemingly innocent REST endpoint was causing significant database load. The telemetry data revealed a classic N+1 query pattern hidden in our layered architecture – for each parent record, we were making separate database calls to fetch child records. By identifying this pattern early in development, we refactored our code to use join fetches, significantly reducing database load.

Cache Effectiveness Analysis: Telemetry data also revealed gaps in our caching strategy. While we had implemented caching throughout our application, the trace data showed we weren’t getting the hit rates we expected. In some cases, we were repeatedly fetching the same data despite having a cache in place. This led us to discover subtle bugs in our cache key generation and helped us optimize our cache eviction policies.

Shifting Left with Observability: Perhaps the most important learning was how integrating observability into our development workflow changed our team’s approach to performance. Instead of treating performance as a production-only concern, we made it part of our daily development practice:

• We started reviewing trace data during code reviews, catching potential performance issues before they reached production
• Team members began annotating their code with custom spans to provide better context for complex operations
• We established baseline performance metrics during development, making it easier to identify regressions

This experience taught me that sharing knowledge about observability patterns and practices was just as important as sharing code solutions. I organized a company-wide presentation about our learnings, demonstrating how early performance visibility had fundamentally changed our development workflow.

The presentation sparked valuable discussions about observability patterns across different teams, leading to the creation of shared instrumentation guidelines and performance monitoring standards. This collaborative approach to solving performance challenges became a model for how we could turn individual technical discoveries into team-wide improvements.

Your experiences, even if they seem ordinary to you, can provide valuable insights for others. Consider starting a technical blog or sharing your learnings on social media. That debugging breakthrough you had last week? Someone else is probably struggling with the same issue right now.

Action Items:

1. Start a “TIL” (Today I Learned) document to track your daily technical discoveries
2. Write a detailed Stack Overflow answer to one Java question this month
3. Contribute to one open source Java project’s documentation
4. Schedule a lunch-and-learn session with your team about a recent technical challenge you overcame

Coming Full Circle – From Audience to Speaker

Remember, your audience wants you to succeed

Frank Delporte

The Path to Devoxx Belgium

As I prepared for Devoxx Belgium, every lesson from my journey came into play. The presentation skills from my fitness instruction days helped me structure my talk. The technical depth from my years as a developer gave me confidence in my material. The inspiration from Venkat’s JavaOne presentation guided my delivery style.

When I reached out to the Foojay community for advice, Frank Delporte responded with invaluable tips. “Remember,” he wrote, “even though the conference is big, it’s a friendly crowd. They want you to succeed.” These words echoed what I had learned from Venkat years ago – that our community grows stronger when we help each other.

Standing on the Other Side

Finally, I found myself standing on that sloped stage at Devoxx Belgium, facing hundreds of developers. In that moment, I thought back to watching Venkat at JavaOne. Now I was the one sharing knowledge, helping others grow. The nervous developer who once sat in the audience was now the one inspiring others.

After my talk, I had the chance to thank Frank in person, and he invited me to join some speakers at a local pub. There, I met Gerrit Grunwald and other community members. As we shared experiences and stories, I realized how far I’d come from the days when I thought, “why would a speaker want to talk to me?”

As you grow in your journey, remember to create opportunities for others. Whether it’s helping a junior developer understand a concept, reviewing someone’s first conference proposal, or sharing speaking opportunities – you can be the bridge for others just as others were for me.

Action Items:

1. Create an outline for a 30-minute presentation on your chosen topic
2. Practice the first 5 minutes of your talk and record it
3. Share the outline with a trusted colleague for feedback
4. Submit the talk proposal to a local JUG or virtual Java meetup

The Virtual Revolution: Community Beyond Borders

Embracing Digital Connections

The evolution of our community took an unexpected turn when global events forced us to change how we connect. What initially seemed like a setback revealed new possibilities for knowledge sharing and community building. Virtual platforms removed geographical barriers, making Java expertise accessible to developers worldwide.

My first virtual conference talk was an eye-opening experience. While I missed the energy of a physical room, I found that the chat was buzzing with questions and discussions, sometimes more actively than in-person sessions. Developers who might have been too shy to raise their hand in a crowded room were now actively participating through text.

Tools like Discord, Twitter Spaces, and virtual JUG meetups have created persistent spaces for continuous learning and mentorship. I’ve had enlightening discussions with developers from Bangalore to Buenos Aires, each bringing their unique perspective to Java development. These platforms have become particularly valuable for developers in regions without active local Java communities.

Some key lessons I’ve learned about virtual community participation:

• Async interactions can be as valuable as live ones – sometimes more so. A thoughtful GitHub discussion or Stack Overflow answer can help countless developers over time.
• Screen sharing during pair programming sessions can be more effective than looking over someone’s shoulder. Tools like VS Code Live Share have transformed how we collaborate on code.
• Recording and sharing technical content has become more accessible. My blog posts and recorded presentations now reach developers I could never have connected with through traditional channels.

Virtual platforms have also democratized knowledge sharing. You don’t need to wait for a major conference to share your insights. Starting a technical blog, contributing to open source discussions, or hosting online workshops can help you build your voice in the community.

Bridging Physical and Virtual Worlds

The future of our community isn’t about choosing between physical or virtual engagement – it’s about leveraging both. When I mentor developers now, we might meet in person monthly while maintaining regular contact through Discord. Local JUG meetings are streamed to reach wider audiences, with remote participants contributing actively to discussions.

The key is understanding the strengths of each medium. Complex technical discussions often benefit from asynchronous, written communication where people can think through their responses. Live sessions, whether virtual or in-person, excel at building connections and handling dynamic Q&A.

Action Items:

1. Join two Java-focused Discord servers or Slack communities
2. Schedule one virtual pair programming session with a colleague
3. Create or join a virtual Java study group
4. Start a weekly technical discussion thread in your team’s communication channel

Lessons for the Next Generation

Looking back on my transformation from silent coder to community leader, I’ve learned several crucial lessons that I believe are valuable for any developer on a similar journey:

The Power of Small Steps

Remember how terrified I was of public speaking? What I didn’t realize then was that presenting isn’t just about standing on a stage – it’s about impact. Each small step built confidence:

• Leading study groups for certification
• Giving lunch-and-learn sessions
• Teaching fitness classes
• Speaking at local meetups
• Writing blog posts
• International presentations

The Importance of Mentorship

My journey has been shaped by various forms of mentorship:

• Indirect mentorship through speakers like Venkat
• Formal mentorship with Bruno
• Peer mentorship in the Java community
• Now, becoming a mentor myself

Technical Excellence Isn’t Enough

What I’ve learned is that technical expertise alone doesn’t make a leader. It’s the ability to:

• Share knowledge effectively
• Build bridges between people and technology
• Create opportunities for others to grow
• Contribute to the community’s collective knowledge

AI and the Evolution of Developer Learning

Transforming How We Learn and Share

The emergence of AI coding assistants has added a fascinating new dimension to how we learn and share knowledge in the Java community. When I first started programming, learning meant poring over documentation and books. Today, developers have AI-powered tools that can explain code, suggest implementations, and even help debug issues.

But rather than replacing community learning, these tools have enriched our discussions in unexpected ways. We are raising the level of abstraction. AI tools can help us discover alternative implementations that we haven’t considered. The focus is shifted from “what’s the right way?” to “what are the tradeoffs between these different approaches?”

AI tools are like having a junior developer who has read all the documentation but needs your expertise to make good decisions.

New Challenges, New Opportunities

This shift brings both opportunities and challenges for our community:

• Code reviews have evolved. Instead of focusing solely on syntax and style (which AI tools can check), we spend more time discussing architecture, maintainability, and business logic.
• The “why” has become more important than the “how.” When AI can suggest multiple valid implementations, understanding the principles behind choosing one approach over another becomes crucial.
• Knowledge sharing has become more nuanced. Rather than just sharing solutions, we’re sharing decision-making frameworks and architectural thinking.

In my mentoring sessions, I’ve noticed a change in the questions I receive. Instead of “How do I implement this pattern?”, developers are asking “The AI suggested these three approaches – how do I evaluate which is best for my use case?” This shift toward higher-level thinking is making our community discussions richer and more valuable.

Community Role in the AI Era

The rise of AI tools hasn’t diminished the importance of community – it’s made it more vital than ever. Here’s why:

• AI tools can provide answers, but they can’t share experiences. When I talked about the Digma observability implementation earlier, the value wasn’t just in the technical solution, but in the real-world context and lessons learned.
• Community discussions help develop critical thinking about AI suggestions. During our team’s lunch-and-learn sessions, we now regularly discuss how to effectively collaborate with AI tools while maintaining code quality and architectural integrity.
• The community helps navigate the rapid evolution of AI capabilities. Through our JUG meetings and online forums, we share best practices for integrating these tools into our development workflows.

Action Items:

1. Document three examples where AI tools helped you solve Java problems
2. Create a team guide for effectively using AI pair programming tools
3. Organize a team discussion about AI best practices in your development workflow
4. Start a repository of interesting AI-human pair programming sessions and their outcomes

I’ve found that AI tools, much like the IDEs and frameworks that came before them, are becoming part of our shared toolkit. But they’re not replacing the human elements that make our community special – the mentorship, the shared experiences, and the collective wisdom that comes from years of solving real-world problems together.

Looking Forward: The Next 30 Years of Java

The future I envision isn’t just about technical innovations – though those are important. It’s about creating an ecosystem where every Java developer feels empowered to contribute their unique perspective. Whether you’re a developer working on enterprise applications in Stockholm, a student learning Java in Lagos, or a startup engineer building microservices in Singapore, your experiences and insights matter.

A Call to Moving Forward

As Java enters its fourth decade, your voice matters more than ever. Throughout this article, we’ve explored various ways to grow from a silent coder to an active community member – from those first tentative steps of sharing in team meetings, to joining local JUGs, to sharing knowledge through blogs and presentations, to finding and becoming mentors.

Remember that becoming a technical leader isn’t about dramatic transformations – it’s about taking small, consistent steps forward while bringing others along with you. Every experienced speaker in our community started exactly where you are now. The strength of Java’s future lies not just in its technical innovations, but in the willingness of developers like you to share your unique perspectives and experiences.

What will your next step be in this journey?

Your Journey Begins Now

As I write this on Java’s 30th anniversary, I can’t help but reflect on my own transformation from that nervous developer who couldn’t imagine speaking to others, to someone who now regularly shares knowledge at international conferences. But more importantly, I think about all the developers reading this who might see themselves in my “silent coder” phase.

Remember: I didn’t transform overnight from a silent coder into a conference speaker. My journey began with a single small step – explaining a Java 8 stream operation to a colleague during lunch. Your journey can start just as simply:

Today:

• Open your IDE and find a piece of code you’re proud of. Write a brief comment explaining not just what it does, but why you designed it that way. This is your first step in documenting knowledge for others.
• In your next team meeting, speak up about one technical challenge you solved recently. It doesn’t need to be revolutionary – even small solutions can help others.

This Week:

• Find your local Java User Group on Meetup.com. Just knowing when they meet is a start. When you’re ready, attend one meeting – you don’t need to speak, just observe.
• Write a “TIL” (Today I Learned) note about something you discovered while working with Java. Keep it in a private repository for now. This builds the habit of documenting your learning journey.

This Month:

• Share one of your “TIL” notes with your team. It could be as simple as a useful method you discovered in the Java Collections API.
• Comment thoughtfully on one open source Java project you use. Even pointing out unclear documentation helps the community.

This Year:

• Give a 10-minute presentation at your company about a Java feature you recently mastered.
• Write your first technical blog post. Start with something you wish you’d known a year ago.
• Submit a proposal for a lightning talk at a local or virtual Java meetup.

The Java ecosystem thrives because developers like you eventually choose to share their experiences. Your unique perspective matters – whether you’re wrestling with Spring Boot configurations in Stockholm, optimizing Android apps in Lagos, or building microservices in Singapore. The solutions you’ve found, the mistakes you’ve made, the workarounds you’ve discovered – these are all valuable pieces of our community’s collective knowledge.

Think back to a moment when you were stuck on a problem, and someone’s blog post or Stack Overflow answer helped you break through. Now you have the opportunity to be that helper for someone else. Your voice – yes, yours – could be exactly what another developer needs to hear.

So, what will your first step be? The Java community has been building for 30 years, and we’re just getting started. Your chapter in this story begins now.

Remember: every Java expert you admire started exactly where you are today. The only difference is they took that first step.

Take yours today.