Don’t you wish your code came with an undo button for every mistake? So do all developers who accidentally pushed a bug into production!
But we got the next best thing: Unit testing. This webinar will show you how to stop breaking your codebase (and your spirit) by writing tests that catch errors before they escape into the wild. Perfect for developers who know they should test but don’t know how—or why.
Table of Contents
What You’ll Learn:
- The differences between two schools of TDD and when to use them.
- How to implement CI pipelines and automate your test execution.
- Practical techniques for leveraging static analysis tools and code profiling.
- Real-world case studies that highlight successful approaches to refactoring and performance optimization.
In this webinar, our experts shared their best practices for developing high-quality C++ code, offering valuable insights to apply in your projects.
This webinar features insights from experts in software design and development, covering practical applications and real-world scenarios to help you streamline your workflows.
This webinar has concluded. Scroll down to watch the replay and review the highlights.
Webinar Replay
Webinar Highlights
Introduction
0:19-1:35: About Nuno: product manager for Visual Assist, clean code enthusiast, contact info shared, alongside mission of Visual Assist and upcoming new version announcement.
Message and Story
1:40-5:12: Importance of programmers writing good quality software and Nuno’s experience with different software development approaches (design thinking, waterfall, agile).
Test-Driven Development Overview
5:12-8:10: Discovery of test-driven development (TDD) and its impact on software quality. Explanation of TDD and the Red-Green-Refactor cycle. Importance of small increments, immediate feedback, and other TDD benefits.
Practical Exercise Setup
8:17-10:09: Overview of the Mars Rover exercise, rules, and references.
10:09-11:00: Visual Studio 2022 setup for the Mars Rover project (source files and test project creation).
First Test Case
11:00-12:08: Writing the first test: Initial position at (0, 0), facing north.
12:08-13:11: Creating the Rover class and implementing execute() to return an empty string initially.
13:11-16:16: Making the test pass by returning the expected position and direction.
Second Test Case
16:16-18:15: Writing the second test: Rotating right from north to east.
18:15-20:09: Updating Rover to handle the “right rotation” command and making the test pass.
Refactoring and Patterns
20:09-20:59: Recognizing patterns in the test code and introducing Google Test fixtures for code reuse.
50:06-52:11: Introducing and implementing a current position variable. Writing and running tests to confirm functionality after the changes.
52:11-53:28: Extending functionality to the left method and replicating the test-driven approach used for the right method.
54:00-55:18: Cleaning up and optimizing the code after successful test results, ensuring all tests remain green.
56:00-56:48: Summary of the refactoring process and demonstration of the final Rover and Direction class setup.
QnA
[56:48–59:02]
Introduction to the Q&A session with Nuno Castro and Ian Barker. The discussion opens with strategies for writing tests for projects without existing tests. Suggestions include starting with end-to-end tests and gradually adding component-specific tests during future changes.
GUI Tools, A/B Testing, and Metrics
[59:02–1:03:07]
Overview of GUI testing tools like SmartBear’s TestComplete and their use in desktop and web testing. The discussion transitions into A/B testing, explaining its purpose and real-world examples (e.g., Coca-Cola product testing). The importance of metrics to gauge feature usage before redesign or development is also highlighted.
Agile Methodologies and Encouragement for TDD
[1:03:07–1:06:50]
Reflection on Agile methodologies, balancing speed with system stability, and evolving approaches such as Facebook’s shift from “move fast and break things” to prioritizing reliability. The session concludes with encouragement to adopt Test-Driven Development (TDD) and a nod to the value of unedited coding demos to showcase realistic problem-solving.
Self-Development, Testing, and TDD Approaches
[1:10:01–1:13:36]
Introduction to self-development as both a science and an art. Discussion includes testing strategies to ensure business logic isn’t broken, addressing overfitting in tests, and balancing test coverage with real-world solutions. User stories are highlighted as a foundation for design, followed by a comparison of the Chicago and London schools of TDD.
Design, User Experience, and Business Logic
[1:13:36–1:17:01]
Emphasis on designing user interfaces first and iterating on user experience challenges. The discussion incorporates Don Norman’s insight that user errors often indicate interface design issues. It concludes with balancing business logic with test coverage in TDD.
Closing
[1:17:01–1:18:00]
The importance of prioritizing timely application releases over perfectionism is discussed. The webinar ends with closing remarks, thanks to participants, replay information, and a final farewell.