When it comes to developing software for the finance and banking industry, C++ is often the language of choice due to its performance, efficiency, and flexibility.

However, writing C++ programs in this highly regulated and fast-paced environment comes with its own set of challenges. From managing the complexity of legacy codebases to ensuring real-time performance for trading systems, developers face numerous hurdles. Regulations and stringent security measures, compliance with industry regulations, and the ever-present demand for high reliability and accuracy also compound this problem. 

In this blog, we will explore some of the biggest challenges C++ developers encounter when creating software solutions for the finance and banking sector.

Why use C++ in Financial Software

Banks and financial institutions are always looking to improve their trading infrastructure and upgrade their data-management capabilities. Having the best financial model mathematical models help generate profits and reduce risk in a highly volatile and time-sensitive market.

And it just so happens that C++, a low-level language, is the top choice due to its speed and efficiency, making it a preferred choice for high-frequency trading platforms, risk management systems, and other critical financial applications.

The challenges to becoming a programmer in the financial industry

When you’re a developer in the financial industry, it’s almost always a given that apart from being able to program, you would also be able to understand the math to validate various financial models. Some developers may also conduct research and hypothesize on new trading strategies themselves.

Becoming a quantitative analyst, bank developer, or high-frequency trader can be very lucrative career choices. However, it also means that there are stricter requirements and skill sets to be qualified.

As an aspiring developer, here are the key problems and frustrations that C++ developers in the financial industry should keep in mind:

Training requirements and developer skill set

• Steep learning curve
  You can be a decent trader and a researcher using basic programming and scripting languages such as Python. But on the other hand, knowing C++ from just a broad level won’t be able to help you as much since you won’t be able to utilize the low latency advantages. If you really want to implement models and develop applications for the industry, there is a certain level of optimization skills you need first.
• Understand modeling and simulations. It comes as no surprise, but there is a hefty amount of math involved in the financial industry. Financial algorithms can be mathematically intensive, requiring developers to have a strong understanding of quantitative finance and numerical methods.
• Need to invest in skills other than programming? Developers often need to implement complex models that simulate market conditions or risk factors, which requires a deep understanding of both finance and C++. However, this is less of a problem if you’re working with a diversified team of developers, traders, and analysts.

Programming requirements: Performance Optimization

• Low Latency Requirements
  Financial applications, especially in trading, require extremely low latency. Developers must continuously optimize their code to reduce execution time to microseconds or even nanoseconds.
• Resource Management
  Efficient memory management is crucial—each unoptimized bit of code can amount to micro delays that can be the difference between a winning and a losing trade. C++ developers need to carefully manage resources, avoid memory leaks, and ensure optimal memory performance in their code.
• Accuracy and code correctness: Financial applications often rely on parallel processing to handle large volumes of data. The source code and the project itself may not be massive, but the intricacies involved must be accurate because of the sensitive nature of market prices. Still, managing developer mistakes and errors in C++ can be challenging and error-prone.

Programming requirements: Performance Optimization

• Low Latency Requirements
  Financial applications, especially in trading, require extremely low latency. Developers must continuously optimize their code to reduce execution time to microseconds or even nanoseconds.
• Resource Management
  Efficient memory management is crucial—each unoptimized bit of code can amount to micro delays that can be the difference between a winning and a losing trade. C++ developers need to carefully manage resources, avoid memory leaks, and ensure optimal memory performance in their code.
• Accuracy and code correctness: Financial applications often rely on parallel processing to handle large volumes of data. The source code and the project itself may not be massive, but the intricacies involved must be accurate because of the sensitive nature of market prices. Still, managing developer mistakes and errors in C++ can be challenging and error-prone.

Programming requirements: Compliance and Regulations

• Compliance with regulations
  Apart from being mathematically complex enough as it is, financial software must comply with stringent regulations within the company and the government. Developers need to ensure that every bit of their code adheres to compliance requirements—this can vary by region and change frequently.
• Auditability
  The code must be auditable, meaning that it should be easy to trace and understand how financial decisions are made by the software, which adds another layer of complexity.
• Vulnerability Management
  There are many available libraries and third party extensions for C++ developers. Developers, however, need to stay on top of potential vulnerabilities in C++ libraries or the codebase itself to prevent exploits.

Tips for facing these challenges

• Study the math, polish your C++
  As mentioned earlier, you can be a pure developer and just implement whatever algorithms that are supplied to you. But to become a better analyst and interpret trends yourself, you need to equip yourself  with more than programming skills.If you’re looking to familiarize yourself with the concepts, there are many great resources available such as Investopedia. For specific use cases or general C++ skills, a good old reference book (such as those from Scott Meyers or one from Bjarne Stroustrup himself) will always be great options.For references regarding high performance C++, there are also great resources online such as:
  • Algorithmica’s Algorithms for Modern Hardware e-book by Sergey Slotin et al
  • Performance-aware Programming series by Casey Muratori
  • Optimising C++ by Agner Fogg: probably the classic C++ optimisation bookThere are two published books with relevant titles which we have not read or evaluated. They are Developing High-Frequency Trading Systems and C++ High Performance. Both are published by Packt, and again we note we have not read these books.
• Invest in understanding above and beyond your tasks

Banks and financial institutions, especially top ones, will only hire the cream-of-the-crop devs. Average devs with pedestrian level finance knowledge will be less appealing for the simple fact that for an expensive role, financial firms expect the maximum returns. 

This often means that being a financial developer entails learning and understanding current market trends, calculating opportunity costs, and economic theories yourself—not just the technical aspects of implementing them into an algorithm.

• Get all the help you can

Take note of tidbits of knowledge you’ll pick up on the spot from existing codebases accessible to you. Colleagues may also come to you directly and give you advice on how best to tackle certain financial puzzles.

As for developer tools, they are oftentimes underestimated in terms of how helpful technology can be when you’re developing software and finance algorithms. Having a conducive and smart development environment can be the small difference between a timely implementation hauling your company massive profits, or an unfortunate missed opportunity.

Try to invest in software that allows you to focus and concentrate on the core work such as thinking and planning. For example, there are many productivity tools available online that seek to help developers monitor their code’s quality. There are also tools that help in maintaining or refactoring code bases. These are all tools that can help you stay on the cutting edge.

Protip for those coding in Visual Studio C++

Visual Studio remains the premier IDE for C++, especially serious C++ programming such as financial services. That includes deploying to Linux. Visual Studio is a robust IDE for developing C++ financial programs because it offers powerful debugging and code analysis tools, which are crucial for maintaining high-quality, error-free code in critical financial applications, plus strong performance and profiling tools. 

It provides extensive support for modern C++ standards and libraries, ensuring compatibility and performance optimization. The IDE integrates well with various version control systems, enabling smooth collaboration and code management among development teams. Additionally, Visual Studio’s extensive ecosystem of extensions and plugins allows developers to customize their environment to fit specific financial industry requirements.

There are general plugins that augment the entire IDE with faster processes and more intuitive workflows. For example, Visual Assist, one of the most popular VS extensions, provides faster ways to navigate projects, convenient one-click solutions to maintaining code, and additional syntax support not available in the default VS IDE. Here are some specific features:

• Code Inspections
• Code Refactoring
• Open File in Solution
• Find Symbol in Solution
• List and Find References
• Special C support

When writing high performance C++ you’ll find yourself doing things like (for example) avoiding memory allocation, and Visual Assist’s set of refactorings can assist with all sorts of work that can move code around to assist your improvements. A trivial example is converting a heap-allocation to a stack allocation via the Convert Pointer to Instance refactoring.

You can’t underestimate how helpful it is especially in a high-stress and time-sensitive profession.

Those jobs are high stress and lots of crunch is expected. Our navigation features get you around much faster than the built in tools Open File in Solution, Find Symbol in Solution and Find References just works that much better and faster.

Conclusion

Becoming a programmer in the financial industry is no small task. There are many significant challenges presented to you both as a programmer and as a learner.  It is a constantly evolving profession—like a perpetual hackathon. You have to stay on top tech and industry trends to ensure your company is getting the best results it can. 

Study beyond your delegation. Utilize all the tools at your disposal. And most importantly, persevere. 

The post The biggest challenges in writing C++ programs for finance and banking first appeared on Tomato Soup.

As a workaround for, what most Mac users have done (and is one of Microsoft’s recommendations) is to install a Virtual Machine on ARM Macs to emulate a Windows environment and use Visual Studio from there.

This guide will walk you through the entire process of installing and using Visual Studio on a Mac, with a special mention of a handy productivity plugin you can add to make its performance closer to a natively-installed app.

The Different Visual Studios on Mac

Before you dive right in, here’s something to consider before you install: there are similarly named versions of Visual Studio—and you need to know which one you are looking for.

The first one is the native app “Visual Studio 2022 for Mac” (VS 2022 Mac). The naming scheme is how Visual Studio Code is to Visual Studio—they’re two completely different products that confusingly share a similar name.

The native Visual Studio for Mac is largely based on Xamarin, another cross-platform framework for building native mobile apps on iOS, Android, and Windows. It is primarily used for C# or .NET development. Consequently, Visual Studio for Mac is also used primarily for C# development. 

VS 2022 Mac has been discontinued in favor of “Visual Studio Code” (VSC) for Mac. You can use Microsoft’s VSC with the new C# Dev Kit and related extensions in lieu of VS 2022 Mac. The caveat is that VSC may not be enough for C++ developers, or for C# developers who rely on VS’s frameworks and libraries for their app or program development needs.

Fortunately, if you’re opting for VSC on Mac, it may be good to know that there is less discrepancy between the Windows and Mac versions of VSC—just a few keystroke and shortcut differences. 

To summarize, here are the Visual Studios that you can use on Mac:

• Visual Studio 2022 for Mac — the Xamarin-like native app
• Visual Studio Code Mac — the VS text editor but on mac. Almost the same as Windows version
• Visual Studio Code Windows — the VS text editor
• Visual Studio Windows — the native Windows version (in our case, installed on a virtual machine)

Of course users can also opt to use alternative IDEs. In this blog, however, we will be teaching you how to install the second option—a virtual machine on your Apple-silicon Mac and installing Visual Studio, the complete Windows version, (VS for Windows on a VM) thereafter.

Why you may need Visual Studio for Windows on Mac

The primary reasons to use Visual Studio for Windows on a Mac are the following:

