DEV Community: Binoy Vijayan

Making Your Own Dictionary(HashMap) in Swift

Binoy Vijayan — Tue, 03 Jun 2025 03:38:47 +0000

Swift has a powerful built-in Dictionary, but learning how it works behind the scenes helps you understand data better. This article explains how to build your own Dictionary using three methods:

Chained Hash Map (uses linked lists)
Double Hashed Map (uses open slots and two hash functions)
Robin Hood Hash Map (makes lookup times more even)

Chained Hash Map (Linked List Method)

ChainedHashMap.swift

What it does

Stores key-value pairs

Each bucket (array slot) can hold multiple items using a linked list

If two keys land in the same bucket, they go into a list

How it works

A hash function gives the index for the key
If that spot is empty, add the item
If it already has items, add to the list

If the number of items becomes too big (over 70%), the table grows bigger

Pros

Easy to understand and use
Good for adding and deleting items

Cons

Can use more memory
Slower if too many items end up in one bucket

Note

_In Java's HashMap, if a linked list in a bucket grows longer than 8 entries, it automatically converts that list into a balanced tree (Red-Black Tree) to improve lookup speed. You can add similar logic to your Swift implementation for better performance.
_

2. Double Hashed Map (Open Addressing with Two Hashes)

DoubleHashedMap.swift

What it does

Avoids using lists

Instead, it uses a second hash to find the next free slot when a collision happens

How it works

First hash gives the starting spot
Second hash tells how far to move if it’s already full
Keeps checking slots until it finds an empty one
Resizes when the table gets too full

Pros

Uses less memory than chaining
Spreads out items better than just linear search

Cons

Harder to remove items
Slower when the table is almost full

3. Robin Hood Hash Map (Fair Probing)

RobinHoodHashMap.swift

What it does

Keeps all items as close to their ideal spot as possible
If a new item has been waiting longer than another one, it “steals” the spot

How it works

Each item tracks how far it has probed
If a new item has probed more than the existing item, they switch places
Keeps lookup times more even

Pros

Balanced and fair
Makes lookups faster even in crowded tables

Cons

More complex to write
Removing items is not covered here
Extra: Turning Long Lists into Trees

Just like Java's HashMap, we can improve ChainedHashMap by changing long linked lists into trees (like Red-Black Trees) when they grow too big (more than 8 items).

Why it's useful

Makes worst-case lookups faster (O(log n) instead of O(n))
Keeps performance smooth

Summary Table

Final Thoughts

Making your own Dictionary helps you understand how real ones like Swift's Dictionary work.

By building these three types, you learn about:

Handling collisions

Balancing speed and memory

Writing smarter data structures

The complete source code is available here.

React Native SDK Architecture (JSI-Based New Architecture)

Binoy Vijayan — Thu, 29 May 2025 02:27:50 +0000

React Native’s new design is a big improvement over the old way it worked. Instead of using a slow "bridge" to talk between JavaScript and native code, it now uses a faster system called JSI (JavaScript Interface). It also adds TurboModules and a new way to draw screens called the Fabric Renderer.

Thanks to these updates, apps run faster, look more consistent, and can connect better with native features (like camera or GPS). This document explains the different layers and how the parts of a modern React Native SDK work together using this new system.

Old Architecture vs New Architecture

Layered Architecture Overview

App Layer (Top Layer)

This is where you write your app using JavaScript or TypeScript.
You use React components (, ) to build your UI.

All your business logic (how your app works) is written here.

React Runtime + JSI Layer (Middle Layer)

This is the engine that runs your JavaScript code.
It uses a JavaScript engine like Hermes or JavaScriptCore.
JSI (JavaScript Interface) helps JavaScript talk directly to native code (like a translator that speaks both languages).
It also uses TurboModules to connect to native features (like camera, battery).

Think of it as a smart brain that handles all the logic and knows how to ask the device(phone) to do things.

Rendering & Bridge Layer (Fabric + UI updates)

This is where your app’s UI is turned into real screens on the phone.
The Fabric Renderer takes the React components and turns them into native views.
It draws everything smoothly and efficiently, using Yoga, which is a layout engine that supports flexbox (just like CSS).

It’s like an artist who paints your app on the phone’s screen, very quickly.

Native Platform Layer (Bottom Layer)

This is the layer that talks directly to the phone's operating system (Android or iOS).

Here, code is written in Kotlin/Java (Android) or Swift/Objective-C (iOS).

It handles hardware features like camera, location, notifications, etc.

Think of this as the hands of your phone, doing the actual work.

Summary Table

Simple Step-by-Step Sequence: "User Taps a Button”

User taps the screen (UI event)

The user touches a button () on the phone screen.
This touch event is handled by the native OS (iOS or Android).

Example: Finger touches a real native button.

Native system sends the touch event to React Native

The OS (Android/iOS) sends the event to the React Native runtime via the native event system.
The Fabric Renderer listens for UI events at the native level.

The native side says, “A tap just happened on this view.”

Fabric passes event to the JS Runtime via JSI

Fabric identifies which React component was tapped.
It sends that event through JSI to the JavaScript engine (Hermes).
No need for the old bridge — this is fast and direct.

Event goes from C++/Fabric into JS via JSI.

React Runtime processes the event

Your JavaScript function (like onPress={() => ...}) gets called.
React may re-render the component if the state/props change.

Your app logic runs: “If button was pressed, do X.”

UI update (if needed) is sent back to native via Fabric

If your button tap causes a UI change (like showing a new message), React will rebuild the virtual tree. -Fabric compares the new tree with the old one (diffing). -Then it updates the native views directly through C++.

Native screen is updated to show new UI (e.g., a message appears).

Layered Pseudocode: Button Tap Flow

User Layer (JS - App Layer)

function MyApp() {
  const handlePress = () => {
    console.log("Button tapped");
    setState("Show Hello Text");
  };

  return (
    <View>
      <Button title="Tap Me" onPress={handlePress} />
      {state === "Show Hello Text" && <Text>Hello World</Text>}
    </View>
  );
}

User taps the button → onPress is called.

JS Runtime & JSI Layer

// JSI bridge exposes the button event handler
installJSFunction(runtime, "handlePress", []() {
  // This is called by Fabric when a native event comes in
  jsRuntime.invoke("handlePress");  // Calls the JavaScript function
});

Uses JSI to invoke JS function directly from C++ without serialisation.

Fabric Renderer Layer (Native C++)

// Native event dispatcher detects tap on button view
void onTouchEvent(ViewID id) {
  if (id == buttonViewID) {
    auto event = createPressEvent();
    dispatchEventToJSI(event);  // Send to JS through JSI
  }
}

// After JS function runs and UI state changes...
void reconcileChanges(ReactTree newTree) {
  auto diff = diffTrees(oldTree, newTree);
  applyNativeChanges(diff);  // Update UI using native view managers
}

Handles touch detection, tree diffing, and UI updates.

Native Platform Layer (iOS/Android)

// Android View Manager or iOS UIView updates UI
fun updateNativeView(componentId, newProps) {
    when (componentId) {
        "TextView" -> textView.setText(newProps.text)
        "ButtonView" -> button.setTitle(newProps.title)
    }
}

Native components (e.g., TextView, Button) get updated with new props.

Conclusion

React Native’s new SDK architecture is a big improvement over the old one. It replaces the slow and complex "bridge" with a faster system using JSI, TurboModules, and Fabric. This new setup lets JavaScript and native code talk to each other directly, without converting everything into messages. As a result, apps start faster, run smoother, and respond more quickly to user actions. For developers, it also makes it easier to build powerful features that work well on both Android and iOS. Overall, this new architecture makes React Native apps feel more like real native apps while still using JavaScript.

Choosing the Right Mobile SDK: Native, Flutter, React Native, or Hybrid?

Binoy Vijayan — Tue, 20 May 2025 15:47:48 +0000

In today’s mobile-first world, building an app isn’t just about great design or killer features — it’s also about choosing the right technology stack. The Software Development Kit (SDK) you choose will shape your app’s performance, user experience, cost, and development time.

With so many options available — from native development using iOS and Android SDKs, to powerful cross-platform tools like Flutter and React Native, and even hybrid frameworks like Ionic and Cordova — developers often face a tough decision.

Each SDK comes with its own strengths and trade-offs:
Native SDKs offer unmatched performance and deep system access.
Flutter shines with consistent UI across platforms and high-speed rendering.

React Native allows JavaScript lovers to build real mobile apps.
Hybrid SDKs cater to those seeking fast, budget-friendly web-to-app conversions.

In this article, we’ll break down how these SDKs differ in architecture, performance, and real-world suitability — helping you decide which path is best for your next mobile app project.

Architecture Comparison: Native vs Flutter vs React Native vs Hybrid

Understanding the underlying architecture of each SDK helps us see how apps are built, how they render UI, and how they interact with device features.

Below is a detailed comparison of the core architectural components of each SDK:

As seen above, each SDK’s architecture influences how the app behaves — from how quickly it loads and runs, to how native it feels to the user. Native SDKs excel in performance and hardware access, while Flutter offers a robust cross-platform solution with its own rendering engine. React Native strikes a balance between native access and JavaScript flexibility, whereas Hybrid SDKs trade off performance for speed and simplicity.

Performance Comparison: Native vs Flutter vs React Native vs Hybrid

Performance is a critical factor when choosing a mobile SDK — especially for apps involving animations, large data sets, or real-time interactions. Here’s how each SDK compares in key performance metrics like frame rate, memory usage, and startup time:

Native SDKs deliver unmatched performance due to direct integration with the operating system and access to all hardware features.
Flutter, powered by its Skia engine and AOT compilation, offers near-native performance, making it excellent for high-FPS, custom UI applications.

React Native, with its updated architecture (bridgeless via JSI, TurboModules, and Fabric), now provides high performance and native view rendering, making it well-suited for most production apps, including those with moderate to complex UIs and animations.
Hybrid SDKs (like Ionic/Cordova), while quick to develop with, rely on WebView-based rendering. This limits their performance and responsiveness, especially for animation-rich or resource-heavy

Here's the Performance Metrics Comparison Chart showing how Native, Flutter, React Native, and Hybrid SDKs stack up across:

Frame Rate (FPS)
Startup Time (seconds)
Memory Usage (MB)
UI Responsiveness (rated on a 1–5 scale)

App Suitability Categorisation: Which SDK Fits Which App?

Each SDK serves a specific kind of app use case based on its performance, development flexibility, UI rendering, and access to native cap

SDK Recommendation by App Type

Choosing the right SDK isn't about which is most popular — it’s about aligning the project’s needs with the SDK’s strengths. Native SDKs are unbeatable for speed and full access, while Flutter delivers both performance and pixel-perfect design across platforms. React Native shines when reusing JavaScript logic across web and mobile. Hybrid SDKs, though limited in performance, are ideal for rapid prototyping or simple apps.

Market Intelligence: Developer & Ecosystem Availability

Beyond architecture and performance, choosing an SDK also depends on the availability of developers, community support, and tooling maturity.

Here's a comparative snapshot:

Key Insights:

Native SDKs dominate in the enterprise and system-level job market but require specialised skill sets.

Flutter is rapidly gaining traction, especially among startups and design-heavy apps. Google’s backing ensures strong future support.
React Native leads in sheer developer numbers due to JavaScript’s ubiquity, with a thriving community and vast plugin ecosystem.
Hybrid SDKs are seeing reduced demand for complex apps but still serve niche cases (e.g., quick prototypes or internal apps).

Strategic Tip:

If you need fast hiring, shared web/mobile talent, or access to a
mature library ecosystem, React Native may be optimal. For custom UI, performance, and future-ready talent, Flutter is a solid bet. If performance and platform control are non-negotiable, Native remains your go-to.

Conclusion

The mobile development landscape offers multiple SDK paths, each tailored to different technical and strategic needs. Through this comparison, it’s clear that no single SDK is universally superior — the right choice depends on the type of app, performance requirements, team skillsets, and long-term business goals.

Native SDKs (iOS & Android) remain the top choice for apps requiring maximum performance, deep hardware integration, or platform-specific compliance — especially in enterprise, gaming, healthcare, and secure fintech sectors.

Flutter provides an excellent balance between UI control, performance, and cross-platform reach, making it a smart choice for startups, design-driven apps, and companies building consistent user experiences across devices.

React Native, with its vast JavaScript developer base, excels in projects that benefit from shared web/mobile logic, rapid development, and access to a mature plugin ecosystem.

Hybrid frameworks still have value for budget-constrained, content-centric, or internal apps, but are less suitable for modern, performance-heavy use cases.

From a market intelligence standpoint, the availability of skilled developers, maturity of tools, and community support also play a key role. While React Native leads in developer availability, Flutter is rapidly closing the gap. Native development requires specialised skills but offers long-term performance reliability.

iOS SDK Architecture
Android SDK Architecture
Flutter SDK Architecture
React Native SDK Architecture

Flutter SDK Architecture

Binoy Vijayan — Sun, 18 May 2025 04:28:12 +0000

Flutter is an open-source UI software development toolkit created by Google. It enables developers to build natively compiled applications for mobile, web, and desktop from a single codebase. The Flutter SDK architecture is layered and optimised for performance, flexibility, and cross-platform consistency
Flutter follows a layered architecture consisting of the following main layers:

1. Flutter Framework

The Flutter Framework is written in Dart and provides a rich set of libraries and APIs to build UIs using a reactive, declarative approach. It consists of four main sub-layers, each responsible for specific tasks in UI creation, event handling, rendering, and layout.

1.1. Widget Layer (Declarative UI)

Purpose: Entry point for app developers.
Key Components:
StatelessWidget, StatefulWidget
InheritedWidget, Widget tree creation
Role: Builds the widget tree and declares the UI structure.

1.2. Element Layer (Bridge between Widget and Render)

Purpose: Manages the lifecycle and relationship between widgets and their underlying render objects.
Key Components:
Element, State, BuildOwner
Role: Maintains the element tree and handles mounting/updating widgets.

1.3. Rendering Layer

Purpose: Actual UI layout and painting.
Key Components:
RenderObject, RenderBox, PipelineOwner
Role:
Manages constraints, layout sizes, painting pixels to screen.

1.4. Foundation Layer

Purpose: Base classes and utilities for the framework.
Key Components:
ChangeNotifier, Diagnostics, Colour, Size
Role: Provides essential building blocks used by all layers above.

1.5. Animation Layer

Purpose: Smooth and controlled animations.
Key Components:
Animation, AnimationController, Ticker, Tween, Curves
Role: Powers all animated transitions in widgets

2. Flutter Engine

The Flutter Engine is the core layer that powers Flutter apps. Built in C++, it handles rendering, Dart code execution, and communication with native platforms. Key components include the Dart Runtime, Skia Graphics, Compositing, Text Rendering, and Platform Channels. Together, they convert Flutter’s UI code into fast, native-like visuals across Android, iOS, web, and desktop platforms.

2.1. Dart Runtime

Purpose: Executes Dart code.

Key Components:

Dart VM (for JIT in dev, AOT in release)
Isolates (for concurrency)
Garbage Collector

Role: Runs the application logic written in Dart.

2.2. Skia Graphics Library

Purpose: Provides GPU-accelerated 2D rendering.

Key Components:

Drawing primitives (lines, shapes, images)
Compositing, Blending, Filters

Role: Turns scene data into pixels on the screen.

2.3. Text & Typography

Purpose: High-quality text rendering.

Key Components:

Paragraph and text shaping
Font resolution and glyph layout

Role: Supports internationalisation, styling, font rendering.

2.4. Compositing Layer

Purpose: Builds and manages the visual scene graph.

Key Components:

SceneBuilder, LayerTree

Role: Composes layers into a final scene for Skia to paint.

2.5. Platform Channels

Purpose: Bridge between Dart and platform-specific code (Java/Kotlin, Swift/Obj-C).

Key Components:
MethodChannel, EventChannel, BasicMessageChannel

Role: Enables use of device features like camera, GPS, sensors.

2.6. Runtime & Embedding

Purpose: Integrates the engine into the host OS.

Key Components:

App entry point (main())
Threading model and event loop
Host platform views (Android/iOS)

Role: Runs the engine inside native shells (Android, iOS, Windows, etc.)

3. Flutter Embedder

The Embedder is the lowest layer of the Flutter architecture. It serves as the platform integration layer—responsible for launching and hosting the Flutter engine inside a native app environment.
It connects the Flutter Engine to the underlying operating system, making it possible to run the same Flutter code across various platforms like Android, iOS, Windows, macOS, Linux, and Web.

It handles:

Window creation and management
Input processing (touch, mouse, keyboard)
Event loop and thread setup
Communication with device APIs (camera, sensors, file storage, GPS)
Rendering surfaces (OpenGL, Metal, Vulkan, etc.)

3.1. Responsibilities of the Embedder

3.2. Supported Platforms & Embedder Roles

3.3. Key Embedder Components (Extended View)

3.4. Why Is the Embedder Important?

The embedder makes Flutter truly cross-platform. Without it, the engine would have no way to:

Interface with OS APIs
Handle device input
Display anything on screen
Access hardware-level functionality

The design allows developers to even create custom embedders for niche platforms (like embedded devices or smart TVs).

4. Flutter Runtime Compilation Modes

Flutter apps can be compiled in three primary modes: Debug, Profile, and Release. Each mode is optimised for a different stage of the app development lifecycle, impacting performance, compilation behaviour, and tooling support.

4.1. Debug Mode

4.2. Profile Mode

4.3. Release Mode

4.4. Summary comparison table

