Based in Europe, the client is a global company specializing in the development and manufacturing of high-performance systems for vehicle technology. As a company that has been in the industry for over a century, their longstanding focus on innovation has positioned them as one of the top automotive manufacturers worldwide. As part of their commitment to quality, they have invested heavily in simulation tools for vehicle design, testing, and validation, ensuring efficiency and reliability for their partner manufacturers.

They engineer and produce various automotive technologies such as engine and electronics systems for passenger cars, commercial vehicles, and data measurement services.

Use case and challenges

We had the privilege of speaking with the lead developer and his team who create modeling and simulation software. We discussed their daily work and the challenges they face:

Use Cases:

• They develop C++ applications in Microsoft’s Visual Studio for internal use.
• They create bespoke programs for modeling components and simulating them in various scenarios.
• Their primary language is using C/C++ in Visual Studio because it can be interfaced easily.
  

Challenges:

• As an advanced tech provider, their workflow and output is highly specialized. Each project is tailor-made specifically for a certain client or customer.
• They have huge legacy code bases that they have to maintain and modernize. 
• Because of the precision involved in measurements, they handle large amounts of data from different sources of measurement.

Solution

Visual Assist was introduced to the team many years ago and it has since been a staple tool used daily by the developer team. They use Visual Assist for a variety of use cases including:

• Refactoring and modernizing code is exponentially faster.
  Because their toolchain was initially built sometime in the 60’s, they had a lot of code modernization and translation projects. Then they also had to integrate them with new tools and update them to the latest coding standards.
  
  Visual Assist’s refactoring feature has been an indispensable asset in updating the outdated code structures, making them more readable, memory-safe, and maintainable. It takes the pain out of manually bringing legacy or deprecated code up to standard by automatically renaming variables or extracting methods, reducing the risk of introducing errors during manual updates. This includes refactoring to use modern, secure and safe coding styles. Effectively Visual Assist simplifies their C++ code maintenance so that they can focus on manufacturing and designing parts, not code.
• Navigating old code and huge projects happens in a single click.
  Visual Assist greatly helps the team get around their huge legacy projects with smart navigation features. Finding and searching for certain sections of code is a cumbersome ordeal that VA just completely skips over with features like Find References, Find Symbols, the various Go To functions, and the like.
• Snappier performance on large projects and solutions.
  When it comes to handling large amounts of data, Visual Assist’s optimized startup speed and low memory footprint provides the team snappy and accurate code assistance. Due to the repetitive nature of their projects, the few seconds that Visual Assist saves compounds over time and can boost productivity by as much as 20%. 

This non-exhaustive list is a testament to how Visual Assist can save hundreds of hours of valuable productivity time by providing smart suggestions, speedy features, and a satisfying experience for the Visual Studio IDE.

Interested?

Interested in getting the same benefits you or your team? Visual Assist is free to try for thirty days. 

Whether you’re looking to boost your team’s productivity or optimizing your own development process, now’s the perfect time to upgrade your toolkit with one of the most trusted Visual Studio plugins. Click on the link below to learn more about Visual Assist.

The post Success Story: Visual Assist for modeling and simulation software for automotive C++ first appeared on Tomato Soup.

Greatly expanded code inspections with over 100 new Clang Tidy checks

The biggest item in this release is the added support for all code checks available from Clang Tidy. Code inspections are semi-automatic checks that prompt the user when Visual Assist’s engine recognizes outdated syntax or an otherwise correctable code issue. 

For context, Visual Assist’s code inspection is based on a series of checks from LLVM Clang Tidy. And before we add support for a new check, we rigorously test it for accuracy and compatibility. This process ensures that the check will give consistent suggestions for almost all use cases. In fact, this is the process undertaken for the two new added code inspections in this release—more on them later.

What we’ve added is the ability to use unevaluated Clang Tidy checkers as Code Inspections straight from Visual Assist. This greatly expands the types of code issues that can be detected with code inspections enabled. There is a slight tradeoff in that you may need to do some manual testing when using unvetted checks. Take a look at the full documented list of Clang Tidy checks.

The latest addition to our list of vetted code inspections are for bugprone-swapped-arguments and bugprone-argument-comment. These checks look for potentially swapped arguments by looking at implicit conversions and detect typos in argument comments and suggest automated fixes for them, respectively.

Lastly, we’re also announcing that code inspection is officially out of beta and is now running on Clang engine version 15.0. The beta label is mostly a formality and all functionality should function the same. If you haven’t, we highly advise enabling code inspections.

Protip: When running comprehensive code inspection checks in a file, you can sort and group issues by level. Code inspection levels refer to an arbitrary metric representing severity given to a code check. Level one signifies critical, level five being on the level of a reminder, and zero refers to unflagged checks.

Extended Shader File Customization

Due to consistent demand and great feedback, a significant portion has also been given to further improve our support for shader files. In fact, as of this release, it is in the last phases of beta testing and will most likely be available for general support very soon.

In this release, you can now use custom shader file extensions (there are no longer extensions considered “default”). Coloring and syntax highlighting has also been drastically improved, with almost all bugs ironed out as well.

Enable support for shader file parsing by accessing Visual Assist Options ->> Game Development ->> Enable support for shader files.

Integrated-style extensions menu (pre-Visual Studio 2019)

In Visual Studio 2019, the toolbars and plugins were rearranged. Instead of being able to access your plugins in the main toolbar, you had to instead go under the Extensions menu. 

For the most part, this made sense—it’s easier to find all installed plugins and access their features correspondingly. However, for users who had one or a handful of plugins or are more comfortable using the mouse instead of shortcuts, the extra step might be bothersome (e.g. mouse users with only VAX installed).

Some users expressed interest so we’ve added the option for an integrated-style menu for extensions (similar to the pre-VS 2019 setup). 

This new menu mode can be enabled via Extensions ->> VAssistX ->> Visual Assist Options ->> Display ->> Switch to Legacy Style Main Menu.

Implement Virtual Methods context menu option to check / uncheck all.

The last of the new features in this release is a quality of life change. Inheriting from other classes is made much easier and intuitive using the Implement Virtual Methods feature.

While in the dialog, we added a small tweak that allows users to check and uncheck all possible methods using a simple checkbox. Neat little addition, we hope.

Visual Assist’s Implement Virtual Methods feature provides a neat little dialog to make inheriting from other classes quick and intuitive.

Bug Fixes

• Fixed issue where installer exe could report errors after a successful install.
• Improved auto type deduction for const, pointers and chained function calls.
• Fixed issue where Code Inspections could fail with the latest MSVC includes.
• Fixed issue where shader coloring may not be applied to the correct file extensions.
• Fixed issue where shader coloring sometimes not applied to files opened automatically on solution load.
• Fixed issues which could lead to the VA Navigation Bar being drawn incorrectly.  
• Fixed issues which could lead to missing icons.
• Improved tab completion in C# to interact better with build in tooling.
• Fixed minor visual theming issues in various VA dialogs. 

Much thanks to those who submitted their feedback and bug reports. Keep ‘em coming. Send us a message or start a thread on the user forums for bug reports or suggestions. Happy coding!

The post Visual Assist 2023.2 released first appeared on Tomato Soup.

Improved parser auto type deduction for pointers

This release updates how Visual Assist handles auto type specifiers, particularly when reference is coming from a pointer. Previously, there was a change that when auto assignments are used, any flags (such as const) may be ignored. With this release, VA now has better pointer deduction avoiding such instances.

Parser support C# tuple deconstruction

This update is useful for those using the C# equivalent of the previously released tuple deconstruction for C++  to avoid verbose initialization of variables.

What this update does is that when you assign multiple variables at once using a predefined struct, VA will be able to recognize those variables. Consequently, this allows its features such as syntax highlighting and navigations to function properly. 

Add parser support for C++ 17’s structured binding from a constructor

This is a simple fix for an edge case for structured bindings that happens when a constructor is used. Similar to the last fix on tuple deconstruction, what this update does is that when you use the auto function to assign variables from a struct, it will now function properly even when a constructor is called.

Support for custom shader file extensions

When we added shader language and HLSL support, one of the most prominent user requests was to be able to enable support for non-standard/custom shader extensions. 

With 2023.1 you can now add custom files by adding the extension in a text field under Options ->> VAssistX ->> Game Development ->> General.

Better code formatting and behavior for Unreal Engine copy-paste

Users can recall that when typing Unreal-specific code, there is unintended indentation behavior as a result of VS not understanding UE specifiers such as UFUNCTION and UMACROS.  

With Visual Assist enabled, the automatic indentation present in default Visual Studio is disabled. And in this release, we’ve improved on this behavior by extending it to copy-paste. What this means is that when copying or cutting blocks of Unreal Engine code, the pasted code will still have the correct indentation in place.

New UI in Find References results

Previously, when using find references, the default scope of the search was the currently opened project or file. This update is for those who found that results shown by find references seem to be incomplete— it is now more apparent that you have the option to specify the scope of the search (ie. just the open project or the entire solution).

In this release, there is a newly added notification after every search that prompts the user to redo the operation for the whole solution.

Code inspections for bugprone-inaccurate-erase and bugprone-bool-pointer-implicit-conversion

Lastly, we’ve added two new code inspections based on clang tidy for bugprone-inaccurate-erase and bugprone-bool-pointer-implicit-conversion.

The first one is useful if you use std::vector and you are using remove() or erase() which often uses hard to read/type syntax. This inspection makes sure that when you use erase(), it works properly. 

The second one is useful when you have a pointer as an argument to an if statement (or anything resembling a bool). This is because it has to be dereferenced first or else it will default to a True. This check notifies the user if the pointer has not been dereferenced. 

Both of these checks are useful because in both of these instances, the code will still compile successfully—giving a false impression that everything would work as intended.

Bug Fixes

We also have a couple of bug fixes. And although they are small bugs, we hope this would be beneficial to users who encountered problems around the following:

• Fixed issue where icons may be missing in Visual Studio 2022.
• Fixed issue where folders / JSON files may be unnecessarily created when hovering the mouse cursor over symbols.
• Fixed convert suggestion listbox keyboard shortcut display to update when the shortcut is changed. Note: shortcuts shown are now dynamic.

Keep the reports coming. Send us a message or start a thread on the user forums for bug reports or suggestions. Happy coding!

The post Visual Assist 2023.1 released first appeared on Tomato Soup.

In this article, we will talk about the main problems that programmers and managers face during the software development process and how Visual Assist and TFS Tool – TestRail Integration can help solve these problems.

What are Common Visual Studio C++ Pain Points?

Visual Studio is one of the most popular IDEs (Integrated Development Environments) used by C++ developers. It provides many powerful and useful features for efficient development. However, there are certain challenges faced by programmers using Visual Studio.

• Slow operation and high volume of requested resources when using Intellisense in large projects.
• Difficult to navigate, especially for beginners.
• Complex debugging process.
• The process of finding errors can be quite complex.
• The code snippet feature is poor, it needs to be updated and improved.
• There is a need for additional functions for automatic code generation.

What are the Difficulties in Project Management?

In addition to good development tools, it is also important to manage and test team projects effectively. Let’s list the difficulties that arise in the project management process.