• Maintain compatibility with Windows-based projects
• Rely on certain features that are Windows version of Visual Studio-specific
• developing .NET applications
• working with Azure
• or integrating specific third-party tools that are Visual Studio-specific
• You use a Mac!

Other considerations may be based on developer preferences such as those who like Visual Studio for tasks like debugging complex applications, managing large solutions, or using specialized extensions that are only available on the Windows version.

For game developers using Unity, Xamarin developers building cross-platform mobile apps, or .NET developers focusing on backend and cloud development, using a VM allows you to retain access to the full suite of Visual Studio’s tools. This includes robust debugging features, integrated version control with Git, and comprehensive support for a variety of programming languages and frameworks.

Prerequisites for Installation

Visual Studio 2022 has official requirements which you can read here. However, we can summarize for some advice:

• It runs on both Intel and ARM computers
• You will need to install either the Intel or the ARM version of Windows. You can’t run the Intel version of Windows on an ARM Mac, not even in a VM. The ARM version of Windows runs Intel apps just fine, even including using a debugger, in our experience.
• Dedicate lots of RAM and multiple cores to your VM. We recommend a minimum of 4GB of your host Mac’s RAM goes to the virtual machine. In general, the beefier a machine is in terms of RAM and cores, the more VMs you can run at once.
• While you can use an old Intel Mac, the Apple Silicon ones are very performant and we strongly recommend using an M-series ARM Mac. Any of them. They’re all good.

If you’ve never used a virtual machine for development before, you might be worried about performance – after all, it’s not running directly on the hardware, right? In practice, this is not an issue. Modern CPUs have inbuilt support for running virtual machines and your VM is not emulated; it runs code directly on the CPU just like the host operating system does.

The biggest mistake people make is not giving a VM enough RAM or dedicated CPU cores. Run on a powerful machine and configure the VM to a couple of cores minimum, and at least 4GB of RAM minimum. If you do heavy computation on the VM (building large projects, etc) increase that. Make sure you have a host machine powerful enough that if you allocate, say, half its resources to the VM then both have enough resources to run. A Macbook Air has 8 cores, so you can allocate 2 to 4 to the VM; if you have 16GB of RAM, you can allocate 4GB to the VM and leave macOS 12GB. This kind of setup works well.

Before diving into the installation process, ensure your Mac meets the following requirements. To summarize, however, any recent computer will meet them in terms of performance—the more important components to consider are available RAM and disk space. 

Hardware Recommendations:

• Processor: Modern M-series (Apple Silicon) or Intel processors are more than capable of handling Visual Studio within a VM.
• RAM: Minimum of 4 GB (16 GB recommended for typical professional solutions).
• Hard Disk Space: Minimum of 850 MB up to 210 GB of available space, depending on the features installed (20-50 GB of free space is typical). Installing Windows and Visual Studio on a solid-state drive (SSD) is recommended for increased performance.

By following the recommended setup, you’ll meet or exceed the necessary hardware requirements, making your development experience seamless even within a virtualized environment.

Step-by-Step Installation Guide

In this guide, we’ll walk you through installing Visual Studio on your Mac using a virtual machine. Since Visual Studio is no longer natively supported on macOS, setting up a virtual machine (VM) is the best approach to ensure you have access to the full range of Visual Studio features. Below, we’ll outline the steps using Parallels Desktop, a popular VM software for Mac.

Step 1: Choosing Your Virtual Machine Software

Before installing Visual Studio, you need to set up a virtual machine that runs Windows on your Mac. Here are some of the top options currently available:

• Parallels Desktop: Known for its seamless integration with macOS, Parallels is user-friendly and optimized for running Windows on Apple Silicon (M1/M2) and Intel-based Macs.
• VMware Fusion: A robust alternative to Parallels, VMware Fusion offers advanced features and supports a wide range of operating systems.
• VirtualBox: An open-source option that is free to use, though it may require more manual configuration and might not offer the same level of performance as Parallels or VMware Fusion.

For this guide, we’ll focus on Parallels Desktop. This is the officially supported way Microsoft offers to run Windows on a modern ARM Mac.

Step 2: Installing Parallels Desktop

1. Download Parallels Desktop:
   • Visit the Parallels Desktop website.
   • Click on the “Try Now” or “Buy Now” button, depending on whether you want a trial or full version.
   • The installer file will start downloading.
2. Install Parallels Desktop:
   • Open the downloaded .dmg file.
   • Drag the Parallels Desktop icon to the Applications folder.
   • Open the Applications folder and double-click the Parallels Desktop icon to launch it.
   • Follow the on-screen instructions to complete the installation. You may need to grant permissions and sign in with a Parallels account.
     
3. Set Up a New Windows Virtual Machine.
   
   • When you first launch Parallels Desktop, it will prompt you to set up a new VM.
     
   • Choose to install Windows from an ISO image file or from an existing Windows installation disk
   • Parallels may also offer the option to download and install Windows directly, streamlining the process
     
     
   • Follow the prompts to complete the Windows installation. This process may take some time as Windows sets up.

If you’ve done everything correctly, you will get to this confirmation screen.

Step 3: Downloading Visual Studio for Windows

Now that you have Windows running on your Mac via Parallels, you can proceed with installing Visual Studio.

1. Download Visual Studio:
   • Within your Windows VM, open a web browser and visit the Visual Studio download page.
   • Choose the edition of Visual Studio you want to install (Community, Professional, or Enterprise).
   • Click the “Download” button to start downloading the installer.
     
     

     Note: This is open on a browser window inside the VM.

      

2. Install Visual Studio:
   • Once the download is complete, open the installer file.
   • Follow the on-screen instructions to select your workload preferences (e.g., C++ desktop development, .NET desktop development, ASP.NET and web development, game development with Unity).
   • Click “Install” to begin the installation. This process may take some time, depending on the selected workloads and your internet speed.
   • After installation, launch Visual Studio from the Start menu within your Windows VM.
     

     
     

Step 4: Setting Up Your First Project

1. Once Visual Studio is installed, open it and select “New Project.”
2. Choose the type of project you want to create (e.g., Console App, Web App, Mobile App).
3. Follow the prompts to configure your project, including setting the project name and location.
4. Click “Create” to generate your new project.
   

Using Visual Studio for Windows on Mac: Navigating the Interface and optimizing the Virtual Machine

When running Visual Studio on a virtual machine (VM) on your Mac, there are some key differences and considerations to keep in mind to ensure a smooth development experience:

Keyboard Shortcuts

Running Visual Studio in a VM can result in some keyboard shortcuts behaving differently than they would on a native Windows PC. This is due to differences in how macOS and Windows handle certain key combinations. Here are a few tips:

• Cmd vs. Ctrl Mapping: Parallels lets you map macOS shortcuts to their Windows equivalents, enabling the use of familiar macOS commands like Cmd+C for copy and Cmd+V for paste in your Windows VM. This can be configured under Devices & Sound > Keyboard by enabling the “Use macOS shortcuts” option.
• Function Keys in Parallels: Adjust the behavior of function keys (F1-F12) in Parallels to operate as standard function keys for Visual Studio commands. Access these settings via Parallels Desktop > Preferences > Shortcuts or under Devices & Sound > Keyboard for your VM.
• Customize Mac System Settings: Alternatively, modify your Mac’s System Preferences > Keyboard by checking “Use F1, F2, etc. keys as standard function keys.” This avoids needing to press the Fn key when using function keys in Visual Studio within a Parallels VM.
• Customizing Shortcuts in Visual Studio: If certain shortcuts aren’t functioning as expected within the VM, customize your keyboard shortcuts directly in Visual Studio under Tools > Options > Environment > Keyboard.
• Windows Apps on the Mac Taskbar: Parallels can display Windows apps on the Mac taskbar. If you prefer a cleaner interface, disable this feature in Parallels settings to avoid taskbar clutter.
• Folder Sharing in Parallels: Parallels shares many folders between your Mac and the VM by default. For increased privacy or security, customize sharing options to limit access to specific folders, such as only sharing your Downloads or a dedicated project folder.
• System Resource Allocation: Optimize CPU, RAM, and disk space allocation for your VM based on your workload. Proper allocation ensures both your Mac and the VM perform smoothly during demanding tasks like code compilation.

Display and Resolution

When running a VM, Parallels offers different display modes to suit your workflow:

• Fullscreen Mode: Parallels can run your VM in fullscreen, integrating it seamlessly into your Mac’s desktop environment. You can use macOS Spaces to switch between your VM and other macOS apps effortlessly.
• Windowed Mode: If you prefer to keep your VM contained, Windowed mode lets you run Windows inside a resizable window on your desktop. This can be useful for quickly accessing other macOS applications without losing sight of your VM.
• Coherence Mode: This mode allows Windows applications to appear alongside macOS apps on your desktop, blending the two environments. While it looks impressive, it can sometimes cause graphical glitches. In my experience, it’s a neat marketing feature, but not always practical for everyday use. However, some users find it very effective for their needs, so it’s worth experimenting with if you’re curious.

Parallels generally sets up Windows with the correct DPI settings automatically, so display resolution issues are rare. Adjusting these settings usually requires deliberate changes, making it easy to maintain a crisp and consistent interface across your VM and macOS.

Enhancing the Experience with Visual Assist

Developing on a VM can present unique challenges, but with the right setup and a few tweaks, you can create a development environment that’s nearly as effective as working on a native Windows machine. By paying attention to how keyboard shortcuts behave, optimizing performance settings, and ensuring good network connectivity, you can make the most out of Visual Studio in a virtualized environment on your Mac.

Visual Assist, renowned for its powerful productivity features, is now fully supported on ARM devices, including Macs with Apple Silicon (M1, M2, etc). Here’s how to install it:

1. Initiate the Virtual Machine environment. Launch whatever VM you installed.
2. Open Visual Studio on your Mac: Launch the Visual Studio application to begin the installation process.
3. Navigate to Extensions > Manage Extensions: In the top menu, click on “Extensions,” then select “Manage Extensions” from the dropdown. This will open the Extensions Manager window.
4. Search for “Visual Assist” and click “Install”: In the Extensions Manager, use the search bar to find “Visual Assist.” Once located, click the “Install” button next to the extension. You can also download it straight from the VS marketplace. The installation process will begin automatically.
   
   
5. Restart Visual Studio to enable the extension: After installation, restart Visual Studio to activate Visual Assist. Once restarted, you will have access to all the powerful features Visual Assist offers.