5. Cross-Platform Support

Mobile: Android, iOS

Web: Compiles Dart to JavaScript (uses CanvasKit or HTML renderer)

Desktop: macOS, Windows, Linux

Embedded: Raspberry Pi, IoT (experimental)

How a widget becomes pixels

Here’s a flowchart of how a Flutter widget becomes pixels on the screen, step-by-step from your Dart code to what the user actually sees:

Explanation of Each Step

Tap Event Flow in Flutter

Detailed Step-by-Step Breakdown

Sequence Diagram: Tap Event Flow in Flutter

Lifelines:

User: The person interacting with the device.

OS: The operating system (Android/iOS) that handles input hardware.

Engine: The Flutter engine (written in C++) that bridges the OS and Dart code.

Framework: Flutter’s Dart-based layer that builds and updates the UI.

Example:

ElevatedButton(
  onPressed: () {
    setState(() {
      counter++;
    });
  },
  child: Text("Tap Me"),
);

In this case:

The user taps the button.
Flutter recognizes the tap gesture.
onPressed triggers setState.
The UI rebuilds to reflect the updated counter

Summary of Roles

Conclusion

Flutter’s layered architecture—comprising the Framework, Engine, and Embedder—offers a powerful, flexible, and high-performance foundation for cross-platform app development. With its declarative UI, widget-based design, and GPU-accelerated rendering, Flutter enables consistent experiences across mobile, web, and desktop from a single codebase.
Understanding the architecture helps developers build efficiently, debug effectively, and create scalable, responsive apps suited to modern needs.

iOS SDK Architecture Explained

Android SDK Architecture Explained

Android SDK Architecture

Binoy Vijayan — Thu, 15 May 2025 02:51:12 +0000

Android apps are built using a layered system, where each layer has a specific job. These layers are stacked on top of each other, and they work together to help developers build apps more easily.

The top layers help you design the app's look and behaviour — like buttons, screens, and how users interact with it.
The middle layers help your app work with data, run business logic, and access features like internet or databases.
The bottom layers handle the technical parts — like talking to the phone’s hardware, managing memory, battery, or connecting to the camera and sensors.

This setup keeps everything organised and allows developers to focus on building features without needing to worry about how everything works behind the scenes.

Key Layers in Android Architecture

1.Application Framework Layer

Purpose: This layer provides the essential building blocks that developers use to create Android apps. It gives access to core app features and handles interactions between the system and your app.
Key Components:

Activity Manager: Controls the lifecycle of each screen (activity) in your app—e.g., when it starts, stops, or resumes.
Window Manager: Manages how windows and dialogs are displayed on the screen.

Content Providers: Helps apps share data securely (like contact info, media files) with other apps.
View System: Contains all the UI elements like buttons, text boxes, and sliders that users interact with.

Notification Manager: Lets apps send notifications to the user.

Package Manager: Manages installed applications and permissions.
This layer allows you to focus on what the app should do without worrying about how lower layers handle the details.

2. Android Runtime (ART) & Core Libraries

Purpose: Execution environment for Android apps.
Key Components:
ART (Android Runtime) – Replaces Dalvik, uses AOT and JIT compilation
Core Libraries – Provides Java APIs (Collections, IO, Threads, etc.)

3. Native Libraries (C/C++)

Purpose: Provides core capabilities through optimised native code.
Key Libraries:
OpenGL ES – Graphics rendering
WebKit – Web browser engine
SQLite – Lightweight relational database
SSL, libc, media codecs

4. Hardware Abstraction Layer (HAL)

Purpose: Acts as a bridge between the Android system and the hardware.
Example: Audio HAL, Camera HAL, Sensors HAL

5. Linux Kernel

Purpose: Core of the Android OS, managing hardware and system resources.

Responsibilities:
Memory and process management
Networking
Device drivers (camera, audio, sensors)
Power management
Security (SELinux)

Data Flow – Button Tap Example

Step-by-step Data Flow:

1.User Tap on UI Button

The user taps a button.
Depending on the app implementation, the tap could be on:
XML Button — traditional Android UI.
Compose Button — declarative UI with Compose.

2.UI Detects Tap Event

XML Button:
Tap is detected by the View system.
The event is dispatched to the View’s onClickListener registered in code or XML.
The listener calls the associated method (e.g., onButtonClicked()).
Compose Button:
Tap event is handled by Compose’s modifier and callback lambda, e.g., onClick = {}.
Compose calls the corresponding event handler function.

3.Call ViewModel / Event Handler

Both UI methods forward the event to the ViewModel.
The ViewModel contains the app’s business logic.
It processes the event, for example:
Update a UI state.
Fetch or update data.
Trigger navigation or other actions.

4.ViewModel interacts with Repository

The ViewModel calls the Repository layer.
The Repository handles data operations:
Queries the local database (e.g., Room).
Makes network requests.
Updates cached data.

5. Repository returns data

Repository responds with requested data or operation result.
ViewModel updates the app state accordingly.

6. UI Reacts to State Change

XML UI:
ViewModel updates LiveData or Observable data.
UI components observe changes and update the screen.
Compose UI:
ViewModel updates State or MutableStateFlow.
Compose automatically recomposes UI based on updated state.

7. System handles any low-level operations

Data persistence, network, or other OS-level tasks are handled by the Android system.

This includes managing threads, security, and device hardware if needed.

How XML and Compose differ in this flow

Conclusion

The Android SDK architecture provides everything needed to build high-quality apps, from managing memory and hardware to building modern user interfaces.

The lower layers (Kernel, HAL) deal with system-level tasks.
The middle layers (Native Libraries, Runtime) power your app's logic.
The top layer (Application Framework) is where developers build screens, logic, and interactions.

With Jetpack Compose, Android now supports a fully declarative way to build UI, making development faster and more maintainable compared to traditional XML.

iOS SDK Architecture Explained

Flutter SDK Architecture Explained

iOS SDK Architecture

Binoy Vijayan — Sun, 11 May 2025 04:34:52 +0000

Apple’s iOS SDK is designed in layered architecture, allowing developers to interact at different levels depending on their needs. Each layer builds on top of the lower ones, abstracting complexity while still providing powerful capabilities.

Key Layers:

Cocoa Touch: High-level frameworks (UIKit, SwiftUI, Foundation)
Media: Audio, video, graphics (Core Animation, AVFoundation)
Core Services: System services (Core Data, iCloud, SQLite)
Core OS: Kernel, Security, low-level access

Execution Model:

Compiled into native ARM code using LLVM (via Xcode).
Uses MVC/MVVM design patterns.
Tight integration with Apple’s hardware and OS features.

Core OS Layer

The Core OS Layer is the foundational layer in the iOS SDK architecture. It directly interacts with the hardware of the device and provides essential system-level services. This layer ensures that the iOS environment operates smoothly, supporting higher-level services and apps.

1. Darwin Kernel:

The Darwin Kernel is the heart of the Core OS Layer and is derived from the Unix-based BSD (Berkeley Software Distribution). It provides essential services to all applications running on the device and manages hardware resources. Darwin includes components like memory management, process management, networking, file systems, and security.
Memory Management: Ensures that each app gets the memory it needs while keeping the system stable.
File System: Manages the file system, including how files are stored and accessed on disk.
Process Management: Handles processes, threads, and scheduling for multitasking.

Key Responsibilities:
Handles low-level operations like CPU scheduling, network communication, and disk management.
Provides system calls to interact with hardware and perform operations

2. libSystem:

libSystem is a collection of system libraries that form the foundation of the iOS system. It includes fundamental APIs required by applications and the operating system.
It encompasses functions for memory allocation, thread management, file I/O, and more.
Key Components:
libc (C Standard Library): Provides standard C libraries and essential functions like printf(), malloc(), free(), and open().
libdispatch: Responsible for managing concurrency through Grand Central Dispatch (GCD), which helps in scheduling tasks in parallel.

3. Security Framework:

The Security Framework ensures that iOS apps and users can safely store sensitive data and communicate securely. It provides features like encryption, certificates, keychain access, and secure networking.
Keychain Services: Secure storage of passwords, keys, and other sensitive data.
Data Encryption: Encrypts files and communications to ensure privacy.
SSL/TLS: For secure communications over the internet.

4. Power Management:

The Core OS Layer handles power management to ensure efficient use of battery life, which is crucial for mobile devices. It regulates how hardware components like the CPU, display, and network interfaces use power to extend battery life.
Idle Sleep: Manages when the device should go into sleep mode to conserve battery.
App Power Usage: Helps manage background tasks to avoid draining the battery unnecessarily.

5. Networking:

iOS supports networking through various protocols and APIs in the Core OS Layer. This layer handles communication over Wi-Fi, Bluetooth, cellular, and NFC.
TCP/IP Stack: The protocol stack for all network communications.
Bonjour: Apple's implementation of zero-configuration networking, allowing devices to discover each other on local networks.

