Entity Component System - a different approach to game and app development

Oct 1, 20180 likes735 views

Presentation delivered at CodeStar Night, discussing ECS (Entity Component System) as a different approach for game and app development.

Entity Component System - a
different approach to game /
application development
Maxim Zaks @iceX33

Object Oriented Programming
SOLID Principals

Entity Component System - a different approach to game and app development

public class Rectangle
{
public double Width { get; set; }
public double Height { get; set; }
}

public class AreaCalculator
{
public double Area(Rectangle[] shapes)
{
double area = 0;
foreach (var shape in shapes)
{
area += shape.Width*shape.Height;
}
return area;
}
}

public double Area(object[] shapes)
{
double area = 0;
foreach (var shape in shapes)
{
if (shape is Rectangle)
{
Rectangle rectangle = (Rectangle) shape;
area += rectangle.Width*rectangle.Height;
}
else
{
Circle circle = (Circle)shape;
area += circle.Radius * circle.Radius * Math.PI;
}
}
return area;
}

public abstract class Shape
{
public abstract double Area();
}

public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public override double Area()
{
return Width*Height;
}
}
public class Circle : Shape
{
public double Radius { get; set; }
public override double Area()
{
return Radius*Radius*Math.PI;
}
}

public double Area(Shape[] shapes)
{
double area = 0;
foreach (var shape in shapes)
{
area += shape.Area();
}
return area;
}

Wassily Kandinsky: Komposition VIII, 1923. Öl auf Leinwand

rectangleArea :: Float -> Float -> Float
rectangleArea a b = a * b

data Shape = Circle Float | Rectangle Float Float
area :: Shape -> Float
area (Circle r) = pi * r * r
area (Rectangle width height) = width * height
sum $ map area [(Circle 5), (Rectangle 2 3), (Circle 7)]

struct RadiusComponent {
float value;
}
struct HeightComponent {
float value;
}
struct WidthComponent {
float value;
}
struct AreaComponent {
float value;
}

Compute Circle Area System
• get all entities which have RadiusComponent
• set computed AreaComponent on this entity

Compute Rectangle Area System
• get all entities which have WidthComponent and HeightComponent
• set computed AreaComponent on entity

Compute Sum of Areas System
• get all entities which have AreaComponent
• compute a sum of values
• do something with it

Systems query for data / get data
injected

Systems don't return
They change sate, or perform side effects

Systems don't care about the whole
picture

Elephant and the blind men
https://en.wikipedia.org/wiki/Blindmenandanelephant

Deﬁne better query
• get all entities which have RadiusComponent and don't have
AreaComponent

What happens when value is changed by
outside interaction?

Solutions
• Introduce special components for outside interactions
• Use an ECS which supports reactive systems

Component events
• Added
• Removed
• Replaced

ECS vs. FP
• ECS is built for interactive computations
• mutation is ok
• side effects are ok

Clean architecture
• SOLID in regards to ECS

If you want to know more
• Have a look at work Unity3D does https://unity3d.com/unity/
features/job-system-ECS
• Mike Acton @ CppCon 2014 https://www.youtube.com/watch?
v=rX0ItVEVjHc
• Catherine West @ Rust Conf 2018 https://www.youtube.com/
watch?v=aKLntZcp27M
• ECS Lab Discord Server https://discord.gg/eCpyZSg

Thank you!
Maxim Zaks @iceX33
Questions?

Entity-Component-System (ECS) is a distributed and compositional architectural design pattern that is mostly used in game development. Elixir is a dynamic, functional language built on top of the Erlang VM designed for building scalable and maintainable applications. In this talk, discover how we can use both ECS and Elixir in a novel approach to structure our programs beyond the traditional OO/inheritance paradigm.

Style & Design Principles 03 - Component-Based Entity SystemsNick Pruehs

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.

React jsJai Santhosh

This document introduces React, describing it as a JavaScript library for building user interfaces by rendering components rather than mutating the DOM directly. It discusses how React uses a virtual DOM for fast re-rendering, building components instead of templates, and the use of JSX syntax to write HTML-like code. Components have state and props, and the whole app re-renders when state changes to guarantee updates.

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.

Reactjs Neha Sharma

The Benefits of Using React JS for Web Development!Baharika Sopori

React JS is a popular library for building user interfaces that was created by Facebook in 2011. It allows developers to create reusable components to build dynamic and interactive applications. React uses a virtual DOM for rendering to improve performance and make code more consistent and stable. It also supports code reuse through components that can be built upon and manipulated through their internal logic.

Events and Listeners in Androidma-polimi

ReactJS presentationThanh Tuong

이승재, 일정대로 출시하기 왜 & 어떻게: 개발자를 위한 제작진행개론, NDC2017devCAT Studio, NEXON

Introduction to react_jsMicroPyramid .

React is a JavaScript library for building user interfaces. It was created by Facebook and is best for building dynamic websites like chat applications. React uses a virtual DOM for efficiently updating the view after data changes. Components are the building blocks of React and can contain state and props. The document provides an example of a simple component class and demonstrates how to add state and props. It also includes links to example code and MicroPyramid's social media profiles.

앱 디자인 시작하기Sangho Lee

앱 디자인 시작하기 Starting App Design 2014. 9. 11 이 강의는 앱 디자인을 시작하는 디자이너를 위한 강의입니다. 강의 순서 1. 강의에 들어가며 2. 앱 디자인 시작하기 3. Case Study 4. 작업하기 5. 마치며 - 강의 페이지: http://isangho.com/study/appdesign - SlideShare: https://www.slideshare.net/SanghoLee1/ss-38908104 - 비트코인 기부하기: http://daramghaus.com/donate/bitcoin - 이메일: [email protected]

