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.

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.

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.

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.

Common pitfalls when scaling applications

When scaling applications, two common pitfalls often arise: spaghetti code and a lack of proper testing. This can occur for various reasons, but one of the most common reasons is the lack of a coding style guide or an overarching design structure.

For instance, when starting a project, it’s fairly simple. An input and one or two outputs. However, as the project grows or the requirements expand, programmers can resort to an experimental approach each time a new component is added. They can also resort to using manual testing—which works for simple unit tests for small projects but overtime becomes too cumbersome. 

The lack of a design structure makes projects prone to gradually growing complexity. As a result, the experimental app ends up in production as an inefficient system that demands continuous maintenance. To avoid breaking essential business logic and harming the overall business, developers allocate unnecessary development time to making one-off solutions.  The time and effort is compounded due the previous iteration’s shortcomings.

Using hex architecture can help address scaling issues.

Hex structure vs traditional three-layer architecture

There is nothing wrong with the traditional 3-layered structure composed of the presentation tier, the application tier, and the data tier. And for most applications this will usually be enough. However, theoretically, as you add more business logic and more functions, the complexity ramps up exponentially. In that case, a traditional approach may no longer be the most efficient. You can always scale and automate by expending more resources, or you can take a step back and reorganize your resources.

A hex structure, contrary to what the name suggests, is not a 6-tiered structure. Instead, it’s an analogy for the freedom of a developer to add ports and adapters—sort of like a honeycomb structure where you can keep adding more hexagons and there would still be no gaps. In the traditional approach, the presentation, business, and data side flow directly to each other; in hexagonal architecture, you add interfaces (or buffers) in between fully functioning components making them semi-autonomous. You would only have to think about how what data passes from one to another and how communication is processed.

Fortifying your app with hexagonal architecture

The Hexagonal architecture provides a solution to this problem by utilizing dependency inversion control, which separates business logic from implementation details like databases and REST clients. It also fosters a clear separation of concerns between components, ensuring a more organized and manageable application as it grows.

Ports and Adapters

As the name suggests, hexagonal architecture utilizes standalone components with a functional core in the middle of the design structure. This means that expansion, maintenance, and designing is easier because the program’s components and roles are clearly defined. Buffers between these components allow easy addition and removal as well as facilitate efficient communication among the program’s functions. 

So how do you initiate a program with a hexagonal design structure? Watch our short presentation hosted by Nuno Castro to get a brief introduction and some great examples. This session has concluded. Browse the presentation slides and replay below.

Presentation Slide Deck

Watch the Replay

The post Summer CodeFest: What the Hex? Ports and Adapters Architecture with C++ [Recap] first appeared on Tomato Soup.

The first Summer CodeFest presentation has concluded! Whole Tomato’s very own lead developer Chris Gardner lead the first session on enhancing your program’s scalability with concurrency techniques in C++!

We’ve prepared a short introductory article about concurrency and a short history on C++ support for threads in this article so you can better understand the session.

What is Concurrency?

Concurrency is an umbrella concept that encompasses multithreading and other techniques that are used to handle multiple tasks simultaneously. It involves managing shared resources (like variables, files, memory, etc.) to avoid race conditions and ensure thread safety.

A term that is almost synonymous with concurrency is multithreading. This is the concept of running multiple threads (smaller units of a process) within a single process. Each thread has its own stack and shares the same heap with other threads in the process. Multithreading is useful for parallelizing tasks and taking advantage of modern multi-core processors.

With parallel processing, programs can execute tasks simultaneously instead of sequentially which cuts completion time.

There is a difference between parallelism and concurrency, but we won’t get to that here as we need to dive into concurrency in C++. If you want to learn more about the theories, you can read more about it here.

The benefits of concurrent processing

The two main benefits of using concurrency is performance and division of labor. Learning how to program for multithreading may be hard to wrap your head around at first. Humans are usually sequential when it comes to executing tasks. Similarly, a single CPU core is only ever doing one task at a time, but it task switches extremely fast much like our brains. 

With the right conceptual program, computers can employ multiple cores or even virtual threads to run tasks in parallel—it does not need to fake with fast task switching. This allows your program to actually use memory and variables in such a way that two tasks can access it simultaneously.

For example, in processing-heavy tasks such as HD video playback, you can divide the processing labor between the video crunching and the interface. The first thread will take care of reading the disk, decoding the image and sound bytes, and finally sending the video and sound to the hardware. On the other hand, the second thread can handle the user inputs such as play/pause, stopping, and the like. This allows your program to focus on each task with a separate “brain”. 

The two threads can communicate with each other only when needed so the overall experience is way more responsive (benefits the user) but is also easy to manage the program (benefits the programmer).

The difficulty in learning parallelism is often in how and when these separate threads should communicate with each other. 

(Note: Relatively, C++ is not a concurrency-oriented language because it usually relies on its innate speed to run complex tasks sequentially—but that’s not to say there is no use for parallelism in C++)

Scaling programs using concurrency and multithreading in C++

In C++ 2011, multithreading support was added to the C++ standard. This included useful components and C++ developers were able to use concurrency without the use of environment-specific extensions.

Included in the Standard library are the following tools and features:

• thread-aware memory models
• Classes for managing threads
• Managing and protecting shared data
• Synchronizing operations between threads
• Low-level atomic operations

To get a better understanding of how to incorporate concurrency and multithreading in your C++ code, sign up for the following tutorial hosted by Whole Tomato’s very own lead developer.

Explore modern C++20 multithreading and powerful parallelism techniques. As programs get more complex, computers get equipped with even more CPU cores. Learn to optimize applications for peak performance with real-world examples and practical insights with C++20’s new concurrency features.

This session has concluded watch the replay or download the slides below.

Presentation Slide Deck

Watch the Replay

The post Summer CodeFest: Next-Level Concurrency: Enhancing Scalability with C++20 [Recap] first appeared on Tomato Soup.