• Unclear business goals and lack of detail in scenarios result in a lot of responsibility for testers to define requirements.
• The need for automation of the testing process.
• The need to reduce the quality control time of new releases.
• Performing testing in a shorter period of time.
• The need to reduce errors in production.
• Tracking the test execution process.
• Increasing the efficiency of the team.
• The need for a clear division of roles and tasks in the team.
• Improvement of cooperation in the middle of the team.
• Increasing deployment frequency.

What is Visual Assist for Visual Studio?

Visual Assist is a productivity extension for Visual Studio development work. It provides a set of intelligent refactoring, navigation, code highlighting, automatic code generation, corrections, and understanding features for C, C++, and C# development. With its highly-efficient memory management and minimal UI, Visual Assist gives developers uninterrupted access to advanced features without slowing down the IDE.

Visual Assist is one of the definitive plugins that conceptualized and shaped most of the current features you see now in Visual Studio. And to this day it continues to develop a user-centric design for maximum productivity and usability.

What are the Benefits of Using Visual Assist?

• A very lightweight solution – minimal UI and intuitive but sparse pop-up menus only when you need them.
• Fully customizable – syntax highlighting, keyboard/mouse shortcuts,
• Advanced navigation features.
• Easy to use. A lot of our users work with very large source codes (and C++ syntax is inherently verbose). Visual Assist decreases the number of steps to perform different actions (open files, find files, find related symbols, classes, etc).
• High-performance coding assistant – Visual Assist’s performance is very fast compared to competitors (eg. parsing and loading time on large code bases).
• Smart – VA is updated to be aware of the most modern coding standards (LLVM/Clang) so users don’t have to study new practices/standards themselves as much.

What is TFS Tool & TestRail Integration?

Microsoft TFS is a popular project management software that includes a lot of tools to simplify the development and testing process and collaboration between team members. Among them are an issue-tracking system, a centralized version control system, a build server, a team portal, and so on. You should sign in via your Microsoft account to start using TFS.

TestRail is a modern centralized test management system, which allows you to combine information about automatic and manual testing in one place. In addition, it provides many features including:

• Ability to create test plans and track progress in their execution.
• Monitor test coverage and traceability.
• Ability to create test cases.
• Running automatic tests and viewing the results of their execution.
• Creating reports.
• And much more.

TestRail provides the ability to integrate with dozens of third-party software, including TFS. Using TFS Tool – TestRail Integration you can easily manage all test cases and test plans in your team project, run tests, add bug reports to TFS and link issue IDs, and track test results, activity, and progress.

TestRail is great for any team project, regardless of the workflow, development method you use, and team size.

Conclusion

In this article, we talked about the main problems faced by programmers, testers, and managers in the software development process. Also, we talked about modern tools that make it easy to solve these problems. The popular and powerful extension Visual Assist for Visual Studio provides many useful features that greatly simplify and speed up the process of writing, testing, and debugging code in Visual Studio. TFS provides tools for project management, and the integration of TFS & TestRail allows you to conveniently view and manage all the tests that are in the project.

Looking for the best test management solution for your project? Try a free 14-day TestRail trial and make sure it’s the best choice.

FAQ

What is the TFS tool?

TFS (Team Foundation Server) is an ALM (Application Lifecycle Management) tool that allows you to manage the complete life cycle of software development, including requirements gathering, development, and testing.

What is TFS and Jira?

TFS is a project management tool that provides many useful functions such as issue tracking, source control, automatic builds, build server, team portal, and so on. Jira is a simple issue-tracking tool that can integrate with other tools to expand functionality.

Is TFS a DevOps tool?

TFS has been renamed to Azure DevOps Server. It provides project management, source code management, build management, reporting, testing, and release management capabilities.

What is TFS server used for?

TFS server is used as a team foundation version control system that allows you to manage all source files and maintain different versions of the source code. In addition, it provides you the ability to track work items, save documents on a special project portal, and do many other actions related to software management, development, and testing.

Is TFS the same as Git?

TFS has a built-in GIT server that can perform almost all the functions that standard Git has.

The post Solving Common Visual Studio C++ Problems With Visual Assist, TFS Tool & TestRail Integration first appeared on Tomato Soup.

This blog is intended for lead developers, team managers, and procurement decision makers.

Why leaders need to keep their developers happy

A satisfied developer is a reliable indicator for two things: work is being done, and work is being done in a timely manner. Have you ever seen someone frantically working with an outdated program produce great output?

Software developers and programmers are the primary drivers of projects. An inconvenience for developers is an inconvenience to the team as a whole. Each second spent on side tasks such as troubleshooting their workspace or reading long documentation is a bother (necessary but a chore nonetheless).

Ensuring a hassle-free work environment

Apart from employee benefits and privileges, one of the best ways to keep developer satisfaction and productivity up is ensuring that the work environment is healthy. For developers, that’s their work desk or more specifically, their IDE.

A well-equipped developer will be able to confront their day to day tasks efficiently. For example, one key benefit of having a productivity plugin like Visual Assist is having better quality code with significantly reduced effort. It provides developers automatic prompts and suggestions that are based on the latest industry standards without them having to study and re-learn themselves.

Visual Assist on the Visual Studio marketplace with a 4.8-star rating.

Conversely, developers will not hesitate to discuss when there are roadblocks; so it’s fair to assume that they will do the same when they feel that their coding environment needs an upgrade.  

That is why it is not that difficult to keep the developers’ toolkit up to date. Feedback from day-to-day interactions  are one of most accessible indicators for performance and friction points—requiring no more than a chat with a team member.

Keeping track of developer satisfaction is one of the easiest productivity boosters. Suffice to say that if a developer asks for a specific tool, the confidence and productivity boost is often worth the initial investment.

The difficulty in gauging productivity

Business decision makers will often try to verify their developers’ sentiments with a numbers-based return on investment (ROI) analysis. In business speak, those are calculations and simulations on whether the purchase of a machine will benefit the business in the long-term.

Decision makers will rightfully ask: How much return of investment can we expect if we buy X number of Visual Assist licenses?

How much can we expect to save when we invest into this productivity extension?
– A common question from our enterprise clients

Empirical studies regarding software dev productivity are hard to come by. Productivity extensions like Visual Assist save time but it cannot say by how much. Those would need sophisticated tracking and behavior monitoring.

While certainly not something to underestimate, in-depth analyses take valuable time and effort on the side of company decision makers because most use cases will vary per team. The ceiling and floor ROI will adjust depending based on a number of factors including: 

• How much of the tool is utilized
• Duration of usage
• Familiarity and skill with the tool

It is a justified question but there is no easy and direct answer to it which is why the fastest and most efficient method would be to trust your developers.

For example, Visual Assist has many users who say that Visual Studio is unusable without Visual Assist. While that may be slightly exaggerated, once you get used to it it’s really hard to go back to vanilla Visual Studio.

With a reasonable amount of practice and familiarity, users also report that they can work 3 times faster with the plugin installed. 

A Visual Assist user shares his review on G2.

Justifying a software purchase

This begs the question: what fact-based estimate should companies and businesses use when choosing productivity software? 

One thing to keep in mind is that productivity-augmenting extensions like Visual Assist are extremely inexpensive compared to the overall cost of hiring a skilled developer. 

To put that into perspective, a Visual Assist-equipped developer is only 0.35% more expensive than a developer without. 

That means that as decision makers, you just need confirmation from your developers that this tool would, at the bare minimum, make them be 1% more productive to justify the initial investment. In terms of time saved, that is around 5 hours per year to break even.

The ROI margin for Visual Assist is low. It pays for itself even with minimal use.

Say for example: A single VA license costs $280 per developer; a C++ developer’s annual wage is around $75,000 per year. Calculating those, you would only be adding 0.35% to the overall cost of hiring a developer. That’s an extremely low margin to reach to justify the purchase.

You can add other factors such as depreciation, deployment costs, and multi-license savings but even if you exaggerate those factors, there is minimal risk involved because of the huge ROI margin.

Simply speaking, listen to your developers. Even without exact numbers, it is one of the simplest and most cost-effective ways to improve the workspace quality–and thus overall productivity. 

 Try Visual Assist

A webinar hosted by Visual Assist lead developer, Chris Gardner, showcasing code inspections, one of VA’s many productivity features.

Ask your developers to give Visual Assist a spin. Leverage its many features and see if the productivity gains that everyone is talking about are true. Try Visual Assist for 30 days. 

The post Make your developers happy with Visual Assist first appeared on Tomato Soup.

If you’re in the market for your or your team’s SaaS fix, you’re in luck. This article will make your research a bit easier. In this blog, we discuss the value of one of the most powerful productivity extensions in Visual Studio and why plugins in general are still necessary in 2022.

What does Visual Assist do?

Visual Assist is a Visual Studio productivity plugin that is designed to help write C/C++ and C# code faster and easier.

VA does this by improving or adding built-in tools and features in Visual Studio with an efficient and a more powerful alternative. These benefits may manifest as more responsive menus, better code analysis tools, or even bespoke shortcuts that streamline complex processes into a single click.

Other articles can give a more complete explanation of what Visual Assist does, but in a nutshell, VA is a tool extension that improves a developer’s productivity.

How much is a developer’s time worth?

Not everyone realizes that time is the most expensive currency we exhaust every day. It is an indispensable and irreplaceable resource—and doubly so in the world of developers and programmers!

the average day for a developer costs a whopping $420…

Did you know that the average day for a developer costs a whopping $420? That’s around $3,000 weekly. That is why it is in the best interest of businesses and teams that the majority of a developer’s eight-hour workday is focused on actual programming. However, this also means that developers are getting pressured with shorter development cycles. A 2020 research found that codebases are increasingly getting larger, and pressure to deliver projects faster has increased in the past 10 years. And as larger and more complex codebases became the norm, demand for tools to support C++ developers has also ballooned.

From Sourcegraph: The Emergence of Big Code Survey

Is a Visual Studio code assistant the solution?

Going back to the main question, why is investing in Visual Studio extensions necessary? VS has made leaps and bounds in usability, efficiency, and support but the advantages are reduced due to increasing project requirements and time pressure.

For example,  there are still areas that lack extensive support and functionality. Game development projects, for instance, have resource-intensive tasks and unfamiliar syntax causing unintended behavior in the IDE. This unsupported niche is filled by plugins and is also why professionals need extensions to perform better. 

The core of development work is problem solving—not typing, navigating, or fixing syntax errors. They are part of the work, but they should not take more time than necessary. 

Visual Studio is a tool. Visual Assist is an enhancement. They are meant to simplify work and increase productivity. With increasing workloads and expectations, developers need to have more and better tools to produce quality work.

Dividing a developer’s attention into other tasks such as debugging small errors, shuffling through blocks of code, and waiting for builds to compile can stunt productivity—resulting in slower project turnaround time.

Some users may rely on native tooling, but as long as Microsoft cannot support every possible use case and application of Visual Studio, having performant plugins will still be a necessity for C/C++ developers. Besides, $129 for Visual Assist is a relatively low opportunity cost to get massive gains in productivity— making it an investment that pays for itself in as fast as two weeks.

The advantages of having Visual Assist

For those who transitioned to VS 2022, the shift to a 64-bit architecture has certainly fixed a few of the issues that long plagued the IDE. But a few problems persist to this day, such as:

• Tedious and repetitive tasks
• Superfluous processes
• Frustrating build and load times
• Unrecognized syntax and false errors