Getting Started with React.jsSmile Gupta

Spring FrameworkNexThoughts Technologies

Spring Framework 4 is an open source application framework for Java. It was created to make enterprise Java development easier by promoting best practices. Some key features of Spring include dependency injection for loose coupling, declarative transactions, and aspect oriented programming for separation of concerns. The Spring framework uses an inversion of control container and aspect-oriented programming to configure and manage objects.

React JS and why it's awesomeAndrew Hull

This document provides an overview of React, including initial reactions to it, fundamental concepts like components and one-way data flow, and how the virtual DOM works. Some key points covered include: - Initial reactions to React were mixed, with some finding it "ugly" but others seeing benefits like separation of concerns with components. - Everything in React is a component, with data flowing in one direction from parent to child via props. State is mutable within a component. - By using a virtual DOM, React can efficiently update the real DOM by only making necessary changes, keeping the interface fast and pure.

Solid principlesDeclan Whelan

The document discusses the SOLID principles of object-oriented design, which are Single Responsibility Principle, Open Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. For each principle, it provides an example of how to apply the principle correctly and how violations of the principle can occur if it is not followed. It also lists some recommended reading materials on software design patterns and principles.

Clean Codeswaraj Patil

Flux architectureBoyan Mihaylov

Flux is an architecture for building JavaScript applications that promotes unidirectional data flow. The key elements of Flux are the Dispatcher, Stores, and Views. The Dispatcher centralizes the flow of data and dispatches actions to the Stores. Stores contain application state and logic. Views are React components that subscribe to Stores and listen for changes to re-render. Actions define activities and are dispatched by action creators through the Dispatcher to the Stores to update state.

A Spring Data’s Guide to PersistenceVMware Tanzu

Introduction to Facebook ReactMitch Chen

The document provides biographical information about Mitch Chen, an expert in front-end engineering with 8 years of experience. It notes that he is a JavaScript expert and React/Flux enthusiast who has worked as a senior frontend manager and software engineer at several companies. The document also lists Mitch Chen's blog and Facebook group on React and provides a brief introduction to React, highlighting how it renders user interfaces, is battle-tested on large sites, uses components instead of templates, and employs a virtual DOM.

React stateDucat

State is managed within the component in which variables declared in function body. State can be changed. State can be accessed using “useState” Hook in functional components and “this.state” in class components. Hook is a new feature in react. To use this expression it’s essential to have good understanding of class components. State hold information that used for UI by browser. https://www.ducatindia.com/javatraining/

React and reduxMystic Coders, LLC

This document provides an overview of React and Redux. It introduces React as a component-based library for building user interfaces using JavaScript and JSX. Key aspects of React include its lifecycle methods, use of a virtual DOM for fast updates, and functional stateless components. Redux is introduced as a state management library that uses a single immutable store with actions and reducers. It follows the Flux architecture pattern without a dispatcher. Hands-on demos are provided for key React and Redux concepts. Resources for further learning are also listed.

React js t2 - jsxJainul Musani

JSX is an extension to JavaScript that allows writing HTML-like code in React files. It combines HTML and JavaScript together, making it easier to manage state changes and events in the DOM. Expressions can be embedded in JSX using curly braces. Files with the .jsx extension contain JSX code, while .js files contain plain JavaScript. The transpiler converts JSX into standard JavaScript that browsers can understand.

Its time to React.jsRitesh Mehrotra

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

LinqVishwa Mohan

이은석 마비노기 영웅전 포스트모템 2부 (kgc 버전)drandom

[Final] ReactJS presentation洪鹏发

React JS is a JavaScript library for building user interfaces. It uses a virtual DOM to efficiently update the real DOM and render user interfaces from components. Components are reusable pieces of UI that accept input data via properties but maintain private state data. The lifecycle of a component involves initialization, updating due to state/prop changes, and unmounting. React uses a single-directional data flow and the concept of components makes code modular and reusable.

React JSSoftware Infrastructure

React is an open source JavaScript library for building user interfaces. It was created by Jordan Walke at Facebook in 2011 and is now maintained by Facebook, Instagram, and a community of developers. Major companies like Facebook, Netflix, Instagram, Khan Academy, and PayPal use React to build their interfaces. React uses a virtual DOM for faster rendering and makes components that manage their own state. It uses JSX syntax and a one-way data flow that is declarative and composable.

affine transformation for computer graphicsDrSUGANYADEVIK

Graphics toolkits take geometry as input and output pixel data. They handle rendering details. OpenGL is an open standard graphics toolkit that provides functions for modeling, rendering, and manipulating the framebuffer. It is portable, hardware supported, and simple to program. In the coming weeks, the document will cover the math and algorithms behind OpenGL and how to access them. Coordinate systems are fundamental to graphics and describe point locations. Transformations convert between systems.

Scene Graphs & Component Based Game EnginesBryan Duggan

More Related Content

What's hot (20)

이승재, 일정대로 출시하기 왜 & 어떻게: 개발자를 위한 제작진행개론, NDC2017devCAT Studio, NEXON

Introduction to react_jsMicroPyramid .

앱 디자인 시작하기Sangho Lee

Getting Started with React.jsSmile Gupta

Spring FrameworkNexThoughts Technologies