What are code inspections?

Code inspections is a feature in Visual Assist that automatically checks source code for issues and code smells, and suggests the appropriate fix. The main benefit of using code inspection is better overall code quality with minimal effort.

Code inspections work by utilizing code checkers, sometimes referred to as static analyzers. These are tools that analyze your source code passively—it happens as you type your code. You do not need to actually compile and execute your code to detect a problem (i.e. finding bugs and errors using run-time techniques such as testing).

Code issues are underlined in blue. Line information and a description of the issue is also shown in the VA Code Inspection Results window.

It looks for common patterns, broken coding conventions, and potential bugs in the code using algorithms and special techniques. The purpose of code checkers is to catch problems early in the development process, which can save a lot of time and effort later on. 

What issues can it detect?

The issues and code smells that can be detected vary widely from stylistic infractions on coding convention, all the way to system critical errors.  Here are some of the common fixable issues:

• Detecting and updating obsolete coding syntax
• Highlights possible readability issues and broken coding conventions
• Checking type-related errors (such as making invalid type conversions or assigning values of incompatible types, using uninitialized variables, or.)
• Wasted resources due to inefficient memory allocation/deallocation.
• Other issues of non-obvious, but potentially dangerous, incorrectness

Visual Assist’s code inspection feature is based on LLVM’s /Clang-Tidy code analysis engine so you can be sure that it covers a variety of checks targeted at finding security and API usage bugs, dead code, and other logic errors. Additionally, we extend the functionality through the use of ‘evaluated’ checkers (more below).

READ: More examples from a blog by Bartek from C++ Stories

Evaluated and unevaluated checkers

Code checkers are added gradually to the list of Visual Assist code inspections. All checkers that are in the list are thoroughly evaluated, checked, and tested. Evaluated checkers often include changed functionality that is not in the base clang-tidy, making them more reliable and safe. This is a key part of the value of the checkers we include. Using evaluated checkers guarantees that the code will be refactored properly and any suggested fix will not break anything.

On the other hand, unevaluated checkers are still based on Clang-Tidy’s extensive list but have not undergone the same quality assurance tests as its counterparts. Almost a hundred unevaluated checkers have been added in Visual Assist 2023.2.

Note that unevaluated checkers will still suggest the recommended fix and behave like normal checks, but users are advised to manually ensure that everything is working correctly. The benefit that this brings is that developers can know what and where a potential issue lies—which is oftentimes the bulk of the work.

Why use code inspections to fix issues and refactor code?

Running code inspections lists down issues in a window for you to examine before implementing fixes.

Code inspections read source code line by line, analyzing the structure, logic, and syntax. It pays attention to specific patterns or coding conventions that may indicate potential issues. As they encounter a line of code, it uses a set of rules and algorithms to determine if the code adheres to best practices or if there are any deviations.

Using code inspections automates a lot of the manual checking and verification that developers would traditionally do. With it, it no longer matters how familiar a developer is on a project, or how large a solution is—it all goes under the same level of scrutiny.

it provides some of the following benefits as well:

• Be able to utilize modern coding practices without actually knowing them.
• Improve code quality with minimal refactoring risk.
• Detecting potential code issues early.

WATCH: Understand how code inspections are evaluated

How to use code inspections to eliminate code smells

First, make sure to enable it by navigating to Extensions -> VAssistX -> Code Inspection (beta) -> Enable code inspection. 

Then you can either click on detected issues underlined in blue, use the Quick Refactoring Menu (Shift + Alt + Q) while on the highlighted issue, or use the code inspection dialogue to implement changes in batches.

WATCH: Code inspections in action

Visual Assist by Whole Tomato: Filling Gaps in Visual Studio for C/C++ and C# Developers

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

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

Download Visual Assist here.

The post Everything you need to know about code inspections first appeared on Tomato Soup.

An AI-generated image built at simplified.com with the prompt ‘A laptop with an AI onscreen’. Impressive it’s possible, but equally it has a long way to go. Images and movies are harder than text. Are they harder than code?

Today’s AI

• Runs on remote servers / the cloud
• Shares knowledge (unless you pay 10x as much) which makes it inappropriate for confidential data like source code
• Is computationally very expensive: the hardware required is expensive and you need a lot of it
• May not be relevant: it’s trained on wide data, but you may have something more specific, such as your own libraries and source

However:

• There’s a lot of work being done reducing the computation cost: for example, Facebook’s Llama and related models have a large number of tweaks that bring it down to single-computer levels at reasonable speeds
• Once it can run locally, accidentally shared knowledge is not an issue (at the same order of magnitude of cost, you could also have an affordable in-house server, shared only with employees)
• Once it can run locally, it can be used any time, not just with a net connection
• It may be much more relevant: if it’s trained on your data, it will be able to suggest domain-specific solutions

What’s key?

For commercial software development, three things are key:

1. Keeping your source code confidential when getting AI input
2. Low cost
3. Giving domain-specific, your-app-specific useful results

We see local and private AI trained on your own codebase becoming a relevant reality quite soon. Compared to a remote cloud-based ChatGPT (for example) instance, that seems far, far more useful, practical, low cost, and safe.

Visual Assist

Tools like Copilot or ChatGPT, which are cool but legally risky for the owners and potentially dangerous for you if your source is added to their knowledgebase, are not the way forward. Plus, an AI that knows your tech is far more useful than an AI that knows generic programming. Local, private, trained-on-your-code AI is where we see industry relevance.

The above is our view on where AI will go for development. As for what this means for Visual Assist, none of this can be taken as a statement of product direction. It’s best to say that we are interested in the topic. VA already provides industry leading refactorings and other tooling powered by a unique code understanding engine, a tool developed to be non-compiler-like and more programmer-like. AI’s potential for features based on code understanding syncs very well with what we provide. Without hype, and moving carefully, we may see movement in this direction. If we do, as always it will be with the Visual Assist ethos: an eye towards true usefulness, not headlines; great performance; and the features we choose will be designed by devs, for devs.