6. Device Drivers:

The Core OS layer provides direct communication with device hardware. This includes access to physical components such as the camera, microphone, GPS, accelerometer, and other sensors.
Hardware Abstraction Layer (HAL): Abstracts hardware communication so that higher layers can interact with devices without dealing with hardware specifics.

Summary of Core OS Layer Functions:

System-level services like memory and process management.
File system and network management.
Security features to protect user data and communications.
Device hardware interaction, including power management and sensor support.
Ensures stability and efficiency for the entire system.

Conclusion:

The Core OS Layer is the most fundamental level in the iOS architecture, dealing with the interaction between software and hardware. It provides essential low-level services that all other layers depend on for functionality, efficiency, and security.

Core Services Layer

The Core Services layer provides essential functionality and services that underpin much of the app logic. It sits just above the Core OS layer and serves as the bridge between the lower-level system functions and higher-level app features.

1. Core Data

What It Is: A powerful object graph and persistence framework provided by Apple.
Purpose: Manages the model layer of an app’s MVC architecture.
Key Capabilities:
Stores complex object graphs.
Handles data persistence using SQLite or binary formats.
Supports data versioning and migration.
Features undo/redo and change tracking.

2. CloudKit / iCloud

What It Is: Apple’s cloud syncing framework that connects apps to iCloud storage.
Purpose: Enables users to sync their app data seamlessly across devices.

Key Capabilities:
Save structured data in private, shared, and public databases.
Push notifications for updates.
Integrated user authentication via Apple ID.
End-to-end encryption for sensitive data.

3. Foundation Framework

What It Is: The fundamental utility layer of iOS and macOS development.
Purpose: Provides essential data types, collections, file handling, and networking.

Key Capabilities:
NSString, NSArray, NSDictionary, and other base types.
Date, TimeZone, and localisation tools.
URLSession for network communications.
Threading and operation queues for asynchronous tasks.

4. SQLite

What It Is: A lightweight, relational database engine built into iOS.
Purpose: Provides low-level SQL access to data, used directly or via Core Data.

Key Capabilities:
ACID-compliant transactions.
Ideal for apps requiring structured local storage.
Portable and zero-configuration.

5. Core Location

What It Is: A framework to access the device's location and movement.
Purpose: Enables features like maps, geofencing, fitness tracking.

Key Capabilities:
GPS and cellular/Wi-Fi-based positioning.
Geofencing and region monitoring.
Heading (compass), speed, and altitude data.

6. HealthKit

What It Is: A centralised repository for health and fitness data.
Purpose: Enables secure sharing of health data between apps and Apple’s Health app.

Key Capabilities:

Unified health data store.
Supports permissions for specific data types (heart rate, steps, etc.).
Background updates and real-time data capture.

7. StoreKit

What It Is: The framework used to implement in-app purchases.
Purpose: Provides monetisation features for apps.

Key Capabilities:
Product listing and purchase handling.
Subscription support.
Receipt validation and app store integration.

8. PassKit

What It Is: Interfaces for Apple Wallet and Apple Pay.
Purpose: Enables apps to use digital passes and integrate payment options.

Key Capabilities:
Create and manage passes (boarding passes, event tickets, etc.).
Apple Pay integration for contactless payments.
Support for loyalty programs and coupons.

9. Accounts Framework

What It Is: System-wide user account management.
Purpose: Simplifies access to external services like social networks and email.

Key Capabilities:
Secure storage of credentials.
OAuth and token handling.
Unified interface to access user accounts.

Media Layer

The Media Layer sits above Core Services and provides high-level APIs for audio, video, graphics, and animations. It empowers developers to create rich and immersive user experiences.

1. Core Animation

What It Is: A powerful graphics rendering and animation framework.
Purpose: Enables smooth animations and transitions across the UI.
Key Capabilities:
Implicit and explicit animations.
Layer-based rendering.
Hardware-accelerated performance.
Used by UIKit and SwiftUI behind the scenes.

2. AVFoundation

What It Is: Apple’s framework for working with audio and video.
Purpose: Handles media playback, capture, editing, and streaming.

Key Capabilities:
Play/record audio and video.
Edit, trim, and compose multimedia.
Stream media from URLs.
Add subtitles and timed metadata.

3. Core Graphics (Quartz 2D)

What It Is: A 2D drawing engine.
Purpose: Enables rendering shapes, images, and text on screen.
Key Capabilities:
Vector-based rendering.
PDF context generation.
Gradient and shadow support.
Anti-aliasing and compositing.

4. Core Image

What It Is: An image processing and analysis framework.
Purpose: Apply real-time filters and effects to images and video.
Key Capabilities:
Face detection, blur, and color correction.
Hardware-accelerated filter chaining.
Custom filter creation with CIKernel.

5. Metal

What It Is: Apple’s low-level GPU-accelerated graphics and compute framework.
Purpose: High-performance rendering and parallel data processing.
Key Capabilities:
3D rendering for games and simulations.
Machine learning acceleration.
Shader customisation and advanced graphics pipelines.

6. SceneKit

What It Is: A 3D graphics framework.
Purpose: Build and render 3D scenes and animations.
Key Capabilities:
Physics simulation.
Importing 3D assets (DAE, USDZ).
Camera, lighting, and materials.

7. SpriteKit

What It Is: A 2D game engine.
Purpose: Create animated sprites and casual 2D games.
Key Capabilities:
Physics engine support.
Sound integration.
Particle systems and animations.

8. AudioToolbox / CoreAudio

What It Is: Lower-level audio processing frameworks.
Purpose: Enable real-time, low-latency audio manipulation.
Key Capabilities:
MIDI, audio units, audio queues.
Audio recording and playback.
3D audio spatialization (with AVAudioEngine).
Implicit and explicit animations.
Layer-based rendering.
Hardware-accelerated performance.
Used by UIKit and SwiftUI behind the scenes.

Cocoa Touch Layer

The Cocoa Touch layer is the topmost layer in iOS architecture. It provides the user interface (UI) frameworks and the building blocks for app development. This is where developers interact most when building native iOS apps.

1. UIKit

Primary framework for building graphical user interfaces.
Handles touch events, layout, animations, views, and user interactions.
Contains classes like UIView, UIViewController, UIButton, etc.

2. SwiftUI

A modern declarative UI framework introduced in iOS 13.
Uses Swift's syntax to define UI in a state-driven way.
Allows live previews and better cross-platform UI code reuse (iOS, macOS, watchOS, tvOS).

3. Foundation

Provides basic data types, collections, date/time, and utility classes.
Classes like NSArray, NSDictionary, Date, FileManager, etc.
Often used in both Swift and Objective-C apps.

4.PushKit & Notification Framework

Enables remote and local notifications.
PushKit handles VoIP and other background notifications.

5. Multitasking

Manages app lifecycle events and background execution.
Enables apps to handle background tasks, fetch operations, and audio playback.

6. Gesture Recognisers

Enables tap, swipe, pinch, and custom gestures.
Auto Layout & Interface Builder (IB)
Tools and APIs for adaptive UI.
Supports dynamic screen sizes and orientations.

Data Flow - Data Flow on Button Tap

1. User Interaction (Cocoa Touch Layer):

The user taps a button on the screen.
UIKit (or SwiftUI) detects the tap using gesture recognisers or target-action patterns.

2. Event Handling (Cocoa Touch Layer):

UIKit routes the tap event to the appropriate view controller.
The view controller runs a method like @IBAction func buttonTapped() or similar logic in SwiftUI.

3. Business Logic (Core Services Layer):

Inside the tapped method, app logic is executed.
This may involve:
Fetching/saving data using Core Data
Communicating with cloud using iCloud
Reading/writing to local DB via SQLite
Making a network request using URLSession

4. System Services & APIs (Core Services & Media Layer):

If media is involved (e.g., playing sound, showing image), Core Animation, AVFoundation, or similar APIs are called.
These interact with lower-level services.

5. OS Interaction (Core OS Layer):

The Core OS manages low-level services like:
Reading from disk
Security checks (Keychain, permissions)
Networking (TCP/IP stack)
Scheduling the CPU, managing memory
Handling device drivers (e.g., sensors if involved)

6. Output to User:

A response (e.g., alert shown, data updated) is processed by UIKit or SwiftUI and rendered on the screen.
If animations or transitions are involved, Core Animation handles rendering.

When a user taps a button in your app:

The top layer (UIKit or SwiftUI) captures the interaction.
The event is passed to your app’s logic (usually in a view controller or SwiftUI handler).
Your logic might fetch data, save something, or request media or cloud services — all handled by the Core Services and Media layers.
Those layers talk to the Core OS, which handles low-level tasks like file access or network communication.
Finally, the result travels back up through the layers and updates the UI for the user to see.

Conclusion

The iOS SDK is built in layers, each with a clear purpose. The lower layers handle important things like memory, security, and how your app talks to the device. The middle layers manage data, media, and system services. The top layer helps you build user interfaces and control how the app works.

