Röck Yoür Cöde: Application Globalization Workshop

In our increasingly interconnected world, creating applications that work seamlessly across diverse languages and regions is more critical than ever. Many projects overlook globalization until it’s too late, resulting in costly and time-consuming retrofitting efforts. This workshop will equip you with the practical knowledge and tools needed to address globalization from the start, saving your team time, money, and frustration.

In this immersive, hands-on workshop, you'll dive deep into the fundamentals of globalization and internationalization. You’ll learn how to correctly handle numbers, dates, and time formats to ensure smooth localization for different regions. Beyond that, we’ll cover how to effectively manage user-facing text by preparing resource files, refactoring strings into these resources, and applying advanced string globalization techniques. These skills will set you on the path to creating applications that users across the globe will find intuitive and easy to use.

This workshop isn’t just theoretical—you will leave with tangible results. Bring your laptop and any relevant work projects to immediately implement what you’ve learned. By the end of the session, you’ll have a solid foundation to continue globalizing your projects back at your workplace.

You'll also discover how to streamline the process of string translation, making it faster, easier, and more cost-effective. Additionally, we will cover how to optimize your development workflow by configuring the .editorConfig file to identify and resolve globalization-related issues seamlessly.

By the conclusion of this workshop, you'll be prepared to build applications that cater to a global audience, improving accessibility, user experience, and market reach. The best part? This workshop is application-agnostic—whether you're working on a web app, desktop software, or mobile solution, the skills you acquire are universally applicable.

Pre-Workshop Instructions:
• Bring your laptop and any relevant work or personal projects that you want to globalize (mandatory).
• Ensure you have Visual Studio 2022 installed and updated to the latest version.
• Make sure your Azure account is set up and ready for use.

Join this hands-on workshop to master the art of building applications that thrive across languages and regions. Learn how to address globalization from the start, saving time and reducing costs. We’ll cover best practices for handling dates, times, numbers, and user-facing text, as well as advanced string globalization techniques. Bring your laptop and work on real projects, applying what you’ve learned to immediately enhance your applications. By the end, you’ll be equipped with practical tools and a solid foundation for globalizing your software, regardless of platform.

Unleash Your Inner Rockstar: The 5 Steps to Dynamic Public Speaking!

Ready to elevate your career, captivate your workplace, or take the leap into the world of conference speaking? This session is for you! With over 30 years of experience in public speaking, I'm thrilled to share the essential five steps that will transform you into a dynamic speaker and presenter.

If you’re like I was at the start of my journey—nervous, unsure, and wondering how to capture the audience's attention—this session will help you conquer those fears. My unique approach to public speaking has not only helped me overcome stage fright but has also allowed me to build an impactful career as an award-winning developer, university educator, published author, blogger, patented inventor, and more!

In this engaging talk, you’ll learn actionable strategies you can implement immediately to:
• Master the art of speaking with confidence and clarity.
• Deliver presentations that resonate with your audience and keep them engaged.
• Overcome stage fright and embrace the spotlight.
• Establish a lasting impact on any audience, whether you're addressing your peers, leadership, or large crowds.

You'll also discover my top-secret tip for presenters—one simple technique that guarantees to leave your audience hungry for more.

This session isn’t just about speaking; it’s about empowering yourself and enhancing your career. Come join me for this electrifying talk and let’s unlock your potential as a rockstar speaker, elevating your communication skills to new heights and amplifying your engineering expertise!

Learn 5 proven steps to master public speaking from a seasoned expert with 30+ years' experience. Discover the secrets to captivating audiences and advancing your career!

Röck Yoür Cöde: Seven Important Requirements for Any Successful Project

In this high-impact session, I will share actionable insights on how developers can ensure that their code meets the stringent quality and performance standards required for successful production deployment. All too often, the pressure to deliver quickly can lead to short-term compromises on code quality, which may accumulate into technical debt and other serious issues down the line. While business goals and deadlines are important, it’s crucial for developers to take the lead in establishing a robust architecture, rigorous standards, and best practices that ensure long-term reliability, scalability, and maintainability.