The post AI for Development: What Do We Expect? first appeared on Tomato Soup.

Join us to discover the benefits of Visual Assist’s code inspection techniques and start maximizing the quality of your code today!

This webinar has concluded. If you missed it,  you can scroll down and watch the replay, skim through the highlights, and access the presentation slide. 

Webinar Slides

Webinar replay and summary

• 0:00:54 Introduction
• 0:02:18 Visual Assist Background
• 0:03:38 Why people use Visual Assist
• 0:04:41 How to find code inspection
• 0:05:36 Common issues solved by code inspection
• 0:06:49 Benefits of using code inspection
• 0:08:35 Using code inspection for single and batch fixes (shortcuts and menus)
• 0:09:44 List of code inspections
• 0:10:01 Clang Engine
• 0:10:40 Configuring checks
• 0:12:21 Enabling code inspection
• 0:13:05 Live Demo
• 0:14:08 Live Demo: NULL PTR
• 0:14:28 Live Demo: make_shared
• 0:14:48 Live Demo: Raw string literals
• 0:15:28 Live Demo: Convert to “using” declaration
• 0:15:48 Live Demo: Bools
• 0:16:12 Live Demo: Configuring highlights and underlines
• 0:20:22 Question and Answer

What’s Next?

Interested in learning more about Visual Assist and it’s many hidden features? Browse through our top 10 features, or for a more complete and comprehensive reference, please visit our documentation. And if you have any questions or clarifications, feel free to send support a message.

If you have something specific to request for the next webinar, send us your feedback at this email.

The post Eliminating Code Smells with Visual Assist Code Inspection [Webinar Recap] first appeared on Tomato Soup.

What Is C++ Refactoring?

Refactoring is the process of improving or updating existing code without changing the functionality of the program. In the process of refactoring, you can improve the design, structure, and implementation of the software, and clean up unnecessary dependencies, code duplications, and other types of confusion.

In software development, development teams are constantly extending the code and adding new functionalities. Over time, the quality of the code can deteriorate, which causes difficulties in its understanding and the occurrence of errors. Code refactoring makes it possible to improve the readability of the code, simplify it, create a modern architecture, simplify the maintenance process, and reduce the number of errors.

What Are The Advantages Of C++ Refactoring?

• Making code easier to understand and analyze.
• Simplifying the addition of new functionality to software results in increased development efficiency.
• Improvement of software architecture.
• Optimizing resource usage.
• Increased security.
• Productivity improvement.
• Simplifying the process of finding and fixing errors.
• Reducing the number of errors.

When Should We Start Refactoring A Code?

For effective refactoring, the developers must be familiar with the code. In addition, to avoid errors in the refactoring process, it is important to have sufficient code coverage with automated tests.

You should think about code refactoring in the following cases:

• The code is hard to understand. In this case, the process of updating the code and finding errors becomes longer, and it is possible to create duplicates, unnecessary dependencies, and even more complexity of the code.
• Software slowdown. When the code is complex and has many dependencies, it can slow down the software. This leads to dissatisfaction among end users who may refuse to use it.
• The presence of a large number of errors in the code. If the code is complex and confusing, the debugging process becomes much more difficult. Fixing one error may cause others to appear. To avoid this, it is important to refactor the code to simplify it as much as possible.
• Code duplication. Each element of the program must be unique. If there are duplications in the code, it increases the time to read it and makes it difficult to understand, as well as increases the probability of errors.

What Are C++ Refactoring Best Practices?

• Before refactoring, it is important to cover the code with automated tests.
• Refactor incrementally, making small changes to the code while keeping the program in a working state.
• Separate the processes of refactoring and creation of new functionality. No new features should be added during refactoring.
• The result of refactoring should be simpler and more understandable code.
• For testing a few refactoring iterations, use not only unit tests but manual testing too.
• Follow the coding standard used by your company.
• Remove deprecated code such as dynamic exception specification.

How To Refactor Code Easily?

Visual Assist is a productivity extension for Visual Studio that provides advanced code refactoring tools, quick navigation, rendering, correction, code maintenance, and code inspection functions. Using the Visual Assist C++ extension, you can easily improve code readability, simplify it, and fix broken code. You can refactor separate class or several dependent classes simultaneously.

How To Access Refactoring Commands?

You can access the refactoring commands in several ways:

• Go to the desired symbol and open the context-sensitive quick action and refactoring menu using the Shift+Alt+Q short keys.

• Use the context menu of the text editor to open a complete list of refactoring commands.
• Place the cursor over the desired symbol to display the icon, then click the icon to open the context menu.

How To Change The Signature Of A Method?

Visual Assist allows you to change the method name, return type, visibility, names, types, number, and order of parameters in a simple dialog box. Automatic signature change is possible in all inherited and overridden methods, as well as in all method references.

How To Encapsulate The Field?

With Visual Assist, you can create accessors to a member field by encapsulating the field. Accessories are created and assigned automatically. You can create accessor methods next to the declaration in the header file and can stay in the header file or implement them in the source file.

How To Extract The Method?

You can quickly simplify long methods and make them easier to read and understand. To do this, highlight the required code segment and call the Extract Method refactoring. Visual Assist automatically detects the method signature, moves the selected code segment into the new method, and replaces the segment with a call to the new method.

How To Move Implementation?

In C/C++, you can easily move a method implementation from the source to the header file and vice versa. To do this, select the desired method, call up the refactoring context menu, and select the move command.

In addition, it is possible to move all methods from the header file to the source file in one operation. To do this, call the move command from the class name. This will bring up a dialog where you can select the methods you want to move.

How To Rename?

Visual Assist provides the ability to quickly and accurately rename symbol definitions and declarations, all references to them, and occurrences in comments and lines in the active project and throughout the solution. You can rename classes, enums, fields, macros, methods, method parameters, and variables. To do this, choose Rename from the refactoring menu, specify a new name, and use the preview to determine which occurrences of the symbol need to be renamed.

