This update introduces a key update to Find References and a new refactoring. We are also introducing a new way to experience Visual Assist—more on this below! And of course, thanks to your feedback, we also have bug fixes and general QoL improvements.

Visit our website page and download the release now.

Replace Find References Tree Control

Whenever you execute a Find References command, the results are shown in  a dialogue at the bottom of the windows. In 2024.9, a portion of the results dialog and the logic behind it was overhauled to (1) make the UI display results faster and (2) to add the ability to search and filter through those results.

Before this update, it may sometimes take a half second or so to display all the references and symbols as the UI tries to catch up with the greatly improved Find References speed.  Now, when you are working with large projects or code bases, there will be minimal lag even as the parser incrementally adds hits to the results dialog.

Additionally, as a result of the overhaul, there is a new feature that allows users to actively search through the found results, even as the primary search is still ongoing. You don’t have to wait for the complete search in order to interact with the results.

Move Method to Base Class (New refactoring)

A new refactoring has been added: the Move Method to Base Class is a powerful tool for improving the design and maintainability of your code. This feature allows you to take a method that was originally implemented in a child (or derived) class and move it to a base (or parent) class.

This essentially transfers the method implementation, for instance, to the base class, and updates the derived classes to remove the redundant implementation. This makes derived classes smaller and more manageable—and thus, more maintainable, more readable, and overall cleaner code.

New Visual Assist Integration Modes 

This release introduces two new available integration modes for the Visual Assist plugin. The available integration modes allow users to personalize their experience with Visual Assist. The two available modes are partial integration and full integration mode.

Partial integration sets fewer features on by default and will not change default key mappings—a more vanilla Visual Studio experience. This may be useful for those using Visual Assist for a few key features, or for those who are accustomed to the default VA experience.

Full integration is the recommended setting as it embodies the experience that VA was designed for. It exposes all code completion, code navigation, autosuggestion features, and the like. Furthermore, it also exposes some of our less apparent features more.

One of the main purposes of this mode is to make it easier to find and familiarize with the features inside Visual Assist. This applies even for beginners as they can see more and use more of the available features and functions.. 

Additionally, it’s the more flexible option as it can be easier to disable a few things manually but keep everything else.  As such, you can consider full integration as the setting that maximizes your experience of all the benefits Visual Assist has to offer. And on the other hand, consider partial integration as the classic version that keeps development a bit more zen with fewer buttons and shortcuts to learn.

New “Ray” style row indicator

Visual Assist’s way of highlighting the current selected line/row now has a new option. This makes the current line appear a bit more unique, and gives it a thinner edge appearance. To be more precise, we added a new style unique to the current iteration in Visual Studio. The new style utilizes a “ray” top and bottom line going across the editor. 

Unit Test Code Generation feature

For those following the Google Test framework, you can use this new feature to create boilerplates to skip the tedium of setting up the test framework and verifying your test’s structure. With just a few clicks, you can create a new test file, pre-filled with test structure and essential placeholders, saving you significant time and effort.

To use this feature, just activate the feature on a class, and VA will create a new file with the foundation you need to start writing tests.

Availability & Feedback

This release is available starting December 30 and can be downloaded via the Whole Tomato downloads page. As always, we encourage your feedback, especially on recently introduced features, to help us make a better experience for you.

Thank you for your continued support, happy holidays and happy coding! If you have any questions or encounter any issues, feel free to reach out to our support team.

Download the release now.

The post Visual Assist 2024.9 release post first appeared on Tomato Soup.

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.

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.

The post Test Driven-Development and UI/UX Design: A Practical Guide [Webinar Recap] first appeared on Tomato Soup.