Download the release now from our website download page.

VA Integration modes: Updated First Run Dialog

In VA 2024.9, new integration modes were added to allow users to personalize their experience with how Visual Assist features were presented and accessed. You can visit the integration mode page to learn more about available integration modes. This dialog was initially shown for fresh installs only. 

VA 2025.1 makes the dialog appear for every user who has not previously encountered it, regardless of whether they are installing Visual Assist for the first time or have updated from an earlier version.

The first run dialog allows users to pick VA integration modes.

Option to exclude symbols in GoTo and List Methods navigation

This small tweak adds an option to skip selecting symbols after you navigate to it. In that way, you can immediately start typing before the symbol, or you would be able to keep your current selection even after jumping to different parts of the code.

This currently works for VA’s Go To and List Methods in Current File (Alt + M). Access the new option via the toolbar.

Open the options dialog to select symbol selection behavior.

Specify access level on Extract Method

VA introduces a new option that allows developers to specify the access level (public, private, or protected) directly when using the Extract Method refactoring tool.

Specify the visibility of methods obtained via Extract Methods using the new options.

This streamlines the refactoring process by providing an immediate choice of access level for the new method being created from the selected block of code. Previously, after extracting a method, the default access level was applied (usually private), and any changes to this required manual adjustment. 

With this update, developers can set the desired access level in the initial step of the extraction, ensuring better code organization and encapsulation from the outset.

New features added for C++ modules when importing

When declaring new modules into your project, VA will recognize what you are trying to do and core navigation and features will work accordingly. This includes autocompletion prompts, adding includes, finding references, and other pertinent navigations.

C++ modules were added in C++ 20 to help improve the compilation times and the overall build performance of C++ programs. Modules provided a modern alternative to traditional header files and includes by allowing programmers to define interfaces that are compiled separately and imported as needed. 

This reduces the need to include headers and recompile code unnecessarily, which can significantly speed up the build process. 

Modules in C++ are fairly new and the committee is still pushing for mass adoption. But whether you’re an early adopter of C++ modules or not, this VA update should help you find available modules should the need arise.

VA now parses C++ modules, enabling core navigations and features.

Support for *.IXX module files.

This change allows VA to parse and understand the new modular structure introduced with C++20. This means that developers can now work with module interface files (.ixx) directly within the Visual Assist environment, benefiting from features like syntax highlighting, code navigation, and intelligent code completion that were previously limited to traditional header and source files.

For instance, if you had symbols declared in an .IXX file, VA now properly parses them and navigation features such as Go To will now work properly.

Configurable snippet base for unit test generation

There are new configuration options available for Unit Test Generation that allow developers to customize the boilerplate code that is automatically generated when creating unit tests. 

The unit test generation feature was first introduced in VA 2024.9 and added a new feature to create a boilerplate that follows the Google Test framework. This creates a new test file, prepopulated with placeholders following the test structure to make it more convenient to users.

VA 2025.1 upgrades this new feature with the flexibility of specifying preferences and settings that align with their project’s requirements or personal coding standards.

New modernized tomato icon 

Our loveable tomato icon has been given a fresher look for the new development year! This was primarily done to improve user experience and accessibility. This change was made to increase contrast, and make VA’s features more distinguishable so users can utilize it more effectively in the IDE.

Updated tomato icon. Will be rolled out for every platform!

We’ve also taken the opportunity to maintain a consistent look and feel across all instances of our tomato icon. This update ensures that they appear correctly and uniformly across all platforms.

Excluding C# files from parsing via “settings.json” file.

VA 2025.1 builds upon a similar functionality introduced in VA 2022.4 where an option to consider configuration instructions outlined in a .json file can be used to skip unnecessary parsing when building solutions. 

This new feature does something similar, but for C# instead. The feature allows developers to specify which C# files should be excluded from parsing by Visual Assist through a configuration in a .json file.

This is particularly useful for developers working cross-platform as this tells Visual Studio and Visual Assist to “open a file but do not parse anything else apart from a specific part.” 

So even if users have dozens of non Visual Studio files in one directory, you can specify which files are part of the project you are trying to open. (Otherwise, VS and VA will try to parse the whole directory—very resource intensive and time consuming.)

Bug Fixes

For bug fixes and general improvements, most of them were based on user feedback and reports. The most notable of these updates are fixes for a crash happening when logging is enabled while debugging, and a hang involving the Go To features. There was also a pesky bug related to having two-monitor setups that is now fixed. 

The following list summarizes the most important bugs addressed in this release:

Fix for flashing in the Find References results window on start or when changing monitors.

• Fix for Encapsulate field in C#.
• Fix for VA Hashtags not being suggested.
• Fix for assignment suggestions not appearing in some cases.
• Fix for dialog hang that could sometimes happen when using Goto.
• Increased the display limit for Move Method to Base Class to 12 base classes (from 6).
• Fix for Move Method to Base Class sometimes not displaying the base class list to move to.
• Fix for tip of the day links opening in Internet Explorer rather than the default browser.
• Fix for a crash that could sometimes happen when troubleshoot logging is enabled.
• Fix for attributes displaying in a difficult to read color when in dark mode.

Availability & Feedback

This release was made generally available on March 28th and can be downloaded via the downloads page. As always, we appreciate feedback, especially on recently introduced features and the UI changes we introduced. Thank you for helping us create a better experience for all our users.

Update now to an active version to utilize all the features and fixes in this release. And if you have any questions or encounter any issues, feel free to reach out to support@ewholetomato.com.

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

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.