React JS and why it's awesomeAndrew Hull

Solid principlesDeclan Whelan

Clean Codeswaraj Patil

Flux architectureBoyan Mihaylov

A Spring Data’s Guide to PersistenceVMware Tanzu

Introduction to Facebook ReactMitch Chen

React stateDucat

React and reduxMystic Coders, LLC

React js t2 - jsxJainul Musani

Its time to React.jsRitesh Mehrotra

ECS architecture with Unity by example - Unite Europe 2016Simon Schmid

LinqVishwa Mohan

이은석 마비노기 영웅전 포스트모템 2부 (kgc 버전)drandom

[Final] ReactJS presentation洪鹏发

React JSSoftware Infrastructure

이승재, 일정대로 출시하기 왜 & 어떻게: 개발자를 위한 제작진행개론, NDC2017devCAT Studio, NEXON

Introduction to react_jsMicroPyramid .

앱 디자인 시작하기Sangho Lee

Getting Started with React.jsSmile Gupta

Spring FrameworkNexThoughts Technologies

React JS and why it's awesomeAndrew Hull

Solid principlesDeclan Whelan

Clean Codeswaraj Patil

Flux architectureBoyan Mihaylov

A Spring Data’s Guide to PersistenceVMware Tanzu

Introduction to Facebook ReactMitch Chen

React stateDucat

React and reduxMystic Coders, LLC

React js t2 - jsxJainul Musani

Its time to React.jsRitesh Mehrotra

ECS architecture with Unity by example - Unite Europe 2016Simon Schmid

LinqVishwa Mohan

이은석 마비노기 영웅전 포스트모템 2부 (kgc 버전)drandom

[Final] ReactJS presentation洪鹏发

React JSSoftware Infrastructure

Similar to Entity Component System - a different approach to game and app development (20)

affine transformation for computer graphicsDrSUGANYADEVIK

Scene Graphs & Component Based Game EnginesBryan Duggan

Software Engineering for Indies #gcmuc18Andreas Pohl

The document discusses various software engineering principles and best practices including SOLID principles, design patterns, technical debt, and skill development. It provides code examples demonstrating SOLID principles like single responsibility, open/closed, and Liskov substitution. Interface segregation and dependency inversion are illustrated through worker classes. The document emphasizes ongoing skills growth and managing technical debt.

1- Create a class called Point that has two instance variables, defi.pdfjeeteshmalani1

1- Create a class called Point that has two instance variables, defined as private, as follows: An x coordinate and a y coordinate of type integer. a) Write two constructors for the Point class as follows: A default constructor that sets the class instance variables to zero and a constructor that receives two integer values and sets the instance variables to them. b) Write the set and get methods for the Point class to set and return the values of its instance variables. c) Write a toString() method for the Point class that prints the class name (Point) and the value of its instance variables. 2- Create three classes called Circle, Rectangle and Square with the following properties: - The Circle class has two instance variables – a position of type Point (the class that you just created above) and a radius of type double. The instance variables position and radius specify the position of the center and radius of the circle, respectively. - The Rectangle class has three instance variables – a position of type Point (the class that you just created above), a length and a width of type double. The instance variables position, length and width specify the position of the top left corner, length and width of the rectangle, respectively. - The Square class has two instance variables – a position of type Point (the class that you just created above) and a lengthof type double. The instance variables position andlength specify the position of the top left corner and length of the square, respectively. For each of the Circle, Rectangle andSquare classes do the following: a) Define the instance variables as private. b) Write two constructors for each class as follows: A default constructor that sets the instance variables to zero and a constructor that receives values for the instance variables and sets them. c) Write the set and get methods for each class to set and return the values of their instance variables. For example, one of the get methods would return a Point. d) Write a toString() method for each class that prints the class name (Circle, Rectangle or Square) and the value of its instance variables. e) Write two methods called getPerimeter() and getArea() for each class, which calculate and return the perimeter and area of the class, respectively. For example, the getArea() method of the Square class returns the area of the Square object. 3- Test the above classes by writing a class called GeometricTest.java that does the following: - Creates instances of the Circle, Rectangle and Square classes as follows: - Circle: positioned at x = 7, y = 3 and the radius = 4.5. - Rectangle: positioned at x = 3, y = -1 and the length = 4.0 and width = 6.0. - Square: positioned at x = 5, y = 8 and the length = 2.0. - Prints each of the above objects. - Changes the length of the Square object to 5.0. - Prints the perimeter and area of each of each of the above objects. - Compares the x coordinates of the Square and Rectangle classes and prints a message spec.

Building a turn-based game prototype using ECS - Unite Copenhagen 2019Unity Technologies

Spark Summit EU talk by Herman van HovellSpark Summit

This document provides a summary of Apache Spark's Catalyst optimizer: - Catalyst optimizes user programs expressed using SQL, DataFrames, or Datasets by automatically finding the most efficient execution plan. It represents programs as trees and applies transformations to these trees. - The key steps in Catalyst are analysis, logical optimization, physical planning, and code generation. Analysis resolves the logical plan using the catalog. Logical optimization applies rule-based transformations. Physical planning selects physical operators and ensures requirements are met. - Transformations are implemented using partial functions that match and replace patterns in trees. Multiple rules are combined using a rule executor. Strategies transform the logical plan to physical operators. The planner also

Leveraging ArcGIS Online for Public Utility DataTrue North Geographic Technologies

Code level change propagation in virtual platformHaiderAli650468

