June 02, 2023

Architecting an application can be challenging. What do you do to keep your application flexible to ever-constant requirement changes? How do you handle landscape changes (cloud, on-premises, databases)? How do you avoid over-engineering the application? How do I make sure my application plays well with other applications?

In this session we’ll take a look at some well-understood and practiced Software Architecture patterns. We’ll cover these patterns at a high level to understand how to use these patterns in different scenarios.

You’ll walk away with some knowledge, tips, and tricks that you’ll be able to use for new and existing applications.

Debugging issues within applications are challenging! In this session, I’ll how debugging works and demonstrate the many ways that Visual Studio enables you to find those annoying issues. I’ll explain the run/debug configurations. What application breakpoints are and to make them conditional, or how you can skip breakpoints altogether. While we are in a breakpoint, we’ll explore the many ways to navigate through the code but skipping lines, running to line, jumping in, and using methods. Once we find an issue, we’ll look at how we can inspect the values in memory and even change them.

At the end of the session, you’ll walk away with a lot of knowledge to help you find those annoying issues in your applications. As a bonus, you’ll walk away with a little debugging secret.

We use Infrastructure as Code (IaC) scripts to create cloud infrastructure. These scripts should be treated as any other application code and must be developed by following the best coding practices. There should be static code quality checks for these scripts. In this session we will discuss various options like TFLint and SonarQube to scan and analyze Terraform Infrastructure as Code (IaC) scripts. We will also explore the best practices to maintain code quality for Terraform based IaC scripts.

Building software is more than just building an application that works. A good software not only focus on its functionality but user experience, security, and performance. In this non-coding talk, I will share some of the tips and advice on building better software.

Naming standards are only the start. A code base is more maintainable when it is consistent. But how do you get to a synchronized and more productive team? Personalities, past experiences, timelines, and geographies can make it difficult. Enter .editorconfig, a solution to inconsistent code on personal, team, and company scale.

As cloud computing keeps growing, so does the usage of Infrastructure as Code (IaC) where you use code to create and manage the systems, networks, and application infrastructure on which your app runs. Since this is code, it has the same requirements for code quality. However, it is a different construct than an application, so its quality needs are different. This session is designed to talk about those needs and how to manage code quality when writing IaC.

Is your application or service running slow? Are they gobbling up too much memory? Do you have to reboot servers or services every once in a while, and you have no idea why? Well, I know exactly why! I have reviewed millions of lines of code from Microsoft .NET projects and hands down, the number one issue is not handing disposable types correctly.

Microsoft .NET has been around for 20 years and one thing that is very critical for every developer to know is exactly how memory management works in the runtime. If you don’t, you will cause performance issues but more serious is causing virtual memory leaks. The way that .NET was designed back in the late ’90s is that it does not have memory leaks in the true sense, but it can create virtual memory leaks.

In this session, I will show examples and metrics from a real-world in production solution. If developers do not deal with these types when the code is first written, it will be very, very expensive and time-consuming to fix later down the road (if they even get fixed). The main topics covered in this session are properly disposing objects, how to properly implement the IDisposable interface for types that you create, and I will finish up by showing tools that can help you find these issues so you too can be a Code Shark!