In this talk, I will dive deep into seven critical topics that every developer must consider when building apps destined for production environments. We’ll explore practical strategies that range from effective testing, debugging, and profiling to the importance of thorough documentation and streamlined deployment processes. Each topic will be supported with real-world examples, including how to integrate these best practices into your development workflow without slowing down delivery timelines.

By adopting these principles, you’ll be able to minimize risk, enhance application performance, and deliver high-quality solutions that your customers will trust and love. Whether you’re tackling your first production release or optimizing an existing system, you’ll walk away from this session with a toolkit that you can immediately apply to improve code quality, reduce future rework, and set your projects on a path to sustainable success.

Join me for this session, part of the "Improving Code Quality… One Developer at A Time" series, and learn how to build apps that not only meet but exceed your customers’ expectations!

In this session, I’ll share seven essential strategies for building production-ready code that meets high-quality, performance, and reliability standards. We’ll cover testing, debugging, profiling, documentation, and deployment, with practical tips for integrating best practices without delaying delivery. Leave with actionable tools to reduce risk, improve performance, and ensure long-term success in your projects.

Röck Yoür Cäreer: Time-Tested Wisdom from a 30-Year Software Engineering Veteran

Your career in tech is more than just code—it’s a long-term journey that deserves intention, strategy, and passion. In this engaging and highly motivating session, I share the lessons I’ve learned over more than 30 years as a software engineer and 18 years as a university educator. Along the way, I’ve authored multiple software engineering books, built and maintained a successful technical blog since the 1990s, earned a technology patent, and led an award-winning user group for over two decades. Everything I’ve done has centered on one mission: helping engineers build meaningful, successful, and sustainable careers.

This session is your roadmap to navigating the tech industry with confidence and clarity. I’ll pull back the curtain on what actually works—not just in theory, but in real life—when it comes to building a career that lasts and thrives.

You’ll learn how to:
• Develop powerful learning habits to stay relevant in a constantly evolving industry
• Create a healthy work-life balance without sacrificing ambition or growth
• Use conferences and community events to build authentic, long-term professional relationships
• Identify and leverage your unique strengths to stand out and advance your career
• Protect your mental and physical well-being for long-term success and happiness

This isn’t a motivational talk filled with empty platitudes. It’s a practical, honest, and energizing conversation about how to build a tech career you’re proud of—one that grows with you, supports your life, and fuels your creativity.

You’ll walk away with actionable guidance, renewed confidence, and a clear sense of direction. Bring your notebook, because this session is packed with career-shaping insights you can apply immediately.

Get ready to be inspired, motivated, and optimistic about what’s next in your tech journey. Your career deserves to rock just as hard as your code.

Your tech career is a marathon, not a sprint. In this session, I share practical, real-world lessons from over 30 years as a software engineer and 18 years as a university educator.

You’ll learn how to keep your skills sharp, build meaningful professional connections, maintain work-life balance, leverage your strengths, and protect your long-term well-being. Walk away with actionable advice to grow your career with confidence, purpose, and passion.

Röck Yoür Cöde: Optimizing Microsoft .NET Code for High-Performance - Game Show Edition

When your back-end systems are handling tens of thousands of requests per second—often across distributed microservices—performance is no longer optional. It directly impacts scalability, reliability, and cloud costs. High-performance code isn’t just about speed; it’s about building smarter, leaner, and more efficient systems.

Microsoft .NET has been evolving for over 25 years, and there are countless ways to solve the same problem. But which approach is truly the fastest? Which allocates the least memory? Which scales the best under pressure?
In this high-energy, interactive session, we turn performance tuning into a game show. You and your fellow attendees will be challenged with real-world coding scenarios, competing to identify the most performant solutions. Expect friendly competition, eye-opening benchmarks, and yes—fabulous prizes.