The document discusses code-level change propagation in a virtual platform for managing software variants. It describes two operators - SynchronizeAsset and IntegrateAsset - that were developed to address issues with existing non-code based propagation. SynchronizeAsset allows two-way synchronization of code changes between assets while wrapping changes in presence conditions and tracking variation points. IntegrateAsset allows one-way propagation of changes from a source to target asset, also wrapping changes in presence conditions. The effectiveness of these operators is evaluated in a developer study where tasks are timed both with and without the operators.

Cleaner Code - CodeStock 2019 EditionDave Fancher

Clean code is code that is easy to read, understand and maintain. It has certain objective characteristics like having single responsibility, avoiding side effects and limiting parameters. Clean code favors small, pure functions over statements with side effects. Functional programming principles like immutability and avoiding null also contribute to clean code. Data structures should expose just data while objects encapsulate data and expose functions to operate on it. Overall clean code follows conventions that make the intent of the code clear.

Les nouveautés de C# 6Microsoft

Programming Augmented Reality - Xamarin EvolveFrank Krueger

【Unite 2017 Tokyo】C#ジョブシステムによるモバイルゲームのパフォーマンス向上テクニックUnity Technologies Japan K.K.

Lecture 9-onlinelifebreath

This document discusses 3D graphics and transformations. It begins by introducing the goals of 3D graphics as producing 2D images from a mathematically described 3D environment. It then covers coordinate systems, affine transformations like translation, rotation, and scaling, and how they are represented by matrices. Homogeneous coordinates are introduced to represent transformations uniformly with matrices. Quaternions are also mentioned as an alternative to rotation matrices. The document provides examples of 3D translation, rotation, and issues around representing rotations.

Oops conceptbaabtra.com - No. 1 supplier of quality freshers

OOP.pptxsaifnasir3

This lecture covers overloaded functions, constant objects and member functions, friend functions, the this pointer, static data members, and composition with objects as members of classes. Specifically, it discusses: 1) Overloading constructors to initialize objects with different values. 2) Using const to declare objects, member functions, and data members as constant to prevent modification. 3) Defining member functions outside the class and using the scope resolution operator. 4) Passing objects as arguments to other functions and returning objects. 5) Using the this pointer implicitly and explicitly to access members of the current object. 6) Declaring static data members that are shared across all objects of a class.

ParametersJames Brotsos

This document discusses parameters and return values in Java methods. It provides examples of parameterized methods that take int, double, and String parameters. These include methods that draw lines and boxes of stars of varying lengths/sizes. The document also covers returning values from methods, including examples using Math class methods. Common errors around not storing return values are discussed.

Autonomous Systems for Optimization and ControlIvo Andreev

Autonomous systems have the ability to operate and make decisions driven by goals without human interaction and have a myriad of applications in the industrial landscape. Autonomous systems are a highly comprehensive mix of sensor technologies, data analytics, simulations, digital twins and predictive algorithms that all combined allow the implementation of optimal strategies with speed and precision beyond human abilities. In the session we will review the general principles, overview existing solutions and discuss how you can design and implement an effective autonomous system of your own. Balancing exploration and exploitation is a key challenge in reinforcement learning, and there are various strategies to address it. The choice of strategy depends on the specific problem, computational resources, and the characteristics of the environment. The advancements in LLM capabilities have opened new avenues for the development of autonomous agents. By focusing on multi-agent collaboration and a robust engineering framework, industries can harness the power of these technologies to automate complex tasks effectively.

Refactoring - improving the smell of your codevmandrychenko

The document discusses refactoring code to improve its quality without changing its external behavior. It defines refactoring and explains why it is important to make code easier to understand and maintain over time. It provides examples of "code smells" that indicate needs for refactoring and discusses techniques for refactoring code, such as renaming methods, extracting interfaces, replacing conditionals with polymorphism, and using tools to help with the process.

Object - Oriented Programming: InheritanceAndy Juan Sarango Veliz

The document discusses object-oriented programming concepts like inheritance, subclasses, and superclasses. It provides examples of inheritance hierarchies for different classes like Shapes, CommunityMembers, and BankAccounts. The key points are: - Inheritance allows subclasses to inherit and customize behaviors from superclasses for code reusability. - Subclasses are more specialized groups of objects that inherit data and behaviors from their superclasses. - Java supports single inheritance but not multiple inheritance. - Relationships between superclasses and subclasses form a hierarchical tree structure. - Access modifiers like private and protected determine whether subclass instances can access members of superclasses.

Chapter i(introduction to java)Chhom Karath

Java is a cross-platform language originally developed by James Gosling at Sun Microsystems. It enables writing programs for many operating systems using a C/C++-like syntax but with a simpler object model and fewer low-level facilities. Java programs are compiled to bytecode that can run on any Java Virtual Machine (JVM) regardless of computer architecture. Common Java development tools include Eclipse and NetBeans integrated development environments.

affine transformation for computer graphicsDrSUGANYADEVIK

Scene Graphs & Component Based Game EnginesBryan Duggan

Software Engineering for Indies #gcmuc18Andreas Pohl

1- Create a class called Point that has two instance variables, defi.pdfjeeteshmalani1

Building a turn-based game prototype using ECS - Unite Copenhagen 2019Unity Technologies

Spark Summit EU talk by Herman van HovellSpark Summit

Leveraging ArcGIS Online for Public Utility DataTrue North Geographic Technologies

Code level change propagation in virtual platformHaiderAli650468

