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

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

Quick Refresher on Maps

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

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

Things to Remember from the Webinar

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

Slide Deck Presentation

Replay

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

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

When to use lambdas:

The main benefits of using lambdas are:

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

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

Comparing lambdas with traditional functor

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

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

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

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

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

Summary: other tips for using lambdas

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

• Variable capture
• Using auto for the type

Slide Deck Presentation

Replay

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

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

Why use C++ for 3D

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

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

Features of C++ used in 3D

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

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

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

Color Management and Color Applications

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

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

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

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

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

Slide Deck Presentation

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

Replay

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

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

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.

Our team of experts will take you on a tour of the new features, highlighting their benefits and demonstrating how they work. Whether you’re a game developer, designer, or engineer, you won’t want to miss this opportunity to unleash the full potential of Visual Assist.

Join us and discover how these new features can take your work to the next level!

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:00 – Presenter & Visual Assist Introduction
  Meet the presenters and learn about the primary features of Visual Assist.
• 0:06:21 – Webinar Rundown
  A brief rundown of the focus of this webinar, Visual Assist 2023.2.
• 0:08:40 – Code Inspections
  Learn about Visual Assist’s code inspections feature, how to use its features properly, and get an idea of how it became the feature it is today. Special mention to unevaluated code checkers—the star update of 2023.2
  Key takeaway: Refactoring via code inspections can catch severe errors that regular error highlighting can miss.
• 0:18:15 – Shaders Support
  Recap on when official support for shaders were added last year, and what new features have been added since then.
  Key takeaway: Exiting beta phase. Better reliability for even more shader files.
• 0:20:20 – Integrated Menu
  Explaining the rationale of why an integrated menu was necessary, and how to access and use it.
• 0:22:07 – Live Demo: Unevaluated code inspections and new shader support
  A demonstration of the key features in VA 2023.2: the 100+ added code inspections and new shader file features.
• 0:28:52 – Audience Q&A
  Chris and David answer questions from the audience. Question range from IDE usage, to feature clarifications, and even to future plans for the extension.

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 Tapping into Limitless Code Inspections: What’s New in Visual Assist 2023.2 [Webinar Recap] 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.

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.