Chapter 6 of the lecture Game Programming taught at HAW Hamburg.
Introduction to unit testing, integration testing, mocking and test-driven development in games.
Software construction is an exercise in managing complexity, more so with the spiralling complexity required by modern games. Automated Testing is an industry proven methodology to deliver more reliable complex software, with a fighting chance to do it on time and on budget. And having fun doing so. Crytek is spearheading this idea in the game industry with its flagship title, and now sharing the experience with you: best practices, potential pitfalls, To-Do’s and No-No’s will be shown with real examples of unit testing game code using its proprietary testing framework and tools. Functional Testing and acceptance testing will also be touched on as a viable way of describing and checking game design requirements. And take automated testing to the next level.
Game Programming 07 - Procedural Content GenerationNick Pruehs
Chapter 7 of the lecture Game Programming taught at HAW Hamburg.
Introduction to procedural content generation and its implication for the game design.
Game Programming 05 - Development ToolsNick Pruehs
Chapter 5 of the lecture Game Programming taught at HAW Hamburg.
Introduction to continuous integration, API documentation generation, analytics, static code analysis and crash dump analysis.
This document discusses challenges in game development based on Nick Prühs' experience. It covers the diversity of game types and roles involved in development. It also discusses art pipelines, game engines, physics examples, and lessons learned from developing the "Campus Buddies" social game. Key lessons include expecting API changes, using existing solutions, making testing and deployment easy, mocking network interactions, standardizing code style, using a feature-based project structure, prioritizing collaboration, listening to players, implementing tutorials, considering 2D animation, and addressing challenges with localization.
Software construction is an exercise in managing complexity, more so with the spiralling complexity required by modern games. Automated Testing is an industry proven methodology to deliver more reliable complex software, with a fighting chance to do it on time and on budget. And having fun doing so. Crytek is spearheading this idea in the game industry with its flagship title, and now sharing the experience with you: best practices, potential pitfalls, To-Do’s and No-No’s will be shown with real examples of unit testing game code using its proprietary testing framework and tools. Functional Testing and acceptance testing will also be touched on as a viable way of describing and checking game design requirements. And take automated testing to the next level.
Game Programming 07 - Procedural Content GenerationNick Pruehs
Chapter 7 of the lecture Game Programming taught at HAW Hamburg.
Introduction to procedural content generation and its implication for the game design.
Game Programming 05 - Development ToolsNick Pruehs
Chapter 5 of the lecture Game Programming taught at HAW Hamburg.
Introduction to continuous integration, API documentation generation, analytics, static code analysis and crash dump analysis.
This document discusses challenges in game development based on Nick Prühs' experience. It covers the diversity of game types and roles involved in development. It also discusses art pipelines, game engines, physics examples, and lessons learned from developing the "Campus Buddies" social game. Key lessons include expecting API changes, using existing solutions, making testing and deployment easy, mocking network interactions, standardizing code style, using a feature-based project structure, prioritizing collaboration, listening to players, implementing tutorials, considering 2D animation, and addressing challenges with localization.
Game Programming 04 - Style & Design PrinciplesNick Pruehs
Chapter 4 of the lecture Game Programming taught at HAW Hamburg.
Introduction to naming conventions, type and member design, exception design and common .NET interfaces.
Game Programming AI
This document discusses behavior trees, an approach to game AI architecture. Behavior trees split AI decision logic from actions and organize them into a directed tree structure. The root node executes logic which reports back as success, running, or failure. This passes control to child nodes. Key nodes include sequences which run children in order until failure, and selectors which run the first successful child. Behavior trees are modular, reusable, and can be data-driven to design AI visually without code. They have been successfully used in many games due to their flexibility and performance.
Learn why you should put your blackbox (or system/integration) tests into Docker Containers.
Brief (remedial) overview of Docker for software testers who don't know docker, and only need to know the basics to wrap their regression tests inside of a container.
Box2D is the world's most ubiquitous 2D physics engine. It's light, robust, efficient and highly portable. It has been battle-proven in many applications on many platforms, and it's open-source and free. Check out the Box2D website athttp://www.box2d.org
Introduction to html5 game programming with impact jsLuca Galli
Luca Galli presented an introduction to HTML5 game programming using ImpactJS. ImpactJS is a JavaScript game framework that uses the HTML5 Canvas element to create 2D games that can be played on the web or mobile. Key points discussed include:
- HTML5 allows for cross-platform game development and deployment without plugins or additional costs.
- Using a framework like ImpactJS avoids needing to write boilerplate code from scratch and provides tools to handle issues like asynchronous loading and variable performance across devices.
- ImpactJS uses a module system to organize code and classes to structure objects in a prototypal inheritance model. Core classes cover game loop, entities, backgrounds, collisions and input handling.
-
The document discusses different approaches to automating testing of user interfaces (UI), including record and replay, coding tests, and using the Jemmy library. It recommends designing a test library that uses higher-level abstractions like the domain model to minimize changes needed when the UI changes, improving test maintenance effectiveness.
A brief introduction about the art of unit test, how to test a class, mock a collaborator and use a fake database. TDD is introduced. Code for exercises is available on github along with a detailed explanation. Examples and exercises are written in Java.
The document is a glossary created by a student for a games design course. It contains definitions for 12 terms related to video game development that the student researched online. For each term, the student provided the definition they found, the relevant URL source, and whether and how they utilized the term in their own game production work. The glossary covers terms such as alpha/beta testing, game engines, debugging, physics, and anti-aliasing among others.
The document is a glossary created by a student for a games design course. It contains definitions for 12 terms related to video game development that the student researched online. For each term, the student provided the definition they found, the relevant URL source, and whether and how they utilized the term in their own game production work. The glossary covers terms such as alpha/beta testing, game engines, lighting, and anti-aliasing among others.
I am Kefa J. I am a Database Management Homework Expert at databasehomeworkhelp.com. I hold a Ph.D. in Programming, Princeton University, USA. I have been helping students with their homework for the past 12 years. I solve homework related to Database Management.
Visit databasehomeworkhelp.com or email info@databasehomeworkhelp.com. You can also call on +1 678 648 4277 for any assistance with Database Management Homework.
This document provides an introduction to JUnit, a unit testing framework for Java. It discusses why unit testing is important, how to write and organize JUnit tests, how to use assertions and mocks, and how to integrate JUnit with IDEs and build tools like Maven and Ant. Key aspects covered include the benefits of unit testing, the core components and design of JUnit, best practices for test-driven development and test maintenance, and resources for learning more about JUnit.
This document provides an introduction to unit testing in Python and the Pytest framework. It discusses writing unit test code using the unittest framework and Pytest, how to test functions and handle failures. It also covers features of Pytest like skipping and expected failures, fixture setup/teardown, and distributed testing using the xdist plugin.
This document discusses using JUnit to automate unit testing of RPG code on an IBM iSeries system. It provides an overview of the benefits of automated testing and outlines the steps to set up the infrastructure for testing, including creating Java and RPG modules, compiling the code, and running tests. Sample code is provided for a simple math module and test. The document recommends automating the testing process through a shell script to run compilation and tests.
This document provides an overview of JUnit, a unit testing framework for Java. It discusses JUnit's history and development by Kent Beck and others. The key aspects covered include: writing test cases by extending TestCase and adding test methods; using assertion methods like assertTrue and assertEquals to check conditions; organizing tests into test suites; and running JUnit tests within the Eclipse IDE. Other unit testing tools for other languages are also briefly mentioned.
This document discusses unit testing ILE procedures in IBM i. It introduces unit testing as a way to identify bugs early and test code as it is written. It outlines how to create a test script in RPG that calls the procedures being tested and produces a report of the inputs, expected outputs, and actual results. The document provides terminology for different types of testing and guidelines for compiling test scripts separately from production code. It emphasizes that unit testing should be integrated into the development process.
TechMentor Fall, 2011 - Packaging Software for Automated Deployment with Wind...Concentrated Technology
There are two parts to automated software deployment: packaging and deployment. Packaging involves reconfiguring software installations to install silently without user input. Deployment involves loading repackaged software into a deployment tool for scheduled installation on target machines. Common packaging methods include analyzing EXE, MSI, and copy-it-yourself formats to determine installation switches or capturing changes through differential analysis. Repackaged software can then be deployed through Group Policy installation, Microsoft Deployment Toolkit task sequences, or other deployment tools.
The document discusses test-driven plug-in development in Eclipse. It introduces PDE JUnit, which extends regular JUnit to allow running tests on plug-ins inside an Eclipse workspace. It outlines installing PDE JUnit if using an earlier Eclipse version. The process of test-driven plug-in development is broken into three steps: using PDE JUnit, setting up a test environment, and writing a test for a contributed plug-in.
Game Programming 02 - Component-Based Entity SystemsNick Pruehs
The document discusses component-based entity systems for building game object models. It outlines some drawbacks of inheritance-based approaches, such as deep class hierarchies leading to call order issues. It then introduces an aggregation-based approach using entities, components, and systems. Entities are simple IDs, with all data and logic contained in independent, reusable components. Systems operate on components to implement game functionality without coupling. This approach has advantages like easy extensibility and multi-threading. Blueprints and attribute tables are discussed as ways to configure entities using components and data at runtime.
Game Programming 04 - Style & Design PrinciplesNick Pruehs
Chapter 4 of the lecture Game Programming taught at HAW Hamburg.
Introduction to naming conventions, type and member design, exception design and common .NET interfaces.
Game Programming AI
This document discusses behavior trees, an approach to game AI architecture. Behavior trees split AI decision logic from actions and organize them into a directed tree structure. The root node executes logic which reports back as success, running, or failure. This passes control to child nodes. Key nodes include sequences which run children in order until failure, and selectors which run the first successful child. Behavior trees are modular, reusable, and can be data-driven to design AI visually without code. They have been successfully used in many games due to their flexibility and performance.
Learn why you should put your blackbox (or system/integration) tests into Docker Containers.
Brief (remedial) overview of Docker for software testers who don't know docker, and only need to know the basics to wrap their regression tests inside of a container.
Box2D is the world's most ubiquitous 2D physics engine. It's light, robust, efficient and highly portable. It has been battle-proven in many applications on many platforms, and it's open-source and free. Check out the Box2D website athttp://www.box2d.org
Introduction to html5 game programming with impact jsLuca Galli
Luca Galli presented an introduction to HTML5 game programming using ImpactJS. ImpactJS is a JavaScript game framework that uses the HTML5 Canvas element to create 2D games that can be played on the web or mobile. Key points discussed include:
- HTML5 allows for cross-platform game development and deployment without plugins or additional costs.
- Using a framework like ImpactJS avoids needing to write boilerplate code from scratch and provides tools to handle issues like asynchronous loading and variable performance across devices.
- ImpactJS uses a module system to organize code and classes to structure objects in a prototypal inheritance model. Core classes cover game loop, entities, backgrounds, collisions and input handling.
-
The document discusses different approaches to automating testing of user interfaces (UI), including record and replay, coding tests, and using the Jemmy library. It recommends designing a test library that uses higher-level abstractions like the domain model to minimize changes needed when the UI changes, improving test maintenance effectiveness.
A brief introduction about the art of unit test, how to test a class, mock a collaborator and use a fake database. TDD is introduced. Code for exercises is available on github along with a detailed explanation. Examples and exercises are written in Java.
The document is a glossary created by a student for a games design course. It contains definitions for 12 terms related to video game development that the student researched online. For each term, the student provided the definition they found, the relevant URL source, and whether and how they utilized the term in their own game production work. The glossary covers terms such as alpha/beta testing, game engines, debugging, physics, and anti-aliasing among others.
The document is a glossary created by a student for a games design course. It contains definitions for 12 terms related to video game development that the student researched online. For each term, the student provided the definition they found, the relevant URL source, and whether and how they utilized the term in their own game production work. The glossary covers terms such as alpha/beta testing, game engines, lighting, and anti-aliasing among others.
I am Kefa J. I am a Database Management Homework Expert at databasehomeworkhelp.com. I hold a Ph.D. in Programming, Princeton University, USA. I have been helping students with their homework for the past 12 years. I solve homework related to Database Management.
Visit databasehomeworkhelp.com or email info@databasehomeworkhelp.com. You can also call on +1 678 648 4277 for any assistance with Database Management Homework.
This document provides an introduction to JUnit, a unit testing framework for Java. It discusses why unit testing is important, how to write and organize JUnit tests, how to use assertions and mocks, and how to integrate JUnit with IDEs and build tools like Maven and Ant. Key aspects covered include the benefits of unit testing, the core components and design of JUnit, best practices for test-driven development and test maintenance, and resources for learning more about JUnit.
This document provides an introduction to unit testing in Python and the Pytest framework. It discusses writing unit test code using the unittest framework and Pytest, how to test functions and handle failures. It also covers features of Pytest like skipping and expected failures, fixture setup/teardown, and distributed testing using the xdist plugin.
This document discusses using JUnit to automate unit testing of RPG code on an IBM iSeries system. It provides an overview of the benefits of automated testing and outlines the steps to set up the infrastructure for testing, including creating Java and RPG modules, compiling the code, and running tests. Sample code is provided for a simple math module and test. The document recommends automating the testing process through a shell script to run compilation and tests.
This document provides an overview of JUnit, a unit testing framework for Java. It discusses JUnit's history and development by Kent Beck and others. The key aspects covered include: writing test cases by extending TestCase and adding test methods; using assertion methods like assertTrue and assertEquals to check conditions; organizing tests into test suites; and running JUnit tests within the Eclipse IDE. Other unit testing tools for other languages are also briefly mentioned.
This document discusses unit testing ILE procedures in IBM i. It introduces unit testing as a way to identify bugs early and test code as it is written. It outlines how to create a test script in RPG that calls the procedures being tested and produces a report of the inputs, expected outputs, and actual results. The document provides terminology for different types of testing and guidelines for compiling test scripts separately from production code. It emphasizes that unit testing should be integrated into the development process.
TechMentor Fall, 2011 - Packaging Software for Automated Deployment with Wind...Concentrated Technology
There are two parts to automated software deployment: packaging and deployment. Packaging involves reconfiguring software installations to install silently without user input. Deployment involves loading repackaged software into a deployment tool for scheduled installation on target machines. Common packaging methods include analyzing EXE, MSI, and copy-it-yourself formats to determine installation switches or capturing changes through differential analysis. Repackaged software can then be deployed through Group Policy installation, Microsoft Deployment Toolkit task sequences, or other deployment tools.
The document discusses test-driven plug-in development in Eclipse. It introduces PDE JUnit, which extends regular JUnit to allow running tests on plug-ins inside an Eclipse workspace. It outlines installing PDE JUnit if using an earlier Eclipse version. The process of test-driven plug-in development is broken into three steps: using PDE JUnit, setting up a test environment, and writing a test for a contributed plug-in.
Game Programming 02 - Component-Based Entity SystemsNick Pruehs
The document discusses component-based entity systems for building game object models. It outlines some drawbacks of inheritance-based approaches, such as deep class hierarchies leading to call order issues. It then introduces an aggregation-based approach using entities, components, and systems. Entities are simple IDs, with all data and logic contained in independent, reusable components. Systems operate on components to implement game functionality without coupling. This approach has advantages like easy extensibility and multi-threading. Blueprints and attribute tables are discussed as ways to configure entities using components and data at runtime.
When developing games, each and every one of us should strive for perfection. At my desk, I have put up a sign saying “What would Blizzard do?” This talk is about motivation, excitement and learning how to dissect other games in order to learn from each other.
Chapter 11 of the lecture Game Programming taught at HAW Hamburg.
Introduction to kinematics and dynamics, numerical integration, rigid bodies, collision detection and resolving.
Scrum - but... Agile Game Development in Small TeamsNick Pruehs
The document discusses Scrum, an agile framework for managing product development. It describes Scrum roles like the Product Owner, Development Team, and Scrum Master. The Scrum process involves sprints, daily stand-ups, sprint planning and reviews. It also introduces an example game development team called Astro City working with Scrum.
You already know TDD, your code coverage is almost at 80%, jUnit has no secret for you? But you feel that you could do more with your tests, the tools you use have limitations. Or maybe you're just tired of assertEquals?
Don't panic! We will see how you can code tests. We will look upon:
- Mutation Testing
- BDD, Behaviour Driven Development
- Property Testing
The design and rules of games constantly change during development, invalidating your carefully engineered software from day to day. Entity systems are a great approach for getting rid of the many drawbacks of inheritance-based game models like the “diamond of death”, moving on to a much more flexible aggregation-based model which has been popular since Gas Powered Games’ Dungeon Siege.
This document discusses component-based entity systems for game development. It describes the disadvantages of inheritance-based models, including deep class hierarchies that are difficult to develop, maintain and extend. It then introduces an aggregation-based approach using entities composed of independent components. This approach favors composition over inheritance and improves extensibility. Finally, it describes entity system architectures where components contain data and systems contain logic, improving performance, serialization and other capabilities. Overall it advocates for entity systems as an easier way to build, maintain and extend game object models.
Entity System Architecture with Unity - Unite Europe 2015Simon Schmid
Entity System Architecture with Unity - Unite Europe 2015
Entitas - open source Entity Component System for C# and Unity: https://github.com/sschmid/Entitas-CSharp
Designing an actor model game architecture with PonyNick Pruehs
Introduction to Pony, actor model, reference capabilities and making concurrent DirectX games with Pony.
Presented at MVP Fusion #3.
http://mvpfusion.azurewebsites.net/
ECS architecture with Unity by example - Unite Europe 2016Simon Schmid
Simon Schmid (Wooga) and Maxim Zaks explain how the introduction of strict ECS architecture in Unity helped them to achieve easy to test, robust and scalable game logic. It also helped them to extract this logic and run it on a server. At Unite Europe 2015 they introduced their Open Source project Entitas-CSharp (https://github.com/sschmid/Entitas-CSharp), which helped them achieve all the benefits they listed before. This year they present an example which explains how ECS and Unity can co-exist and empower developers to have a clean, scalable and testable architecture. They cover the following topics: User Input, Integration with Unity Collision System, Reactive UI, Re-Playable games
Clean, fast and simple with Entitas and Unity - Unite Melbourne 2016Simon Schmid
This document discusses using an entity component system architecture with Entitas, an open source C# entity component system framework for Unity. It explains that Entitas keeps data separate from behavior using data-only components, and organizes game logic into systems. This results in code that is clean, fast and simple to work with. The document provides examples of how movement logic can be handled within a system in Entitas, and demonstrates that Entitas uses less memory and CPU than the default Unity object model. It positions Entitas as a viable alternative for organizing game code in a consistent and modular way.
http://bit.ly/1xZBgMd
Checklist: User Testing Your Game
You’re working on a new game, and you know you’ll run QA tests. But have you planned to get feedback from real users? Feedback on engagement and entertainment could be the key to success!
This checklist will help you plan, run, and analyze user research of your game - and will help you get the feedback that you need.
The document discusses NUnit, an open source unit testing framework for .NET. It describes what NUnit is, how to install and use it, key concepts like test fixtures and methods, and provides an example of writing unit tests for a calculator class using NUnit's attributes. The document also covers running tests via the NUnit GUI or console, and examining the output XML file for test results.
Unit Testing with JUnit4 by Ravikiran JanardhanaRavikiran J
Unit testing with JUnit allows testing individual units of code, especially methods. JUnit provides annotations like @Test to mark test methods and assert methods to validate results. Tests can initialize objects and environment with @Before, validate outputs with assertEquals and other assert methods, and clean up with @After. Multiple test classes can be run together as a test suite with the @RunWith and @SuiteClasses annotations. JUnit is useful for finding bugs, ensuring code works as intended, and allowing test-driven development.
The document describes how to create and structure a Coded UI test in Microsoft's testing framework. It explains that a Coded UI test is created by selecting "New Test" and choosing "Coded UI Test". It then outlines the typical anatomy of a Coded UI test, including adding necessary namespaces, applying attributes like TestMethod and TestInitialize, and including properties for the TestContext and UIMap.
Tool Development 09 - Localization & TestingNick Pruehs
This document discusses localization and testing for WPF applications. It begins by explaining the differences between globalization and localization, with globalization referring to making applications work in multiple locations and localization being the translation of resources. It then provides best practices for WPF UI design to support localization. The document outlines the process for localizing WPF applications using the LocBaml tool to extract and replace resources. It also discusses unit testing WPF applications using the NUnit framework, including test design, assertions and attributes. The document notes advantages and limitations of both unit testing and test-driven development (TDD).
Test-driven development (TDD) involves writing unit tests before writing code to help ensure code quality and avoid omitted tests. The document discusses the NUnit testing framework for .NET, which uses attributes to identify test fixtures, methods, and setup/teardown functionality. It also covers how to write tests using assertions and run tests using the NUnit GUI or console applications.
This document provides an introduction to unit testing using Nunit. It discusses what unit testing is, the benefits of unit testing, and what is needed to perform unit testing. It then focuses on Nunit, explaining that Nunit is a unit testing framework for .NET languages. It provides hands-on examples of creating a test project using Nunit to test methods in a BMI calculator application. It demonstrates running tests using both the Nunit graphical user interface and console modes.
● What is Unit Testing?
● Benefits
● What is Test Driven Development?
● What is Behavior Driven Development?
● Categories of (Unit) Tests / Software Testing
Pyramid, Frameworks
● C++, Java, .NET, Perl, PHP frameworks
● Unit-testing Zend Framework application
Unit Testing - Nakov's Talk @ VarnaConf 2013Svetlin Nakov
Unit testing involves writing small pieces of code called unit tests to test specific areas of functionality in code. A unit test verifies that a particular function or method works as expected. Frameworks like JUnit provide annotations and assertions to help write and organize unit tests. Unit tests should be written by developers and stored alongside the code being tested to ensure code quality.
Unit testing involves writing small pieces of code called unit tests to test specific areas of functionality in code. A unit test verifies that a particular function or method works as expected. Frameworks like JUnit provide annotations and assertions to help write and organize unit tests. Unit tests should be written by developers and stored alongside the code being tested to ensure code quality.
JUnit is an open source framework for writing and running tests in Java. It allows developers to write unit tests as they develop code to help find and fix bugs. JUnit provides tools to help keep tests organized, run tests automatically, and see results visually. Tests using JUnit isolate areas of code being tested and help ensure new code changes don't break existing code.
Are you involved in testing or QA on projects in Unity? Richard will provide a quick overview of the state of Unity for all things testing related, and then invite you to share your stories of success, failure, pain, and glory. Learn from your fellow developers and give feedback on how Unity could help you hold your projects to a higher quality standard.
Richard Fine - Unity Technologies
Beginners - Get Started With Unit Testing in .NETBaskar K
Beginners - Get started with unit testing in .NET. Introduction to unit testing and mocking.. List of unit testing frameworks available in .NET - NUnit, xUnit.net, Visual Studio unit test framework. List of mocking frameworks available in .NET - Moq, Rhino Mocks, FakeItEasy, NSubstitue, JustMock, and TypeMock. Introduction to Visual Studio Unit Testing Framework, NUnit and xUnit.net.
This document discusses how to set up unit testing with xUnit and .NET Core using Visual Studio Code. It includes steps to:
1. Download and install the .NET SDK and Visual Studio Code.
2. Create a unit test project in Visual Studio Code and add the xUnit testing framework package via NuGet.
3. Write the first test and parametrized test, using xUnit's Fact and Theory attributes to test methods in the project.
4. Execute the tests directly from Visual Studio Code.
JUnit is an open source unit testing framework for Java applications. It was written by Erich Gamma and Kent Beck and is part of the xUnit family of unit testing frameworks. JUnit allows developers to write test cases that test individual classes and methods. These test cases can be grouped into test suites and run automatically to ensure code meets requirements and to catch errors early in the development process. JUnit includes annotations like @Test to identify test methods and asserts to validate method output. It integrates with development tools like Eclipse to provide test results.
Unit testing and acceptance testing have different purposes:
- Unit testing is done by developers during development to test individual code units and find faults, while acceptance testing is done after development and specified by customers to test that system meets requirements.
- Unit tests are automated and test small parts of code, while acceptance tests test larger parts of the system or whole system and are often manual.
- Unit tests are written before code is developed, while acceptance tests are written after code is developed to verify it meets customer needs.
This document provides a tutorial for using Ranorex to test the GUI of a SimpleCalculator application. It discusses:
1. Installing and setting up Ranorex, which allows simulating user interactions for GUI testing.
2. Adding a GUITester class to an existing SimpleCalculator project and referencing the Ranorex library.
3. Writing tests that use Ranorex methods to control the mouse, interact with calculator controls, and assert the result is correct.
4. Running the GUI tests using the NUnit test runner to automatically simulate user interactions and verify functionality.
Sixth chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Understanding how to drive final character animation poses through animation blueprints and blend spaces
- Learning how to configure, combine and play sound assets
- Understanding the modular nature of particle effects in Unreal Engine
Unreal Engine Basics 05 - User InterfaceNick Pruehs
Fifth chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Understanding the difference between Unreal’s UI frameworks Slate and UMG
- Learning how to create basic and complex user interfaces in UMG
- Learning how to build a simple main menu
Forth chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Getting familiar with behavior trees in general
- Learning how to set up and use behavior trees in Unreal Engine
- Learning about the very basics of the Unreal Engine navigation system
Third chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Learning how to expose class fields and functions to blueprints
- Writing basic Unreal gameplay code, such as spawning actors, accessing components and listening for events
- Getting familiar with gameplay concepts in the context of Unreal, such as damage and collision
Second chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Getting familiar with the Unreal Level Editor
- Learning how to bind and handle player keyboard and mouse input
- Understanding character movement properties and functions
Unreal Engine Basics 01 - Game FrameworkNick Pruehs
First chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Getting familiar with Unreal Engine as a technology, framework and toolset
- Learning the basics about writing Unreal Engine C++ code
This document provides an overview of version control systems and how to use Git. It discusses local and centralized version control before focusing on distributed version control with Git. The document then demonstrates how to install Git and SourceTree, create a GitHub account, add and commit files to a repository, pull and push changes, view history and more. It also covers advanced Git topics like branching, merging, and divergent histories.
Tool Development 10 - MVVM, Tool ChainsNick Pruehs
Chapter 10 of the lecture Tool Development taught at SAE Institute Hamburg.
Introduction to the MVVM pattern and advanced data binding concepts such as data conversion and data validation.
Essentials of Automations: Exploring Attributes & Automation ParametersSafe Software
Building automations in FME Flow can save time, money, and help businesses scale by eliminating data silos and providing data to stakeholders in real-time. One essential component to orchestrating complex automations is the use of attributes & automation parameters (both formerly known as “keys”). In fact, it’s unlikely you’ll ever build an Automation without using these components, but what exactly are they?
Attributes & automation parameters enable the automation author to pass data values from one automation component to the next. During this webinar, our FME Flow Specialists will cover leveraging the three types of these output attributes & parameters in FME Flow: Event, Custom, and Automation. As a bonus, they’ll also be making use of the Split-Merge Block functionality.
You’ll leave this webinar with a better understanding of how to maximize the potential of automations by making use of attributes & automation parameters, with the ultimate goal of setting your enterprise integration workflows up on autopilot.
inQuba Webinar Mastering Customer Journey Management with Dr Graham HillLizaNolte
HERE IS YOUR WEBINAR CONTENT! 'Mastering Customer Journey Management with Dr. Graham Hill'. We hope you find the webinar recording both insightful and enjoyable.
In this webinar, we explored essential aspects of Customer Journey Management and personalization. Here’s a summary of the key insights and topics discussed:
Key Takeaways:
Understanding the Customer Journey: Dr. Hill emphasized the importance of mapping and understanding the complete customer journey to identify touchpoints and opportunities for improvement.
Personalization Strategies: We discussed how to leverage data and insights to create personalized experiences that resonate with customers.
Technology Integration: Insights were shared on how inQuba’s advanced technology can streamline customer interactions and drive operational efficiency.
What is an RPA CoE? Session 1 – CoE VisionDianaGray10
In the first session, we will review the organization's vision and how this has an impact on the COE Structure.
Topics covered:
• The role of a steering committee
• How do the organization’s priorities determine CoE Structure?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
High performance Serverless Java on AWS- GoTo Amsterdam 2024Vadym Kazulkin
Java is for many years one of the most popular programming languages, but it used to have hard times in the Serverless community. Java is known for its high cold start times and high memory footprint, comparing to other programming languages like Node.js and Python. In this talk I'll look at the general best practices and techniques we can use to decrease memory consumption, cold start times for Java Serverless development on AWS including GraalVM (Native Image) and AWS own offering SnapStart based on Firecracker microVM snapshot and restore and CRaC (Coordinated Restore at Checkpoint) runtime hooks. I'll also provide a lot of benchmarking on Lambda functions trying out various deployment package sizes, Lambda memory settings, Java compilation options and HTTP (a)synchronous clients and measure their impact on cold and warm start times.
This talk will cover ScyllaDB Architecture from the cluster-level view and zoom in on data distribution and internal node architecture. In the process, we will learn the secret sauce used to get ScyllaDB's high availability and superior performance. We will also touch on the upcoming changes to ScyllaDB architecture, moving to strongly consistent metadata and tablets.
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
Freshworks Rethinks NoSQL for Rapid Scaling & Cost-EfficiencyScyllaDB
Freshworks creates AI-boosted business software that helps employees work more efficiently and effectively. Managing data across multiple RDBMS and NoSQL databases was already a challenge at their current scale. To prepare for 10X growth, they knew it was time to rethink their database strategy. Learn how they architected a solution that would simplify scaling while keeping costs under control.
Taking AI to the Next Level in Manufacturing.pdfssuserfac0301
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
2. Objectives
• To learn how to properly set up automated testing for your games
• To get an overview of common unit testing frameworks and tools
2 / 49
3. Unit Testing
• Method by which individual units of source code are tested to
determine if they are fit for use
• Unit of source code is the smallest testable part of an application
(e.g. method)
• Created by programmers during the development process
• Usually split up into three parts:
▪ Arrange
▪ Act
▪ Assert
3 / 49
4. Unit Testing
• Ideally, each test case is independent from the others
• Substitutes such as mocks can be used to assist testing a module in
isolation (e.g. database, mails)
• Can be implemented as part of automated builds
4 / 49
5. Unit Testing with NUnit
• Unit Testing framework for all .NET languages
• Initially ported from JUnit
• Written entirely in C#
• Stand-alone tools and R# integration
5 / 49
6. Setting up NUnit
1. Add new Class Library project to the solution.
2. Add reference to bin/framework/nunit.framework.dll.
6 / 49
11. Expected Exceptions
C#
11 / 49
[Test]
[ExpectedException(typeof(ArgumentOutOfRangeException))]
public void TestNegativeWidth()
{
Map map = new Map(-10, 20);
}
12. SetUp and TearDown
C#
12 / 49
public class MapTest
{
private const int Height = 16;
private const int Width = 32;
private Map map;
[SetUp]
public void SetUp()
{
this.map = new Map(Width, Height);
}
[Test]
public void TestTileIndexer()
{
// Arrange.
const int X = 1;
const int Y = 2;
// Act.
var mapTile = new MapTile(X, Y, "Desert");
this.map[X, Y] = mapTile;
// Assert.
Assert.AreEqual(mapTile, this.map[X, Y]);
}
}
15. NUnit Console
Console Output
15 / 49
D:DevRepositoriesSAE-ToolDevelopmentVendorNUnit-2.6.3bin>nunit-console-x86.exe
......SourceLevelEditor.TestsbinDebugLevelEditor.Tests.dll
NUnit-Console version 2.6.3.13283
Copyright (C) 2002-2012 Charlie Poole.
Copyright (C) 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov.
Copyright (C) 2000-2002 Philip Craig.
All Rights Reserved.
Runtime Environment -
OS Version: Microsoft Windows NT 6.2.9200.0
CLR Version: 2.0.50727.7905 ( Net 3.5 )
ProcessModel: Default DomainUsage: Single
Execution Runtime: net-3.5
...
Tests run: 3, Errors: 0, Failures: 0, Inconclusive: 0, Time: 0.046059608766156 seconds
Not run: 0, Invalid: 0, Ignored: 0, Skipped: 0
18. Advantages of Unit Testing
✓ Finds problems early
▪ Test Driven Development
✓ Facilitates changes
▪ Can be run before each commit or build
▪ In combination with source control, can identify the revision (and
originator) that broke the code
18 / 49
19. Limits of Unit Testing
• Won’t catch every error in the program
• Won’t catch integration errors
• Combinatorial problem
▪ Every boolean decision statement requires at least two tests
• Can’t test non-deterministic or concurrency problems
19 / 49
20. Limits of Unit Testing
• Setting up realistic and useful tests is a challenge
• Test case failures need to be reviewed daily and addressed
immediately
• Embedded system software presents a unique challenge
▪ Software is being developed on a different platform than the one
it will eventually run on
20 / 49
21. Test Driven Development
1. Write an (initially failing) automated test case that defines a desired
improvement or new function.
2. Produce the minimum amount of code required to pass that test.
3. Refactor the new code to acceptable standards.
21 / 49
22. Advantages of TDD
✓ Client-first development
✓ Taking small steps
✓ All written code is covered by at least one test
✓ Can lead to more modularized code
22 / 49
23. Limits of TDD
• Support of the entire team is essential
• Test are typically created by the developer who is writing the code
being tested, and may therefore share the same blind spots with the
code
• Maintenance overhead
23 / 49
24. Unity Test Tools
• Released by Unity in December 2013
• Partly integrated since Unity 5.3
• Completely open-source
• Available on the Asset Store and Bitbucket
• Based on NUnit
24 / 49
25. Unity Test Tools
• Unit tests are discovered using reflections
• Can be run automatically on recompile
26 / 49
27. Unity Test Tools
• Integration tests allow testing integration of components, game
objects and assets
• Each test suite is a separate scene containing a game object with a
TestRunner attached
• Each test is a separate game object with a TestComponent attached
▪ Everything beneath that object in the hierarchy is considered to
belong to that test
• The CallTesting behaviour can modify the test result without having
to actually write additional code
28 / 49
28. Unity Test Tools
When you run the tests, the following steps are performed, in order:
1. Play mode is enabled.
2. The first or next test object is activated.
3. Wait until the test has finished (or a timeout has occurred).
4. The current active test gets deactivated.
5. If there are more tests in the queue, go to step 2.
6. Report results and finish test run.
29 / 49
30. Unity Test Tools
• Assertions check invariants – conditions you expect to be always
true
• You can specify when to check these conditions
• If any assertion fails, an exception is thrown
• You can automatically cause the game in that case by enabling
Error pause in the Unity console window
31 / 49
32. Unity Test Tools
Just like with NUnit, Unity integration tests can be run from command
line:
"C:Program Files (x86)UnityEditorUnity.exe“
–batchmode
-projectPath D:TempUnityTest
-executeMethod UnityTest.Batch.RunIntegrationTests
-testscenes=NpruehsScene
-targetPlatform=StandaloneWindows
-resultsFileDirectory=D:TempResults
33 / 49
33. NSubstitute
• Creates substitutes for interfaces
• Saves you from having to use stubs, mocks, spies, test doubles
34 / 49
public interface ICalculator
{
int Add(int a, int b);
}
34. NSubstitute
• Creates substitutes for interfaces
• Saves you from having to use stubs, mocks, spies, test doubles
35 / 49
ICalculator calculator = Substitute.For<ICalculator>();
35. NSubstitute
• Allows you set up return values to method calls.
• Great for mocking database connections or email plugins.
36 / 49
calculator.Add(1, 2).Returns(3);
37. Unit Testing in C++
• googletest is a platform-independent framework for writing C++ tests
• Used for a variety of Google projects, including Chromium and
Google Protocol Buffers
• googlemock allows you to write and mock C++ mock classes
38 / 49
38. Unit Testing in C++
1. Create a new Win32 console application.
2. Add the projects you want to test to the additional include
directories.
3. Add the gtest root folder and gtest-a.b.c/include folder to the
additional include directories.
4. In your test source file, #include "src/gtest-all.cc“.
5. Provide a main entry point like this:
39 / 49
GTEST_API_ int main(int argc, char
**argv)
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
39. Unit Testing in C++
Test method signatures are automatically generated by the TEST
macro:
40 / 49
TEST(TestSuiteName, TestName)
{
// Arrange.
// Act.
// Assert.
}
40. Unit Testing in C++
Assertions are made using macros as well.
41 / 49
TEST(TestArithmetic, TestAdd)
{
// Arrange.
auto i = 3;
auto j = 4;
// Act.
auto k = i + j;
// Assert.
EXPECT_EQ(7, k);
}
41. Unit Testing in C++
Run the tests by just starting the console application…
42 / 49
42. Unit Testing in C++
… or by using the UI of gtest-gbar.
43 / 49
43. Unit Testing in C++
googlemock provides macros for mocking methods.
44 / 49
#pragma once
#include "gmock/gmock.h"
class ICalculator
{
public:
virtual int Add(int x, int y) = 0;
};
class MockCalculator : public ICalculator
{
public:
MOCK_METHOD2(Add, int(int x, int y));
};
44. Unit Testing in C++
Just like NSubstitute, it allows you to specify results:
45 / 49
#include "src/gtest-all.cc"
#include "src/gmock-all.cc"
#include "MockCalculator.h"
using ::testing::Return;
TEST(TestArithmetic, TestCalculator)
{
// Arrange.
MockCalculator calculator;
EXPECT_CALL(calculator, Add(3, 4))
.WillRepeatedly(Return(7));
// Act.
auto sum = calculator.Add(3, 4);
// Assert.
EXPECT_EQ(7, sum);
}
49. 5 Minute Review Session
• What are unit tests?
• What are the main advantages of unit testing?
• What are the most important limits of unit tests?
• Explain the process of Test Driven Development!
• What are the upsides and downsides of TDD?
• What are integration tests?
• How do you test functionality that depends on external
communication (e.g. database, mails)?