This setup makes it easier for developers to build apps without worrying about how everything works underneath. Apple designed this system to work smoothly with their devices, so apps run fast, look great, and stay secure.
Overall, the iOS SDK gives developers everything they need to create powerful and reliable apps for iPhones, iPads, and other Apple devices.

Android SDK Architecture Explained

Flutter SDK Architecture Explained

A Deep Dive into WhatsApp’s Encryption: Identity, Keys, and Message Security

Binoy Vijayan — Wed, 15 Jan 2025 09:42:55 +0000

WhatsApp's End-to-End Encryption

End-to-End Encryption (E2EE) is a way to keep your messages private. With this feature, only you and the person you're talking to can see your messages. WhatsApp uses E2EE by default to ensure your messages are protected.

What is End-to-End Encryption?

End-to-end encryption means that your messages, calls, and shared files are encrypted on your phone and can only be decrypted on the other person’s phone. No one else, not even WhatsApp, can read or listen to them.

E2EE involves three key components: identity verification, session key generation, and message encryption. Here’s how each part works:

Identity Verification ensures that the communication partners are legitimate and that they are who they claim to be. This prevents impersonation and ensures the authenticity of both parties.
Session Key Generation establishes a secure connection between the two users. It allows both parties to independently derive the same shared secret (session key) that will be used to encrypt and decrypt the messages.
Message Encryption ensures that the content of the communication remains private. The session key is used to encrypt the messages, so only the intended recipient, who has the corresponding key, can decrypt and read the messages.

Step-by-Step Explanation of Identity Verification

1. User Setup: Generating Keys

Each WhatsApp user generates a public-private key pair when they first set up their account:

Private Identity Key: This is kept secure on the user’s device and is never shared with anyone.
Public Identity Key: This is shared with other users so they can authenticate the user’s identity.

Example:

Ahalya generates her Identity Key Pair:
- Private Identity Key: Stored securely on Ahalya’s phone.
- Public Identity Key: Shared with WhatsApp’s servers.
Bharath generates his Identity Key Pair:
- Private Identity Key: Stored securely on Bharath’s phone.
- Public Identity Key: Shared with WhatsApp’s servers.

2. Key Exchange: Sharing Public Keys

When Ahalya wants to start a conversation with Bharath, both exchange their public identity keys. These keys are used to authenticate each other and ensure they are communicating with the correct person.

Example:

Ahalya sends Bharath a message. Along with the message, Ahalya’s Public Identity Key is also sent to Bharath.
Bharath’s WhatsApp app receives Ahalya’s Public Identity Key, and Bharath’s Public Identity Key is also shared with Ahalya’s device.

3. Security Code Verification: Confirming Key Authenticity

WhatsApp provides a Security Code to help users verify the authenticity of the public keys they receive. This code acts as a fingerprint of the user’s Public Identity Key.

WhatsApp automatically displays security codes for each user’s Public Identity Key in the contact info section.
If a user’s Public Identity Key changes (e.g., due to a device reinstall), WhatsApp notifies both users.

Example:

Ahalya’s app displays Bharath’s Security Code, and Bharath’s app displays Ahalya’s Security Code.
If the security codes match, both users can trust that their communication is secure. If not, WhatsApp alerts them to potential issues.

Step-by-Step Explanation of Session Key Generation

1. Key Exchange Setup

Before generating the session key, both users exchange the following public keys:

Identity Key Pair: A long-term key pair for verifying identity.
Signed Pre-Key Pair: A pre-generated key pair signed using the user’s private identity key.
One-Time Pre-Key: A disposable public key ensuring session uniqueness.

When User A wants to communicate with User B, they exchange:

User A’s public identity key
User A’s public signed pre-key
User A’s one-time pre-key
User B’s corresponding public keys

2. Key Authentication

After receiving each other’s public keys, both users verify the keys:

User A verifies User B’s signed pre-key using User B’s public identity key.
Similarly, User B verifies User A’s signed pre-key using User A’s public identity key.

This prevents impersonation and ensures both users are legitimate.

3. Deriving the Shared Session Key

Each user independently computes the same shared session key using their private keys and the other user’s public keys. The session key is unique and never transmitted over the network. Here’s how this happens in detail:

Private and Public Key Combination:
- User A combines:
  - Their private identity key with User B’s public signed pre-key to derive a partial key.
  - Their private identity key with User B’s public one-time pre-key to ensure uniqueness for the session.
- User B performs a similar process:
  - Their private identity key is combined with User A’s public signed pre-key.
  - Their private identity key is combined with User A’s public one-time pre-key.
Mathematical Agreement:
- Both users perform calculations to derive the same shared session key using the exchanged public keys and their private keys. The use of the one-time pre-key ensures that the session key is unique for this specific conversation.

For example:

User A calculates:

• Session Key = f(Private Key of A, Public Key of B)
User B calculates:

• Session Key = f(Private Key of B, Public Key of A)
The function ( f ) ensures that both calculations produce the same session key.

So, when you see f(Private Key of A,Public Key of B), it implicitly includes the process of combining A's private identity key with:

B's public identity key,
B's signed pre-key,
B's one-time pre-key.

Reference implementation in Swift

import Foundation
import CryptoKit

// Function to generate key pair (private and public keys)
func generateKeys() -> (privateKey: P256.KeyAgreement.PrivateKey,
                        publicKey: P256.KeyAgreement.PublicKey) {
    let privateKey = P256.KeyAgreement.PrivateKey()
    let publicKey = privateKey.publicKey
    return (privateKey, publicKey)
}

// Function to compute a shared symmetric key using private and peer's public key
func computeSharedSecret(privateKey: P256.KeyAgreement.PrivateKey,
                         peerPublicKey: P256.KeyAgreement.PublicKey) throws -> SymmetricKey {
    let sharedSecret = try privateKey.sharedSecretFromKeyAgreement(with: peerPublicKey)

    let symmetricKey = sharedSecret.hkdfDerivedSymmetricKey(
        using: SHA256.self,
        salt: "Diffie-Hellman".data(using: .utf8)!,
        sharedInfo: Data(),
        outputByteCount: 32
    )
    return symmetricKey
}

// Function to validate that both users derive the same shared secret
func validateSharedSecrets() -> Bool {
    let userAKeys = generateKeys()
    let userBKeys = generateKeys()

    do {
        let sharedSecretA = try computeSharedSecret(privateKey: userAKeys.privateKey, peerPublicKey: userBKeys.publicKey)
        let sharedSecretB = try computeSharedSecret(privateKey: userBKeys.privateKey, peerPublicKey: userAKeys.publicKey)

        // Compare the symmetric keys
        return sharedSecretA == sharedSecretB
    } catch {
        print("Error computing shared secret: \(error)")
        return false
    }
}

// Main execution
let isSharedSecretSame = validateSharedSecrets()
print("Shared secrets are the same: \(isSharedSecretSame)")

Ensuring Security:
- Since the session key is generated locally on each device and not transmitted over the network, it remains secure from potential eavesdroppers.
Session Key Properties:
- The session key is:
  - Unique to each session.
  - Disposable after use.
  - Essential for encrypting and decrypting messages during the conversation.

4. Ensuring Uniqueness with the One-Time Pre-Key

To make the session key unique for every session:

User A and User B incorporate the one-time pre-key into the key generation process. This ensures that even if keys are reused, the resulting session key will be different.
Once the one-time pre-key is used, it is discarded and cannot be reused, further enhancing security.

Message Encryption: Ensuring Privacy with the Session Key

1. Encrypting the Message (Sender Side)

When User A sends a message to User B:

The message starts as plaintext on User A’s device.
- Example: “Hello, how are you?”
The session key is used to encrypt the plaintext into ciphertext.
A nonce (a unique random number) is added to ensure identical messages produce different ciphertexts.
- Example Ciphertext: 4A8f2H93l!#gkL2
The ciphertext and nonce are sent to User B.

2. Decrypting the Message (Recipient Side)

When User B receives the encrypted message:

The ciphertext and nonce are received by User B’s device.
The session key (already generated on User B’s device) decrypts the ciphertext back into plaintext.
- Example: “Hello, how are you?”

Key Features of Message Encryption

Role of the Session Key:
- The session key ensures that only the sender and receiver can encrypt and decrypt messages.
- It is never transmitted over the network.
Use of a Nonce:
- Prevents identical messages from producing identical ciphertexts.
- Adds randomness, making it harder for attackers to identify patterns.
Message-Specific Encryption:
- Each message is encrypted individually, ensuring that compromising one message doesn’t affect others.
Forward Secrecy:
- Unique session keys for each conversation prevent past or future messages from being compromised.

Conclusion