You can also rename the document and related files without breaking the build. Visual Assist automatically updates files, projects, and solutions and then propagates the renames through source control systems that integrate with Microsoft Visual Studio.

How to automatically inspect your code?

Visual Assist provides a function to check the code for certain quality issues based on LLVM Clang tidy. It diagnoses and corrects common programming errors, such as style violations, misuse of the interface, and errors that can be detected by static analysis. The code inspection function runs in a process separate from the Visual Studio process. This avoids reducing IDE performance.

Enable code inspection in the Visual Assist options to highlight code issues in the Visual Studio text editor. Code inspections will appear as a blue line on the line where an issue is found. You can click on this to accept the suggestion. You can also scan an entire file and make batch edits.

Here are some of the code inspection checks available in Visual Assist. If you want the complete list, head on over the list of code inspections.

Are you interested in how to improve developer productivity in Visual Studio using Visual Assist and C++ refactoring? Download a free trial of Visual Assist today.

The post C++ Refactoring Tips And Tricks first appeared on Tomato Soup.

What Is Visual Studio?

Visual Studio 2022 is one of the most powerful and popular IDEs (Integrated Development Environments) among .Net and C++ developers. It can be used for the development of various types of software, including websites, web services, mobile, desktop, web apps, games, and so on.

Visual Studio provides many features that speed up and simplify the process of writing and testing code, including a code editor with IntelliSense and code refactoring, an integrated debugger that can work as a source-level and machine-level debugger, tools for creating the user interface, a code profiler, etc.

You can download the Visual Studio installer from the official website.

How To Use Visual Studio For C++?

C++ is a popular low-level, high-performance programming language that can be used to create many different types of applications. Visual Studio has all the tools you need to easily write C++ applications.

Visual Studio supports various versions of the standard for the C++ programming language and allows you to use all its modern features. With Visual Studio C++, you can perform classic Microsoft Windows desktop development or universal Windows applications for HoloLens, Surface Hub, PC, and Xbox development.

In addition, you can use Microsoft Visual C++ for Linux development, mobile, and game development.

What Are The Most Common Visual Studio C++ Pain Points?

Although Visual Studio offers many useful tools and is a great solution for C++ development, there are pain points that developers who use it occasionally run into.

Poor performance

While it is designed for C++, these projects can sometimes be extra complex and Visual Studio may struggle performance-wise. It would require more resources such as disk space and operating system memory. This is especially noticeable when working with large projects.

Long build time and slow compilation

The process of building projects takes a lot of time. The compilation is slow, which greatly complicates and slows down the process of finding and correcting bugs in the source code.

Stutters and freezes during coding

Sometimes there are cases where the machine freezes during coding, which leads to the need to reboot it. In this case, the programmers need to start over the unfinished work should they be unlucky enough to have forgotten to save.

Chaotic file organization

When working with C++ files in Visual Studio, you need to first create folders and files on the computer disk. Then you need to create a project in Visual Studio and add the already created files and folders to it. The project only lists the names and paths of files and folders that should already exist on your drive. This is different from how Visual Studio works with other programming languages and is awkward and confusing, especially on collaborative projects or complex solutions.

Understanding Complex C++ Language

C++ is a complex programming language that supports higher-order types, a standard library for CPU cache line sizing, dimensional analysis, and other functional paradigms. Even experienced C++ developers have to learn hidden features and discover new ways to optimize their development.

So, it’s time to solve the most common Visual Studio pain points.

What Are The Visual Studio Extensions Available In The Market?

Visual Studio Marketplace [1] provides a wide range of extensions to enhance the capabilities of Visual Studio. GitHub Extension for Visual Studio, CodeMaid, and Visual Assist are very popular among the developer community.

By making it simple to connect to and collaborate with your repositories on GitHub and GitHub Enterprise, GitHub Extension improves Visual Studio 2015 and Visual Studio 2017. It creates new repositories or clones existing ones to get working together.

Our C#, C++, F#, VB, PHP, PowerShell, R, JSON, XAML, XML, ASP, HTML, CSS, LESS, SCSS, JavaScript, and TypeScript coding may be cleaned up and made simpler with the help of the open source CodeMaid Visual Studio extension.

More extensions are available in the marketplace to enhance the capabilities of Visual Studio and improve productivity. However, Visual Assist provides solutions for most Visual Studio C++ pain points mentioned earlier. The following section will discuss it in detail.

The Pain Killer You Need – Visual Assist

Visual Assist is a productivity extension for Visual Studio that has many features for refactoring, quick navigation, code generation, and much more. It provides tools for the automatic detection and correction of errors in the code, automatic understanding, and completion of the code, syntax highlighting, and improved debugging functions. Using Visual Assist greatly simplifies the process of coding in Visual Studio C++ and increases development productivity.

Advantages of Using Whole Tomato –  Visual Assist

Let’s list the main benefits of using Whole Tomato Visual Assist.

Increase Your Productivity

Visual Assist offers advanced navigation features that let you quickly go to any file, method, reference, or code symbol in your projects or solutions. You can also automate code refactoring activities. Advanced features of automatic code generation make the process of writing code as fast as possible, which significantly increases development productivity.

Fast & Responsive Tooling

All Visual Assist commands and tools are responsive and work quickly, which allows you to use them even when working with large and complex projects.

Helps Optimize Workflows

With Visual Assist tools that make code generation and debugging easier, you can optimize and streamline your project workflows.

Adds Support (Fills Gaps)

If you have any problems with Visual Assist, you can use our knowledge base or search for a solution to your problem in the forum. In addition, there is technical support where you can get answers to all questions about working with the Visual Assist extension.

Everything Becomes Customizable

You can fully customize Visual Assist to your liking. This includes customizing colors and shortcuts.

Final Verdict