Cleaner Code - CodeStock 2019 EditionDave Fancher

Les nouveautés de C# 6Microsoft

Programming Augmented Reality - Xamarin EvolveFrank Krueger

【Unite 2017 Tokyo】C#ジョブシステムによるモバイルゲームのパフォーマンス向上テクニックUnity Technologies Japan K.K.

Lecture 9-onlinelifebreath

Oops conceptbaabtra.com - No. 1 supplier of quality freshers

OOP.pptxsaifnasir3

ParametersJames Brotsos

Autonomous Systems for Optimization and ControlIvo Andreev

Refactoring - improving the smell of your codevmandrychenko

Object - Oriented Programming: InheritanceAndy Juan Sarango Veliz

Chapter i(introduction to java)Chhom Karath

More from Maxim Zaks (20)

Nitty Gritty of Data SerialisationMaxim Zaks

The document discusses data serialization formats and techniques. It covers basic data types like bits, bytes, integers of various sizes, floating point numbers, strings, and structured data representations like tables, trees and graphs. It then discusses techniques for efficient serialization like variable length quantities, bit packing, deduplication, storing deltas, and memory alignment. Finally it covers binary serialization formats and related considerations like format specifications, code generation, schemas, and tooling.

Wind of changeMaxim Zaks

The document discusses different types of changes to data representations and APIs, including additive, non-destructive changes and various destructive changes. It proposes solutions like making properties optional, using numeric IDs, deprecating properties, and adding new properties. Semantic versioning is presented as a way to communicate breaking vs. non-breaking changes. The importance of team dynamics and psychological safety is discussed at the end.

Data model mal andersMaxim Zaks

Talk Binary to MeMaxim Zaks

The document discusses the advantages of using binary formats like FlatBuffers and FlexBuffers over JSON for serialization. It notes that binary formats have smaller payload sizes and faster encoding/decoding speeds which can significantly improve performance for machine to machine communication and state persistence. The document demonstrates how FlatBuffers and FlexBuffers can be used to efficiently store and access structured data like user profiles and city data. It concludes that developers should evaluate their use cases and consider binary formats instead of only using JSON because others do.

Entity Component System - for App developersMaxim Zaks

Entity Component System is a software development pattern which has its roots in game development. The first use of this pattern dates to 1998. Even though it is almost 20 years old, the pattern is not widely known by non game programmers. I implemented two iOS Apps based on the pattern and would like to share my experiences and compare it to a more widely known patterns like MVC, MVVM, Rx and ReSwift.

Beyond JSON - An Introduction to FlatBuffersMaxim Zaks

This document provides an introduction and overview of FlatBuffers, a cross-platform library for efficient serialization of structured data. It discusses why data serialization is needed, important criteria for persisting and sending data, comparisons of JSON and FlatBuffers, and demonstrates FlatBuffers features like the IDL, size and performance benefits, partial reads, and support for data versioning.

Beyond JSON @ Mobile.WarsawMaxim Zaks

FlatBuffers is an efficient cross-platform serialization library for C++, Java, C#, Go, Python and JavaScript. It allows defining schema and generating code to easily read and write data in a compact binary format. It is faster than JSON for parsing large data and supports backwards compatible schema evolution. While writing data is more cumbersome than JSON, optimizations like eager serialization mode and schema editing tools aim to improve the experience. FlatBuffers shows great performance in benchmarks and is used by large companies like Facebook and games for efficient data transfer.

Beyond JSON @ dot swift 2016Maxim Zaks

This document introduces FlatBuffers as an efficient cross-platform serialization library that avoids the overhead of JSON parsing. It has backwards and forwards compatibility, can be compressed or encrypted easily since it is not human-readable, and FlatBuffersSwift provides a nice API for working with FlatBuffer data in Swift applications. The document encourages exploring FlatBuffers further and links to the FlatBuffersSwift GitHub repository.

Beyond JSON with FlatBuffersMaxim Zaks

FlatBuffers is an efficient cross-platform serialization library that avoids the overhead of JSON parsing. It allows data to be read lazily with almost zero cost and maintains backwards and forwards compatibility between old and new data. The FlatBuffersSwift library provides a nice API for working with FlatBuffer data in Swift projects, allowing binary data to be easily converted to and from object representations.

Basics of Computer ScienceMaxim Zaks

This document discusses several concepts in computer science that the author learned on the job after earning their CS degree. It covers how data is represented and stored in Swift using value types like tuples and reference types like classes. It also discusses data structures and how to represent collections of data, highlighting the benefits of immutable, purely functional data structures. The document concludes by discussing singletons and shared state as well as some best practices like avoiding coupling.

Entity system architecture with Unity @Unite Europe 2015 Maxim Zaks

Unity incorporates the component based architecture in a seamless manner. However for some games a more data driven approach (entity system architecture) fits better. We had very good experience using entity system architecture for simulation and even match three games. Therefore when we switched our development to Unity, we created a small library and a couple of Unity editor extensions to make Unity work seamlessly with entity system architecture. We called it Entitas-CSharp. The code is open source and available on github. In this talk we would like to show why entity system architecture fits us better and how you can use Entitas-CSharp in your own Unity project.

UIKonf App & Data Driven Design @swift.berlinMaxim Zaks

This document describes an app architecture and data-oriented design using entities and components. A Context manages data and creates Entity objects which are bags of Component objects. Components are just value types that store data. Groups are subsets of Entities that can be observed. The app imports JSON data into Components and Entities. Entities can be detached to modify on background threads before syncing changes. This allows building reactive UIs that update based on Entity and Component changes.