WhatsApp’s End-to-End Encryption ensures that every message, call, and file shared is private, secure, and accessible only to the intended recipient. By combining robust identity verification, session key generation, and message encryption, WhatsApp protects users from eavesdropping, impersonation, and data breaches. Whether you’re sharing personal messages or sensitive information, WhatsApp’s encryption system provides the highest level of security and privacy.

With features like nonce-based encryption and forward secrecy, WhatsApp sets a high standard for secure communication, ensuring users can communicate confidently and privately.

Cryptographic Foundations

Whatsapp System Design

Navigating Escalation: How to Effectively Address Issues and Avoid Common Mistakes

Binoy Vijayan — Thu, 19 Sep 2024 06:30:43 +0000

Escalation is a crucial process in effective problem-solving, involving the referral of issues to higher levels of authority or expertise when they cannot be resolved at the current level. This approach ensures that challenges are addressed efficiently, leveraging additional resources and knowledge to overcome obstacles and drive success. Understanding the principles of escalation is essential for maintaining smooth operations and achieving organisational goals. This article explores the key aspects of escalation, including best practices, common mistakes, and the benefits of a well-managed escalation process.

Definition

Escalation is the process of seeking intervention or assistance from a higher level of authority or expertise when an issue or challenge cannot be resolved at the current level, ensuring that all reasonable efforts have been made to address the problem. This involves notifying relevant higher-ups or specialists to address critical issues, make decisions, or provide additional resources needed to overcome obstacles and ensure the success of a project, task, or operation.

Purpose

The real purpose of escalation is to ensure that unresolved issues are addressed and resolved in a timely and effective manner, by involving higher levels of authority or expertise. It is not about blaming or bypassing colleagues but about safeguarding the progress of a project, process, or operation.

Here are key reasons for escalating:

1. Resolve Critical Issues - When an issue cannot be solved at the current level and threatens to delay or derail a project, escalation brings in higher authority or additional resources to resolve it quickly.

2. Ensure Timely Decision-Making - Escalation is often necessary when a decision or action is needed urgently, and the current team or individual is unable or unwilling to make the required decision.

3. Overcome Bottlenecks - When a process or task is stuck due to lack of resources, expertise, or authority, escalating to a higher level can help unblock the situation by involving people who have more power or access to the necessary resources.

4. Prevent Negative Impact - Escalation helps mitigate risks by ensuring that potential problems are addressed before they cause significant damage to the project, budget, timelines, or team morale.

5. Access to Expertise - In cases where specialised knowledge or skills are needed to solve an issue, escalation helps bring in the necessary expertise that isn’t available at the current level.

6. Maintain Accountability - Escalating ensures that accountability is upheld and that the responsible individuals or teams are either equipped to handle the issue or the appropriate stakeholders are made aware of their limitations.

7. Protect Team Relationships - Escalation can be a neutral way to address conflicts or issues without damaging relationships within the team, as it allows for third-party intervention to facilitate resolution.

In summary, escalation is about ensuring that issues are resolved efficiently and preventing them from escalating further into larger problems, while ensuring the success of the task or project.

Common scenarios for escalating to the immediate upper level

Lack of authority: If a decision needs to be made but the current team or person doesn’t have the necessary authority.

Resource constraints: When additional resources, like time, budget, or personnel, are required to overcome an obstacle.

Expertise gaps: If the issue requires knowledge or skills beyond what the current level can provide.

Conflict resolution: When conflicts between teams or individuals cannot be resolved internally and need a higher-level perspective.

Critical risks or delays: If an unresolved issue could threaten the project’s success, timeline, or quality.

Mandatory recipients in escalation mail

1. Immediate Supervisor/Manager - They need to be informed of the issue and the escalation. They may also offer guidance or support.

2. Relevant Higher Management - If the issue requires decisions or intervention from higher levels of authority, include them to ensure the issue is addressed promptly.

3. Key Stakeholders - These individuals or teams are directly impacted by the issue or have a significant interest in its resolution.

Mandatory recipients in escalation mail

1. Subject Matter Experts (SMEs) - If the issue involves technical or specialised aspects, include SMEs who can provide insights or solutions.

2. Team Members Involved - If the issue affects or involves specific team members, they should be kept in the loop for transparency and collaboration.

3. Support or Help-desk Teams - If the issue relates to systems or services managed by support teams, they should be informed to assist with resolution.

Example Structure for an Escalation Email:

To: Immediate Supervisor/Manager
Cc: Relevant Higher Management, Key Stakeholders
Bcc: (if necessary for confidentiality)

Common Mistakes In Escalation

When escalating issues, certain common mistakes can undermine the effectiveness of the process.
Here are some key pitfalls to avoid:

1. Escalating Too Early

Mistake: Raising an issue before fully exploring all possible solutions at the current level.

Impact: Can lead to unnecessary escalation and may appear as if you’re avoiding responsibility.

2. Escalating Too Late

Mistake: Waiting until the issue becomes critical before escalating.

Impact: Can result in increased damage or delays, making the resolution more difficult and costly.

3. Lack of Clarity

Mistake: Failing to provide a clear, concise description of the issue, its impact, and any steps taken to resolve it.

Impact: Can lead to confusion and ineffective intervention from higher-ups.

4. Inadequate Documentation

Mistake: Not including relevant details or evidence of previous attempts to resolve the issue.

Impact: Higher management may not have enough information to make an informed decision.

5. Inappropriate Recipients

Mistake: Including individuals who are not relevant to the issue or omitting key stakeholders.

Impact: Can lead to delays or ineffective resolutions due to the wrong people being involved.

6. Emotional or Blameful Language

Mistake: Using emotional language or assigning blame in the escalation communication.

Impact: Can create defensiveness or conflict, making it harder to resolve the issue.

7. Failure to Propose Solutions

Mistake: Not suggesting potential solutions or actions to address the issue.

Impact: Higher management may struggle to decide on an appropriate course of action.

8. Ignoring Follow-Up

Mistake: Failing to follow up on the escalation to track progress or ensure resolution.

Impact: The issue may remain unresolved or may not be handled as expected.

9. Over-Escalating

Mistake: Escalating issues that could be managed at the current level or by the immediate supervisor.

Impact: Can strain relationships and create unnecessary workload for higher management.

Avoiding these mistakes helps ensure that the escalation process is effective, efficient, and maintains professionalism.

Escalation Etiquette

Escalation etiquette refers to the proper way of raising concerns or issues to higher management or relevant authorities when they can't be resolved at a lower level.

Here are some key principles to follow:

1. Evaluate the Issue First

Ensure that all reasonable efforts have been made to resolve the problem at the current level before escalating.

Avoid escalating trivial issues that could be resolved through direct communication.

2. Follow the Chain of Command

Escalate issues through the proper hierarchy, starting with your immediate supervisor or lead.

Bypassing layers of management can lead to misunderstandings and tension.

3. Be Objective and Professional

Present the issue clearly, factually, and without emotion. Focus on the impact on the project or team rather than personal feelings.

Avoid assigning blame. Instead, describe the problem and its effects.

4. Provide Evidence and Context

Document all the steps taken to resolve the issue, including communication records and any attempts at mediation.

Be specific about why the issue needs escalation (e.g., missed deadlines, unresolved conflicts).

5. Suggest Solutions

When escalating, also propose potential solutions or alternatives.

This shows that you’re focused on resolving the problem, not just pointing it out.

6. Be Timely

Don’t wait until an issue becomes critical. Escalate in a timely manner, allowing enough time for it to be addressed without causing further delays.

7. Communicate with Transparency

Inform the involved parties before escalating, so they’re aware of your concerns and the reason for escalation.

Ensure that the person you escalate to is fully aware of the situation and its urgency.

8. Follow-Up

After escalating, keep track of the issue’s progress and follow up if necessary.

Ensure that the issue is either resolved or addressed in a way that is satisfactory for all parties involved.

These principles help maintain professionalism while ensuring issues are handled effectively.

Advantages Of Escalation

Escalation ensures that problems are addressed quickly by involving higher authority or expertise, preventing issues from escalating further and causing more significant delays or damage.

Higher levels of authority or specialised experts often have access to additional resources, such as budget, personnel, or tools, that can help resolve complex issues more effectively.

By involving individuals with more experience or higher decision-making authority, escalation helps in making well-informed decisions that consider broader implications and long-term impacts.

Engaging higher-ups or experts brings new perspectives and expertise to the table, which can lead to more innovative and effective solutions to complex problems.

Addressing issues promptly through escalation can prevent them from becoming larger problems, reducing the risk of negative outcomes and ensuring smoother project progress.

Escalation helps in clarifying responsibility and accountability, as it involves individuals who are positioned to take decisive action and ensure follow-through.

Escalating issues provides visibility to higher management, ensuring that they are aware of critical challenges and can provide necessary support or intervention.

Proper escalation can foster better team collaboration by involving relevant stakeholders and ensuring that everyone is aligned in addressing significant challenges.

By analysing and learning from escalation scenarios, organisations can identify areas for improvement, refine processes, and enhance their overall problem-solving strategies.