You’ll learn:
• How to recognize hidden performance traps in everyday .NET code
• Which modern .NET techniques consistently outperform traditional approaches
• How small optimizations can lead to massive gains in throughput and cost savings
• How to think like a performance engineer when writing production code

All demos are built on .NET 10, ensuring you’re seeing the latest language features, runtime improvements, and performance enhancements in action.
This session blends education with entertainment, delivering practical, immediately applicable techniques in a format you won’t forget. You’ll walk away with sharper instincts, stronger code, and a renewed passion for writing high-performance .NET applications.

Part of my ongoing series:
“Improving Code Quality… One Developer at a Time.”

This session also features insights and benchmark data from the fifth edition of my book, Rock Your Code: Code & App Performance for Microsoft .NET, available on Amazon: https://bit.ly/CodePerf5

Get ready to play, compete, and rock your code performance to the next level.

Performance matters when your applications are handling massive traffic and running in the cloud. It affects speed, scalability, and cost. With over 25 years of evolution, .NET offers many ways to solve the same problem—but which one is the most performant?

In this interactive, game-show-style session, you’ll compete with other attendees to identify the fastest and most efficient coding approaches using real-world .NET examples. Expect live benchmarks, practical tips, friendly competition, and prizes.

You’ll learn how to spot performance pitfalls, choose the best-performing patterns, and apply modern optimization techniques using .NET 10. Walk away with actionable insights you can use immediately to make your code faster, leaner, and more cost-effective.

Part of the series: “Improving Code Quality… One Developer at a Time.”

Rock Your Code: The ROI of Deep Experience – Tapping into Untapped Engineering Power

Some of the most valuable assets in tech aren’t frameworks or tools—they’re engineers who have scaled systems, stabilized teams, and debugged production disasters at 3 a.m. Yet too often, this deep experience is overlooked, underutilized, or misunderstood.
This session is a practical, story-driven exploration of how long-term engineering experience can be a game-changer for companies looking to ship better software, faster—and with fewer fires to put out. Engineering managers, CTOs, team leads, architects, technical recruiters, and developers will walk away with actionable insights and proven strategies to recognize, engage, and fully leverage deep technical experience as a force multiplier for product success.
Key Takeaways:

✔ How deep technical experience delivers faster ROI with less ramp-up
✔ How to prevent technical debt before it becomes a silent project killer
✔ Why mentorship matters and how to structure teams for long-term growth
✔ What companies get wrong about experience—and how to fix it
✔ Real-world lessons from cloud transitions, production outages, and scaling teams

This session is a practical, story-driven exploration of how long-term engineering experience can be a game-changer for companies looking to ship better software, faster—and with fewer fires to put out. Engineering managers, CTOs, team leads, architects, technical recruiters, and developers will walk away with actionable insights and proven strategies to recognize, engage, and fully leverage deep technical experience as a force multiplier for product success.

Rock Your Code: Rebuilding the Human Side of Software Development

In today’s engineering world, we’re surrounded by powerful tools, AI-assisted workflows, and endless online learning. Yet somehow, the human element of software development—the community—is quietly vanishing.

In this session, David McCarter shares how the decline of in-person collaboration, slashed training budgets, and a metrics-obsessed corporate mindset are eroding code quality and developer morale. But this isn’t a nostalgic rant—it's a rallying cry to bring back what made this industry great: mentorship, connection, and pride in our work.

You’ll hear real stories, personal experiences, and practical ideas for reviving community engagement—whether you’re an engineer, team lead, or exec. Let’s stop coding in isolation and start creating software people truly love—together.

Target Audience:
Software Engineers (Mid-Level to Senior)
Team Leads & Engineering Managers
Developer Advocates & Community Organizers
Technical Decision-Makers

This session is based on my widely shared article: "The Day the Software Community Died: Let’s Stop Coding in Isolation and Start Creating Community—And Software—People Truly Love."

