This document discusses improving iteration times through reloading code and data. It covers reloading code in various languages like C/C++ and scripting languages. It also discusses reloading data like materials, models, textures and game logic/settings. The document recommends tools like REPLs and online compilers that allow live editing. It suggests next level techniques like in-engine live editing of UI, levels and object settings. Finally, it mentions other approaches that can help like good APIs, entity component systems and shorter compilation times.

1. Improving Iteration Times Through The Reloading of
Code and Data
Boyan Spassov

2. Overview
Short talk on the virtues of reloading, hot-swapping, exploratory
programming, live editing and not waiting for the compiler

3. https://xkcd.com/303/
How not to
improve
iteration times

4. How context
switching affects
productivity

5. Topics
Reloading code
Reloading data
In-engine live editing
APIs, Component systems and other ways to improve iteration times

6. Who am I
Game programmer at Gameloft for 2.5 years
Games I have worked on: World at Arms

7. Why reload code and data

8. Why reload code and data
More time to try stuff
More time to explore
Inspirational (and useful) tools:
REPLs: Lisp, Python, Lua
IPython notebook: code, documentation, output and history all in the
same place
http://ipython.org/notebook.html
http://jupyter.org/
Shadertoy
https://www.shadertoy.com/
Online compilers/playgrounds/assemblers
https://gcc.godbolt.org/ - online compiler that outputs pretty assembly
https://jsfiddle.net/

9. How to reload code and data

10. Reloading Code

11. Reloading Code
Use Unreal, Unity, etc.
Reloading C/C++
Reloading Scripting languages

12. Reloading C/C++
Casey Muratori’s Handmade Hero
https://www.youtube.com/watch?v=WMSBRk5WG58
Especially the video Looped Live Code Editing
https://www.youtube.com/watch?v=xrUSrVvB21c
Molecular Matters blog
http://blog.molecular-matters.com/2014/05/10/using-runtime-
compiled-c-code-as-a-scripting-language-under-the-hood/
RuntimeCompiledC++ http://runtimecompiledcplusplus.blogspot.bg/
Bitsquid’s Cutting the Pipe talk from GDC 2012
https://github.com/niklasfrykholm/blog/tree/master/presentations

13. Reloading Scripting languages
E.g.: Lua
Generally easier
But can get complicated depending on your data and function bindings
(please don’t use luabind)

14. Reloading Server code
E.g. Python (beware)
Languages designed for hot-swapping (Erlang, maybe Common Lisp,
maybe others?)
Serialize, Shutdown, Restart
Fixing bugs in production

15. Reloading Data

16. Reloading Data
Use Unreal, Unity, etc.
Custom solutions depend on the data: materials, models, textures,
game logic, settings, ui
During development or on a live game
DLC
Game settings (especially how to resolve conflicting changes)
Fixing bugs which were caught too late
Insomniac games patching Ratchet and Clank: Up Your Arsenal via a
buffer overrun in the EULA
http://gamasutra.com/view/feature/194772/dirty_game_develop-
ment_tricks.php

17. Next level

18. Next level: In-engine live editing
UI
Levels
Object settings / logic
Live prototyping
Collaborative editing
What happens when the engine/game is broken/won’t start?
Version control

19. Other stuff which can help improve iteration times
Good and versatile APIs
Another talk by Casey Muratori: Designing and Evaluating Reusable
Components http://mollyrocket.com/casey/stream_0028.html
Entity Component systems
Shorter compilation times
Determinism, recording & playback
Awesome but hard and not always possible