Knowing that there is a clear process for escalating issues can boost team confidence and morale, as employees feel supported and assured that challenges will be managed effectively.

Disadvantages Of Escalation

Escalating issues can slow down the resolution process as higher-level approvals or interventions may take time, potentially causing delays.

Excessive escalation can overwhelm senior management with minor issues, diverting their attention from strategic responsibilities.

Frequent escalation can undermine a team’s ability to resolve problems independently, leading to reduced problem-solving skills and initiative.

Regularly escalating issues can foster a culture where team members rely too heavily on higher-ups for solutions, diminishing individual accountability.

Continuous or frequent escalation can lead to “escalation fatigue,” where senior management becomes less responsive or less diligent in addressing escalated issues.

Escalation can create friction between teams or departments, especially if it implies that one group is failing to meet expectations.

Excessive escalation may be perceived as a sign of incompetence, which can damage professional reputations and undermine trust.

The need to escalate issues can add stress to employees, especially if they view it as a failure in handling responsibilities

Premature escalation can waste senior management’s time on issues that might have been resolved at lower levels, leading to inefficiencies.

Unnecessary escalation can divert resources, including time and personnel, from other critical tasks or projects.

Summary

In summary, escalation is a vital process for addressing issues that cannot be resolved at the current level of authority. It offers numerous advantages, such as timely resolution, access to additional resources, and informed decision-making, all of which contribute to effective problem-solving and organisational success. However, it also has its disadvantages, including potential delays, overburdening of senior management, and the risk of creating dependency within teams.

Understanding and managing the escalation process is essential for maintaining smooth operations and achieving project goals. By following best practices—such as escalating issues only when necessary, providing clear documentation, and choosing the right recipients—organisations can leverage the benefits of escalation while mitigating its drawbacks.

Ultimately, a well-managed escalation process enhances accountability, transparency, and resource allocation, supporting continuous improvement and fostering a more resilient and adaptive organisation. Effective escalation ensures that critical issues are addressed promptly and efficiently, paving the way for successful outcomes and sustained organisational performance.

In my view, escalation should be the final step in addressing an issue, only pursued after all possible solutions at the current level have been thoroughly explored. Immediate escalation, without attempting to resolve the problem within the team or department, is not a good practice and is generally discouraged. This approach undermines the team's ability to handle challenges independently and places unnecessary burden on higher management. Escalating too soon can signal a lack of problem-solving initiative, whereas a well-considered escalation demonstrates due diligence and responsible decision-making.

Competence vs. Performance: Key Differences

Binoy Vijayan — Sat, 27 Jul 2024 15:18:41 +0000

Competence and performance are often misunderstood or used interchangeably without a clear understanding of their differences. Competence refers to the underlying knowledge, skills, and abilities that a person possesses, representing their potential to perform a task. It is what someone is capable of doing under ideal conditions. On the other hand, performance is the actual execution or demonstration of these tasks in real-life situations, showing how well someone applies their competence practically.

This means that a highly competent person might not always be a high performer, and conversely, a high performer might not always have high competence. Competence represents the potential and ability to perform tasks, but various external factors can influence actual performance. For example, someone with great musical competence might underperform in a concert due to nervousness or poor conditions. Conversely, a person with moderate competence might perform exceptionally well under optimal conditions or due to other strengths, such as effective practice or adaptability.

In software development, competence refers to a developer's knowledge, skills, and abilities related to coding, problem-solving, and understanding software architecture. This is what the developer is capable of doing under ideal conditions. Performance, however, is the actual application of these skills in real-world projects, which includes meeting deadlines, debugging, collaborating with team members, and adapting to changing requirements.

For instance, a developer might have high competence, knowing multiple programming languages, understanding complex algorithms, and being familiar with best coding practices. However, their performance might not always reflect this competence due to factors such as tight deadlines, inadequate tools, or workplace stress. Conversely, a developer with moderate competence might consistently deliver high performance by effectively managing their time, using efficient coding practices, and leveraging strong teamwork and communication skills.

This demonstrates that high competence does not automatically translate to high performance, and high performance can be achieved even with moderate competence, depending on the circumstances and other influencing factors.

How you can assess whether the candidate will be a good performer:

Behavioural Interviews: Use behavioural interview questions to understand how the candidate has handled specific situations in the past. Focus on questions about problem-solving, teamwork, conflict resolution, and adaptability.

Situational Questions: Pose hypothetical scenarios related to the role and ask how they would handle them. This can give insight into their thought process and decision-making skills.

Cultural Alignment: Assess whether the candidate’s values, work style, and approach align with your company’s culture and values.
Team Interaction: Involve key team members in the interview process to gauge how well the candidate interacts with potential colleagues and fits within the team dynamic.

Portfolio or Work Samples: Review any portfolios, work samples, or project reports they provide to see tangible evidence of their achievements and capabilities.

Achievements and Awards: Consider any awards or recognitions they’ve received that may indicate high performance.

By combining these methods, you can gain a comprehensive view of the candidate’s potential to perform well in your organisation, even without reference checks.

Swift Custom Array Implementation Using UnsafeMutablePointer

Binoy Vijayan — Sun, 09 Jun 2024 12:33:58 +0000

In this article, we explore a custom array implementation in Swift using UnsafeMutablePointer. This implementation offers insights into manual memory management, dynamic resizing, and conformance to protocols such as CustomDebugStringConvertible and Sequence. The goal is to provide a detailed overview of the internal workings of Swift arrays.

Overview

The custom array MyArray allows storage and manipulation of elements of any type T. It supports dynamic resizing, appending, insertion, and removal of elements, while ensuring memory safety through proper allocation and deallocation.

Key Features

Dynamic Resizing: Automatically adjusts the capacity of the array when it reaches its limit.
Memory Management: Uses UnsafeMutablePointer for low-level memory operations.
Sequence Conformance: Implements the Sequence protocol for iteration.
Debug Description: Provides a custom debug description for easier debugging.

Implementation Details

Properties

struct MyArray<T> : CustomDebugStringConvertible, Sequence {
    private var capacity: Int
    private var storage: UnsafeMutablePointer<T>
    private var size: Int

    var count: Int {
        return size
    }