Includes real-world examples from over 30 years in software, Microsoft MVP experiences, and running developer user groups.

I am happy to incorporate Q&A or an optional discussion circle post-talk.

Röck Yoür Cöde: Optimizing Microsoft .NET Code for High-Performance

In today’s high-demand, cloud-driven world, code performance is no longer a “nice to have”—it’s mission critical. When your back-end systems are processing tens of thousands of requests per second, often across microservices, even the smallest inefficiencies can translate into higher costs, reduced scalability, and unhappy users.

This session dives deep into the real-world dos and don’ts of high-performance .NET development. You’ll discover proven techniques that can improve execution speed by up to 98% while significantly reducing memory allocations. Every concept is demonstrated live using modern .NET, showing you exactly how small code changes can produce massive performance gains.

But this isn’t just theory or micro-benchmarks. You’ll see:
• How to identify common performance killers in everyday business code
• Which .NET patterns and APIs consistently outperform traditional approaches
• How to reduce memory pressure and improve throughput in high-load systems
• How to think like a performance engineer when designing and reviewing code

What makes this session truly unique is the direct connection to real, production-tested performance data. You’ll gain exclusive insights from the latest benchmarks and research published in the newly released fifth edition of Rock Your Code: Code & App Performance for Microsoft .NET: https://bit.ly/CodePerf5

As a bonus, this talk draws from my ongoing series, “Improving Code Quality… One Developer at a Time,” blending performance engineering with clean, maintainable, and scalable design principles.

You’ll walk away with practical, immediately actionable techniques that will make your applications faster, leaner, and more cost-efficient in the cloud. Whether you’re a senior architect pushing system limits or a developer looking to level up your skills, this session will change how you write, evaluate, and optimize .NET code.

High-performance code is essential when your applications handle heavy traffic and run in the cloud. Even small inefficiencies can impact scalability, reliability, and cost.

In this session, you’ll learn the key dos and don’ts of optimizing .NET applications, with live demonstrations showing how code changes can improve performance by up to 98% while reducing memory usage. You’ll see real-world examples and practical techniques you can apply immediately.

The session also includes insights from the fifth edition of Rock Your Code: Code & App Performance for Microsoft .NET and draws from the series “Improving Code Quality… One Developer at a Time.” Walk away with the skills to make your .NET applications faster, leaner, and more efficient.

Rock Your Technical Interview

Have you ever not gotten a job because you weren’t prepared for the interview? Would you like a big raise? Do you need motivation to rock your career? I’ve interviewed 100’s of software developers and will share my knowledge on how to survive, what we look for and even divulge some of the secrets we use during the process. Whether you are looking for a new position within your company or at a new company you need to attend this session. Included are crazy and strange interview stories from engineers just like you! Learn tips to get you started, working with recruiters, getting prepared, the technical interview and more. You will also learn what is the #1 question you need to ask during an interview… it’s a game changer!

Röck Yoür Cöde: How Coding Standards Supercharge .NET Quality & Performance

Great code doesn’t happen by accident. It’s the result of clear standards, proven practices, and a commitment to quality. This session shows you how to write .NET code that is consistent, maintainable, and built to perform at a professional level—no matter where you are in your career.

Based on the 20th Anniversary Edition of Rock Your Code: Coding Standards for Microsoft .NET https://bit.ly/CodingStandards20th this talk is your practical roadmap to writing cleaner, safer, and more efficient .NET applications using modern language features and best practices.

Join me for a high-energy, hands-on session where we break down:

• How to structure your projects for long-term maintainability
• How to apply coding standards that actually improve productivity
• Common pitfalls that quietly destroy code quality
• How to write clearer, safer, and more performant code
• How modern .NET features can simplify your architecture and reduce bugs

You can expect live demonstrations, real-world examples, and battle-tested techniques that you can start using immediately. This isn’t about academic theory—it’s about what works in production and what saves teams time, money, and frustration.