Swift the implicit partsMaxim Zaks

The document discusses Swift's implicit features such as constants, variables, optionals, tuples, functions, operators, and structures. It provides examples of declaring constants and variables, optional binding, tuple decomposition, function parameters and return types, operator overloading, and defining structures. The document is intended to explain Swift's type inference and implicit features through code examples.

Currying in SwiftMaxim Zaks

The document discusses the use of currying in Swift programming. It provides multiple examples of refactoring a function that calculates VAT amounts to be curried versions. This allows partial application of arguments to transform the function into new functions. The examples demonstrate how currying can encapsulate state by passing a VAT rate and transforming the function to only require the amount. It also notes that Swift method dispatch is internally implemented using currying behind the scenes.

Promise of an APIMaxim Zaks

96% macoun 2013Maxim Zaks

Diagnose of Agile @ Wooga 04.2013Maxim Zaks

The document discusses different aspects of agile methodologies like Scrum and XP. It analyzes practices from each in terms of the principles of discipline, transparency, participation, and feedback. For Scrum, it examines practices like organizing work in sprints, daily standups, planning poker, burn down charts and more. For XP, it looks at practices like pair programming, test driven development, and continuous integration. It also briefly covers Kanban and some of its practices like visualizing workflow and limiting work in progress. The document aims to diagnose agile approaches based on these key principles.

Start playing @ mobile.cologne 2013Maxim Zaks

This document provides an overview of key considerations for mobile game development. It discusses starting with an original idea or borrowing one. It emphasizes the importance of user experience (UX) and analyzing user behavior. Technical topics covered include game engines, OpenGL ES, physics engines, anti-cheating strategies, and determinism. The document recommends prioritizing idea, configuration, and tracking over specific technologies. It stresses the importance of playing your own games and provides a link for job opportunities.

Under Cocos2D Tree @mdvecon 2013Maxim Zaks

The document discusses implementing a memory game using Cocos2D. It covers embedding Cocos2D, using scenes and transitions, layers and actions, game logic and interaction, sprites and textures, frame-by-frame animation, drawing primitives, and particles. The presentation aims to provide an understanding of Cocos2D concepts and walk through an unpolished memory game implementation covering these topics over 8 sections.

Don’t do Agile, be Agile @NSConf 2013Maxim Zaks

This document discusses how being truly agile means facing fears and uncertainties rather than relying only on rules and processes. It argues that methodologies like Scrum and Kanban may give a false sense of protection from mistakes but will not prevent bad decisions. True agility requires embracing mistakes and failures as opportunities to learn. The most important aspects of being agile are discipline, transparency, feedback, embracing uncertainty, and understanding what agility really means.

Nitty Gritty of Data SerialisationMaxim Zaks

Wind of changeMaxim Zaks

Data model mal andersMaxim Zaks

Talk Binary to MeMaxim Zaks

Entity Component System - for App developersMaxim Zaks

Beyond JSON - An Introduction to FlatBuffersMaxim Zaks

Beyond JSON @ Mobile.WarsawMaxim Zaks

Beyond JSON @ dot swift 2016Maxim Zaks

Beyond JSON with FlatBuffersMaxim Zaks

Basics of Computer ScienceMaxim Zaks

Entity system architecture with Unity @Unite Europe 2015 Maxim Zaks

UIKonf App & Data Driven Design @swift.berlinMaxim Zaks

Swift the implicit partsMaxim Zaks

Currying in SwiftMaxim Zaks

Promise of an APIMaxim Zaks

96% macoun 2013Maxim Zaks

Diagnose of Agile @ Wooga 04.2013Maxim Zaks

Start playing @ mobile.cologne 2013Maxim Zaks

Under Cocos2D Tree @mdvecon 2013Maxim Zaks

Don’t do Agile, be Agile @NSConf 2013Maxim Zaks

Recently uploaded (20)

Exceptional Behaviors: How Frequently Are They Tested? (AST 2025)Andre Hora

Exceptions allow developers to handle error cases expected to occur infrequently. Ideally, good test suites should test both normal and exceptional behaviors to catch more bugs and avoid regressions. While current research analyzes exceptions that propagate to tests, it does not explore other exceptions that do not reach the tests. In this paper, we provide an empirical study to explore how frequently exceptional behaviors are tested in real-world systems. We consider both exceptions that propagate to tests and the ones that do not reach the tests. For this purpose, we run an instrumented version of test suites, monitor their execution, and collect information about the exceptions raised at runtime. We analyze the test suites of 25 Python systems, covering 5,372 executed methods, 17.9M calls, and 1.4M raised exceptions. We find that 21.4% of the executed methods do raise exceptions at runtime. In methods that raise exceptions, on the median, 1 in 10 calls exercise exceptional behaviors. Close to 80% of the methods that raise exceptions do so infrequently, but about 20% raise exceptions more frequently. Finally, we provide implications for researchers and practitioners. We suggest developing novel tools to support exercising exceptional behaviors and refactoring expensive try/except blocks. We also call attention to the fact that exception-raising behaviors are not necessarily “abnormal” or rare.

Adobe Illustrator Crack FREE Download 2025 Latest Versionkashifyounis067