Benefits of Visual Assist on ARM Devices

With Visual Assist enabled on ARM devices, Mac users can experience a significant boost in productivity and code quality. Here are some of the key benefits:

• Full ARM support. Visual Assist added ARM support which includes Mac silicon-based devices. For those using VMs, this is one of the best workarounds to getting a better VS experience.
• Enhanced Code Navigation: Quickly jump to definitions, references, and symbols within your codebase. This feature allows you to navigate complex projects with ease, reducing the time spent searching for specific code elements and improving overall efficiency.
• Refactoring Tools: Easily refactor code with powerful tools like Rename, Encapsulate Field, and Extract Method. These tools help maintain clean and organized code by automating common refactoring tasks, making it easier to implement changes and ensure code consistency.
• Code Assistance: Improved IntelliSense with better suggestions and real-time error checking. Visual Assist enhances IntelliSense by providing more accurate and context-aware code completions, helping you write code faster and with fewer errors. Real-time error checking also helps you catch and fix issues as you code, reducing the likelihood of bugs in your final product.
• Performance Optimization: Visual Assist is optimized for ARM architecture, ensuring smooth and efficient performance on M1 and M2 Macs. This optimization takes full advantage of the advanced capabilities of Apple Silicon, providing a responsive and lag-free development experience even for large and complex projects.
• Advanced Code Analysis: Visual Assist includes advanced code analysis tools that help you understand and improve your codebase. These tools identify potential issues, suggest improvements, and provide insights into code complexity and maintainability, enabling you to write high-quality code.
• Customizable Shortcuts and Commands: Tailor your development environment to your workflow by customizing shortcuts and commands. Visual Assist allows you to configure key bindings and commands to suit your preferences, making it easier to access frequently used features and streamline your coding process.
• Seamless Integration with Visual Studio: Visual Assist integrates seamlessly with Visual Studio for Mac, providing a cohesive and unified development experience. The extension works alongside other Visual Studio tools and features, enhancing the overall functionality of the IDE without disrupting your workflow.

By leveraging the capabilities of Visual Assist on ARM devices, you can significantly enhance your coding experience on Mac. Whether you’re working on small projects or large-scale applications, Visual Assist provides the tools and features you need to be more productive and write better code.

Conclusion

Congratulations! You have successfully installed Visual Studio on a virtual machine. You should now be able to develop as you would normally on a native Windows device. Tech is always changing and we can assume that with advances in both hardware and software, we will be able to utilize more performance with less in the future—but for now, enjoy your new virtual machine, fit with a fresh install of Visual Studio! Happy coding.

The post Installing Virtual Machines to use Visual Studio on Mac first appeared on Tomato Soup.

IMPORTANT: Users of 2024.5 should upgrade as soon as possible, or install the previous version 2024.4.
To get the latest version, visit our website now and download the new update.

Visual Assist 2024.6 brings two critical fixes for Visual Assist’s interaction with Visual Studio.

• The first fix in this release addresses a critical issue that could sometimes cause Visual Studio to crash when saving files. This fix enhances the stability of the IDE, ensuring a smoother and more reliable experience while working on your projects.
• Secondly, we have resolved an issue where the Visual Studio installer would crash on versions of Windows older than Windows 10. This fix ensures that users running older operating systems can install and update Visual Studio without encountering disruptions. This should provide a seamless setup experience across all supported Visual Assist-supported versions of Visual Studio.

We appreciate your patience and feedback as we continue to improve Visual Assist for all our users. Please continue to report issues and we will do our best to get them sorted out quickly.

The post Visual Assist 2024.6 release post – Important fixes for Visual Studio first appeared on Tomato Soup.

VA had significant improvements in 2024, particularly in the initial startup time for projects, as well as in the responsiveness of a few key features. It is not farfetched to say that performance has been the primary consideration for the development direction of the plugin.

Why? Because performant, responsive software is productive software, and fast interaction is key to you getting your work done.

We have a lot of solid, robust features based purely on providing not the kitchen sink, but what you need. We already had a reputation for being faster than other products. Now we are even faster: VA is a lean, mean, coding machine.

We’re midway through the year, and we’re summarizing all the recent performance updates in this handy update blog. Read on further to get a more complete picture of when and why these changes were introduced to VA.

Faster startup sequence

Whatever task you have, you first must open and launch Visual Studio—along with any installed plugins you have. Opening a Visual Studio-associated file initiates the startup process which starts loading the essential IDE assets, the solution files you have chosen, and ultimately any auxiliary components like Visual Assist.

While we cannot alter the core loadout of Visual Studio, we’ve worked on every facet of our tool that can be optimized for faster startup:

• Project initial parsing
  

  Project parsing is an extra step that code assistant plugins like Visual Assist need to undertake. VA uses its own parser independent of Visual Studio’s which allows it to pre-scan projects so it can be faster, smarter, and able to provide different functions.
  
  The release in January 2024 featured an overhaul of the parser, which reduced startup times for opening previously unparsed project files by up to 15 times.
  
  While an initial parse is only done the first time you open a project. The next time you open it, it will be instant. (This was an existing feature.) However, we made it 15x faster for those of you who are opening multiple new projects on a more frequent basis.

  For example, an Unreal Engine project with its typically massive code base previously took 15 minutes to parse. We’ve brought this down to a mere one minute of parsing.

  Tech details: Visual Assist implemented a cache for parsed directories to bypass slow Windows file IO API calls where the same call is expected to give the same result—this significantly reduced the initial parse time.

   

• Plugin load time
  

  This update refers to the time it takes for Visual Assist’s features to become functional. As mentioned above, the time-to-functional is the sum of all Visual Studio’s startup routine which includes loading in plugins.
  Every time you close and open a solution, VA’s features take a few moments to load—or at least that’s how it was before. With this update, time-to-functional is more or less instantaneous even in extremely large solutions! 

  As soon as Visual Studio calls on Visual Assist to start loading, you’ll immediately see coloring and syntax highlighting, and have access to all navigation and features. (Note: How Visual Studio initializes plugins and components is indeterminate; results may vary slightly depending on how many components it loads first before Visual Assist.)

  What these changes mean for you:

   

  Depending on how often you need it, the Visual Studio startup sequence and project load can be a part of your feedback cycle when testing and coding. And even a mere 30 seconds are painful and a threat to productivity when repeated, especially when they add up in a work week.

  This is even more pronounced when your work entails opening new projects multiple times in a week. Visual Assist is the best in-class plugin that offers significantly less startup time—giving you more time to be productive.

  READ: Visual Assist startup duration update

Search dialogs: Find References and File Finding

Since starting our crusade against a slow and unresponsive IDE,  there have been two updates that shortened the loading time for finding references and symbols. Utilizing techniques such as parallelism and removing extraneous string searches, you’ll  enjoy up to ten times faster search time.  

Furthermore, better accuracy and new functionality has been added for other search dialogs, including fuzzy search for Open File in Solution.

• Find references speed and responsiveness

Find references is a feature that looks for symbol usage within the current project or solution. Depending on the project size, there may be hundreds to thousands of symbol definitions in your solution, and many of those, tens of thousands of times they may be used. In order for code navigation to work, VA must scour its database for the correct results.

Find references time increases with the number of symbols in the database. However, VA’s feature has been greatly improved for performance and speed—almost ten times faster than before! That means that this performance improvement applies to many key features and navigations.

Some other common and key features in VA improved by this change: 

• Renaming finds references in order to rename them.
• Implement Methods finds methods in order to know which ones do and do not exist
• Change signature works similarly.
  
  

  Visual Assist’s Find references window. Takes significantly less time to find all references in 2024.3.

• Fuzzy search and uppercase search for opening files and searching symbols
  

  Fuzzy search is a technique used in searches and information retrieval to find approximate matches for a given query, accommodating variations like typos and misspellings. It employs string distance metrics to measure the similarity between strings.
  
  Apart from being fast, Open File in Solution and Find Symbol in Solution support this technique, so you can expect more meaningful results with fewer, less accurate search queries.
  
  Furthermore, beyond fuzzy searching for inexact matches, VA will also match capital letters. For example, if you have a class named MyClassName, searching for “mcn” would find it. Similarly, suppose you have a global variable named myGlobalVariable and type “mgv” – the lowercase “my” is treated as if it were MyGlobalVariable, providing expected results.
  

• Move Class feature
  

  Refactoring and moving entire classes can be a hassle. This feature has completed its beta phase to provide full support for porting an entire class to the file(s) of your choosing.

• Bonus QoL Change: Select all items in open file in solution (Ctrl + A)
  

  You can now select and highlight multiple files and open them simultaneously when using open file in solution. The usual shortcut Ctrl + A works.
  

  What these changes mean for you:

  As a C++ developer, you frequently search for files and symbols in massive projects. So even small reductions in wait times or interruptions cumulatively boost your overall productivity to a significant degree.

Summary

Performance improvements are and will remain the focus of Visual Assist in upcoming releases. As projects grow larger and C++ features grow in complexity, we too must adapt and scale our performance to meet the increasing workload and demands on our parser and product capabilities.

This is our most important aim: speedy performance and accurate responses so you can focus on thinking and problem solving—the crucial parts of coding.

We’re only halfway through the year, so let us know what we should improve upon next. Thank you for your continued use and support of Visual Assist!

The post Catching up with VA: Our most recent performance updates first appeared on Tomato Soup.

We hope you find this release useful. Visit our website to download the release.

ARM support

Big news for Visual Assist’s device support! Windows ARM is now supported starting this release, Visual Assist 2024.4. Visual Assist is now available as a fully ARM-native plugin, fully supported in Visual Studio’s ARM build. This means that Visual Assist is now fully compatible for those of you using Macs or Windows devices with an ARM processor. 

We first asked our community about ARM support some time ago. At the time, while it was clear ARM was growing for Macs, it was unclear how strongly it would grow for Windows and we planned support at a future time. Since then, we’ve seen growing interest and customer requests – and we’re happy to deliver! The appearance we see is that many people, including large companies, are increasingly interested in or using ARM for Windows.