Visual Assist is the best extension for Visual Studio C++ development, which has numerous advantages and makes the coding process quick and easy. Give Whole Tomato a spin. Sign up for free.

FAQ

Which Visual Studio is Best for C++?

Visual Studio is a widely used IDE that is excellent for development in C++ and supports various standards of this programming language. Another popular Microsoft product used for C++ coding is Visual Studio Code. It is an open-source, cross-platform code editor that offers “Microsoft C/C++” extensions for C++ programming.

How do I Find Build Errors in Visual Studio?

To find build errors in Visual Studio you should choose View -> Error list or use the shortcut Ctrl+\, E. In addition to errors, you can also view a list of warnings and other messages.

How do I Resolve to Build Errors in Visual Studio?

Select the error message in Visual Studio and press F1. Visual Studio will open the documentation page for this error, where you can find workarounds.

[1] https://marketplace.visualstudio.com/

The post Solving The Most Common Visual Studio C++ Pain Points first appeared on Tomato Soup.

Luckily, there are certain techniques and technology that developers can utilize to make it a bit easier. Learn more about how cloud-hosted Perforce is something you should be capitalizing on for collaborative Unreal game development in this webinar co-hosted by Whole Tomato and Assembla.

Expect the following in this webinar:

• Know about the benefits of collaborative asset management and remotely managing them.
• Build familiarity with web-based version control and source code management software
• Set up an Unreal game project to sync with remotely hosted perforce server and productivity tools

The webinar is happening on February 22nd, Wednesday 10 AM CST and will be presented by Whole Tomato’s own lead engineer and product manager, Chris Gardner and David Millington. Completing the trio is Chris Hughes from Assembla.

—

This webinar has concluded. If you missed it,  you can scroll down and watch the replay, skim through the highlights, and access the presentation slide. 

Slides

Webinar replay and summary

Timestamps and Section Summary

• 0:00:00 Introduction and Agenda
  A brief introduction of the presentation’s agenda and what the audience can expect to learn from the presentation.
• 0:04:15 Assembla Feature Highlight
  Learn about what Assembla is, and what powerful features it provides with an explainer from Assembla PM himself. Learn more about Projects, spaces, issues, and the possible integrations available in the platform.
• 0:09:44 Where to Use Assembla
  Setting Assembla with Unreal Engine is the core of this webinar but there are many different possible use cases for it depending on how you set up your workspace and views. It could be an all-encompassing project manager and planner, or it could be an internal help desk ticketing solution. Chris explains the possible setups in detail in this section.
• 00:14:09 Using cloud-hosted Perforce with Assembla
  Apart from providing a cloud-based system, Assembla also provides users access to a support and devtools team ready to assist. Chris provides an explainer.
• 00:15:55 Intro to Cloud-based management and Source Control
  In this section, Chris G. gives a rundown of his part of the webinar. He explains the process of downloading and uploading to cloud-based systems. And he explains that the process remains the same whether it’s source code, or even gigabyte huge assets. If you want to set up your own cloud-based Perforce system for Unreal and don’t know where to start, it would be best to begin here.
• 00:17:40 Source control: Definition and Benefits
  What is source control and what are the following factors to consider when choosing a platform? Learn more about it in this section. Chris also talks about regression, version security, and historical recall in this section.
• 00:21:30 Unreal Engine 5 & Perforce (Helix Core)
  Why does Unreal have specific integration and built-in support for Perforce? What features does Unreal provide that makes this integration easier? Chris talks about the scripting features inside Unreal and how you can set this up to connect to servers and automatically sync changes internally and externally among team members.
• 00:23:18 Partner Shoutout: Visual Assist
  While not directly related to setting up Perforce with Unreal, Visual Assist is something that Unreal Engine developers should have. Get a brief intro to one of the best C++ Visual Studio plugins in this section by the lead developer of the tool himself.
• 00:25:17 Demo Start: Unreal Engine 5 source control
  The main event of the presentation. Chris G. takes us step by step into how to set up Unreal Engine with Assembla—from initializing Perforce, all the way to setting up your first space and first repository, and finally to your first commits.
• 00:25:49 Demo: Adding a repository
  The very first thing you need to do to sync to Assembla is initialize a P4 repository in your space. This section discusses how to set your first repository, find the connecting link on Perforce, and logging in to your Assembla instance.
• 00:27:27 Demo: Create a workspace
  After connecting to Assembla, you will need a place to upload your files and assets to. Chris opens up Perforce and sets the main stream in this part of the demo.
• 00:30:11 Demo: Summary of process
  Few reminders and things to keep in mind before you are all set and ready to go. He also opens the Unreal editor to check if the initialization was successful.
• 00:31:28 Demo: Verifying integration via Unreal Editor
  Check to see if you did the setup correctly by verifying the integration inside the Unreal Editor/Perforce P4. Chris commits a sample change using a blueprint file.
• 00:34:25 Demo: Final checks
  Some other tips and reminders for using other integrations such as Visual Studio plugins and hookups. Afterwards, you just have to share the repository with teammates and everyone should be able to collaborate.
• 00:38:50 Question and Answer
  Here are some of the questions from the Q&A
  – Is Assembla beginner friendly?
  – Does version control work for binaries?
  – Supported languages for security scans?
  – License costs?
  – Perforce client vs Assembla web client?

What’s Next?

Interested in getting started with Assembla and its Perforce integration for game development? Get started by visiting Assembla’s game development web page.

And if you’re using Unreal Engine, give Visual Assist a try. It’s the perfect plugin to pair with Assembla for faster and easier development.

If you have something specific to request for the next webinar, send your feedback to this email.

The post Setting up cloud-hosted Perforce source control for Unreal Engine [Webinar Recap] first appeared on Tomato Soup.

Games can suffer from technical issues, poor performance, and negative player experiences without proper QA testing. This can lead to a loss of player engagement and damage the game’s reputation. QA testing helps identify improvement areas and ensure that the game meets industry standards and player expectations. Let’s check out what is QA testing phase in game development.