🌍📱👉COPY LINK & PASTE ON GOOGLE http://drfiles.net/ 👈🌍 Adobe Illustrator is a powerful, professional-grade vector graphics software used for creating a wide range of designs, including logos, icons, illustrations, and more. Unlike raster graphics (like photos), which are made of pixels, vector graphics in Illustrator are defined by mathematical equations, allowing them to be scaled up or down infinitely without losing quality. Here's a more detailed explanation: Key Features and Capabilities: Vector-Based Design: Illustrator's foundation is its use of vector graphics, meaning designs are created using paths, lines, shapes, and curves defined mathematically. Scalability: This vector-based approach allows for designs to be resized without any loss of resolution or quality, making it suitable for various print and digital applications. Design Creation: Illustrator is used for a wide variety of design purposes, including: Logos and Brand Identity: Creating logos, icons, and other brand assets. Illustrations: Designing detailed illustrations for books, magazines, web pages, and more. Marketing Materials: Creating posters, flyers, banners, and other marketing visuals. Web Design: Designing web graphics, including icons, buttons, and layouts. Text Handling: Illustrator offers sophisticated typography tools for manipulating and designing text within your graphics. Brushes and Effects: It provides a range of brushes and effects for adding artistic touches and visual styles to your designs. Integration with Other Adobe Software: Illustrator integrates seamlessly with other Adobe Creative Cloud apps like Photoshop, InDesign, and Dreamweaver, facilitating a smooth workflow. Why Use Illustrator? Professional-Grade Features: Illustrator offers a comprehensive set of tools and features for professional design work. Versatility: It can be used for a wide range of design tasks and applications, making it a versatile tool for designers. Industry Standard: Illustrator is a widely used and recognized software in the graphic design industry. Creative Freedom: It empowers designers to create detailed, high-quality graphics with a high degree of control and precision.

Explaining GitHub Actions Failures with Large Language Models Challenges, In...ssuserb14185

GitHub Actions (GA) has become the de facto tool that developers use to automate software workflows, seamlessly building, testing, and deploying code. Yet when GA fails, it disrupts development, causing delays and driving up costs. Diagnosing failures becomes especially challenging because error logs are often long, complex and unstructured. Given these difficulties, this study explores the potential of large language models (LLMs) to generate correct, clear, concise, and actionable contextual descriptions (or summaries) for GA failures, focusing on developers’ perceptions of their feasibility and usefulness. Our results show that over 80% of developers rated LLM explanations positively in terms of correctness for simpler/small logs. Overall, our findings suggest that LLMs can feasibly assist developers in understanding common GA errors, thus, potentially reducing manual analysis. However, we also found that improved reasoning abilities are needed to support more complex CI/CD scenarios. For instance, less experienced developers tend to be more positive on the described context, while seasoned developers prefer concise summaries. Overall, our work offers key insights for researchers enhancing LLM reasoning, particularly in adapting explanations to user expertise. https://arxiv.org/abs/2501.16495

Scaling GraphRAG: Efficient Knowledge Retrieval for Enterprise AIdanshalev

If we were building a GenAI stack today, we'd start with one question: Can your retrieval system handle multi-hop logic? Trick question, b/c most can’t. They treat retrieval as nearest-neighbor search. Today, we discussed scaling #GraphRAG at AWS DevOps Day, and the takeaway is clear: VectorRAG is naive, lacks domain awareness, and can’t handle full dataset retrieval. GraphRAG builds a knowledge graph from source documents, allowing for a deeper understanding of the data + higher accuracy.

Exploring Code Comprehension in Scientific Programming: Preliminary Insight...University of Hawai‘i at Mānoa