There are many advantages to using Windows ARM devices, from battery usage to performance. One key one is that many developers target ARM devices and are used to debug remotely; while debugging on-device or on-simulator remains important, it can be slow and doing minute-to-minute development on a device that shares the same CPU architecture can be very useful.

ARM is a completely new front for us and we would like to know more about how we can improve the experience for ARM users. If you’re part of the group that would benefit from this update, please let us know more by answering this short survey.

Path “/” delimiter

This simple change adds an option for users who are used to using “/” as path delimiters for searching directories. This comes at the heel of users from different operating systems sharing how their default style of delimiter is not supported. 

With this change, you can now choose what the default delimiter will be used. This will apply to most of Visual Assist’s search windows such as Open file in solution and the like.

Bug fixes and improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The highlights are a fix for recognizing one of the features in the standard library. 

The complete list is below: 

• Fixed issue where std::tuple would not be recognized in some cases.
• Move Class to New File will no longer jump to a new file before showing the dialog.
• Fixed broken Discord invite link.

Send us a message or start a thread on the user forums for bug reports or suggestions. Don’t forget to join our Discord too!

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.4 release post – ARM Support first appeared on Tomato Soup.

Many of our most ardent Visual Assist champions are game developers, so for us, these cuts are not simply about numbers. This is about our user community – your careers, your livelihoods, and your families. And while the challenges and uncertainties that those affected now face might seem daunting, we know that carving out a career in the gaming industry requires talent, discipline, and grit. So if you are one of those personally affected by the cuts, even if your current situation feels overwhelming, we believe in your ability to rebound and forge a rewarding and successful career.

And as a company deeply rooted in this industry, we want to help. Maybe you can benefit from Visual Assist while you’re looking for a new position…maybe while making a demo. Maybe you’ll start a solo game and be the next indie hit. Maybe you simply want to keep your coding skills sharp while looking for your next opportunity.

To that end, we’re offering a 25% discount on our flagship product, Visual Assist, for any developer impacted by the recent layoffs. No questions asked, no proof of eligibility required – just an immediate 25% off on a personal license to help get you back on your feet.

You can grab the discount by using this link to get it now. While we know it’s not much, it’s our way of supporting and standing with those who’ve been affected. Since so many of you rely on Visual Assist for your work, we’ll ensure you still have the tools you need no matter your employment or economic situation.

And, of course, beyond the discount, know that our team is here to provide any resources or guidance you might need during this transitional period. Whether it’s helping you get more out of Visual Assist or collaborating on what we can do to improve the product for you, please reach out to us any time. We’re here to help!

Ultimately, our encouragement for those affected is to stay strong and remain vigilant. This is a highly competitive yet highly rewarding industry. New opportunities will come, even if you can’t see them yet. Take a break to clear your head if you need. We’ll be here when you get back.

The post On the recent video game industry layoffs first appeared on Tomato Soup.

Download the release now from our website.

Better find references results in multiple faster features

If you’ve updated to at least Visual Assist 2024.1, you may have been enjoying the benefits of the significantly improved parser performance that cut initial parsing time fifteenfold. In this release, we’ve added something even bigger: performance improvements not at startup, but all the time

Find references, the feature that looks for symbol usage within the current project or solution, has been greatly improved for performance and speed. But the Find References engine is used for many other common and key features in Visual Assist! Renaming finds references in order to rename them; implement methods finds methods in order to know which ones do and do not exist; and so forth. That means that this performance improvement applies to many key features and navigations; Rename, Change Signature, Implement Methods and more.

Visual Assist’s Find references window. Takes significantly less time to find all references in 2024.3.

Test Results

The development team ran a few tests to compare the performance of find references between the new Visual Assist version versus an older version of the same plugin. Furthermore, they also tested it against the performance of Visual Studio’s default Find References. 

The test was done on Unreal Engine 5.3 source code using Lyra game examples with two symbols: TOptional and MakeBox as the basis for which references are to be searched. The test was done using Visual Studio 2022 17.8 and Visual Assist 2024.3 & 2024.2. Time was measured from the start of Find References to all references found.

The result of the tests are as follows:

Setup 1 – TOptional:

Setup 2 – MakeBox:

As one can surmise from the results, the latest update brings Visual Assist’s symbol finding performance well above that of default Visual Studio’s and other similar plugins. Further testing on other platforms will be undertaken. Please refer back to this page later for more testing.

Exiting Beta: CUDA core development support & Move Class feature

Two VA features enter their stable phase and are now on general availability. If you have not tried these yet, we highly recommend trying them out as it provides a lot of usefulness that might not be readily apparent.

• CUDA support
  First added in 2023.4, CUDA support allowed Visual Assist to recognize CUDA files and parse and highlight them like regular C/C++ files. This feature now enters full supported status and you can reliably use Intellisense-like features for CUDA files.
• Move Class feature
  Refactoring and moving entire classes can sometimes be a hassle. This feature moves from beta to supported status and allows you to easily choose an entire class and port it over to file/s of your choosing.

Create File: specify a directory + auto implementation.

This is a tiny but useful quality of life change for creating files. Prior to this change, Visual Assist would sometimes display a failure error and ask you if you wanted to Create File or to stop if a target was not found. Now, it runs create file automatically and you can hit Cancel instead.

Furthermore, a bug fix for when using create file: Visual Assist will consistently move the implementation afterwards. (In the past, it sometimes failed to do so.) 

These two changes will hopefully make your experience more seamless and intuitive.

Discord link and feedback options in the Help menu

Introducing our newly opened Discord server for all Visual Assist users. We’re hoping for this hub to function like our forums wherein users can request for changes, report bugs, and share useful information and tips around the plugin.

As it’s a WIP, anyone who is interested in helping us manage and build the community is welcome to do so. Send us a message here if you’re interested.

Furthermore, we’ve added new feedback channels in one of our menus. Navigate to Help and browse new feedback options and let us know what you think!

Bug fixes and improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The complete list is below: 

• Fixed issue where Move Implementation would not move the implementation if a new file needed to be created.
• Improved editor performance when editing C#.
• Fixed Add Include issue where C headers would sometimes be added instead of their C++ counterparts.
• Fixed issue where Move Class to New File would sometimes not be offered near macros.

Send us a message or start a thread on the user forums for bug reports or suggestions.

Visit our download page to update to the latest release manually. Happy coding!

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

Download the release now from our website.

Significantly faster plugin startup time—especially in large solutions.

This update refers to the time it takes for Visual Assist’s features to become functional. Every time you close and open a solution, the plugin’s features take a few moments to load—or at least that’s how it was before. With this update, time-to-functional is more or less instantaneous even in extremely large solutions! 

As soon as Visual Studio calls on Visual Assist to start loading, you can immediately see coloring, syntax highlighting, and all the navigation and features are accessible. (Note: How Visual Studio initializes plugins and components is indeterminate; results may vary slightly depending on how many components it loads first before Visual Assist.)

This is not to be confused with the initial parse time update that we did in VA 2024.1 which is only a one-time process that happens with each new solution.

Further improvement to our initial parse time.

As mentioned above, we made significant improvement with the initial project parsing. Most of the benefits from 2024.1 were the result of optimizing how Visual Assist goes through files as it traverses references and includes. 

To summarize, Visual Assist used a cache for parsed directories so that it does not have to access the hard disk when an include is referenced multiple times—this significantly reduced the initial parse time.

In 2022.2, however, the developers have squeezed more performance by optimizing smaller items such as string operations, parse logic, etc. This produced a relatively modest but still significant decrease in project parse time.The result is a up to 50% faster parse time versus the previous version. Or in absolute units, that means VA 2024.2 is around 20 seconds faster than VA 2024.1 in our test scenario, where the Lyra demo is now ready in under a minute.

Testing:

Initial parsing time is defined as the point where the Visual Assist starts parsing up to the end where it completes it. This project used the latest Visual Studio 2022 version 17.8.6, again on the Lyra sample game project provided by Epic Games. This is using the same high-end PC and laptop setup used to test the 2024.1 changes.

Setup 1:

Setup 2: 1.19x faster

Setup 3: 1.54x faster

Improved add include for Unreal Engine.

Adding includes when working with Unreal projects has been improved in two ways. First, add include formatting in C++ generally uses either alligator brackets or quotation marks. Generally, <> are for system includes and “” are for user includes, however, there is a stylistic convention when working with Unreal. 

This update adds logic such that when you’re adding includes in an Unreal project, Visual Assist will consistently choose quotations—the preferred style for Unreal development.

Second, the include directory that is used when adding includes will now produce more accurate paths. Visual Assist will try to make sense of directory paths, subfolders included. This is especially useful when working with Unreal Engine which is known to arbitrarily produce paths.

Unreal Engine changes how solutions are generated; and while these are not actually used to build your game, these incorrect include directories are still read and used to generate other include paths when adding new includes. VA adds includes perfectly for normal C++ projects, but this situation may pose issues with some UE solutions, because some solutions could have incorrect include paths set up. 

This manifests as very long and unwanted paths, such as this one when adding the player controller: #include “../../../../../../../Source/Runtime/Engine/Classes/GameFramework/PlayerController.h”

Now, VA instead traverses the directory structure and figures out the paths, instead of trusting the solution. We replaced our logic to mostly ignore the include directories given to use by the solution in lue of traversing the directory structure ourselves. This lets us build our own ‘effective’ list of include directories which we will use to generate include paths for new includes.

For the above example, it would now add: #include “GameFramework/PlayerController.h”—which is what you expect and want as a UE developer. 

Fix syntax coloring in C# for Visual Studio 2022.

A recent Visual Studio 2022 update changed an API that Visual Assist uses to provide coloring and syntax highlighting. This update broke Visual Assist’s coloring and syntax highlighting for C#. 

A near total rewrite has been implemented and syntax coloring should be working now. However, there may be a slight difference in how Visual Assist colors C# files as we reoptimize with the rewritten code.

Syntax highlighting and coloring in C++ has remained unaffected but Visual Assist plans on implementing the new API setup for it as well. This should also fix some minor coloring issues. 

Fixed compatibility issues with GitHub Copilot.

Visual Assist is now completely compatible with Copilot, Microsoft’s AI coding assistant. 

Earlier this year, a bug report was filed on our forums describing a situation where Visual Assist seems to be interfering with Copilot’s chat functionality. This has led to the unwanted situation wherein users have to disable either Copilot or Visual Assist, as some features may not work simultaneously.