What Is QA Testing Process?

QA (Quality Assurance) testing is a process that involves evaluating the software product or application to identify defects, bugs, and other issues. This helps us resolve application functionality, performance, and user experience issues. The game software testing process typically consists of the following steps:

Test Planning

This involves defining the scope of testing, identifying the types of tests to be performed, and creating a detailed test plan.

Test Design

This involves writing test cases, creating test data, and setting up the test environment.

Note that QA testing is integral to the software development life cycle.

Test Execution

This involves running the tests and collecting test results.

Defect Reporting

This involves identifying any defects, bugs, or issues found during testing and reporting them to the development team for resolution.

Defect Resolution

This involves fixing the defects and retesting to ensure that the problem has been resolved.

Test Closure

This involves documenting the test results of software quality and finalizing the testing process.

QA testing can be iterative, with several rounds of testing, defect reporting, and resolution until the product meets the requirements. The process also involves continuous monitoring and reporting to ensure that the project is on track and that any issues are addressed promptly.

Some most common types of QA testing are:

• unit testing
• usability testing
• regression testing
• load testing
• white box testing

What Is The Difference Between A QA Tester & A Developer?

A QA (Quality Assurance) tester and a developer are critical software development team members, but they have different roles and responsibilities.

A QA tester is responsible for evaluating the software product or application to identify defects impacting its performance. The QA tester writes test cases, executes tests, and reports defects to the development team. Their goal is to ensure that the final product meets the required standards for quality and reliability.

On the other hand, a developer is responsible for writing the code that creates the software product or application. The developer works closely with the design team to understand the requirements and implement the necessary features and functions. The developer also works with the QA team to resolve any defects or bugs that are found during testing.

Example: What Would An Unreal Game Development Project Look Like Without QA Testing?

Unreal game development in Visual Studio can use C++ or other programming languages to create games using the Unreal Engine. We can divide the process of developing a game with Unreal Engine in Visual Studio into several stages, including planning, design, implementation, and deployment. Let’s check out what it would look like with and without QA testing.

Scenario Without QA Testing

The development team creates the game using Unreal Engine and Visual Studio based on the design specifications and requirements.

Once the game is complete, the team moves straight to deployment without thoroughly testing it for defects and bugs.

As a result, the game may contain critical flaws that can negatively impact its functionality, performance, and user experience.

We can discover these issues once the game is released to users, leading to frustrated customers and wasted resources

Scenario With QA Testing

With QA testing, the Unreal game development process in Visual Studio would look like this:

The development team creates the game using the Unreal Engine and Visual Studio, following a thorough and detailed test plan

The game is then subjected to various types of QA tests, such as functional testing, performance testing, and security testing

The QA team identifies and reports any defects or bugs they find, and the development team works to fix them

We repeat the process until the game meets the required standards for quality and reliability

Then, we deploy the final game to users with confidence that it will perform as expected and provide a positive user experience.

Choosing QA Tools: Visual Assist For Game Development

Visual Assist is a popular Visual Studio extension for game development, known for its code generation and productivity features.

Here are some reasons why you may choose Visual Assist for game development:

1. It quickly generates and maintains code, reducing the time and effort required to develop games.
2. Visual Assist provides enhanced code navigation features that make it easier for developers to find and understand code.
3. It provides code analysis features that help developers identify and resolve errors and warnings in their code.
4. Visual Assist increases developer productivity by automating repetitive tasks, reducing the time and effort required to complete tasks.
5. It is compatible with a wide range of game development tools and platforms, making it an ideal choice for game developers who work with different technologies.

Best Tools For QA Testing

There are other tools that QA professionals prefer for QA testing & quality control. Some of them are:

• TestRail
• Selenium
• Jira
• Postman

However, QA testers mostly prefer TestRail for QA testing procedures. Let’s check this tool.

TestRail

TestRail is one of the best testing tools due to its features and user-friendly interface. Some reasons for this test automation tool’s popularity include the following:

Test case management

TestRail provides a centralized repository for storing and organizing test cases in the software testing life cycle. This feature makes it easier for teams to manage and track their testing efforts.

Collaboration

TestRail allows teams to collaborate and communicate effectively by providing tools for discussion, assigning tasks, and tracking progress.

Reporting and tracking

TestRail provides detailed reports and graphs that give teams insight into the progress of their testing efforts. It can help us identify areas for improvement.

Customization

TestRail is highly customizable, allowing teams to tailor the tool to their specific needs and processes.

Integration

TestRail integrates with other tools, such as Jira, Jenkins, and Selenium, making it easier for teams to manage their testing activities.

TestRail is a comprehensive tool that helps teams streamline their testing processes and improve their QA testing efforts.

Final Thoughts

We must realize the importance of QA testing for our game development. The reason is that it can give us high-quality games for our users. Moreover, we must use reliable tools for development and testing processes. For example, Visual Studio and TestRail are the most popular these days. These tools can help us achieve the desired game without affecting the quality.

FAQs

What Benefits Does QA Testing Provide?

It helps us ensure that our software gives the highest possible quality to the users—saving costs on expensive fixes down the road.

Is Being A QA Tester A Viable Profession?

Yes. As it is an industry with growing demand, it is a good and well-paying job.

Is QA Testing Easy To Learn?

QA testing is an interesting and easy process when you do it with the right mindset and with the right tools.

What Is QA vs. Qc vs. Testing?

QA testing refers to the process that ensures the achievement of the quality requested. While QC refers to fulfilling the quality requested.

Sign Up for free to test your game development process and release high-quality games.

The post Why Is QA Testing Essential? first appeared on Tomato Soup.

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

What are Common Visual Studio C++ Pain Points?

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

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

What are the Difficulties in Project Management?

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

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

What is Visual Assist for Visual Studio?

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

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

What are the Benefits of Using Visual Assist?

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

What is TFS Tool & TestRail Integration?

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

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

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

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

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