This presentation explores code comprehension challenges in scientific programming based on a survey of 57 research scientists. It reveals that 57.9% of scientists have no formal training in writing readable code. Key findings highlight a "documentation paradox" where documentation is both the most common readability practice and the biggest challenge scientists face. The study identifies critical issues with naming conventions and code organization, noting that 100% of scientists agree readable code is essential for reproducible research. The research concludes with four key recommendations: expanding programming education for scientists, conducting targeted research on scientific code quality, developing specialized tools, and establishing clearer documentation guidelines for scientific software. Presented at: The 33rd International Conference on Program Comprehension (ICPC '25) Date of Conference: April 2025 Conference Location: Ottawa, Ontario, Canada Preprint: https://arxiv.org/abs/2501.10037

How Valletta helped healthcare SaaS to transform QA and compliance to grow wi...Egor Kaleynik

This case study explores how we partnered with a mid-sized U.S. healthcare SaaS provider to help them scale from a successful pilot phase to supporting over 10,000 users—while meeting strict HIPAA compliance requirements. Faced with slow, manual testing cycles, frequent regression bugs, and looming audit risks, their growth was at risk. Their existing QA processes couldn’t keep up with the complexity of real-time biometric data handling, and earlier automation attempts had failed due to unreliable tools and fragmented workflows. We stepped in to deliver a full QA and DevOps transformation. Our team replaced their fragile legacy tests with Testim’s self-healing automation, integrated Postman and OWASP ZAP into Jenkins pipelines for continuous API and security validation, and leveraged AWS Device Farm for real-device, region-specific compliance testing. Custom deployment scripts gave them control over rollouts without relying on heavy CI/CD infrastructure. The result? Test cycle times were reduced from 3 days to just 8 hours, regression bugs dropped by 40%, and they passed their first HIPAA audit without issue—unlocking faster contract signings and enabling them to expand confidently. More than just a technical upgrade, this project embedded compliance into every phase of development, proving that SaaS providers in regulated industries can scale fast and stay secure.

Exploring Wayland: A Modern Display Server for the FutureICS

Avast Premium Security Crack FREE Latest Version 2025mu394968

🌍📱👉COPY LINK & PASTE ON GOOGLE https://dr-kain-geera.info/👈🌍 Avast Premium Security is a paid subscription service that provides comprehensive online security and privacy protection for multiple devices. It includes features like antivirus, firewall, ransomware protection, and website scanning, all designed to safeguard against a wide range of online threats, according to Avast. Key features of Avast Premium Security: Antivirus: Protects against viruses, malware, and other malicious software, according to Avast. Firewall: Controls network traffic and blocks unauthorized access to your devices, as noted by All About Cookies. Ransomware protection: Helps prevent ransomware attacks, which can encrypt your files and hold them hostage. Website scanning: Checks websites for malicious content before you visit them, according to Avast. Email Guardian: Scans your emails for suspicious attachments and phishing attempts. Multi-device protection: Covers up to 10 devices, including Windows, Mac, Android, and iOS, as stated by 2GO Software. Privacy features: Helps protect your personal data and online privacy. In essence, Avast Premium Security provides a robust suite of tools to keep your devices and online activity safe and secure, according to Avast.

How to Optimize Your AWS Environment for Improved Cloud PerformanceThousandEyes

Microsoft AI Nonprofit Use Cases and Live Demo_2025.04.30.pdfTechSoup

In this webinar we will dive into the essentials of generative AI, address key AI concerns, and demonstrate how nonprofits can benefit from using Microsoft’s AI assistant, Copilot, to achieve their goals. This event series to help nonprofits obtain Copilot skills is made possible by generous support from Microsoft. What You’ll Learn in Part 2: Explore real-world nonprofit use cases and success stories. Participate in live demonstrations and a hands-on activity to see how you can use Microsoft 365 Copilot in your own work!

Requirements in Engineering AI- Enabled Systems: Open Problems and Safe AI Sy...Lionel Briand

Get & Download Wondershare Filmora Crack Latest [2025]saniaaftab72555

Copy & Past Link 👉👉 https://dr-up-community.info/ Wondershare Filmora is a video editing software and app designed for both beginners and experienced users. It's known for its user-friendly interface, drag-and-drop functionality, and a wide range of tools and features for creating and editing videos. Filmora is available on Windows, macOS, iOS (iPhone/iPad), and Android platforms.

Top 10 Client Portal Software Solutions for 2025.docxPortli

Mastering Fluent Bit: Ultimate Guide to Integrating Telemetry Pipelines with ...Eric D. Schabell

It's time you stopped letting your telemetry data pressure your budgets and get in the way of solving issues with agility! No more I say! Take back control of your telemetry data as we guide you through the open source project Fluent Bit. Learn how to manage your telemetry data from source to destination using the pipeline phases covering collection, parsing, aggregation, transformation, and forwarding from any source to any destination. Buckle up for a fun ride as you learn by exploring how telemetry pipelines work, how to set up your first pipeline, and exploring several common use cases that Fluent Bit helps solve. All this backed by a self-paced, hands-on workshop that attendees can pursue at home after this session (https://o11y-workshops.gitlab.io/workshop-fluentbit).

Adobe After Effects Crack FREE FRESH version 2025kashifyounis067

🌍📱👉COPY LINK & PASTE ON GOOGLE http://drfiles.net/ 👈🌍 Adobe After Effects is a software application used for creating motion graphics, special effects, and video compositing. It's widely used in TV and film post-production, as well as for creating visuals for online content, presentations, and more. While it can be used to create basic animations and designs, its primary strength lies in adding visual effects and motion to videos and graphics after they have been edited. Here's a more detailed breakdown: Motion Graphics: . After Effects is powerful for creating animated titles, transitions, and other visual elements to enhance the look of videos and presentations. Visual Effects: . It's used extensively in film and television for creating special effects like green screen compositing, object manipulation, and other visual enhancements. Video Compositing: . After Effects allows users to combine multiple video clips, images, and graphics to create a final, cohesive visual. Animation: . It uses keyframes to create smooth, animated sequences, allowing for precise control over the movement and appearance of objects. Integration with Adobe Creative Cloud: . After Effects is part of the Adobe Creative Cloud, a suite of software that includes other popular applications like Photoshop and Premiere Pro. Post-Production Tool: . After Effects is primarily used in the post-production phase, meaning it's used to enhance the visuals after the initial editing of footage has been completed.

Not So Common Memory Leaks in Java WebinarTier1 app

This SlideShare presentation is from our May webinar, “Not So Common Memory Leaks & How to Fix Them?”, where we explored lesser-known memory leak patterns in Java applications. Unlike typical leaks, subtle issues such as thread local misuse, inner class references, uncached collections, and misbehaving frameworks often go undetected and gradually degrade performance. This deck provides in-depth insights into identifying these hidden leaks using advanced heap analysis and profiling techniques, along with real-world case studies and practical solutions. Ideal for developers and performance engineers aiming to deepen their understanding of Java memory management and improve application stability.

The Significance of Hardware in Information Systems.pdfdrewplanas10

Revolutionizing Residential Wi-Fi PPT.pptxnidhisingh691197

Meet the Agents: How AI Is Learning to Think, Plan, and CollaborateMaxim Salnikov

LEARN SEO AND INCREASE YOUR KNOWLDGE IN SOFTWARE INDUSTRYNidaFarooq10