VA’s suite of features is specifically designed to alleviate these pain points with quick and responsive menus and options. “Fast performance is still one of [our] main advantages over other plugins,” notes Chris Gardner, lead developer of Visual Assist.

However, it’s also lightweight and works 100% alongside other VS plugins. “We believe it’s part of being a good member of the [plugin] ecosystem where [we] sit alongside others,” explains David Millington, a product manager of Embarcadero Technologies and Whole Tomato.

Visual Assist users can reallocate ~21% of their day to more pertinent tasks.

Feature Demo: example of time-saving feature (Code Inspection)

Here is a concrete example of how VA can save a ton of time. Code inspection is a nifty feature that checks code for quality issues and suggests the appropriate fixes.  

The two main advantages of Visual Assist over the native refactoring options are a) it automatically suggests corrections as you’re working on it, and b) it works just as well on large codebases.

Check out Visual Assist’s code inspection in action:

A webinar hosted by Visual Assist lead developer, Chris Gardner

Give Visual Assist a spin

If you’re still unsure whether investing into a small plugin is worth it, VA offers a 30-day trial for free. Experience it for yourself and see why VA users cannot go back to vanilla Visual Studio.

The post Why It’s Necessary to Invest in Visual Studio Extensions first appeared on Tomato Soup.

#1 Navigation through the elements of the project

In a large project, there are a lot of classes and methods, which greatly complicate the process of finding the right place in the code for you. Visual Studio provides special features to simplify the work with such projects.

To search for class members, you can use the Class Navigation menu located in the upper right corner of Visual Studio. When you click on the triangle button in this menu, a drop-down list appears with a list of all members of the class. When you click on a specific member, you navigate to it in the code.

To navigate through code elements, you can also use the Go to All feature. It allows you to find the desired element and filter the type of elements to search.

Go to All feature searches code elements through the entire project.

#2 Navigation through definitions and implementations

If you want to look at the definition of a member implemented in some class, then this is easy enough to do. You just need to select the Go to implementation command in the context menu that opens when you right-click on the selected member. You can also use the F12 hotkey.

In some situations, it is helpful to go to some implementation of a class member. To do this, select the command Go to implementation or use the hotkeys CTRL+F12.

Another useful feature that improves Visual Studio productivity is the possibility to find all references for the selected class member. It is easy to do using the Find All References command or Shift+F12 hotkeys. After executing the command, a search results window will open with a list of all references. By clicking on the selected reference, you will be redirected to it in the code. Find out more about setting up Visual Assist.

#3 Browsing the Structure of the Code

With Solution Explorer, you can view the overall structure of your code. It contains information about classes, their types, and members. If you select a code element in Solution Explorer, the associated file opens and the cursor moves to the selected element in the file.

You can also browse the hierarchy of method calls, search for symbols and symbol references, and so on.

#4 Code Editor Split For Productivity

You can split the code editor vertically or horizontally. This is very useful if you need to edit code in several related files at the same time. Also, vertical groups of documents improve Visual Studio productivity on very wide screens. You can easily move files between different groups of documents.

#5 Quick Search In Visual Studio

In Visual Studio, there is a search text box in the menu bar. You can use it for searching menu commands, dialog boxes, files, types, members, and more. To do this, just enter the keywords you want to find.

Also, it is possible to filter the content of tool windows. A lot of tool windows have a search bar that you can use to find the items you need.

In the Error List window, you can use the filter to display errors only in the files currently opened in the editor, errors only in the current file, or errors only in the current project.

#6 Conditional Debugging

In Visual Studio, you can add conditions to breakpoints. In this case, the break in the debug process occurs only if the specified condition is met. This can be especially useful when debugging loops that have a large number of elements and you only want to examine the element that matches the specified criteria.

#7 View objects that are out of scope

When debugging applications, in the Watch window, objects are tracked by their reference names. When such a reference goes out of scope, its value in the Watch window becomes unavailable, even if the object pointed to by the reference is still active.

Visual Studio provides the ability to continue tracking the state of an object outside of the scope. To do this, you need to create an object ID. Then, when the reference goes out of scope, this ID can be used to observe the state of the object.

#8 Code Snippets Increase Productivity

An important tool for increasing Visual Studio productivity is the ability to insert code snippets into your project. Using this feature, you can automatically insert frequently used pieces of code, which significantly speeds up the process of writing code.

There are a lot of ready snippets in Visual Studio. For example, snippets for creating a constructor, properties, loops, conditional operations, etc. If you often use the same piece of code in your project, then you can create your own snippet.

#9 Extract methods and interfaces

Visual Studio provides the ability to automatically perform various actions that otherwise would take a long time if you were performing them manually.

You can generate a new method from the selected part of the code using the quick action Extract method. A method will be created with all the required parameters and the code you chose. All that’s left for you to do is enter the method name.

It is also easy to create interfaces from existing classes. Just click the quick action Extract interface near the class name and select the class members you want to extract to the interface.

#10 Work with images in web applications

Visual Studio greatly simplifies working with images when developing web applications. You can drag and drop images from Solution Explorer into HTML code. In this case, the code is generated automatically. You can encode the image to base64 automatically, as well as automatically insert image height and width attributes.

#11 Shortcuts

Visual Studio has a huge list of keyboard shortcuts that allow you to perform various actions from code navigation to code generation, refactoring, debugging, and more. Using keyboard shortcuts is the best way to improve Visual Studio productivity and speed up the coding process.

#12 Extensions

If you are missing the standard tools that Visual Studio offers, you can install extensions. There are a lot of extensions available for Visual Studio that can be easily installed and customized to suit your needs.

One of them is Visual Assist, which simplifies the process of navigating through code, writing, and debugging code, and also allows you to customize code highlighting in a way that suits you.

Ready to get started boosting your Visual Studio productivity?

In this article, we learned a lot of interesting features that improve Visual Studio productivity. Want 10 more reasons? We are confident that when using them, you will write code much faster and easier.

Head over and download the latest version of Visual Assist!

The post 12 Helpful Tips For Visual Studio Productivity first appeared on Tomato Soup.

In this article, we will look at 13 interesting Visual Assist For Visual Studio 2022 features you may not know yet, but they will be definitely useful for you.

#1 How to quick fix code issues?

Visual Assist For Visual Studio 2022 automatically analyzes your C++ code and uses statistical analysis to find common programming errors. The place in the code where the error is found is underlined.

To find out the cause of the error, you need to hover over the underlined characters. If the problem in the code is dimmed or solid underlined, there is a quick fix available for the error. If the error is dotted underlined, no quick fix is available, but you can still find out the cause of the error.

#2 How to surround code with a snippet?

You can surround the selected part of the code with a snippet. Some snippets allow you to wrap only entire lines of code, while others can wrap code in the middle of a line.

You can surround some code with a snippet using the appropriate menu command or hotkeys that need to be specially configured.

#3 How to create a snippet from the selection?

You can quickly create snippets from ready-made code using Visual Assist For Visual Studio 2022. Just select the desired code and choose the menu command VAssistX -> Tools -> Create VA Snippet from the selection.

The snippet editor will open. In this editor, you can change the code, replace variables and constants with placeholders, and enter a title, description, and hotkeys to insert the snippet.

#4 How to debug crash dumps with VA Memory View?

Visual Assist Memory View is a tool that allows you to debug crash dumps when the call stack is corrupted or is in a release build.

Memory View displays the following data:

• The address. By default, the start address is the one pointed to by ESP/RSP.
• Content. This is the value that is stored in the address.
• Module. The name of the module where the memory address resides. This field is empty if the memory address is not in the module.
• Symbol name. The symbol at the memory address, if it is found or recognized.

#5 How to step over methods using the debugger?

Visual Assist For Visual Studio 2022 has a Step Filter tool that allows you to step over certain methods when debugging applications.

If the method in the parameter list contains another method, then, during debugging, we must first get inside the method that is in the parameters. If for some reason you want to step over this method, then you can add it to the Step Filter.

#6 How to add source links to comments?

With Virtual Assist you can add source links to comment substrings. They connect comments to external applications or websites such as bug trackers, documentation, case managers, etc.

A source link opens when you double-click on it. Hovering the mouse over a link will open a tooltip that contains basic information about the connected application or website.

#7 How to go to a related symbol?

This feature allows you to simplify the process of navigating through the code and quickly jump to the associated symbol by using the current symbol’s location.

Depending on the type of symbol, you can go to different places such as base class or method, inherited class or method, type, hashtag, header file, constructor, declaration, etc.

#8 How to list all classes and methods in the file?

The Context field allows you to list all classes and methods declared or implemented in the current file. Also, you can filter the opened list. The Context field is located on the left side of the Visual Assist navigation bar.

In addition to classes and methods, the list can also include member variables, structures, enumerations, defines, events, properties, and regions.

#9 How to automatically encapsulate a field?

The encapsulate field command is available from the refactoring menu. It allows you to automatically create methods for reading and writing the value of a field while restricting access to the field itself. When you call this command, a dialog box opens in which you can edit the name of the setter and getter, as well as change the visibility of the field.

#10 How to create a declaration or implementation?

If a method in a class has only an implementation, then with Visual Assist For Visual Studio 2022 you can automatically generate its declaration. To do this, select the appropriate command from the refactoring menu. The method declaration and implementation will have the same parameters.

If a matching header file exists, then the declaration will be placed in it. Otherwise, the declaration will be generated in the source file.

Similarly, you can generate a method implementation for an existing method declaration.

#11 How to document a method?

Visual Assist For Visual Studio 2022 allows you to easily document a method. To do this, select the declaration of the required method and click the required command from the context menu.

After that, a block of comments will appear before the method. This block will list the parameters of the method and the return value in separate lines.

#12 How to repair the case?

Virtual Assist has an automatic case correction feature. You can enter characters in the wrong case and they will be automatically corrected. If there is more than one way to correct the value, no automatic correction occurs.

#13 How to highlight syntax?

Visual Assist For Visual Studio 2022 allows you to add or change your IDE’s code highlighting. You can choose colors that suit you for classes, variables, preprocessor macros, enum members, methods, and namespaces.

In addition, it is possible to add highlighting to various components, such as tool windows.

Choose Visual Assist For Visual Studio 2022 and make the application development process quick and easy.

The post 13 Things About Visual Assist For Visual Studio 2022 You May Not Have Known first appeared on Tomato Soup.

The reason is the growing popularity of video games. The ever-increasing power of modern game engines has also led many people in gaming industries to strive for a more visually impressive and immersive gaming experience.

In this article, we will focus on how successful people make the most of their Unreal Engine with the help of WholeTomato’s Visual Assist.

1. What is Unreal Engine?

Unreal Engine is a video game engine developed by Epic Games. The founder, Tim Sweeney, designed it to help developers create video games for both PC and Mac platforms.

As the product grows, it can now be used by creators across industries. You can use it to create any VR, AR, mobile game, traditional console game, or animated feature film.

The company offers a free version of the software and a subscription-based version that allows you to use its engine on multiple platforms.

Unreal Engine is easy to use because it has Blueprints’ development tools. Blueprints tool helps a beginner game developer, who doesn’t quite master the programming language yet, to create their game from scratch.

The key benefits of using Unreal Engine include:

• You can use Unreal Engine to create games on mobile platforms, consoles, VR, and AR platforms.
• Unreal Engine also allows you to create 3D games.
• Unreal Engine also allows you to use code written in C++ and C#. Even if you’re not familiar with programming, there are many extensions out there that can help you use it.

2. What is Visual Assist?

Visual Assist is a tool that helps you simplify your game development workflow. When paired with Unreal Engine, it helps you work with a slew of efficiency.

It is a plugin for Visual Studio and it is available for all versions of Visual Studio. It is a Visual Studio extension and can make your life easier when working with Unreal Engine. 

You can use it to make the most of your time while working on a project and it will help you save hours of your time by eliminating tedious tasks.

Visual Assist has settings to customize how it works to suit your workflow better.

For example, you can choose to autocomplete U*Macro specifiers or make intelligent suggestions based on what you’re writing.

You can also automatically select which type of return value you want in C++ and C# by making implicit application and validating method aware of all U*Macro specifiers.

3. What Are the Top Features of Visual Assist?

Visual Assist is famous for several of its key features, including:

• Refactoring
• Code Generation
• Coding Assistance
• Code Inspection
• Debug Assistance

Refactoring

The Refactoring feature allows you to refactor your code quickly without losing the source code. Visual Assist makes it easy to rename variables, methods, classes, etc., and instantly shows you what will happen if you apply the change.

Code Generation

Visual Assist is also known for its code generation feature. This feature allows you to auto-generate methods and classes for your code.

You can choose between different code generation methods and define a custom set of rules for generating code.

Visual Assist will then provide a list of methods generated based on your defined rules.

Coding Assistance

The coding assistance feature of Visual Assist offers syntax highlighting, which shows the format of your current program.

It also includes auto-completion, which offers suggestions as you type a method name or variable name.

This feature provides handy functionality in helping to write large programs more quickly.

Code Inspection

The Code Inspection feature of Visual Assist allows you to view any part of your program. It gives instant feedback about what is wrong with the current line or block of code that you are viewing (if any).

The feedback is provided by “understanding” what you are doing. It can guide you to fix the problem on that line or block of code.

Debug Assistance

The Debug Assistance feature of Visual Assist provides an easy way to debug your program. It will show you all methods that have been called and the values they have returned.

This feature allows you to quickly and efficiently track down why your program doesn’t work.

4. How Can You Use Visual Assist to Make The Most Of Unreal Engine?

There are several ways Visual Assist can help you make the most of your career in the games industry.

You can use it to:

a. Remove Annoying Tabs

When you’re working on a project with Visual Assist, you won’t have to worry about creating tabs for every file you work with. Visual Assist will do that for you.

You will only need the tabs when you want to add or edit code. Therefore, this feature is crucial for developers who are new to programming. They’ll be able to focus more on what they’re doing and less on the mundane tasks.

b. Smart Suggestions for U*Macro Specifiers

U*Macro specifiers allow developers who are new to programming to use C++ and C#. With this feature, developers don’t have to enter them manually every time they write code.

Visual Assist automatically selects the best way, such that new developers do not need to think which specifier is which every time they write code.

c. Implicit Application and Validate Method Aware

Implicit application and validate method awareness is another feature that makes it easy for developers who are new to programming. The feature lets them know when they make mistakes in their coding logic and how they can fix those mistakes.

d. Go Without IntelliSense

Visual Assist lets you work without worrying about the type of return value you want to get from a function or method. It will auto-select the best way to write code for you.

Therefore, you don’t need to use IntelliSense in Unreal Engine. In addition, you can remove unnecessary built-in plugins from your software. Finally, creating more space is essential for developers who need more memory and storage.

e. QuickInfo for U*Macro Specifiers

The QuickInfo feature lets you know the specifier of a function or method when you hover over it. This feature is helpful for developers because they can read up on specifiers whenever they need to.

5. Ready to Snatch Success with Visual Assist?

WholeTomato’s Visual Assist is a tool that makes it easy for developers to focus more on their craft and less on coding. So, any game maker can have it easy while working on the next-gen console game and test their creative side.

It’s not a replacement for a dedicated team of programmers, but it can significantly lift developers’ work burden.

To get started with Visual Assist, check out the trial version and the tutorials on our site. Make the most of Unreal Engine now!

The post How Successful People Make The Most of Unreal Engine first appeared on Tomato Soup.

Although Visual Studio is the most extensible IDE on the planet, it cannot cater to all development needs. Game development is one such instance where better support from Visual Studio for Unreal Engine development becomes necessary.

This guide will cover everything relating to the Visual Studio Unreal Engine. It’ll help us link Unreal Engine with Visual Studio. Moreover, we will explain the innovative things happening with Visual Studio Unreal Engine.

What is Unreal Engine?

Unreal Engine is the one of the most potent 3D creation tool and game engines available on the market. It features several components that become the building blocks of a game. 

It is made up of components that work together to drive the game. It has a massive system of tools and editors. The Unreal Engine editor helps game developers to organize their assets and create the gameplay. 

Hence, Unreal Engine is a suite of creation tools for game development and automotive visualization. It also helps with linear film and television content creation and other real-time applications. 

What are 5 Innovative Features of Visual Studio Unreal Engine?

To build applications with unique features, integrating Visual Studio and Unreal Engine is important. Visual Studio works perfectly to turn vision into reality with tailored support for Unreal Engine. If you have already linked both, you can access tailored navigation, refactoring, code generation, etc. 

Additionally, note that Visual Assist is a Visual Studio extension. It offers support for an Unreal Engine. Below, we will take on five innovative features of the Visual Assist Unreal Engine. Developers can leverage these features for optimal performance. 

Here are the five most innovative features of Visual Studio Unreal Engine:

1. Removes Annoying Tabs

Ever wondered how you can turn off macro warnings? Or how to get rid of pop-up tabs? As a game developer, tabs opening is the most annoying thing. It opens whenever a function or class is declared. If you are struggling with the same issue, visual assist Unreal Engine has a solution for you.

With Visual Studio Unreal Engine, this isn’t a problem. Visual assist removes the annoying tabs after U*Macros. So, whenever a developer declares a function or class, it halts the pop-up warning. Plus, it also gives complete autonomy to the developer.

2. Gives Smart Suggestions for U·Macros Specifiers 

Forget annoying pop-ups, but who does not love the intelligent suggestions for macro specifiers? Smart suggestions make your code more productive and fast while giving you control over all the specifiers. You can type specifiers rapidly and with less switching to credentials for most U·Macros. 

If you change the Unreal Engine and add new specifiers, visual assist detects and suggests them. So, you have to worry less about the specifiers and focus more on developing games. 

3. Implicit Application and Validate Method Aware

One amazing feature of visual assist is that it reads U·Macro specifiers. With this feature, all its other features can be made smarter too. 

For instance, visual assist provides features that can find references. It can also rename and change signatures to support implicit methods.

4. No Need for IntelliSense

IntelliSense is a general term used for code editing features. These include code completion, parameter info, member lists, and quick info. All these features help developers learn more about the code. 

However, you do not need IntelliSense anymore as visual assist does all this better. The coding becomes more effortless and devoid of any incorrect red squiggles with the visual assist. It also helps save memory by disabling the built-in tooling. 

5. Shows U·Macro Specifiers With Additional Info

The macro specifier’s additional info helps the game developer better understand the code. For this, visual assist has smart features that show comments from base classes, including the U*Macro specifiers.

The record for Unreal Engine C++ is often in the code itself. It contains the guiding material for all developers.  

The above innovative features are possible only if Unreal Engine is linked with Visual Studio. So, here is how to connect Visual Studio with Unreal Engine. 

How to Link Visual Studio with Unreal Engine?

Unreal Engine (UE) is designed to integrate smoothly with Visual Studio (VS). It enables you to make code changes in your projects quickly and easily. Setting up a Visual Studio Unreal Engine can help improve the overall user experience. 

To integrate, include the Unreal Engine installer when installing Visual Studio. After this, locate the summary sidebar on the right. Expand the game development with the C++ section. Under the ‘optional,’ make sure the checkbox for ‘unreal engine installer’ is enabled. Lastly, click install, and Visual Studio will be linked with Unreal Engine. 

It is worth mentioning that unlocks Unreal Engine’s maximum potential when used with Visual Studio. Visual Studio Unreal Engine is poised to integrate to create great game development projects. 

Want to Increase Your Productivity with an Unreal Engine? Get Visual Assist Today

Visual assist is a C++ extension that turns vision into reality with tailored support for an Unreal Engine. With this, a developer writes code faster and gets code corrections as he makes them. 

It is possible due to the visual assist features. Features like code generation, code understanding, code assistance, and refactoring enhance the developer’s capacity. It also improves virtually every Microsoft IDE with the multitude of Visual Assist features. 

If you have not tried it yet, try Visual Assist for free. It will be fully functional for the next 30 days under the trial period. Once the trial period ends, you can decide whether to keep it or not. If you decide against it, remove it at any time with the IDE extension manager. 

The post The Most Innovative Things Happening With Visual Studio Unreal Engine first appeared on Tomato Soup.

Visual Assist extends Visual Studio to improve the development experience by providing tools for understanding, checking, and writing code. Its benefits include code inspection, fast navigation, refactoring, code assistance, code correction, and more. This article will discuss the top 10 reasons to use Visual Assist for Visual Studio 2022. 

What are the Benefits Provided by Visual Assist for Visual Studio 2022?

Visual Assist has several features to enhance developer productivity. These features virtually improve every Microsoft IDE with great benefits. Visual Assist helps fill gaps in Visual Studio for C/C++ and C# developers. Let’s discuss the reasons why developers need Visual Assist for Visual Studio 2022.

Write Code Faster With Assistance

VAX coding assistance helps write code faster, especially when on a roll. It suggests completions to avoid typing errors and quietly fixes mistakes in your wake.

• Acronyms: Write code faster using acronyms. Visual Assist extends the acronyms into the valid symbols in current content. Continue typing the lowercase letters if uppercase fails to isolate a symbol. 
• Auto-extend Multi-Line Comments: You can quickly expand multi-line comments from anywhere. Divide a line, and VAX opens a new line using an appropriate comment token at the right indent level.
• Enhanced Listboxes: Hover over the list boxes and control the content with a toolbar from VAX. Reorder Listbox content, or you can filter it by type. Find the required member by investigating a class without leaving your position.
• Multiple Clipboard: Quickly paste the copy-before-last using Ctrl+Shift and Enter because VAX always preselects the second clipboard in the menu. 

Reduce Code Complexity

Refactoring helps reduce the code complexity, enhance its readability, and extend it without changing the external behavior. This feature allows refactoring the legacy code, inherited code, or the first version of your work.

• Access to Refactoring Commands: These commands are available in menus accessible by mouse and keyboard, and the menu contents may vary with the context. 
• Extract Method: Move a code segment into a separate method and then replace the segment using a call to the extracting method.
• Introduce Variable: Replace an expression using a variable that explains the purpose of replaced code.
• Move Implementation to Header File: In C/C++, move a method implementation from the source to the class declaration or a header file.

Faster Code Generation

Visual Assist helps you generate code faster than you think, even only using a few features. You can write and update code faster once you become a proficient user.