Conclusion

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

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

FAQ

What is the TFS tool?

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

What is TFS and Jira?

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

Is TFS a DevOps tool?

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

What is TFS server used for?

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

Is TFS the same as Git?

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

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

In this article, we will explain why you should use C++ extensions and analyze the top 5 extensions that allow you to improve Visual Studio productivity.

C++ and Visual Studio: How is One Incomplete without Another?

C++ is a popular programming language that is widely used to develop software for various industries. With C++, we can create applications for different operating systems, including Windows, Mac OSX, and Linux, and develop new programming languages, games, embedded systems, and more.

Visual Studio is a powerful IDE (integrated development environment) that is one of the most popular among C++ developers. It provides advanced features that allow them to significantly simplify and speed up the process of writing, debugging, and testing C++ code.

Also, Visual Studio makes it easy to install extensions using the Manage Extensions dialog. When this dialog opens, you can see the list of currently installed extensions. A list of available extensions you can find in the Visual Studio marketplace. Also, you can publish your own extension to the marketplace.

Visual Studio Extensions: How they help You Become a Pro?

There are a lot of extensions for Visual Studio. They provide additional functionality and convenient tools that allow you to simplify, speed up, and automate the process of writing code, resulting in increased Visual Studio productivity.

Since there is a large selection of Visual Studio extensions, it can be difficult for some to choose the best one. So, go through the list of the Top 5 Visual Studio Extensions.

Top 5 Visual Studio Extensions

We have selected the 5 best Visual Studio Extensions and analyzed their main functionalities, advantages, and disadvantages. Read and choose the extension that suits you better than others.

Visual Assist

Whole Tomato Visual Assist is a popular powerful extension that provides a lot of functions to significantly simplify and speed up the process of writing code.

The main Visual Assist features are:

• Quick navigation. You can easily navigate to any file, method, or symbol in your code.
• Easy formatting. Visual Assist is an opinionated code formatter that automatically formats code according to the given style.
• Refactoring allows you to simplify and improve code readability.
• Automatic code generation and auto-completion make the process of writing code much faster.
• Ability to use ready-made code snippets.
• Automatic error correction in code and comments when typing.
• Ability to search files using regular expressions and patterns.
• Ability to automatically diagnose and correct common programming errors.

In addition, Visual Assist supports the popular and powerful 3D graphics development tool Unreal Engine. This feature allows you to easily create high-performance 3D applications using C++ and Unreal Engine.

ReSharper C++

An alternative popular extension that allows you to increase development productivity is ReSharper. It provides quick search and navigation features, auto-completion and code generation, refactoring, and more.

The main disadvantages of ReSharper are its high cost and slow operation, which can cause windows to freeze.

Code Runner

Another good Visual Studio extension is Code Runner. It allows you to run the source code of the file, the selected code snippet, or a custom command and view the results of the invocation in the Output Window with no need for terminal interaction.

Code Compare

Code Compare is a handy tool for comparing and merging files and folders. It highlights the inserted, deleted, and modified text in rows in detail.

Code Compare allows you to collapse unchanged areas of text, edit files on the fly, and easily merge using the mouse pointer. However, Code Compare for Visual Studio IDE can operate slowly.

SonarLint

SonarLint is a static code analyzer that allows you to find bugs and code quality and security issues. It uses hundreds of rules to analyze the code. You can disable some rules on the fly or exclude some project files from the analysis.

Final Verdict

Using Visual Studio Extensions greatly simplifies the coding process and reduces the number of errors. In this article, we talked about the top 5 Visual Studio C++ extensions and analyzed their advantages and disadvantages. You should choose the right extension for your according to your budget and requirements.

Whole Tomato Visual Assist is a powerful Visual Studio extension that provides all the features you need to quickly code, navigate, search, and debug.

Install a free trial version of Visual Assist and make sure that it is the best C++ extension on the market.

FAQ

Is Visual Studio a good IDE for C++?

Visual Studio is one of the best IDEs for C++ as it provides powerful functionality for quickly writing code, debugging, and testing software.

Is Visual Studio 2022 good for C++?

Visual Studio 2022 has new features to improve development productivity and also includes robust support for C++ workloads, making it a good choice for C++ development.

How can I be more productive in VS Code?

In order to be more productive when developing using Visual Studio Code, you should use hotkeys, functionality for quick navigation,  search and replace symbols. In addition, you can install code extensions that provide even more functionality to increase development productivity.

In which ways can you extend the functionality of Visual Studio?

Visual Studio has a large selection of extensions available in the Visual Studio marketplace that you can easily install to extend its functionality.

The post Level-up your C++ productivity using Visual Studio Extensions first appeared on Tomato Soup.

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

Why leaders need to keep their developers happy

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

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

Ensuring a hassle-free work environment

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

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

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

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

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

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

The difficulty in gauging productivity

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

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

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

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

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

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

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

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

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

A Visual Assist user shares his review on G2.

Justifying a software purchase

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

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

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

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

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

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

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

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

 Try Visual Assist

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

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

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

Visual Assist is a native plugin, so compiled for either 32-bit or 64-bit Intel depending on which version of Visual Studio you’re using. If you run the normal version of Visual Studio, this is exactly what you need. But if you run the ARM version, you would need an ARM build of Visual Assist, and we haven’t yet shipped one. That is, right now you can’t use Visual Assist using the ARM build of Visual Studio.

We have a history of supporting new versions of Visual Studio very close to release. When Visual Studio 2022 was announced, we spent many months moving Visual Assist to 64bit, including blogging about our progress and which preview builds of Visual Studio we suggested using our beta version with. So you might expect us to release an ARM build within a few days… but we are not.

First, we will support ARM. It’s coming. It’s important to us to be on all platforms where Visual Studio is.

Second, we’re not prioritizing as urgently as we did for Visual Studio 2022 support, for the simple reason that very few of our customers are expressing interest in it, including requiring it – ie moving to ARM for development and thus being unable to use Visual Assist. What we’ve seen is interest along the lines of,

