June 27, 2024

Join Sagar Mahendrakar, Software Quality Engineer at Red Hat, as he explores the critical role of Quality Assurance (QA) for achieving superior software performance and reliability.

In this session, Sagar will address the cultural and organizational challenges of embedding QA practices within DevOps, emphasizing the need to foster collaboration, dismantle silos, and cultivate a culture of continuous improvement. He will also highlight the importance of toolchain integration and skills development to support effective QA processes. Learn the strategies to navigate these challenges and enhance software delivery in today's dynamic technology environments.

In the field of software development, code quality and performance are of utmost importance. High quality code not only ensures that the software is easy to maintain and scalable, but also minimizes the risk of bugs and security vulnerabilities. Performance, on the other hand, is critical for seamless user experience and resource efficiency.

Enter AI-driven tools like GitHub Copilot, which are transforming the way developers write code. GitHub Copilot helps you quickly create robust and efficient code by using an AI pair programmer that suggests entire lines or blocks of code as you type. It's trained on a dataset of public source code, so it understands context and makes relevant suggestions.

Without the overhead of manual search and recall, GitHub Copilot can help developers improve the quality of their code by adhering to best practices and design patterns. It can also recommend performance optimizations, such as more efficient algorithms or memory management techniques, to improve the overall performance of the software.

This session will explore how AI and GitHub Copilot can be used as powerful allies in writing better code, ensuring that developers can focus on creative problem-solving while leaving the routine coding tasks to their AI counterpart.

In this session, we will discuss the importance of code quality and then evaluate various code quality metrics available to measure and benchmark code quality using relevant examples using C#.

Software architecture is one of the most important and challenging concepts in software development. In order to properly address software architecture, it should be evaluated and analyzed in four aspects: architectural patterns, architectural charactristics, architectural decisions, and design principles. In this session, I am going to talk about how to measure architectural charactristics, and while familiarizing ourselves with the Cyclomatic Complexity, we will examine how to calculate it together.

Code reviews are vital for ensuring good code quality and fostering teamwork. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standard practices. How can we improve this crucial process?

From a decade's worth of experience and consulting across varied companies, I've extracted essential lessons about code reviews. In this session we will cover:

- The Art of Effective Code Reviews: Learn ``how not to come across as a passive-aggressive jerk``, the value of self-reviews, and effective communication strategies.
- Streamlining the Review Process: Embrace clear repository ownership and refined review guidelines for more efficient and constructive reviews.
- Elevating Reviews with Automated Tools: The most fun part! Explore tools that reinforce code consistency and quality, from automated style fixes to architecture checks. Let's cut through the noise of bikeshedding and focus on the essence of the changes.

This session will leave you with practical tactics for improving pull requests, performing better code reviews, and a suite of tools to simplify the review process and boost code quality.

Code quality is an abstract concept that fails to get traction at the business level. Consequently, software companies keep trading code quality for new features. The resulting technical debt is estimated to waste up to 42% of developers' time, causing stress and uncertainty in the process. Yet it's hard to build a business case for code quality: how do we quantify and communicate the benefits to our non-technical stakeholders? Or even inside the own team?

In this talk, Adam tackles this challenge head-on by leveraging innovative code quality metrics and deep analyses of how engineering interacts with code. By linking these metrics to key business drivers such as time-to-market, customer satisfaction, and roadmap risks, Adam demonstrates how investing in code quality translates directly into a competitive advantage. The recommendations and insights are backed by cutting-edge research, delivering a perspective on software development that will change how you view code. Promise.

This presentation aims to explore and discuss best practices for writing clean and maintainable code, emphasizing the importance of such practices in ensuring the longevity, scalability, and ease of collaboration within software development projects.

The session will start with an introduction discussing the significance of clean and maintainable code. We will explore how well-structured code not only facilitates easier debugging and enhancement but also improves team collaboration and reduces technical debt.

Following this, we will identify and analyze common code smells—indicators of underlying issues that necessitate refactoring, and how to transform smelly code into clean and maintainable code, showcasing real-world scenarios and refactoring techniques.

Following this, the discussion will explore the influence of team culture and practices on code quality, and examine how fostering a positive development culture, implementing consistent coding standards, and encouraging best practices within teams contribute to producing cleaner and more maintainable code.

The session will focus on best practices for writing clean and maintainable code. Key principles such as simplicity, DRY (Don’t Repeat Yourself), YAGNI (You Aren’t Gonna Need It), and SOLID principles will be explored. The session will also highlight practical techniques for improving code readability, consistency, modularity, and testability.

This session will conclude with a summary of the key points and provide attendees and viewers with actionable takeaways to implement in their coding practices.

Key Takeaways:
- Understanding the importance of clean and maintainable code.
- Identifying common code smells and learning effective refactoring techniques.
- Understanding the impact of team culture on code quality.
- Insights into practices for writing clean and maintainable code.

Code reviews are mostly useless… and it's all your fault!

Please litigate my syntax and formatting choices across fifteen separate comments on Github… for this five line-of-code change. Better yet, why don't you reject my pull request until I guess exactly what you're thinking the code should look like. Supportive, coöperative co-working can be an enormously beneficial process for improving our ability to deliver high quality work, but let's make our code review process as antagonistic and accusatory as possible!

In this presentation, we'll gnash our teeth for a bit about how useless and pointless most code review processes tend to be… and when we eventually calm down, we'll try to talk about how to improve these processes, and provide a framing for how to conduct these as a useful quality control tool.

Working SQL code can be generated via an ORM or written directly, but most common code analysis techniques don’t help your confidence that the SQL code is “good.” Ideally, you can check the SQL code in a database or in source control for antipatterns to detect code that performs poorly, severely limits future structural changes, or doesn’t match your code formatting guidelines. There are several libraries capable of analyzing your T-SQL code and your selection will depend on your development and deployment workflows. In this session we’ll review the SqlCheck, ScriptDOM, and SQL projects code analysis options such that you can confidently add code analysis to the SQL components of your applications.