• Forward Declaration: Add a forward declaration for a referenced symbol. For example, a pointer to a class from the current location.
• Add Member: Quickly add a member variable or method from any class reference without interfering with your normal flow.
• Add Similar Member: Open a refactoring menu from a reference to create a member similar to the existing reference. This top-down programming style doesn’t interrupt your normal flow.
• Add a Directive: In C/C++, add a directive quickly to the current file for making a symbol known. 

Makes Complex Code Easier

Make complex code easier with various tool windows, fields, and browsers, providing information where and when you need it.

• Column Indicator: VAX displays an indicator at the trailing edge of the specified column.
• Context Field: Glance at the Visual Assist navigation bar contact field to determine the definition and scope of the current symbol.
• Definition Field: Glance at the VA navigation bar right portion to determine the definition of the current symbol.
• Highlight Matching Word: It automatically highlights words that match the symbol at the caret as you move through comments and strings.

Fix Errors With Core Correction

Visual Assist quickly corrects mistakes as you make them, particularly errors in pointer notation and symbol case. Type in lower case and let Visual Assist correct the case symbol in your code.

• Highlights Files in Output Window: Add a standout after files built in your solutions with errors. The code correction feature makes it easier to determine what needs to be resolved.
• Repair Case: Type in virtually all lowercase or a mix of lowercase and uppercase. Visual Assist resolves the case symbol errors in the current context. Type definitions and declarations in camelCase.
• Underline Spelling Errors: Recognize the misspelled words in the code and repair them. Misspelled words appear with similar squiggles. VA lets you browse code without distractions of squiggles, as they appear only in modified files.

Code Inspection

Inspect your code for resolving quality issues. Based on LLVM/CLANG, this Visual Assist feature detects and fixes programming errors, such as interface misuse, style violations, and bugs that can be inferred through static analysis.

• Code Inspection Setting: Enable code inspection and quality checks in the Visual Assist options dialog box. The LLVM/CLANG parser executes in a separate process from Visual Studio to avoid degrading performance.
• Code Issues in the Editor: When you enable this feature, it highlights code issues in the Visual Studio text editor. The first few characters of code issues are underlined in a dotted or solid fashion.
• Quick Fixes in a Tool Window: Code issues are also available in a tool window identifying all issues for the current file. Apply fixes to all issues in a batch for a specified level.

Edit Custom Code Snippets

You can extend frequently typed code segments with a powerful version of like-named features. Include symbols from the current content and edit snippets in a custom editor.

• VA Snippers: Insert common code snippets with the powerful and accessible version of the like-named IDE snippet.
• VA Refactoring Snippets: You can edit various Visual Assist snippets bound to code-generation and refactoring commands and force new code adhering to the formatting preferences.
• Smart Suggestions: It defines suggestions to speed typing and optimize accuracy while assigning a value to a user-defined or built-in type and building constructs, such as loop, switch and a class.

Reduce Debugging Time

Use the Virtual Assist memory view and the step filter to reduce the time required to debug native C/C++. 

• Address Resolver: Debug native C/C++ while debugging information reaches in text form. Address Resolver reads DLLs, EXEs, and PDBs, and detects the symbols associated with the text version of visual addresses.
• PDB Explorer: Browse and search for module symbols comprising executable code, whether or not the code is in the running process. Find symbols in DLLs and EXEs as you were detecting symbols in a solution.
• VA Step Filler: Step directly into methods while stepping through native C/C++ without necessarily stepping into an argument list methods.

Efficient Tool Windows

View code from 30,000 feet and rearrange it to make it easier to understand and maintain. Visual Assist tool windows supply entirely new functionality to the IDE and bring together often-used built-in functionality for more efficient tool windows.

• VA Hashtags: Access your VA hashtags in the single tool window. You can view bookmarks and defined tasks in the comments throughout the project. 
• VA Outline: Inspect methods, classes, and file-scope declarations in the active document with VA outline. Modify the active document, and the VA outline stays in sync. 
• VA view: You can browse and navigate code efficiently with the VA view, a window generally kept in the foreground while editing. You can access the best features of various IDE tool windows in the VA view.

Easy Configuration

You can adjust many features in Visual Assist that suit your programming habits and environment. Find your favorite features and use them for maximum productivity.

• Context Menus: Use menus to access context-specific content. You can bind a shortcut to the VA context menu containing all features available for the current symbol, file, or position in the editor.
• Custom File Extensions: Make Visual Assist parse files without extensions as header files and consider files with specific extensions as header files or sources.
• Keyboard shortcuts: Learn the shortcuts assigned during Visual Assist installations, evaluate recommended shortcuts and assign them for the remainder of your favorites. 

Ready to use Visual Assist for Visual Studio 2022?

Visual Studio extensions are efficient tools to enhance developers’ productivity and efficiency. There are various extensions for Visual Studio, but developers find Visual Assist more productive than others. 

Visual Assist for Visual Studio 2022 helps you make coding easier with its unique and productive features. You can make the development environment more comfortable with the right practical measures. 

This article highlighted the most compelling reason showing that you need Visual Assist for Visual Studio. Visual Assist offers plenty of features to let developers code faster and more efficiently. Install Visual Assist to get a reliable extension for Visual Studio to increase code efficiency and speed. 

The post 10 Compelling Reasons Why You Need Visual Assist For Visual Studio 2022 first appeared on Tomato Soup.

This blog could be as short as that sentence, but I’d like to write a bit more about our support and how we got here. Meanwhile I recommend if you’re using VS2022 you download and install 2021.5 now!

Background

Historically it’s been very important to us to release support for new versions of Visual Studio very quickly, and if you’ve read our blog posts this year about VS2022, you’ll have read me say that before. While many customers stay on older versions for some time, we have a lot of people who upgrade immediately, so we’ve always put a lot of emphasis on being able to ship a version of Visual Assist supporting new versions of Visual Studio quickly. While I’ve been product manager here for almost three years, this is the first new major version of Visual Studio during that time, and I and the whole team were keen to continue that speedy-support tradition.

We started work supporting VS2022 early, and we’ve shared our progress over this past nine months about the work we’ve been doing to support VS2022, with beta support for Previews 3, skipping 4 due to a breaking bug, and 5, 6, and 7/RC. We released Visual Assist 2021.4 shortly before Visual Studio 2022 was released, and many of you are using it with VS2022 already.

Visual Studio 2022 was a large change from previous versions. Not only did it change to 64-bit, but there are many new APIs as well, and these APIs change the interaction model from synchronous to asynchronous interaction. This is a pattern Visual Studio has been following for several years (and we encourage it—it really helps the IDE) but as you may know migrating from any sync to async model is rarely trivial. Usually, the majority of the work for each new Visual Studio release is around adapting to API changes, and that was the case here too. In fact, the most major bug we saw using Visual Assist (abbreviated VAX) 2021.4 with VS2022 and which was one of the issues we fixed for today’s official support, an issue where the code suggestions window sometimes did not show in the right place, was related to the move to one specific async API.

Timeline

• We released Visual Assist 2021.4 on October 29.
• Visual Studio 2022 was released on November 8, nine days later.
• VAX 2021.4 overall worked pretty well with the final VS2022 build
  • But both we and some customers found a few more issues, and we’ve spent the past two weeks since VS’s release resolving them
• VAX 2021.5 with official support for Visual Studio 2022 was released on Nov 22!

Official Support for VS2022

Yesterday afternoon US time we posted Visual Assist 2021.5 on our website. We have a rolling release mechanism and in about a week you should see in-IDE notifications about the new release, followed a couple of weeks later with the new version being available in the Visual Studio Marketplace. However you can directly download and install it now.

We’ve been working on VS2022 for something like nine months now and we’re really happy to have Visual Assist publicly available with Visual Studio 2022 support. We hope it is useful to you!

A note of thanks: VS2022 was a large change from previous versions, and Microsoft has been very open and helpful. We’re very grateful to them for their communications with us, the beta program, and their assistance while we’ve added support. Thank you!

I want to note as well that though as PM I get to write these posts, I really do very little, and all the credit for this release and VS2022 support goes to our amazing team. Thank you!

The post Visual Studio 2022 Support! first appeared on Tomato Soup.

VAX 2021.4 is a quality-focused release. Our last release, 2021.3, was mostly focused on supporting the upcoming Visual Studio 2022 Previews. That early work on support for VS2022 means that when the official release of VS2022 is out, we’ll be able to ship official support very fast. (More on this below.)

However, not everyone upgrades to a new Visual Studio release immediately — in fact many people have very good reasons for staying on older versions for quite some time! — and we want to focus on providing what all our customers across many versions need. (We still support VS 2005!) That’s the focus for this version. This release, as a quality release, focuses on fixing bugs and adding changes for everyone.

Our release notes contain full info, but some notable changes include support for the new External Include Directories property in Visual Studio, and updating the Code Inspection engine to LLVM/Clang version 12.0.1. There are a plethora of bug fixes as well. All up we feel this release is a solid update for you no matter which version of Visual Studio, and for all ways that you use Visual Assist.

Visual Studio 2022

Swiftly supporting new versions of Visual Studio is very important to us, because we understand it’s important to many of you, and we hope you’ve enjoyed seeing VAX working in many of the Visual Studio 2022 Previews. We expect VS2022 to be released very soon. In fact, as we were preparing this release, Previews 5, 6 and 7 came out, the pace increasing so fast that our installer only mentions support for Preview 6, but we do in fact support Preview 7 as well. At the same time we’ve seen significant stability improvements with each newer preview.

We don’t want to delay our release schedule to wait until VS2022 is shipped, especially because this release is focused on what customers using other versions need, which is why we’re releasing now. But since VS2022 will be released so soon, and since we are very ready for that to happen, you can expect a swift mini-update from us adding official support.

In other words:

• VAX 2021.4 supports Visual Studio 2022 Previews 5 and 6 (with issues leading to hangs), and 7/RC3 (fully)
• We’re eagerly waiting for VS2022 to be released, and we’ll add official support for it very quickly when it’s out

We recommend you install Visual Assist 2021.4 now, and we look forward to shipping official support for Visual Studio 2022 very soon.

The post Visual Assist 2021.4 is released! (And notes on Visual Studio 2022) first appeared on Tomato Soup.

Visual Studio Preview

Visual Studio (VS) 2022’s main change—and it’s a significant one—is that it will become a 64-bit process. Since Visual Assist (VA or VAX) runs as a plugin, in-process, we needed to build a 64-bit version of our plugin DLL. Those who have upgraded 32-bit code to 64-bit code before know that, even in well-architected code, it takes some work even just to review code to ensure it is correct. In addition, the new version adds and modifies a number of APIs we rely on to interact with the IDE. Adapting to those was the most significant change for us.

We’ve tested fully against VS 2022 Preview 2, and in fact the installer says ‘Preview 2’. There are some known regressions:

• VA Quick Info not appearing when triggered by keyboard in VS 2022 [case: 146063]
• Source Links example plugin does not load in VS 2022 [case: 146012]
• Changing from Cascadia to another font for italicized system symbols requires restart in VS 2022 [case: 145979]
• plus a few others.

Visual Studio 2022 Preview 3 was released two days ago—overlapping timing with our release—and our regression tests are showing some failures. Currently we believe those are because of changed behaviour in a Visual Studio API which we use when verifying in-IDE behaviour (ie not an issue in VAX itself), but it is always possible that once that is resolved further test failures will need to be resolved. However, we believe the current build is well worth trying out on Preview 3 as well.