This session is part of my ongoing series, “Improving Code Quality… One Developer at a Time,” and is designed to help you level up your craftsmanship and think like a professional engineer.

Whether you’re just starting out or you’ve been writing .NET code for years, you’ll walk away with sharper instincts, stronger habits, and a renewed focus on writing code you’re proud to put your name on. By the end, you’ll be well on your way to becoming a true Code Shark™.

Don’t miss this opportunity to future-proof your skills and take your .NET development to the next level.

What Attendees Are Saying:

“I saw this presentation at the SoCal Code Camp and was a little shell-shocked about all the things that the other courses (Pluralsight, MVA, Microsoft Learn) failed to state.”
— Joseph D.

“Your talks around code quality, memory, and performance were insightful and thought-provoking. Not to mention the guitar picks, which were like a cherry on top.”
— Sachin Y.

Before attending, please take my Coding Standards Survey:
https://bit.ly/CodingStandardsSurvey25

Great .NET code starts with great standards. In this session, you’ll learn how professional coding standards improve readability, maintainability, performance, and team productivity.

Through real-world examples and live demos, you’ll see how small changes in structure and style can dramatically improve code quality. Whether you’re new to .NET or a seasoned developer, you’ll walk away with practical techniques to write cleaner, safer, and more professional code.

Röck Yoür Cöde: Everything That Every .NET Developer Needs to Know About Disposable Types

Is your application feeling sluggish? Is memory usage steadily climbing? Are you rebooting services or servers just to “fix” performance problems without ever finding the real cause?

If so, there’s a good chance disposable types are at the heart of the problem.
After decades of working with millions of lines of .NET code in real-world systems, I’ve seen one issue surface again and again as a silent performance killer: improper handling of disposable resources. Streams, database connections, file handles, HTTP clients, and many other types rely on correct disposal. When they’re mishandled, your application doesn’t leak memory in the traditional sense—but it does suffer from virtual memory leaks, resource starvation, and performance degradation that quietly cripple your system.

.NET is incredibly powerful, but its memory and resource management model is often misunderstood. Developers assume the garbage collector will “take care of everything,” and that assumption leads to:

• Excessive memory usage
• Slower response times
• Unstable services
• Costly infrastructure scaling
• Mysterious reboots that treat symptoms instead of the disease

In this session, I’ll show you exactly how and why disposable types become a hidden epidemic in .NET applications. Using real production examples backed by metrics, you’ll see how small mistakes can snowball into major performance and stability problems—and how simple, disciplined coding practices can prevent them entirely.

You’ll learn:

• How to correctly dispose of objects and why timing matters
• How to properly implement IDisposable in your own custom types
• Common anti-patterns that silently drain memory and system resources
• Tools and diagnostic techniques to identify disposal-related issues
• How to design code that is safe, clean, and resource-efficient from day one

This session focuses on prevention, not damage control. Fixing these problems early in your code saves countless hours of debugging, avoids costly post-deployment firefighting, and dramatically improves application stability and performance.

This content draws directly from the 20th Anniversary Edition of my book, Rock Your Code: Coding Standards for Microsoft .NET, available on Amazon: https://bit.ly/CodingStandards20th

After this session, you won’t just understand disposable types—you’ll master them. You’ll leave armed with proven techniques and practical tools that help you write safer, faster, and more reliable .NET applications.

Welcome to the next level. It’s time to evolve into a Code Shark™ and take full control of your application’s performance and resource management.

Sluggish performance, rising memory usage, and mysterious service restarts are often caused by improper handling of disposable types. Many .NET developers assume the garbage collector will manage everything, but unmanaged resources must be explicitly released or serious performance and stability issues follow.

In this session, you’ll learn how to correctly use and implement IDisposable, avoid common anti-patterns, and identify disposal-related problems using practical tools and techniques. Walk away with the skills to prevent virtual memory leaks, improve application stability, and make your .NET applications faster and more reliable.