All known incompatibility issues have been resolved and addressed in 2024.2. If you encounter any similar bugs, please send us a bug report.

Fixed Open File in Solution issue when the filter starts with a dot.

When starting a query with a dot (.), Open File in Solution may sometimes fail to display the expected results. 2024.2 fixed the ‘dot’ filtering which was a common user complaint.

Search filtering features are available by starting with a dot to find files that begin with the filter, or contain the dot and substring. A filter that ends with a dot matches the ends of file names. For example “string.” finds files whose base names end with “string”. This dot filtering is also possible in other dialogs of Visual Assist that support filtering.

Bug Fixes & General Improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The complete list is below.

• Fixed UI conflict with GitHub Copilot.
• Fixed issue where Add Include would sometimes not add the new include.
• Fixed long Add Include paths for some symbols in Unreal Engine 5.3.x.
• Fixed issue where Open File in Solution would sometimes not display results when the filter starts with a dot.
• Fixed issue where C# syntax coloring would not be applied in Visual Studio 2022 17.9.0.
• Fixed issue where readability-magic-numbers Code Inspection would not properly underline hex numbers.
• Fixed issue where GoTo would not navigate to classes without a constructor.
• Fixed issue where suggestions could show suggestions for non-existent types.
• Updated Create Account link to point to the correct page.
• Added Alt+O to Recommended Keyboard Shortcuts as Visual Studio 2022 now uses that binding.

Send us a message or start a thread on the user forums for bug reports or suggestions.

Visit our download page to update to the latest release manually. Happy coding!

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

Why Visual Studio?

Visual Studio is the de facto IDE for editing Unreal’s C++ projects. Unreal Engine (UE) is designed to integrate smoothly with Visual Studio (VS), allowing you to make source code changes in your projects quickly and easily, and immediately see results upon compilation. Setting up VS to work with UE can help improve efficiency and the overall user experience for developers using UE.

Installing and Getting Set Up

Things You Need to Download Before Doing Everything:

• Visual Studio (VS22 Recommended)
• Epic Games Launcher for Unreal Engine (You download UE using the launcher)
• A sample game project (Optional downloadable from the UE marketplace)

Step 1: Installing Visual Studio

First up, you want to install Visual Studio, the IDE of choice for Unreal Game development. It is recommended to install the latest version of Visual Studio, or any version from VS 2022 to take advantage of 64-bit address space with virtually unlimited memory limit—this will be useful for working with Unreal’s project sizes.

You can pick between a professional (commercial for teams) and a community license (free for individuals). Download the bootstrap .exe and open it to start the installer.

You will then be shown a number of customization options for workloads, additional components, and installation location. For the workloads, which contain components you need for the programming language or platform that you’re using, we recommend installing the following: 

• .NET development
• Desktop development C++
• Game development C++.

Adding Visual Studio Tools for Unreal Engine

Make sure to tick the following items when choosing your workloads.

Visual Studio has come a long way with its integration with Unreal Engine’s features and dev tools. Microsoft has added extra support for Unreal that enables you to add UE classes, view UE logging, and more, all from within Visual Studio.

Step 2: Installing the Unreal Engine editor

Next up, you need to install the Unreal Engine editor. This allows you to open and run pre-cooked versions of the games you will develop. This allows you to run unsaved, uncompressed, and uncompiled programs using the Unreal Engine. This makes it easier to run, edit, tweak, demo, and overall quickly test things in your games.

To download the Unreal Engine editor, you first have to download the Epic Games launcher and follow the installation process. Once you have the Epic Games launcher installed, sign up for an Epic Games account using whatever login option you prefer.

Once you have logged in, you can navigate to the Unreal Engine tab and start downloading the Unreal Editor. This will also install the editor in your system automatically. The most common way to open the Unreal Editor will be through this launcher. You could also double click your *.uproject file or if you prefer, open the Visual Studio solution and then compile and run the editor from there. 

Use the dropdown on the top right to choose which version of Unreal you want to install (in most cases, the latest version will be the best choice.) Follow the instructions and customize your install locations and shortcut options if you prefer.

Tip: There is usually a prompt to associate UE with Visual Studio, but in case it has not followed the succeeding steps. In the “Edit” menu of the Unreal Editor, navigate to “Editor Preferences” and then navigate to the “Source Code” section. Choose the corresponding Visual Studio version as the preferred source code editor.

Step 3: Finding sample project files

Congratulations! You have installed the two primary programs needed for Unreal Engine development. At this point, you will decide whether you would like to use the blueprint visual scripting system or C++. For the purposes of this tutorial, we will go further and set up C++ project files. (Remember for when you progress: it is more efficient if you use both the blueprint system and C++ in tandem.) 

Creating a game from scratch is a gargantuan task. And even with a game engine handy, it may still feel overwhelming. Luckily, Epic provides a number of free sample projects so you can test the waters out and familiarize yourself first before starting a project entirely on your own.

Browse through the marketplace or the sample game projects available inside the Epic Games library. This catalog will include almost every genre of games, tech demos, and sample studios that you can think of. 

Epic Games has provided a number of sample games and projects so you can jump right in and practice your development skills.

For this tutorial, we chose the Lyra Starter game—a sample FPS game continuously updated with the latest UE has to offer. You can easily invest hundreds of hours just tweaking the gameplay, graphics, and user interface systems to get better at the complexities of the C++ integration.Choose and download your sample game of choice and save it on your system.  This will save the game files, preconfig files, and most importantly a *.uproject file—a text file that contains basic settings for your game project, which can be conveniently read by the Unreal Editor to launch your game. This will also be useful for the next step.

Choose your install location and click on create and wait for the process to complete. This will create the essential project files for editing the source code in Visual Studio.

Step 3: Building your first project files and opening for Visual Studio

To open the  downloaded game file source code in Visual Studio, you have to make a Visual Studio project file (or its collective known as solutions).

Navigate to where you created your project files.. If everything was installed correctly, this will have a *.uproject file that will have an entry for the associated source code. This allows you to generate a Visual Studio solution based on the UE Lyra Game source code. Right click on the *.uproject file and click on “Generate Visual Studio project files”.

Right click a *.uproject file to create source folder that contains .cpp and .h files.

This will build a Source folder that contains .cpp source files, .h header files, and a .sln Visual Studio solution file that you can open inside Visual Studio. 

Launch Visual Studio and open the corresponding solution. This will start a short loading process as your project initializes, but don’t worry; it’s just the initial pre-project parsing. Opening the same solutions in the future will take significantly less time.

This process maps out the entire network of source files and builds a database of symbols so that the IDEs navigation and search features work. If you’ve reached this far, congratulations! You have successfully set up Unreal Engine and integrated its source code for development in Visual Studio.

A Lyra game C++ header file opened in Visual Studio.
Note: Syntax highlighting and navigations are added by a nifty tool called Visual Assist—more on that later!

Making changes to your first project

After installation, you may want to start as simply as possible to familiarize yourself with the process of using the Unreal Editor in conjunction with Visual Studio C++ to change or add gameplay mechanics to your sample game. 

You will find that Visual Studio development comes with its own set of workflows before you can see actual results in the editor. You may be writing new code, debugging, or compiling projects. And it may be easy to lose track of what comes after which. 

If you want to get your hands dirty on an actual project, it is highly recommended to watch the following tutorial on how to add a powerup pickup to the sample shooter game. Watch and learn to set up projects, find project files, retrofit existing assets, and write and build your own C++ to make new content.

Watch and learn how a seasoned Unreal dev sets up Visual Studio + Unreal Engine. See how you can use C++ to add your own power up. Watch the tutorial here.

Removing false errors in Unreal Projects

When you first start working on an Unreal solution you will notice that there are syntax and symbols specific to Unreal development. Unfortunately, these symbols and functions can be mislabeled or flagged as false errors by Visual Studio as they are not part of the normal C++ workload. The C++ files will still compile but this caused a lot of confusion, especially among beginners. 

A group of game developers grew tired of the false errors and unresponsiveness of the IDE in large gaming projects, so they built their own tools tailored specifically for Unreal. The developers from Whole Tomato created a plugin called Visual Assist that understands Unreal Engine syntax—improving the frustrating situation they were in.

Overtime, the plugin grew from adding simple syntax comprehension and handy navigations to a full-fledged productivity augmentation for Visual Studio C++. The plugin developed a smart parser that understood what users were trying to accomplish, and thus was able to visually provide timely and contextual assistance in real time.

Red squiggles under source code signify errors. However, these are all normal Unreal Engine code mislabeled by the IDE.

Visual Assist remains one of the top productivity plugins for C++ and Unreal Engine work. It is responsive, performant, and parses your game files extremely fast so you can jump right in with complete support. You can download Visual Assist and try it out for yourself on freshly installed or existing Unreal projects.

The post Installing Unreal Engine 4/5 + Visual Studio: A complete step-by-step guide with pictures first appeared on Tomato Soup.

The makers and developers of Visual Assist will make their return to Moscone Center in San Francisco from March 18-22 for GDC 2024! Whole Tomato will be at booth number P1769 sharing space with a sister company, Assembla! Two of the best tools for game development in one booth—efficient!

GDC has always been one of the most awaited gaming events for video game professionals every year. It’s also one of the few opportunities for us to meet with daring new developers, colleagues in the industry, and of course enthusiastic users. That’s why we are excited to physically meet the community once again in this year’s GDC! 

We hope to see you there!

PS: We will be handing out exciting prizes and giveaways for our booth visitors!

Book an appointment with us

If you’re attending GDC and have access to the conference virtual platform, you can book a meeting with any of team members. Use the link below and navigate to the Teams section and take your pick among our dazzling booth members.

The post See you at San Francisco for GDC 2024! first appeared on Tomato Soup.

The post What’s New in Visual Assist 2024—Featuring lightning fast parser performance [Webinar] first appeared on Tomato Soup.

Download the release now and get the benefits of VA 2024.1.

Significantly faster initial startup time

Initial parse time is defined by how long it takes Visual Assist and Visual Studio to become fully active, starting from the moment a new file is loaded up for the first until it fully completes its initial parse (i.e. all features loaded and functional.)