• ‘Do you have any plans in your roadmap?’
• ‘Will there be support for ARM sometime in the future?’
• ‘I’d like to use Apple Silicon.’

Those are close to verbatim quotes from the inquiries we’ve got, and we have only a handful. None of the feedback we’ve been sent indicates an urgent need for it, just interest. And that’s why we’re working on it, but not as urgently.

Currently, and with the caveat nothing is promised until it’s GA-ed / shipped, that means first half 2023.

We want to check: is this the right decision for you?

Do you need ARM? Do you need it now? What’s your use case: why are you using ARM?

Please send us an email at support@wholetomato.com. We will read with interest!

– David Millington, Visual Assist Product Manager

The post Visual Assist and ARM first appeared on Tomato Soup.

This is a very effective method to streamline your workflow and increase your productivity. But if you find yourself jumping into the marketplace often, you may need something more than an extension.

In this blog, we talk about managing the number of tools for your work and how a text editor with integrated solutions can save you time and money.

Picking your tools and extensions

When extensions aren’t enough for a specific task, developers usually divert to using auxiliary tools to support their IDEs. The demand for software has ballooned, especially with the prevalence of remote work setups. Some of these tools include stand-alone text editors,  file readers, Git clients, file-comparison tools, and more—it largely depends on what deliverables are needed.

The problem is that having specialized tools for every use case can actually reduce productivity. With the number of “good” extensions available, we spend more time than necessary on finding the “perfect” extension. 

This is known as the paradox of choice. Having too many options distracts us. The surplus of choices can make us focus on optimizing our workstations because of the possibility that we can be way faster. In reality, having a handful of tools or extensions would be faster in the overall scheme of things.

Top rated extensions for Visual Studio 2019.

So how should programmers and IT professionals deal with unnecessary tool creeping? Here’s a couple of ways to ensure you’re making the most out of the auxiliary tools you use:

• Identify the core of your work.
  What’s the main task? Your auxiliary tools and extensions should help you finish it faster or easier.
• Find the gaps in your work process.
  Try to optimize your current tools and programs. Use them until you find yourself facing the same problems repeatedly; that’s when you find more specialized tools.
• Minimize the number of tools you have.
  Weigh your options wisely. Ask yourself if that one-off task merits the time and effort it takes to find, try, and learn a new tool.
• Opt for the best option available now.

When you find a couple of tools that do similar things, choose the one that’s best for what you’re doing, not what you might eventually be doing.

UltraEdit: An catch-all solution for programmers and IT professionals

UltraEdit is one of the few tools that masterfully merges many basic processes into one streamlined workflow. It is a text editor designed for multiple purposes so you don’t have to search for a new tool or extension. UE is not designed to replace an IDE’s extensive capabilities but it integrates many basic IT functions, and it does it well. That’s why it’s sometimes referred to as the “Swiss Army knife” of text editors.

As a text editor, it is a powerful, flexible, and highly configurable tool with an extensive array of data-editing features designed to meet every user’s needs. It allows users to jump from task to task elegantly, regardless of the programming language, input files, or size of the project.

UltraEdit Features

• Fast startup and file load
• Supports dozens of programming languages and file types
• Large file-handling (4 GB+)
• Dynamic code auto-completion
• Native FTP/SFTP browser, SSH/telnet console
• Special XML and JSON support (parse and reformat)
• OS integration (command line, shell extension)
• Replace and find in files/replace in files
• File and selection sorting
• Integrated file compare and diff operations
• Column/block mode editing
• And more…

A backup text editor for Visual Studio

Most developers use VS as their main workhorse for development work. That’s what an IDE, or integrated development environment, is for.  It’s meant to be an entire coding environment.  VS includes everything a developer needs: an editor, a compiler, a debugger, and the option to expand functionality via plugins.

Realistically, however, developers and IT professionals have other projects that should not be done in an already resource-intensive IDE. 

WATCH: UltraEdit can instantly open this XML dump file that’s 34GB.

UltraEdit has the basic features of Visual Studio, but it’s also lightweight and supports more kinds of processes.  You can be writing C++ code one second and working on HTML or JavaScript the next. It gives developers the all-in-one tool they need to edit almost any type (or size) of file—all packaged in one highly optimized editor. 

UltraEverything

While nominally a text editor, UE also comes equipped with the option of the All-Access Bundle. UE has a suite of stand-alone development tools so you don’t have to worry about looking for one. These products integrate with one another giving you a simplified process.

 The All-Access Bundle includes the following:

• UEStudio
  A variant of UltraEdit with better features for teams and developers, such as intelligent code completion, project management, and Git integration
• UltraCompare
  A powerful file-compare application that can search and process duplicates in text files and folders 
• UltraFinder
  A quick and lightweight Windows search program designed to find text in files anywhere—more powerful than basic 
• UltraFTP
  A personal, stand-alone FTP client built upon the framework of other UltraProducts

UltraCompare visually compares/merges 2 or 3 files from multiple locations at once. Compares from UC can be viewed and edited in UltraEdit.

UltraEdit includes UltraCompare Pro. Every UE license comes with a license for UltraCompare Professional—a similarly powerful diff tool. UC Pro offers users the following:

• Two-way and three-way file and folder comparisons
• Integrated sync with UltraEdit
• Local/remote compare and sync
• Visually inspect file differences
• Quick and easy merge operations
• Hex, table/Excel compare
• Git integration

Extensions are Visual Assist can make your coding life so much easier, but if you find yourself constantly optimizing the IDE with plugins, you may consider having a reliable backup external editor. Choosing from the library of tools can seem confusing at times, so if you’re tired of constantly looking for tools, it is highly advised to get a versatile and powerful tool like UltraEdit.

Visit ultraedit.com to learn more.

The post The Ideal Visual Studio Companions first appeared on Tomato Soup.