Runtime, Hot Reload and Build in Mobile Development: What They Are, Key Concepts and How They Work

Runtime and Reflection: iOS Runtime, Method Swizzling and Dynamic Dispatch

Runtime (execution environment) is the software that manages application execution. In the context of iOS Runtime, it is Objective-C's dynamic system that allows sending messages to objects, creating classes on the fly and replacing methods at runtime. This is possible because Objective-C is a dynamically typed language built on top of C.

Reflection is a program's ability to examine and modify its own structure at runtime. In iOS Runtime, this is implemented through functions like class_getInstanceMethod, method_exchangeImplementations and objc_getAssociatedObject. In Kotlin/Java, reflection uses KClass / java.lang.reflect.

At IT Sectr, we use Runtime very rarely — only for specific tasks where there is no alternative. For example, Method Swizzling for centralized analytics logging or fixing bugs in libraries. However, Runtime is a powerful tool that requires deep understanding and caution.

Method Swizzling

Method Swizzling is a technique for replacing an Objective-C method implementation with another at runtime. This is a specific case of Aspect-Oriented Programming (AOP) for iOS. Swizzling allows adding logging, analytics or caching to existing methods without changing their source code.

A typical example: replacing viewWillAppear: on UIViewController to add automatic screen logging. Important: swizzling must be performed in the +load or +initialize method to ensure execution before the class is used. Incorrect swizzling can lead to undefined behavior and bugs that are difficult to debug.

// Method Swizzling for logging viewWillAppear:
@implementation UIViewController (Tracking)

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = [self class];
        SEL originalSelector = @selector(viewWillAppear:);
        SEL swizzledSelector = @selector(xxx_viewWillAppear:);
        
        Method originalMethod = class_getInstanceMethod(class, originalSelector);
        Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
        method_exchangeImplementations(originalMethod, swizzledMethod);
    });
}

- (void)xxx_viewWillAppear:(BOOL)animated {
    [self xxx_viewWillAppear:animated]; // calling the original method
    [Analytics logScreen:NSStringFromClass([self class])];
}

@end

This code replaces viewWillAppear: on all UIViewController instances via swizzling. After method_exchangeImplementations, calling the original viewWillAppear: results in calling xxx_viewWillAppear:, which calls the original method (via recursive call) and adds analytics. DispatchOnce guarantees single execution of swizzling.

Web Tools (Transpilation, Polyfill, Bundler, Webpack, Metro)

Modern web development and mobile development with React Native or Flutter are impossible without build tools. Transpilation is converting code from one language to another. The most popular example: TypeScript → JavaScript. A transpiler (Babel, tsc) converts modern code into a backward-compatible version.

Polyfill is code that adds missing functionality to older browsers. For example, Promise.allSettled() does not work in Internet Explorer, but a polyfill adds this capability. Unlike native Runtime, which manages code execution directly on the device, polyfills and transpilers operate at the language abstraction level — they adapt syntax and APIs, but do not interfere with the execution environment.

Webpack is the most popular bundler (used in 72% of projects according to State of JS 2024). Metro is Facebook's bundler, used by default in React Native. Reflection in JavaScript exists through Object.getPrototypeOf, Proxy and Reflect API — these mechanisms allow examining and modifying objects at runtime, which is fundamentally different from static module analysis in bundlers. Webpack uses a configuration file that describes entry point, output, loaders (for processing different file types) and plugins (for additional functionality).

// webpack.config.js — minimal configuration
const path = require('path');

module.exports = {
    entry: './src/index.js',
    output: {
        filename: 'bundle.js',
        path: path.resolve(__dirname, 'dist'),
    },
    module: {
        rules: [
            {
                test: /\.js$/,
                exclude: /node_modules/,
                use: 'babel-loader',
            },
        ],
    },
    mode: 'production',
};

This configuration defines the entry point (index.js), output file (bundle.js) and a rule for processing JavaScript through Babel. The production mode enables optimizations: minification, tree shaking and automatic environment detection. At the Runtime stage, all these optimizations no longer affect the logic — the browser executes the minified bundle as regular JavaScript.

Code Optimization (Minification, Tree Shaking, Obfuscation)

Minification is the process of compressing code by removing whitespace, comments and renaming long variables to short ones. Popular minifiers: Terser (JS/TS), CSSNano (CSS), html-minifier-terser. Minification reduces file size by 50–70%. In Production, Runtime executes minified code the same as the original — the difference is only in readability and file size, not in semantics.

Tree Shaking is the removal of dead code that is not used in the application. It works based on static analysis of ES modules (import/export). If a function is exported but never imported, Tree Shaking removes it from the final build. Tree Shaking analyzes code statically — unlike Reflection, which works dynamically and can access methods and properties invisible at compile time.

Tree Shaking

Tree Shaking in Webpack is enabled automatically in production mode. An important condition: the code must use ES modules (import/export), not CommonJS (require). If a library is written in CommonJS, tree shaking will not work. For optimal tree shaking, use precise imports: import { merge } from 'lodash-es' instead of import _ from 'lodash'. This reduces bundle size from 500 KB to 10 KB for a single function.

Hot Reload

Hot Reload is a technology that allows updating application code without a full reload. In React Native and Flutter, Hot Reload updates the changed file on the fly, preserving the current application state. This radically speeds up development: changes are visible in 1–2 seconds instead of 10–30 seconds for a full rebuild. Hot Reload works within Runtime: the changed module is injected into the running application without restarting the execution environment.

Hot Restart is a quick restart of the application with updated code, but without preserving state. It is used when Hot Reload is not possible (for example, when native code or global variables have changed). At IT Sectr, we use Hot Reload at all UI development stages — it saves up to 50% of time on visual adjustments.

Table 3. Comparison of build tools. Webpack is the universal standard. Metro is specialized for React Native. Vite and esbuild are the new generation focused on speed. Rollup is the best choice for publishing libraries.

Hot Reload (Hot Reload, Hot Restart)

Hot Reload is a technology that originated in web development (React Hot Loader, HMR — Hot Module Replacement) and transitioned to mobile development with Flutter and React Native. The essence: when a file changes, the bundler sends the updated module to the running application, which replaces the old code without losing state. Unlike a full rebuild, Hot Reload does not restart the Runtime — the execution environment continues running, and the changed module is connected dynamically through a mechanism like HMR or a Reflection-like reference update.

Hot Reload works because the framework keeps widgets (Flutter) or components (React) in memory and updates only the changed parts. Hot Restart is a coarser mechanism: it fully restarts the application, but is faster than a full rebuild because it does not recompile native code. At IT Sectr, we use Hot Reload when developing UI and Hot Restart when changing navigation or state management.