Startup times just got extremely buffed in the first release of Visual Assist this year. The initial project parsing that Visual Assist executes when opening projects for the first time has now been significantly reduced. An example Unreal Engine project, when opened for the first time, used to take 15 minutes; it now takes just under two minutes instead! This is a huge improvement, and you will see this reflected in all projects that are opened and parsed.

More testing is underway to provide a better and more accurate performance number, but the developer team has found excellent results in their tests so far. Reports show a trend of having significantly reduced parse time for a sizable Unreal Engine project—with results averaging up to fifteen times faster initialization.

Update on Initial Parsing Time: More Testing Results

More testing results for Visual Assist’s updated parser are in! Here are the results:

Initial parsing time is defined as the point where the Visual Assist starts parsing up to the end where it completes it. This project used the latest Visual Studio 2022 version as of Feb 10 (VS 2022 17.8.6) on the Lyra sample game project provided by Epic Games. Two performance benchmarks on two different devices were done using the same methodology. 

Device 1  (High-end Desktop PC)

Device 2 (Gaming-class laptop)

Both test runs show very exciting results for the overhauled VA 2024.1 parser over its immediate predecessor VA 2023.6.

The test showed an average 1075% faster parse time using a high-end desktop PC; and 1333.08% faster parse using a powerful albeit relatively less performant gaming laptop. That’s 11 and 13 times faster, respectively. 

There is variance in the advantages gained between the two devices, with a significant performance edge on the less powerful laptop. We suspect the gains could be much larger on low and mid-end computers or laptops.

Curious to see how VA 2024.1 performs on your platform? Download a free trial of Visual Assist and try it for yourself now.

Navigate directly to a class constructor definition from an explicit constructor call

This neat addition to VA’s find reference and go to reference features allows users to find and navigate to a class’s constructor definition from a call to that constructor. 

Highlight or click over a constructor and use the shortcut Alt + G to navigate instantly to the default constructor.

Improved and expanded header selection when using Add Include

This release greatly improves VA’s Add Include detection and expands the number of actual includes supported. 

If you have not used this feature extensively VA can automatically add includes directives for you if it detects you are using an undeclared feature or type from a known library such as STL or even your own code elsewhere. Specifically, this update adds many new types baked into C++ such as std::stringstream and std::once_flag.

In essence, using Add include should automatically insert the correct include under many more circumstances.

Code completion dropdown toolbar now displayed by default 

The coding completion toolbar will now be turned on by default and will be displayed more frequently. This new quality of life change brings a visual UI as you write code. VA tries to predict your intended actions so the options shown will always be contextual apart from being accurate.

Furthermore, when you type code, the code completion UI will be shown by default regardless if you are hovering your cursor over the current portion of the code.

The code completion toolbar is displayed as you type code.

For very large projects and long source code, you can use the filter options (highlighted in the screenshot above) to select which options are shown in the new toolbar.

Bug fixes and improvements

For this release, we have severak fixes—both from examining recent features and user reports. The most notable of these improvements include functional visual changes to a plethora of features and better parser recognition of Unreal code.

• Fixed visual issues with completion dropdown toolbar
• Fixed issue where trial activation dialog could display an error and prevent activation
• Fixed issue with new “Magic Numbers” detecting Code Inspection where it was highlighting only a portion of the constant
• Fixed issue where logging could overflow and cause a crash when enabled alongside very large solutions
• Fixed issue where preprocessor directives in shader files were sometimes colored as methods
• Fixed issue where Unreal Engine Create***Subobject symbols were not recognized by our parser
• Fixed issue where changing the signature of an Unreal Engine method which requires a *_Validate thunk would result in rewriting the return of the *_Validate thunk to void.
• Fixed issue where typing a dot the start of the word in a few of our dialogs would result in no hits being displayed

Many thank to those who submitted their suggestions and error reports. Please continue reporting problems you may find along the way. To report bugs, you can send us a message or start a thread on the user forum.
You can also check our download page to update to the latest release manually. Happy coding!

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

Great news! The Whole Tomato experience just got even more complete and well-rounded! 

The hobbies and recreational activities you do during your early days in school often become the gateway to the skills you’ll develop and use in the real world. It is no surprise, then, that the tools and machines you use when starting out as a complete novice influence how you grow from a curious enthusiast into a full-blown professional.

This also means that one of the biggest gatekeepers for novices and students learning the basics is access to tools and machines that are fundamental to learning a skill.

This is why Whole Tomato is proud to announce that we’ve recently launched our academic licensing program to help students—as well as their teachers—get a headstart in their programming career!

The benefits for students, instructors, and teaching departments

To help more people learn about the wonders of fast and efficient programming in C, C#, and C++, Whole Tomato is lowering the barriers to accessing its renowned Visual Assist plugin for Visual Studio. From now on, students and instructors can secure fully sponsored Visual Assist licenses.

Visual Assist is kicking off its foray into accessibility for young learners, instructors, and teachers.

For Students
Students can easily secure a license using a verified educational email address. They will be able to purchase discounted licenses—friendly to an apprentice’s allowance. And if a learner is only willing to test the waters, they can also opt for a monthly subscription plan. Just visit our webstore and follow the checkout process for students.

A student is someone who is enrolled in an accredited educational program. Students can also check with their university or program organizers if they have existing packages with Whole Tomato. 

For teachers, instructors, and departments
Sometimes a beginner needs a push in the right direction. Recommending Visual Assist to students has never been easier. If an instructor is looking to share Visual Assist with their class or department, they have access to a number of tiered options ranging from fully sponsored deals to specially tailored plans.

If you’re interested in sharing the unrivaled power of Visual Assist to a class or a group of learners, contact the Whole Tomato sales team to explore your options.

Why an academic licensing program?

Picture this: rolling out academic licenses could be a game-changer, especially with the new generation of developers and programmers in mind. Think of it as guiding the future workforce with a backstage pass to industry-grade tools while they’re still in school. This early exposure to efficient and optimized instruments and applications makes learning a more encouraging and satisfactory experience. 

Partnering up with schools and departments also means that we, as software providers, get a chance to know what the new wave of developers are interested in trying or what problems they are facing. This allows Visual Assist to grow alongside the ever-changing demands of C/C++ development. 

And you students, on the other hand, get a more suitable and optimized tool to help you become fast and efficient developers. You won’t need to train and study as much when you graduate, as well since you will already be accustomed to the tools in the industry. This makes you a more attractive candidate for the occasional picky recruiter.

Supporting young learners is also one of the initiatives that the community should always strive to promote. As an interdependent and ever-changing industry, developers and the software world must ensure that people remain interested in learning our craft. Offering software at student-friendly rates (or even sponsoring them completely) levels the playing field and makes it more accessible. It’s totally the way to go! ?

Why would students need Visual Assist?

Long loading times, incomplete prompts, incorrect suggestions, and missing navigations, among others. The Visual Studio IDE has gone through leaps and bounds to improve C development, however, there are still areas in C++ that are in dire need of improvement.

Visual Assist provides the necessary support  and tooling learners need in their journey to becoming developers. Visual Assist provides new tools and improves existing ones in VS to eliminate the frustration in C/C++ development.

The latest additions to Visual Assist

Visual Studio 2022 
Cash in on that sweet x64 process. With virtually limitless memory available to Visual Studio, your productivity plugins no longer have to squeeze themselves for the remaining memory allocation. Visual Assist has been tweaked to properly utilize the newfound bandwidth.

Extremely fast project parsing
Interruptions and long loading times can make a significant hit on productivity. Stop fighting your development environment. Visual Assist’s raw performance allows users to focus on thinking and coding.

Better coding support and tooling
It’s easier to teach new learners new things. Visual Assist keeps the development environment updated with the latest features available. Follow the latest C++ standards and conventions with VA’s 100+ New code inspection checks and updated LLVM Clang Tidy 15.0 engine.

Specialized support
Unreal Engine source, shader files, CUDA core development, you name it. Visual Assist adds special support for lookalike C++ code. Enable basic IDE features such as navigations, refactoring, and code completion for these applications.

 The best time to get Visual Assist

Visual Assist was running at a discounted price when we publicly launched academic licenses—but luckily for you, being a student or a teacher ain’t seasonal! Visual Assist academic licenses will be available continuously for students using our webstore. And if you’re an instructor looking to secure some seats for your students, just contact our sales team to browse your fully-sponsored options.

Not a student or a teacher but you’re looking for affordable sets of licenses? Not a problem! Contact us to check your available options for bulk and enterprise licensing.

The post Another reason to cheer: Visual Assist academic licenses! first appeared on Tomato Soup.

We also have a new code checker, support for two new C++ language features, and small but useful improvements to VA’s behavior. Read on further to get the complete details of the changes and improvements in this release, or download the release right away.

Share source code via email, GitHub, and more.

Starting from VA 2023.6, users can now highlight sections of code from the editor and open the Quick Actions and Refactoring (Shift + Alt + Q) menu, or right-click on the code and select the “Share with team member” option to instantly send code to other developers.

Select and share sections of code by highlighting it and using the Quick Actions
menu (Shift + Alt + Q).

Choose where and how you want to share your code. This new feature can work in conjunction with GitHub Gist and GitLab’s snippets feature, where you can instantly share and upload parts of your source code. You can also send your source code via email for more general-use purposes. 

Improvements to VA’s navigation features

This release provides a number of improvements and additional functionality to VA’s bread and butter navigation features, such as open file in solution and find symbol in solution.

• Fuzzy search and uppercase search for opening files and searching symbols
  Fuzzy search is a technique used in searches and information retrieval to find approximate matches for a given query, accommodating variations like typos and misspellings. It employs string distance metrics to measure the similarity between strings.
  
  Visual Assist’s open file in solution and find symbol in solution will now employ this algorithm, so you can expect more results with fewer, less accurate search queries.
  
  Furthermore, besides fuzzy searching for inexact matches, VA will also match capital letters. If you have a class named MyClassName, searching for “mcn” would find it. It works similarly if you have a global variable named myGlobalVariable and type “mgv”. It is smart enough to count the lowercase “my” as if it were MyGlobalVariable leading to expected results.
  
  

  Enable fuzzy search and see smarter search results using approximate string matching.

   

   

• Select all items in open file in solution (Ctrl + A)
  You can now select and highlight multiple files and open them simultaneously when using open file in solution. The usual shortcut Ctrl + A works.
  

  Select and open all files with the new select all shortcut.