Performance

Many of our customers strain the Visual Studio IDE, with many plugins and SDKs installed. Both to help them, and because we believe it’s part of being a good member of the Visual Studio ecosystem where our plugin sits alongside others, last November we greatly reduced the in-process memory usage largely through (spoiler: the full blog is worth reading) use of memory-mapped files.

Now that Visual Studio 2022 is a 64-bit process, that work is not necessary for VS2022. For older versions of Visual Studio, those techniques are still used, so if you’re using VS 2019 or even VS 2005 with Visual Assist 2021.3, you’ll still benefit from the lighter memory impact within the IDE.

When we did that work, we also focused on performance to ensure that the changes to memory access had either zero or a positive impact. The blog notes that for heavy usage, we had equal performance; for small projects, VAX actually was a bit faster. Despite no longer needing the memory usage code we added, VS 2022 benefits from that performance work as well, plus some more work we’ve done while adding support. Since it’s a beta build, and Visual Studio itself is in preview, we do not have hard numbers. But a rough guideline is that an operation like Find References that previously may have taken (say) two minutes will now take about one minute twenty seconds, or about two thirds the time.

Overall

It’s historically been very important to us to have swift support for new versions of Visual Studio, and this work is our foundation for quickly officially supporting Visual Studio 2022 when it is officially released. While the main focus of this release was VS 2022 support, there are other changes as well in 2021.3, which we’ll document in the What’s New. We know we have many customers using older versions of Visual Studio, and as well as those improvements today you can look forward to further improvements focusing on other, non-VS areas as we switch back to a more normal focus in our next release.

We’re really happy to be able to ship beta support for the Visual Studio 2022 previews, and providing an even faster Visual Assist is a happy bonus. We’ll continue to work and look forward to shipping full support when Visual Studio publishes its final release.

Visual Assist 2021.3 is available for download on our website now, and will be on the Visual Studio Marketplace in a few days. Enjoy!

The post Visual Assist support for Visual Studio 2022 Previews! first appeared on Tomato Soup.

Visual Studio 2022 Public Preview is Here

Visual Studio 2022 is in public beta, with some exciting changes – they’re moving to 64-bit! The team at Microsoft has been super supportive, and we’ve been working on adding full support as we learn more and more about the changes being made. Much of this work is just making sure we’re ready for the release, but there will be some improvements made along the way. Don’t worry. If you’re not ready to move to VS 2022, we’re not dropping support for 2019, or 2017, 2015, or… (we do support a lot of versions, don’t we?) If you are an early adopter, be sure to opt-in for beta downloads. We’ll be releasing a new version with initial support for VS 2022 in the coming weeks!

Unreal Engine 5 Early Access

The team at Epic has been a great partner and supportive of our development efforts, and granted us an early look at some of the things we might encounter with the update. Again, much of the effort is just making sure everything works for UE5 the same way it does for UE4. While initial support is there, we know there will be more to come. We know our game devs are excited about this update and so are we. Again, be sure to sign up for beta to get the latest updates from our end. 

Windows What?

While most (I mean myself) weren’t expecting a big update from Windows, it looks like it is indeed happening. This won’t have as big of an impact on Visual Assist, as we’re more dependent on the IDE than anything else. However, we’re more excited to see what the future holds for Windows and what the downstream effects will be. If you’re in the know, feel free to comment. Either way, we’ll be supporting any moves made as we are able.

All this to say we’re busy and excited about this year in development news. As things get back to somewhat normal in day-to-day life, it looks like we’ll be making up for lost time from 2020 fairly quickly.

Looking for a New Database?

A last note for Visual Studio users: our sister company InterBase has released a new plugin on the VS extension store, adding support for ADO.NET to an already amazing database. We know everyone’s needs around a database are different and think InterBase is a solid mix of lightweight and full-featured with solid encryption all around. Learn more and give it a try here.

The post Busy Busy Busy! first appeared on Tomato Soup.

Visual Assist is a coding productivity tool for C++ and C# developers. It extends Visual Studio to make the programming experience better by providing tools for understanding code, checking code, and writing code. Some of its benefits include fast navigation, code inspection and modernization, many refactorings, code correction, Unreal Engine 4 support (for which it is famous), and code assistance. In this article, we will walk through the steps needed to set up Visual Assist and show you a very brief overview of how to use it.

1. Installing Visual Assist

First, visit the Whole Tomato Visual Assist website to download the installer. You can use Visual Assist for free for a month as a trial, or alternatively, you can choose to buy a license from the get-go. Keep in mind that once your free trial is over, you will need to buy the license to keep using it.

On the main page, click the red “Try it for free” button, and on the next page, click “Download Free Trial” to download the installer.  

Before downloading the file, you will need to fill in some required information.

Once you have completed this step, your download will begin.

When you are done downloading the installation file, open it to begin the installation process. Visual Assist supports many versions of Visual Studio, and you can install it for any version you have on your computer.

Once the installation is complete, you can immediately start making use of Visual Assist.

When you run Visual Studio, Visual Assist will show you a tip. You can turn this off, but we recommend you keep it on since it shows helpful information about what you can achieve each time you start.

And that’s it! Visual Assist is installed. 

Visual Assist is very powerful but has a very low UI. That’s great for power users who know it well, but if you’re new to using it, it can be harder to discover all the things it can do. Read on for a short intro about using it with a new application. 

Using Visual Assist

The following few steps show you how to create a new application in Visual C++. If you’re familiar with this, you can skip ahead to where we demonstrate Visual Assist.

When starting Visual Studio, you will be directed to the Welcome page, where you will be able to create new projects from the pop-up window. Click on “Create new project” to move to the next step.    

You can create different types of applications using Visual Studio. In this guide, we will create a Windows C++ application for the purpose of illustration. 

Select Windows Desktop Application (note the C++ label) to start building your app. You can select whichever type of application you are interested in building. Once this is complete and you have successfully configured your project, you will finally be able to make use of Visual Assist. Click on “Create” and watch the magic unfold.  

Note that Visual Assist is low UI to prevent it from getting in your way while making use of Visual Studio. Click on “Extensions” in the toolbar and navigate to “VAssistX,” which will present a list of functionalities that you can explore.

You can also access the Quick Action and Refactoring menu by using the following shortcut (Shift+Alt+Q). For a comprehensive list of keyboard shortcuts, click here.

3. Like Visual Assist?

When your trial comes to an end, you will be prompted to use a license. Select “Buy” to purchase a license or “Register” to use an existing one. 

By now you should be able to set up Visual Assist without any problem and start making use of it alongside Visual Studio. To find out more about Visual Assist and some of its functions, and why everyone from developers in major studios right down to students uses it, click here.

The post How to Set Up Visual Assist first appeared on Tomato Soup.

1. Override

Let’s have a look at the following code with a simple class hierarchy:

using BmpData = std::vector<int>;

class BaseBrush {
public:
virtual ~BaseBrush() = default;

virtual bool Generate() = 0;

virtual BmpData ApplyFilter(const std::string&) { return BmpData{}; }
};

class PBrush : public BaseBrush {
public:
PBrush() = default;

bool Generate() { return true; }

BmpData ApplyFilter(const std::string& filterName) {
std::cout << "applying filter: " << filterName;
return BmpData{};
}

private:
BmpData m_data;
};

When you run VA code inspections, you’ll immediately see that it complains about not using the override keyword on those two virtual methods.

In short, the override keyword allows us to explicitly specify that a given member function overrides a function from a base class. It’s a new keyword available since C++11.

As you might already know, you can go to VA Code Inspection Results and apply the fixes automatically. You’ll get the following code:

class PBrush : public BaseBrush {
public:
PBrush() = default;

bool Generate() override;

BmpData ApplyFilter(const std::string& filterName) override;
private:
BmpData m_data;
};

What are the benefits of using override?

The most significant advantage is that we can now easily catch mismatches between the virtual base function and its override. When you have even a slight difference in the declaration, then the virtual polymorphism will might not work. 

Another critical point is code expressiveness. With override, it’s effortless to read what the function is supposed to do.

And another one is being more modern as this keyword is also available in other languages like C#, Visual Basic, Java, and Delphi.

2. nullptr

When I work with legacy code, my Visual Assist Code Inspection Result is often filled with lots of the following items:

This often happens with code like:

if (pInput == NULL) {
    LOG(Error, "input is null!")
    return;
}

or

pObject->Generate("image.bmp", NULL, NULL, 32);

Why does Visual Assist complain about the code? It’s because NULL is just a define and means only 0, so it doesn’t mean a null pointer, but it means 0. This is also a problem when you have code like:

int func(int param);
int func(float* data);
if you call:
func(NULL);

You could expect that the function with the pointer should be called, but it’s not. That’s why it’s often a guideline in C or early C++ that suggests not making function overrides with pointers and integral types.

The solution? Just use nullptr from C++11.

nullptr is not 0, but it has a distinct type nullptr_t.

Now when you write:

func(nullptr);

you can expect the proper function invocation. The version with func(float* data) will be invoked.

Not to mention that nullptr is a separate keyword in C++, so it stands out from the regular code. Sometimes NULL is displayed in a different color, but sometimes it is not.

Visual Assist makes it super easy to apply the fix, and it’s a very safe change.

3. Convert enum to scoped enum

Another pattern that is enhanced with Modern C++ is a way you can define enums.

It was popular to write the following code:

enum ActionType {
    atNone,
    atProcess,
    atRemove,
    atAdd
};

ActionType action = atNone;
Since C++11 it's better to you can define this type in the following way:
enum class ActionType {
    None,
    Process,
    Remove,
    Add
};

ActionType action = ActionType::None;

What are the benefits of such transformations?

• They don’t pollute the global namespace. As you may have noticed, it was often necessary to add various prefixes so the names wouldn’t clash. That’s why you see atNone. But in the scoped enum version, we can write None.
• You get strong typing, and the compiler will warn when you want to convert into some integral value accidentally.
• You can forward scope enums and thus save some file dependencies.

What’s best about Visual Assist is that it has a separate tool to convert unscoped enums to enum classes, all with proper renames and changes in all places where this particular type was used. Right-click on the type and select “Convert Unscoped Enum to Scoped Enum.”. This opens a preview window where you can see and select which references will be replaced.

Read more in Convert Unscoped Enum to Scoped Enum in the VA documentation.

4. Use more auto

One of the key characteristics of Modern C++ is shorter and more expressive code. You saw one example where we converted from for loops with long names for iterators into a nice and compact range-based for loops.

What’s more, we can also apply shorter syntax to regular variables thanks to automatic type deduction. In C++11, we have a “reused” keyword auto for that.

Have a look:

std::vector<int> vec { 1, 2, 3, 4, 5, 6, 7, 8};
std::vector<int>::const_iterator cit = vec.cbegin();

We can now replace it with:

std::vector<int> vec { 1, 2, 3, 4, 5, 6, 7, 8};
auto cit = vec.cbegin();

Previously, template-type deduction worked only for functions, but now it’s enabled for variables. It’s similar to the following code:

template <typename T> func(T cit) {
    // use cit...
}
std::vector<int> vec { 1, 2, 3, 4, 5, 6, 7, 8};
func(vec.cbegin()); // template deduction here!

Following are some other examples:

auto counter = 0;   // deduced int
auto factor = 42.5; // deduces double
auto start = myVector.begin(); // deduces iterator type
auto& ref = counter; // reference to int
auto ptr = &factor;  // a pointer to double
auto myPtr = std::make_unique<int>(42);
auto lam = [](int x) { return x*x; };

Have a look at the last line above. Without auto, it wouldn’t be possible to name a type of a lambda expression as it’s only known to the compiler and generated uniquely.

What do you get by using auto?

• Much shorter code, especially for types with long names
• Auto variables must always be initialized, so you cannot write unsafe code in that regard
• Helps with refactoring when you want to change types
• Helps with avoiding unwanted conversions

As for other features, you’re also covered by Visual Assist, which can automatically apply auto. In many places, you’ll see the following suggestions:

This often happens in places like

SomeLongClassName* pDowncasted = static_cast<SomeLongClassName*>(pBtrToBase); 
// no need to write SomeLongClassName twice:
auto pDonwcasted = static_cast<SomeLongClassName*>(pBtrToBase);

or

unsigned int val = static_cast<unsigned int>(some_computation / factor);
// just use:
auto val = static_cast<unsigned int>(some_computation / factor);

As you can see, thanks to auto, we get shorter code and, in most cases, more comfortable to read. If you think that auto hides a type name for you, you can hover on it, and the Visual Studio will show you that name. Additionally, things like “go to definition” from Visual Assist work regularly.

5. Deprecated functionality

With C++11, a lot of functionality was marked as deprecated and was removed in C++17. Visual Assist helps with conversion to new types and functions.

For example, it’s now considered unsafe to use random_shuffle as it internally relied on simple rand(), which is very limited as a random function generator.

std::vector<int> vec { 1, 2, 3, 4, 5, 6, 7, 8 };
std::random_shuffle(vec.begin(), vec.end());

Visual Assist can replace the above code with the following:

std::shuffle(vec.begin(), vec.end(), std::mt19937(std::random_device()()));

Additionally, you’ll get suggestions to improve old C-style headers and convert them into C++ style:

Some other handy fixes

We have covered a few inspections, but there’s much more! Here are some exciting items that you might want to see:

• Standard algorithm can be replaced by container’s more efficient implementation: clang-tidy – performance-inefficient-algorithm
• typedef can be converted to using declaration: clang-tidy – modernize-use-using
• Redundant call to c_str() or data() on string: clang-tidy – readability-redundant-smartptr-get
• Optimize call to std::string::find() to use single character literal: clang-tidy – performance-faster-string-find

The whole list is available here: List of Code Inspections

Summary

Thanks for reading our small series on Clang Tidy, Code Inspections, and Visual Assist. We covered a lot of items, and I hope you learned something new. The techniques I presented in most cases are very easy to use, especially thanks to VA support, and you can gradually refactor your code into Modern C++.

The post How To Modernize With Visual Assist Part 2 first appeared on Tomato Soup.

Written by David Millington (Product Manager), Goran Mitrovic (Senior Software Engineer) and Christopher Gardner (Engineering Lead)

Visual Assist is an extension which lives inside Visual Studio, and Visual Studio is a 32-bit process, meaning that its address space, even on a modern 64-bit version of Windows, is limited to a maximum of 4GB. Today 4GB doesn’t always go very far. A typical game developer, for example, may have a large solution, plus perhaps the Xbox and Playstation SDKs, plus other tools – already using a lot of memory – plus Visual Assist. A lot of Visual Assist is built around analysis of your solution, and that requires storing data about your source code, what we call the symbol database. Sometimes, with all of these things squashed into one process’ memory space together, some users with large and complex projects start running out of memory.

The latest version of Visual Assist (build 2393, 28 Oct 2020) reduces in-process memory consumption significantly. It’s a change we think will help many of you who are reading this, because those with large solutions who run into memory issues should find those memory issues alleviated or disappearing completely; and those with small or medium solutions may find Visual Assist runs a little faster.

Plus, it’s just part of being a good member of the Visual Studio ecosystem: as an extension relied on by thousands of developers, yet sitting in the same shared process as other tools, we should have as little impact as we can.

The chart above shows that the new build of Visual Assist reduces VA’s memory usage by about 50% – that is, half as much memory is used. You can see more charts below, and we consistently see 30%, 40% and 50% memory savings.

We’d like to share some technical information about the approaches we took to achieve this, and we hope that as C++ or Windows developers you’ll find the work interesting. This is a fairly long blog, and starts off light and gets more technical as it goes on. It covers:

• Concepts
• Background – Where Visual Assist Uses Memory
• String Storage Optimizations
• Moving Out Of Process: Entire Parser
• Moving Just Memory
• Chunk / Block Structure and Allocation / Freeing
• Optimizations
• Results

Concepts

Many readers may know this, but to follow this post here’s a quick primer on some concepts. Feel free to skip to the next section if you’re already familiar.

Address space refers to the total amount of memory an application can use. It’s usually limited by the size of a pointer (because a pointer points to memory): a 32-bit pointer can address 2³² (about 4 billion) bytes, which is 4GB. So we say that a 32-bit process has a 32-bit address space, or an address space of 4GB. (This is hand-wavy – although true, on 32-bit versions of Windows this 4GB was split between kernel and user mode, and a normal app can only access usermode memory; depending on settings, this actually meant your app could access only 2GB or 3GB of memory before it could not allocate any more. On a 64-bit version of Windows, a 32-bit app has the entire 4GB available. Plus, there are techniques to access more memory than this even on 32-bit systems, which is getting ahead of where this blog post is going.)

This address space is a virtual address space; the application uses virtual memory. This means that the 4GB is not actually a sequential block of memory in RAM. Pieces of it can be stored anywhere, including on disk (swapped out) and loaded in when needed. The operating system looks after mapping the logical address, the address your application uses, to the actual location in RAM. This is important because it means that any address you use has what backs it, where it actually points to, under Window’s control.

A process is how your application is represented by the operating system: it is what has the virtual address space above, and contains one or more threads which are the code that runs. It is isolated from other processes, both in permissions and memory addresses: that is, two processes do not share the same memory address space.

If you’re really familiar with those concepts, we hope you’ll forgive us for such a short introduction. OS architecture including processes, threads, virtual memory etc is a fascinating topic.

Background – Where Visual Assist Uses Memory

Visual Assist parses your solution and creates what we call the ‘symbol database’, which is what’s used for almost every operation – find references, refactoring, our syntax highlighting (which understands where symbols are introduced), generating code, etc. The database is very string-heavy. It stores the names of all your symbols: classes, variables and so forth. While relationships between symbols can be stored with relatively little memory, strings themselves take up a lot of space in memory.

Our first work on memory optimization focused on the relationships, the links between data, and metadata stored for each symbol, and we did indeed reduce the memory they used. But that left a large amount of memory used by strings generated from source code. In addition our string allocation patterns meant strings were not removed from memory when memory became full and there was allocation pressure, but instead at predefined points in code, and that also increased the risk for large projects of getting out of memory errors.

Clearly we needed to solve string memory usage.

We researched and prototyped several different solutions.

String Storage Optimizations

Stepping back in time a little, string memory usage is obviously not a new problem. Over time, Visual Assist has used several techniques to handle string storage. While there are many possible approaches, here’s an overview of three, one of which Visual Assist used and two of which it has never used, presented in case they are new or interesting to you.

String interning addresses when there are many copies of the same string in memory. For example, while Visual Assist has no need to store the word “class”, you can imagine that in C++ code “class” is repeated many times throughout any solution. Instead of storing it many times, store it once, usually looked up by a hash, and each place that refers to the string has a reference to the same single copy. (The model is to give a string to the interning code, and get back a reference to a string.) Visual Assist used to use string interning, but no longer: reference counting was an overhead, and today the amount of memory is not an issue itself, only the amount of memory used inside the Visual Studio process.

While we’re discussing strings, here are two other techniques that are not useful for us but may be useful for you:

• To compress strings. Visual Assist never used this technique: decompression takes CPU cycles, and strings are used a lot so this would occur often.
• To make use of common substrings in other strings: when a string contains another string, you can refer to that substring to save memory. A first cut might use substrings or string views. This is not useful for us due to the overhead of searching for substrings, which would be a significant slowdown, and the nature of the strings Visual Assist processes not leading to enough duplication of substrings to make it worthwhile. A more realistic option (in terms of performance, such as insertion) for sharing string data than shared substrings would be to share data via prefix, such as storing strings in tries. However, due to the nature of the strings in C++ codebases, our analysis shows this is not a valuable approach for us.

The approach we took to the recent work was not to focus on further optimising string storage, but to move where the string storage was located completely.

Moving Out Of Process: Entire Parser

Visual Assist is loaded into Visual Studio as a DLL. The obvious approach to reducing memory pressure in a 32-bit process is to move the memory – and whatever uses it – out of process, which is a phrase used to mean splitting your app up into multiple separate processes. Multi-process architectures are fairly common today. Browsers use multiple processes for security. Visual Studio Code hosts extensions in a helper process, or provides code completion through a separate process.

As noted in the primer above, a second process has its own address space, so if we split Visual Assist into two, even if the second was still a 32-bit process it could double the memory available to both in total. (Actually, more than double: the Visual Studio process where Visual Assist lives has memory used by many things; the second process would be 100% Visual Assist only. Also, once out of Visual Studio, we could make that second process 64-bit, ie it could use almost as much memory as it wanted.) Multi-process architectures can’t share memory directly (again hand-wavy, there are ways to read or write another process’s memory, or ways to share memory, but that’s too much for this blog); generally in a multi-process architecture the processes communicate via inter-process communication (IPC), such as sockets or named pipes, which form a channel where data is sent and received.

There were two ways to do this. The first is to move most of the Visual Assist logic out to a second process, with just a thin layer living inside Visual Studio. The second is just to move the memory-intensive areas. While the first is of interest, Visual Assist has very tight integration with Visual Studio – things like drawing in the editor, for example. It’s not trivial to split this and keep good performance. We focused instead on having only the parser or database in the second process.

Prototyping the parser and database in a second process, communicating with IPC back to the Visual Studio process, showed two problems:

• Very large code changes, since symbols are accessed in many places
• Performance problems. Serializing or marshalling data had an impact. Every release, we want VA to be at least the same speed, but preferably faster; any solution with a performance impact was not a solution at all

Moving Just Memory

Multi-process is not a required technique, just one approach. The goal is simply to reduce the memory usage in the Visual Studio process and move the memory elsewhere; we don’t have to do that by moving the memory to another process—and this is a key insight. While multiprocess is a fashionable technique today, it’s not the only one for the goal. Windows provides other tools, and the one we landed on is a memory mapped file.

In the primer above, we noted that virtual memory maps an address to another location. Memory-mapped files are a way to map a portion of your address space to something else – despite the name, and that it’s backed by a file, it may not be located on disk. The operating system can actually store that data in memory or a pagefile. That data or file can be any size; the only thing restricted is your view of it: because of the 32-bit size of your address space, if the mapped file is very large you can only see a portion of it at once. That is, a memory mapped file is a technique for making a portion of your address space be a view onto a larger set of data than can fit in your address space, and you can move that view or views so, although doing so piece by piece, ultimately a 32-bit process can read and write more data than fits in a 32-bit address space.