    var isEmpty: Bool {
        return size == 0
    }

capacity: The maximum number of elements the array can hold without resizing.

storage: A pointer to the array's memory storage.

size: The current number of elements in the array.

count: Returns the number of elements in the array.

isEmpty: Checks if the array is empty.

Initialiser

init(initialCapacity: Int = 2) {
        self.capacity = initialCapacity
        self.size = 0
        self.storage = UnsafeMutablePointer<T>.allocate(capacity: initialCapacity)
    }

Resizing

private mutating func resize() {

   if size >= capacity {

     /* Double the capacity */
     let newCapacity = capacity * 2

     /* Allocating new storage with new capacity */
     let newStorage = UnsafeMutablePointer<T>.allocate(capacity: newCapacity)

     /* Copying the existing elements to the new storage */
     for i in 0..<count {
         newStorage[i] = storage[I]
     }

     /* Deallocating old storage */
     storage.deallocate()
     storage = newStorage
     capacity = newCapacity
   }
}

The resize method doubles the capacity when needed and reallocates memory, copying existing elements to the new storage.

Adding Elements

public mutating func append(_ item: T) {
   resize()
   storage[size] = item
   size += 1
}

The append method adds a new element to the end of the array, resizing if necessary.

Inserting Elements

public mutating func insert(_ item: T, at index: Int) {
   guard index >= 0 && index <= size else {
       fatalError("Index out of bounds")
   }
   resize()
   for i in stride(from: count, to: index, by: -1) {
       storage[i] = storage[i - 1]
   }
   storage[index] = item
   size += 1
}

The insert method inserts an element at a specified index, shifting elements as needed.

Removing Elements

@discardableResult
public mutating func remove(at index: Int) -> T {
   guard index >= 0 && index < size else {
       fatalError("Index out of bounds")
   }
   let removedElement = storage[index]
   for i in index..<size - 1 {
      storage[i] = storage[i + 1]
   }
   size -= 1
   return removedElement
}

The remove method removes an element at a specified index and returns it.

Clearing the Array

public mutating func removeAll() {
    // Deallocate the existing elements
    storage.deallocate()
    capacity = 2
    // Reinitialise the storage
    storage = UnsafeMutablePointer<T>.allocate(capacity: capacity)
        size = 0
}

The removeAll method deallocates all elements and resets the array.

Subscript

subscript(index: Int) -> T {
   get {
       guard index >= 0 && index < size else {
           fatalError("Index out of bounds")
       }
       return storage[index]
   }
   set {
       guard index >= 0 && index < size else {
           fatalError("Index out of bounds")
       }
       storage[index] = newValue
   }
}

The subscript allows getting and setting elements at a specified index.

Sequence Conformance

func makeIterator() -> AnyIterator<T> {
   var index = 0
   return AnyIterator {
       guard index < self.size else {
           return nil
       }
       let element = self.storage[index]
       index += 1
       return element
   }
}

The makeIterator method provides an iterator for the array.

Debug Description

var debugDescription: String {
   var result = "["
   for i in 0..<size {
      result += "\(storage[I])"
      if i < size - 1 {
        result += ", "
      }
   }
   result += "]"
   return result
}

The debugDescription property returns a string representation of the array.

Conclusion

This custom array implementation demonstrates how to manage memory manually and provides basic array functionalities. While UnsafeMutablePointer offers powerful capabilities, it requires careful handling to avoid memory leaks and ensure safety. This implementation serves as an educational example and can be extended for more advanced use cases.

Please find the complete source code Here

Youtube Video

Efficient and Flexible Communication in Software Architecture: Swift custom implementation of NotificationCenter

Binoy Vijayan — Sun, 02 Jun 2024 12:41:34 +0000

In many software applications, efficient and flexible communication between various components is essential for maintaining a clean and maintainable architecture. Apple’s NSNotificationCenter is a widely used mechanism that facilitates such communication by allowing objects to post and observe notifications without needing to know about each other.

This article aims to guide you through the process of creating a custom notification center, similar to NSNotificationCenter, called MyNotificationCenter. We will explore its key features, including adding and removing observers, posting notifications, and ensuring thread safety. By the end of this guide, you will understand how to implement a robust and efficient notification system tailored to your application's unique needs.

Here are the components explained with the code snippet.

MyNotificationCenter

MyNotificationCenter is a singleton class designed to facilitate a custom notification center for broadcasting and receiving notifications within an application. It enables objects to register for specific notifications and handle them when posted.

Properties

static let shared: MyNotificationCenter

A shared singleton instance of MyNotificationCenter.

private var observers: [String: [(AnyObject, Selector)]]

A dictionary storing observers for each notification name, where the key is the notification name and the value is a list of tuples containing the observer object and its associated selector.

private let queue: DispatchQueue

A concurrent dispatch queue used to synchronise access to the observers dictionary.

Initializer

private init()

Initializes the observers dictionary and the concurrent dispatch queue. The initializer is private to enforce the singleton pattern.
Methods

func addObserver(object: AnyObject, name: String, selector: Selector)

Registers an observer for a specific notification.

Parameters:

object: The observer object.
name: The name of the notification.
selector: The selector to be called when the notification is posted.

func post(name: String, userInfo: [AnyHashable: Any]? = nil)

Posts a notification to all registered observers.

Parameters:
name: The name of the notification.
userInfo: An optional dictionary containing additional information about the notification.

func removeObserver(object: AnyObject)

Removes a specific observer from all notifications it is registered for.

Parameters:

object: The observer object to be removed.

MyNotificationObserver

MyNotificationObserver is a class that demonstrates how to use MyNotificationCenter to register for and handle notifications. It conforms to the Observable protocol.

Initializer

init()

Registers the instance as an observer for the "MyNotification" notification with MyNotificationCenter.

Methods

@objc func notificationSelector(_ userInfo: [AnyHashable: Any]?)

Handles the "MyNotification" notification when it is posted.

Parameters:

userInfo: An optional dictionary containing additional information about the notification.

Deinitializer

deinit

Removes the instance from the observers of "MyNotification" in MyNotificationCenter.

This documentation provides an overview of the MyNotificationCenter and MyNotificationObserver classes, explaining their purpose and how they interact to enable custom notification handling in your application.

Here is the complete source code for the same

GoF-Interpreter Pattern

Binoy Vijayan — Wed, 13 Mar 2024 09:21:17 +0000

The Interpreter Pattern is a behavioural design pattern that defines a way to evaluate language grammar or expressions. It provides a mechanism to interpret or parse sentences in a language, represented as a set of objects or expressions. This pattern is particularly useful when dealing with problems that can be easily represented in a grammar and when efficiency is not a primary concern.

Structure :

AbstractExpression: Defines an abstract interface for interpreting expressions. Typically, each grammar rule in the language corresponds to a subclass of this interface.

TerminalExpression: Represents terminal symbols in the grammar. These are the basic building blocks of the language. Terminal expressions implement the interpretation operation directly.

NonterminalExpression: Represents non-terminal symbols in the grammar, which are combinations of one or more terminal or non-terminal symbols. Non-terminal expressions interpret complex expressions by delegating interpretation to their subexpressions.

Context: Contains any necessary global information that the interpreter may need to interpret expressions. It provides the context for interpretation.

Client: Builds the abstract syntax tree representing a particular sentence in the language and initiates the interpretation process.

Workflow:

Construction of Abstract Syntax Tree (AST): The client builds an abstract syntax tree representing the structure of the sentence or expression to be interpreted. Each node in the tree represents a construct in the language, such as a terminal or non-terminal expression.

Interpretation: The client initiates the interpretation process by calling the interpret() method on the root node of the abstract syntax tree. The interpretation process recursively traverses the tree, evaluating each node based on its type and context.

Example Use Cases

Query Languages Interpreting queries in databases or search engines.

Rule-Based Systems Implementing rule engines or expert systems where rules are defined in a formal language.

Mathematical Expressions

Evaluating mathematical expressions in calculator applications or mathematical software.

Real world example

An example of the Interpreter pattern in a common person's life can be found in the context of navigating and understanding street signs while driving.

Here's how the Interpreter pattern applies

AbstractExpression: This represents the abstract class or protocol defining the interpret(context:) method. In the example, it could be represented by the abstract notion of interpreting traffic symbols and signals.

TerminalExpression: These are the basic expressions that cannot be further decomposed. In the example, street signs and traffic signals serve as terminal expressions.

NonterminalExpression: These are composite expressions formed by combining multiple sub-expressions. In the example, driving actions or pedestrian actions based on the interpretation of street signs and traffic signals could be considered non-terminal expressions.

Context: The environment or context in which the expressions are evaluated. In the example, the road network and traffic regulations form the context.

Client: This is the entity that uses the interpreter pattern to interpret expressions in the context. In the example, drivers and pedestrians act as clients, interpreting street signs and traffic signals to navigate safely.

Here we are trying to translate the same into Swift code

// AbstractExpression
protocol TrafficInterpreter {
    func interpret(_ context: RoadContext) -> String
}

// TerminalExpression
class StreetSign: TrafficInterpreter {
    private let message: String

    init(message: String) { self.message = message }

    func interpret(_ context: RoadContext) -> String {
        return "Interpreting street sign: \(message)"
    }
}

class TrafficSignal: TrafficInterpreter {
    private let color: String

    init(color: String) { self.color = color }

    func interpret(_ context: RoadContext) -> String {
        return "Interpreting traffic signal: \(color)"
    }
}

// NonterminalExpression
class DrivingAction: TrafficInterpreter {
    private let action: String

    init(action: String) { self.action = action }

    func interpret(_ context: RoadContext) -> String {
        return "Taking driving action: \(action)"
    }
}

class PedestrianAction: TrafficInterpreter {
    private let action: String

    init(action: String) { self.action = action }

    func interpret(_ context: RoadContext) -> String {
        return "Taking pedestrian action: \(action)"
    }
}


// Context
class RoadContext {
    /* Additional context information if needed */
}

// Client
class Driver {
    private let roadContext: RoadContext

    init(roadContext: RoadContext) { self.roadContext = roadContext }

    func interpret(_ expression: TrafficInterpreter) -> String {
        return expression.interpret(roadContext)
    }
}

class Pedestrian {
    private let roadContext: RoadContext

    init(roadContext: RoadContext) {
        self.roadContext = roadContext
    }

    func interpret(_ expression: TrafficInterpreter) -> String {
        return expression.interpret(roadContext)
    }
}

// Example Usage
let roadContext = RoadContext()

let driver = Driver(roadContext: roadContext)
let pedestrian = Pedestrian(roadContext: roadContext)

let streetSign = StreetSign(message: "Speed Limit 40")
let trafficSignal = TrafficSignal(color: "Red")

print(driver.interpret(streetSign)) // Output: Interpreting street sign: Speed Limit 40
print(pedestrian.interpret(trafficSignal)) // Output: Interpreting traffic signal: Red

In this diagram:

TrafficInterpreter is the abstract expression defining the interpret(context:) method.

StreetSign, TrafficSignal, DrivingAction, and PedestrianAction are concrete implementations of TrafficInterpreter, representing various expressions.

RoadContext represents the context in which the expressions are interpreted.

Conclusion:

The Interpreter Pattern provides a powerful mechanism for interpreting and evaluating expressions defined in a language grammar. By representing expressions as objects and separating interpretation logic, it simplifies complex expression evaluation tasks. Understanding and applying this pattern can lead to more flexible, maintainable, and reusable code in applications involving expression parsing and evaluation.

Overview of GoF Design Patterns