Improved support for Braced Initialization Lists / Uniform initialization (C++ 11)

2023.6 also improves support for braced initialization of lists and/or uniform initialization. Brace initialization lists and uniform initialization provide a more consistent and flexible way to initialize objects in C++. 

These features  improve code readability and reduce the chances of certain types of errors. Visual Assist’s parser will recognize these lists and highlight and suggest auto corrections within them.

Improved support for constexpr, consteval and constinit  (C++ 20)

These features are related to compile-time evaluation and initialization. They have specific use cases and are used to enforce certain behaviors at compile time. If you haven’t been using these, here’s a quick breakdown:

• constexpr used to indicate that a function or variable can be evaluated at compile time.
• consteval a stricter version, ensuring that the function or expression is only evaluated at compile time and cannot be evaluated at runtime.
• constinit is used to indicate that a variable must be initialized at compile time and, once initialized, its value cannot be changed during the program’s lifetime.

When using these features, Visual Assist will recognize what you are trying to accomplish such as refactoring commands mainly. Refactorings such as Create From Usage will now properly handle these keywords.

New code inspection for detecting “magic-numbers”

This new Clang-based code inspection checks for instances of magic numbers—or numeric literals that are used without any definition—that are advised against by many coding guidelines for readability sake.

Enable code inspections by navigating to Extensions ->> VAssistX ->> Code Inspection ->> Enable code inspections.  This specific code inspection is disabled by default because some users may be intentionally using it and are not interested in “fixing” it.

Then you can either click on detected issues underlined in blue, use the Quick Refactoring Menu (Shift + Alt + Q) while on the highlighted issue, to allow VA to do it for you. In this case, there is no automatic fix so it will prompt you to define a variable with that number as its value and use the variable instead. 

Protip: VA can help do that for you with the introduce variable feature. If you highlight the number, then use the Quick Actions menu and select Introduce Variable it will ask you for a name and pull the number out into a variable for you.

You can read more about the readability-magic-numbers code checker on Clang’s documentation. 

New move class feature

You can now move entire classes into different files with the new move class feature included in 2023.6. 

For example, if you have a class named MyClass, with its declaration in MyClass.h and its definition in MyClass.cpp, you can move the entire class into a new pair of files, MyClassNew.h and MyClassNew.cpp. 

This is useful if you have a header and source file pair (.h and .cpp) that contain multiple classes and you want to break that up into multiple files.

Bug fixes and improvements

For this release, we have a couple of fixes based on user requests. The most notable of these improvements include a fix for file exclusion instructions using .json configs similar to a previous release, a parser improvement for Unreal Engine 5, and improved auto-detect logic for Unity.

• Fixed multiple issues with file exclusion logic when reading from “.vscode\settings.json” configs.  
• Our parser now better understands Unreal Engine 5.0 (specifically that build) types, such as FVector.
• Fixed Create from Usage behavior when used inside const inline methods. 
• Fixed coloring of [[fallthrough]] marked enum items. 
• Attempted to fix rare temporary hang when debugging C# Unity projects.
• Code Inspections options dialog now displays much more quickly. 
• Improved Unity engine auto detect logic to reduce false positives.

Thanks to those who submitted their feedback and bug reports. Please continue sending them our way. Send us a message or start a thread on the user forums for bug reports or suggestions.

You can also check our download page to manually update to the latest release. Happy coding!

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

Modern programming languages evolve and are continuously refined even further with each new update. During these incremental stages of development, components such as compilers, IDEs, libraries, their units, their components, and tools undergo changes.

Furthermore, there are also rapid changes in operating systems and hardware systems. This means that if you are developing applications professionally, you must test your units or components at the beginning of your main application development to make sure it is compatible with the newly released versions. 

C++ is a very powerful and modern programming language but to keep up with ever changing industry demands, standard language practices and conventions constantly change. Thus, C++ applications need be to be regularly maintained by software developers and engineers.

All these require rapid unit testing to ensure that company and tech requirements are met using better memory management and improved runtime performance of the main application. Let’s learn more about unit testing and how it’s used to maintain source code.

Why do developers need to test C++ Code?

Developers need to test C++ code for various crucial reasons. First and foremost, testing is a fundamental means of detecting and addressing bugs, errors, and issues within the codebase. By running tests, developers can catch problems early in the development process, saving time and resources. Additionally, testing ensures that the software behaves as expected and meets its requirements and specifications. 

It also plays a pivotal role in regression prevention, safeguarding existing functionality as code evolves. Moreover, tests serve as documentation, providing examples of code usage and clarifying its intended behavior, making it easier for developers to understand and work with the code. Testing encourages good coding practices, promoting modularity and maintainability. It facilitates collaboration by allowing multiple developers to work on a project with confidence. 

But more importantly, performance is another aspect that can be tested and memory and CPU usage are really important in C and C++ programming—it’s one of its main strengths. Ensuring the safety of your product and minimizing memory usage is crucial for achieving reliability and usefulness, as it also impacts the performance of your application during runtime. Increased CPU usage can lead to slower operations, making your app lag behind those of your competitors. This will result in higher energy consumption and higher battery usage in mobile applications that are not liked by users. 

However, this performance comes at a cost. C++ is considered to be a little harder than other programming languages because you need to have a solid grasp of how to manage and use memory. Furthermore, C++ can be extended with headers of libraries, units, and components giving it even more complexity. Consequently, diagnosing problems and tracking issues in C++-based applications require more skill and know-how. Launching a version of an application without testing can lead to unwanted outcomes such as the dreaded blue/black windows screen. Failure to properly test code can also lead to random performance drops, higher CPU usage, and unoptimized energy consumption.

For example, using multi-threading development skills on the CPU, GPU, and memory operations is important in programming, but it can give rise to problems in synchronization of multi-threaded operations and accessing data for reading and writing. Thus, multi-threading functions/methods or classes/libraries should be rigorously tested before general availability. In C++, testing multithreaded and parallel-programming application codes requires more professional skills than testing traditional C++ code.

Nowadays most of these problems can be monitored by tools baked into operating systems, which means it is easier to detect issues on runtime. Thus, there should be minimal reasons to publish and use untested applications. C++ developers should test their codes and other codes embedded into the main code.

What is unit testing and why do I need to use it?

Unit testing is a technique for developing and  experimenting with software applications that focuses on individual units or components of a main software application. This process seeks to validate whether each unit or component meets the project requirements.

Generally, unit testing is applied in the early stages of the development process before any of the code is released as an alpha or beta release. Every unit or component needs to be updated based on the requirements  of the operating systems or with the coding  standards and conventions of a language.

Generally, tests do not require technical developer skills, but in some tests, there may be more precise work that can lead to better informative results.  These tests involve computational, multi-tasking applications such as AI applications or other computational engineering applications. These applications are mostly based on C/C++ codes or  are using languages that are related to C++ modules or libs, such as Python, Delphi, etc.

Unit testing is also applied to test different versions of units or components of a software system. Sometimes new versions of units may not fit your requirements or may cause problems during the runtime of your applications. Here are some of the problems:

• lower performance issues
• higher memory or CPU usage issues
• graphical issues
• crash issues (rare)
• Random freezes on runtime. 

If there are problems in your main applications, it may be hard to define which unit or component causing this kind of issue. This is why unit testing is important in the early stages of development. Thus, the developer or the dev team determines whether these tested units and/or components are suitable for use or not.

Here are few bad excuses example for not doing unit tests and some tips on how to possibly address them:

Testing our software is too difficult!

•  try to redesign or refactor
• try to decouple
• try TDD which helps ensure a cleaner design

We can’t test now. We are too pressed for time.

• Technical debt accrues and bugs are more time consuming in the long run
• prioritize, but make sure you test the most relevant partsHere are few bad excuses example for not doing unit tests and some tips on how to possibly address them.
  

Unit testing may be applied manually for some specific unit or components or they can be automated for general purposes to test some parts of units. These tests are applied on run-time when the code is changed to ensure that the new code does not break existing functionality.

Unit tests are generally small codes that have a unit or component and are applied to validate possible units of code. This code may be using a function or a method of a class or library. These are tested in isolation from the main software system. Thus, developers may test these units to identify possible problems and they may find a way to fix these problems in the early stage of the development process. This improves the overall quality of the main software application and reduces bugs, and issues in the main software, and reduces the time required for later testing.

Executing basic unit testing

How can I do better unit testing and code maintenance in C++?

When you do unit tests there are many C++ features to help maintain your code. Here are some features included in the Visual Assist C++ productivity plugin that can be used in application development, when testing a unit, or using a unit in the main application:

• Code Generation 
• Code Correction and Refactoring
• Code Understanding and Assistance
• Additional tool windows

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 user-centric design for maximum productivity and usability.

The post Ensuring Code Quality: Why Every C++ Developer Needs Unit Tests first appeared on Tomato Soup.

As many of our readers know, Visual Assist is a productivity extension for Visual Studio that provides a set of intelligent refactoring, navigation, code highlighting and generation features for C++ development, along with tailored features that help game devs make the most of Visual Studio’s integration with Unreal Engine. For those who are newer to our blog, check out this article for a quick overview of how Visual Assist can make game dev with Unreal Engine easier. In addition, last month was the first version of Visual Assist to officially support Unity. Read more about it in the VA 2023.4 build announcement.

Today, we’d like to introduce you to one of our partners, Assembla, and share how their Perforce hosting offerings can make game dev with Unreal and Unity even more efficient. Assembla provides a cloud-based source code management platform that brings project management, source code hosting, security solutions and other integrations under one roof to streamline your E2E dev pipeline. 

Assembla hosts Perforce Helix Core in the cloud under two solutions: Perforce Cloud, a quick-to-deploy SaaS platform, and Perforce Enterprise, where Assembla DevOps engineers set up Perforce Helix Core in a fully managed, dedicated AWS server or a custom network of servers to support global teams. With Assembla’s solutions, gaming studios save the overhead of managing their own on-prem or cloud solution and can focus on creating the best game possible rather than infrastructure. Additionally, teams can scale globally without worrying about how source control and file transfers will perform across locales.

Assembla was the first company to package Helix Core for the cloud and remains a leading expert today, bringing you the best features: 

• Fast commit performance
• Faster revisions, code testing and binary file handling 
• Automatic backups for every commit
• Virtually unlimited cloud repository storage
• Track and trace any code changes to identify security threats
• Native support for Unreal Engine and Unity
• Helix DAM to help speed up the creative process for your artists and designers
• Helix Swarm for code review