Benchmarking showed memory mapped files were significantly faster than an approach using any form of IPC.

The release notes for this build of Visual Assist referred to moving memory ‘out of process’. Normally that means to a second process. Here, we use the term to refer to accessing memory through a file mapping, that is, accessing memory stored by the OS, and potentially more memory than can fit in the process’ address space. Referring to it as out of process is in some ways a holdover from when the work was planned, because we had initially thought we would need multiple processes. But it’s an accurate term: after all, the memory is not in our process in a normal alloc/free sense; it’s an OS-managed (therefore out of process) resource into which our process has a view.

Note re ‘memory mapped files were significantly faster than … using any form of IPC’: sharing memory mapped files can be a form of IPC as well – you can create the mapped file in one process, open in another, and share data. However, we had no need to move logic to another process – just memory.

Chunk / Block Structure and Allocation / Freeing

We already mentioned that the data we stored in the memory mapped file is strings only. In-process, we have a database with metadata fields; in the mapped view are all strings. As you can imagine any tool that processes source code uses strings heavily; therefore, there are many areas in that mapped memory we want to access at or near-at once.

Our implementation uses many file mappings to read and write many areas at once. To reduce the number, each is a fixed size of 2MB. Every one of these 2MB chunks is a fixed heap, with blocks of a fixed size. These are stored in lists:

• 2MB chunks that are mapped, and locked as they are being used to read or write data
• Chunks that are mapped, but unused at the moment (this works like a most recently used cache, and saves the overhead of re-mapping)
• Chunks that are not mapped
• Chunks that are empty

Most C++ symbols fit within 256 bytes (note, of course, this is not always the case – something like Boost is famous for causing very long symbol names.) This means most chunks are subdivided into blocks 256 bytes long. To allocate or free is to mark one of these blocks as used or unused, which can be done by setting a single bit. Therefore, per two-megabyte chunk, one kilobyte of memory is enough to represent one bit per block and to allocate or deallocate blocks within a chunk. To find a free block, we can scan 32bits at a time in a single instruction, BitScanForward, which is handily an intrinsic in Visual C++.

This means that Visual Assist’s database now always has a 40MB impact on the Visual Studio memory space—twenty 2MB chunks are always mapped—plus a variable amount of memory often due to intermediate work, such as finding references, which can be seen in the charts below and which even in our most extreme stress test topped out at a couple of hundred megabytes. We think this is very low impact given the whole 4GB memory space, and given Visual Assist’s functionality.

Optimizations

There are a number of optimizations we introduced this release, including improvements for speedily parsing and resolving the type of type deduction / ‘auto’ variables, changes in symbol lookup, optimisations around template handling, and others – some of which we can’t discuss. I’d love to write about these but they verge into territory we keep confidential about how our technology works. We can say that things like deducing types, or template specialisation, are faster.

However we can mention some optimizations that aren’t specific to our approach.

The best fast string access code is code that never accesses strings at all. We hash strings and use that for string comparison (this is not new, but something Visual Assist has done for a long time.) Often it is not necessary to access a string in memory.

Interestingly, we find in very large codebases with many symbols (millions) that hash collisions are a significant problem. This is surprising because hash algorithms usually are good at avoiding collisions, and the reason is that we use an older algorithm, and one with a hash value only 32 bits wide. We plan to change algorithms in future.

We also have a number of other optimizations: for example, a very common operation is to look up the ancestor classes of a class, often resolving symbols on the way, and we have a cache for the results of these lookups. Similarly, we reviewed all database lookups for areas where we can detect ahead of time a lookup does not need to be done.

Our code is heavily multi-threaded, and needs to be performant, avoid deadlocks, and avoid contention. Code is carefully locked for minimal locking, both in time (duration) and scope (to prevent locking a resource that is not required to be locked, ie, fine-grained locking.) This has to be done very carefully to avoid deadlocks and we spent significant time analysing the codebase and architecture.

In contrast we also reduced our use of threads. In the past we would often create a new thread to handle a request, such as to look up symbol information. Creating a thread has a lot of overhead. Now, we much more aggressively re-use threads and often use Visual C++’s parallel invocation and thread pool (the concurrency runtime); the performance of blocking an information request until a thread is available to process it is usually less than creating a thread to process it.

Symbols are protected by custom read-write locks, which is written entirely in userspace to avoid the overhead of kernel locking primitives. This lock is custom written by us, and is based around a semaphore which we find provides good performance.

Results

All these changes were done with careful profiling and measurement at each stage, testing with several C++ projects. These included projects with 2 million symbols, 3 million symbols, and 6 million symbols.

The end result is the following:

• For very large projects – we’re talking games, operating systems, etc – you will see:
  • 50% less memory usage between low/high peaks doing operations such as Find References (average memory usage difference is less once the operation is complete; this is measured during the work and so during memory access.)
  • Identical performance to earlier versions of Visual Assist
• For smaller projects:
  • Memory usage is reduced, though for a smaller project the effect is not so noticeable or important. But:
  • Improved performance compared to earlier versions of Visual Assist

In other words, something for everyone: you either get far less memory pressure in Visual Studio, with the same performance, or if memory was not an issue for you then you get even faster Visual Assist results.

Here are the results we see. We’re measuring the memory usage in megabytes after the initial parse of a project, and then after doing work with that project’s data—here, doing a Find References, which is a good test of symbol database work. Memory usage here is ascribed to Visual Assist; the total memory usage in the Visual Studio process is often higher (for example, Visual Studio might use 2GB of memory with a project loaded between itself and every other extension, but we focus here on the memory used by Visual Assist’s database and processing.)

One good test project is Unreal Engine:

Another excellent large C++ codebase is Qt:

Our feedback has been very positive: we often work with customers with very large codebases and significant memory usage from many sources inside Visual C++, and the lower impact of Visual Assist has made a noticeable difference. That’s our goal: be useful, and be low-impact.

We hope you’ve enjoyed reading this deep dive into the changes we made in Visual Assist build 2393. Our audience is you – developers – and we hope you’ve been interested to get some insight into the internals of a tool you use. While as the product manager I get to have my name on the post, it’s not fair because I did nothing: the credit goes to the engineers who build Visual Assist, especially Goran Mitrovic and Sean Echevarria who were engineers developing this work, and Chris Gardner our team lead, all of whom helped write this blog post.

A build of VA with the changes described in this post is available for download now, including trying it for free if you’d like. If you’re new to VA, read the quick start or browse our feature list: our aim is not to have the longest feature list but instead to provide everything you need, and nothing you don’t. We also do so with minimal UI – VA sits very much in the background. Our aim is to interrupt or distract you as little as possible while being there when you need it. You can see the kind of engineering we put into VA. It’s built by developers for developers.

The post Technical Deep Dive: Reducing Memory Consumption in Visual Assist build 2393 first appeared on Tomato Soup.

C++ with Visual Assist, Visual Studio and Unreal Engine

It’s inspiring that software like Microsoft’s Visual Studio IDE and Epic’s Unreal Engine have been “free” for so long now. It pains me to think about where indie developers would be without the forward thinking force of these larger companies and their seemingly never-ending generosity. Helping start-ups and the like to get their feet on the ground is something I will forever be grateful for.

Although the tools come close to it, it would be naive to think that they can fulfil the job of every requirement. I want to point out a few problems we were facing at Distalsoft when it came to developing in Visual Studio using Unreal Engine and the solution we ended up going with.

Unreal Engine at its core uses the C++ language. Visual Studio – being a Microsoft product – makes development in C# very enjoyable. On the other hand, development in C++ has been a point of frustration for many years. From VS 2010 to VS 2017, improvements have been made to the overall speed of compilation, Intellisense, file searching and the like, but it has taken until 2019 for them to really make a dent in the problem. I must say that VS 2019 has done an excellent job of addressing the aforementioned issues but the question still stands – could it be better?. 

A few years ago when I was using VS 2015, I’d had enough. I’d sometimes be waiting several minutes for Intellisense to bring back a list of methods or properties that belonged to an object. I’m pretty sure we’ve all done it – smashing the heck out of the ctrl+shift+space keys and cursing at the screen while waiting for the Intellisense to pop up. Or simple searches in the solution explorer that end up taking longer to resolve than simply finding the file yourself. Perhaps even trying to navigate to the definition of a method only to be waiting minutes for the document to load up. Something had to change. I went searching on the internet for a solution. It didn’t take long to stumble across a piece of software called Visual Assist by Whole Tomato. It had been recommended many times on various parts of the AnswerHub forum for Unreal Engine and StackOverflow. Due to it having a trial version, I downloaded a copy to give it a try.

The expression “night and day”, really doesn’t do the software justice but it’ll have to do for now. I was extremely relieved. Searching for files, definitions, even just including header files were now as you would expect from an IDE. The additional dialog menu that is available when right clicking on bits of code you want to perform actions against, has a variety of options that make you realise what was/is missing from the ootb VS. To be honest, I don’t use half of them, but it’s the baseline mechanics that just work so much better. And, to address my biggest issue – the speed of Intellisense – type-ahead now loaded within seconds and sometimes even instantly. What a relief!

Unreal Engine have improved their documentation, but unfortunately it’s still not quite there. I would always see people answer questions in AnswerHub with “Look through the Unreal Engine code, it’s open source”. I always assumed they were joking. Pressing F12 to go to method definitions without Visual Assist would take forever. Thanks to my new found friend Visual Assist, I finally had the ability to go find the answers to some of the most annoying questions. It’s hard to really communicate just how irritating it used to be. Seriously, Visual Assist has made me a happy C++ coder again.

I suppose the last thing to make note of is that Visual Assist is not currently free, but the trial is sufficient to make you realise just how much happier you can be when using it. I would be interested to see Visual Assist introduce a subscription based payment plan, but you can’t complain. They have done a stellar job at creating a brilliant tool.

So in conclusion, go check it out. See for yourself. You won’t be disappointed.

This blog was brought to you by Distalsoft. If you’d like for us to showcase what you’re building (better and faster) with Visual Assist contact us.

The post Developer Showcase: Visual Assist in Action first appeared on Tomato Soup.

Thank you to all of the customers who stopped by our booth at the Build conference. It’s clear we have ardent supporters. We look forward to providing you with the debugger improvement we demo’d. Expect a beta in a few months. To the many first-time visitors, we hope you find Visual Assist as valuable as we led you to believe.

Build 2031 of Visual Assist was made available the first day of Build, to coincide with Microsoft’s announcement of universal solutions and shared projects. Although beta, Visual Assist build 2031 has support for the new features of Visual Studio 2013 Update 2 RC. We’ll blog separately to discuss the impact of shared projects on several features of Visual Assist, including Find References, Rename, and Change Signature.

Visual Assist build 2031 requires maintenance through 2014.03.31. The build includes an entirely new editor for VA Snippets. The editor is available only for Visual Studio 2010 and newer, but since VA Snippets are shared among IDEs, edit VA Snippets with your newest IDE and your changes will be available in any old code you still maintain. We already have changes planned for the editor before GA, including a redo of the type filters, but we’d love to hear suggestions for more.

If you use a dark theme in Visual Studio 2012 or 2013, you won’t need your sunglasses when our find dialogs open. Enough said.

Learn what’s new in build 2031, or skip directly to download the installer.

The post Visual Assist build 2031 is available first appeared on Tomato Soup.