Assembla also supports Perforce’s third-party integrations with standard game dev tools such as Visual Studio, Jira, Adobe, Maya, Microsoft, and AWS. To further streamline your dev pipeline, Assembla recently launched a new CI/CD integration that supports GPU builds through Travis CI, improving the speed and efficiency of processing your games. 

Discover how Assembla can help you make the most of Perforce so you can create virtual worlds and immersive games by visiting their Gaming Development page.

The post Game Development Showcase: Visual Assist + Cloud Hosted Perforce from Assembla first appeared on Tomato Soup.

Std::maps is a staple in the C++ world for sure. It’s reliable and useful, but in this presentation, David Millington goes a level deeper and examines how other features offered beyond the standard library can be used to maximize the usefulness of the data structure. 

Quick Refresher on Maps

Maps are essentially a way to store key-value pairs in an ordered structure. This creates an associative array that can be used to lookup connected pieces of data. Maps are ubiquitous. Value-key lookup is used everywhere: filenames to files, index number to row/column, ID number to name, and the list goes on. 

Maps can be ordered or unordered. They are also similar to static arrays and vectors but they possess a few key differences such as memory management, performance, and appropriate types—watch this section of the webinar to learn more.

Things to Remember from the Webinar

• Where to use std::map and std::undordered_maps
• Difference between maps, static arrays, and vectors
• The many map implementation libraries available
• The importance of iterating in order
• Comparing performance of ordered and unordered maps

Slide Deck Presentation

Replay

The post Summer CodeFest: Magnificent or Malevolent: Maps! Measured, Monitored, & Magnified! [Mrecap] first appeared on Tomato Soup.

This presentation by product manager, David Millington, talks about the convenient way to define an anonymous function object added in C++11. This topic was chosen because while it’s extremely useful, the data we see is that there tend to be two groups of C++ developers: those who use them extensively, and those who barely use them.

When to use lambdas:

The main benefits of using lambdas are:

• Improves readability for you or your team.
• Anonymity makes them easier to maintain (no names needed for smaller functions/functors).
• Localizes functions to your code.

Furthermore, lambdas are especially useful if your logic goes inside something else. These code layering problems are a nuisance to reading code—lambdas make it easier to “localize” logic.

Comparing lambdas with traditional functor

A comparison between a sort functor written in traditional structure vs a lambda.

On the left is a standard functor with structs and operators written traditionally. It works and functions just as a lambda would but it is longer and arguably more difficult to comprehend when viewed in the context of actual source code.

On the other hand, a lambda is seen as significantly shorter and easier to read. With the structure of a lambda, the code being called is emphasized directly after the functions. The syntax is also unmistakable; just look for the following method syntax:

• [ ] – capture state
• ( ) – function
• { } – body of method
  

Skip to 18:18 of the replay to learn more about lambda syntax and how to structure inline functions.

Summary: other tips for using lambdas

Here are a couple of other things you should look out for according to the presentation:

• Variable capture
• Using auto for the type

Slide Deck Presentation

Replay

The post Summer Codefest: Lambdas go Baa! [Recap] first appeared on Tomato Soup.

Dr. Yilmaz Yoru shares his knowledge on graphics, as well as its counterpart analyzers and calculations used in 3D C++. He uses C++ Builder for most of his examples but almost any compiler can be used for the projects he demoed. Check out his website and other projects here.

Why use C++ for 3D

C++ is one of the top options if you are working with 3D graphics for the same reason you use it in embedded systems and high frequency trading—speed and performance. 

Any programming language can execute basic 2D graphics, but if we want to display 3D graphics in real-time (e.g. 3D simulations or rendering for video games),  then a language and environment that runs fast is essential. Furthermore, C++ also provides support for some of the most popular 3D libraries available such as OpenGL (GLUT) or Direct3D libraries. 

Features of C++ used in 3D

There are a couple of useful features in C++ that can be used in general programming as well as 3D work. Watch the session to grasp the fundamentals of these features and how it can be used in 3D C++. Some of the features included:

• Class features (constructors, move, copy, move operator, etc.)
• std::array
• std::vector
• std::map
• lambdas
• templates
• unique_ptr
• std::sort

We have other sessions in the Summer CodeFest that talk about some of these features such as lambdas and templates. Visit our blog to find them.

Color Management and Color Applications

[In modeling for 3D,] Pixels are the real graphics.

Graphical work in 2D/3D is primarily managing how the colors of pixels change and the underlying mathematics that decides when and how these changes happen. 

The bulk of the work is computational and applied mathematics. Determining how pixels change will rely on complex mathematical models. And consequently in modern 3D, programmers must find a way to visualize gigabytes worth of numbers. Fortunately, the C++ features mentioned earlier can greatly simplify this as you are working more closely with the actual data and memory—and the results can be shown in real time too.

As discussed earlier, 3D work is fundamentally the crunching of numbers using appropriate mathematical operations and models. Here are some examples shared in the presentation:

• Rotation matrices (used in 3D projection, vectors, robotics)
• Euler formulas (shows how a single axis parameter in 2D can be rotated to create 3D shapes)
• Quaternions (used to describe orientation or rotations in 3D space using an ordered set of four numbers)
• Octonions, rotors, and beyond (even more complex scalar and complex vectors using advanced algebra)

Slide Deck Presentation

Please email Dr. Yilmaz for his copy of his presentation slides.

Replay

You can also find Dr. Yoru’s website here.

The post Summer CodeFest: Modern C++ with Modern 3D [Recap] first appeared on Tomato Soup.

This release marks a major milestone in Visual Assist’s history as it starts its official support for Unity engine development. Also in this release: start of support for CUDA development for C/C++ and numerous parser improvements. Read on further to get the complete details of the changes and improvements in this release.

Start of official support for Unity

It’s been a long time coming but Whole Tomato is glad to announce that the upcoming 2023.4 build will feature the first of many Unity-specific features. Nope, not the hivemind—we are of course talking about the very versatile game engine and game development platform.

For those unaware, the Unity engine is the backbone of both 2D and 3D games ranging from wildly popular and suspicious games, all the way to full blown highly-acclaimed triple A titles.

Visual Assist has been popular for helping game developers deal with complex C++ code. Starting from the upcoming release, Visual Assist will expand its focus to C# game development. Users can expect VA staples such as refined navigation, intelligent autocomplete, code refactoring, and the like to work as well for C# work.

Furthermore, users can also submit feature requests specific for Unity development. We are starting with shaders—more on this below—but if you have any suggestions as to what features are missing in your Unity development, do let us know by emailing support.

Shaders for Unity

The start of official support for Unity development is headlined by shader file support. Similar to our previous addition of supporting HLSL, we are kicking off Unity updates by adding its shader files to our list of supported languages.

CUDA C/C++ Development

If you are a data scientist, software engineer, or a plain hobbyist looking to harness the power of your GPU for general purpose programming tasks, then you would most likely know about Compute Unified Device Architecture (CUDA). This programming model developed by Nvidia allows programmers to utilize the multi-core performance of graphics cards for other non-graphic applications (although it’s perfectly fine to use for 2D/3D too!)

If you are interested in CUDA, then rejoice! VA 2023.4 also marks the start of official support for CUDA development. Visual Assist’s can now parse and analyze CUDA related syntax, libraries, and APIs so you can have IntelliSense-like features, navigation, and highlighting for CUDA (.cu) files.

A CUDA file with proper syntax highlighting and code analysis features.

Parser Improvements: template functions with auto / trailing return type and std::tuple autocompletes 

With VA 2023.4 will now properly highlight and parse trailing return type features that bypasses a C++ limitation where the return type of a function template cannot be generalized if the return type depends on the types of the function arguments. This release specifically deals with some of the edge cases reported by our users.

Trailing return type features can be used by declaring a generic return type with the auto keyword before the function identifier, and specifying the exact return type after the function identifier. Learn more about it here.

The parser is aware of sum and proper syntax highlighting and navigation features are applied.

Also fixed in this release are initializations of std::tuple autocompletes. This improves how the VA parser handles certain templated types. In the end, users will find better completion suggestions when you are typing in your codebase, such as when typing std::tuple.

Better Add Include logic

Visual Assist can add include directives for headers that resolve unknown symbols in the current C++ source file. The underlying logic for add include has been improved for better context-awareness resulting in better predictions on where to place the new include.

Add include now inserts new lines in most logical place.

Add include can be accessed by hovering over unknown symbols and opening the quick actions and refactoring menu ( Shift + Alt + Q ).

Some other spring cleaning-type improvements

We’ve also made some changes to a few minor things to the UI and the options in the app that you should know about. Firstly, our shader support has been available for a few rounds of releases already and we’re excited to announce that it has finally finished its beta phase and will now be enabled by default. 

Secondly,  we’ve streamlined our game Development tab of our options dialog. This is to make room for upcoming additions (stay tuned!)

Thirdly, we’ve tweaked some tomatoes and icons along the way to better respond to your actions and better display what options are available to you. Relevant options and menus will be emphasized when they are needed; secondary options will subtly fade into the background otherwise. This is in line with our commitment to distraction free coding.

Lastly, if you’ve missed or haven’t installed the latest version yet, you may have noticed that the Visual Studio marketplace listings for the 32 and 64-bit versions of Visual Assist have now been combined. Versions 2010 – 2022 will now be accessible from one listing.

Bug Fixes

• Fix for ‘VaMenuPackage’ package error affecting VS2022 17.7.0 3.0 load
• Fixed issue where some types with leading macros before template definitions were not parsed correctly.
• Fixed issue where autocomplete of some types, such as std::tuple, would produce partial results.  
• Fixed rendering of suggestion list tomato icons in Visual Studio 2022. 
• Fixed issue where the VA Navigation Bar could become smaller than intended.
• Fixed Code Inspections error that could happen in some cases in Visual Studio 2022 17.6+. 

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.

Contrary to the preview blog statement, VA 2023.4 is a bit different as it will be released simultaneously—no rolling release mechanism as it includes some crucial updates we want to share to everyone as fast as possible. You can also check our download page to manually update to the latest release too. Happy coding!

The post Visual Assist 2023.4 now released first appeared on Tomato Soup.