This article explains how a simple macOS application was built to generate iOS app icons and launch images of various sizes, describing its UI layout, resource‑plist configuration, and the Objective‑C code that handles path selection, image processing, and export logic.
This article explains how to create a flexible paginated interface in iOS using the custom QiPageMenuView and QiPageContentView components, covering implementation analysis, key properties, code examples, and two usage patterns that enable decoupled menu and content views for seamless scrolling and navigation.
This article walks through creating a hierarchical menu using NSOutlineView entirely in code, covering view initialization, data model preparation, custom cell and row views, essential NSOutlineViewDataSource and NSOutlineViewDelegate methods, and handling selection to achieve a fully functional macOS outline interface.
This article explains the concept of tail call optimization in Objective‑C, illustrates correct and incorrect tail‑call examples, describes how the compiler reuses stack frames to achieve O(1) space complexity, and demonstrates the optimization with visual demos and practical code.
This article investigates a crash caused by calling IMP pointers on ARM64 iOS devices, explains how variadic function argument passing differs from the standard ABI, demonstrates the issue with test code and assembly analysis, and provides a solution by explicitly casting IMP to the correct function type.
This article provides an in‑depth exploration of the Objective‑C runtime, covering the underlying object model, class and metaclass structures, the isa_t layout, how classes are loaded and initialized, dynamic loading mechanisms, and practical applications such as ORM and automatic NSCoding implementation.
This article explores the underlying principles of Objective-C objects, analyzing instance objects, class objects, and meta-class objects through memory allocation, data structures, and pointer relationships.
This article explores the low‑level implementation of Objective‑C objects by examining instance memory allocation, the differences between class_getInstanceSize and malloc_size, the internal structures of instance, class, and meta‑class objects, and how isa and superclass pointers link them together.
EasyReact is an iOS reactive programming framework that replaces closure‑based data flow with object‑graph nodes, offering visual EZRNode debugging, automatic memory management, and cross‑platform potential while delivering up to 725 % faster performance than ReactiveCocoa, simplifying learning, debugging, and future Swift‑based extensions.
The article explains how a repeating iOS animation caused a hidden memory leak by retaining its view controller through a strong CABasicAnimation delegate and a performSelector‑afterDelay timer, and shows how replacing the delegate‑based animation with a CAKeyframeAnimation/CAAnimationGroup and using weak references or cancelling pending selectors eliminates the retain cycle.
This tutorial explains why iOS code obfuscation is needed, how to prepare the required scripts and PCH file, configure Xcode’s build phases, and apply the obfuscation tool to hide method and variable names, while noting its limitations to .m/.h classes.
This guide walks through building a complete iOS VoIP solution using CallKit and PushKit, covering UI differences, step‑by‑step configuration of CXProvider and PKPushRegistry, handling incoming calls, common pitfalls such as lock‑screen crashes and token issues, and extending functionality with Call Directory extensions.
This guide explains why and how to use Google Protocol Buffers for efficient data exchange in iOS, covering environment setup, installation, .proto definition, compilation to Objective‑C files, project integration, and a complete encode/decode test with sample code.
This article explains a crash‑protection strategy for iOS apps that detects and blocks special characters causing crashes by marking risky strings during layout/rendering, counting crashes, and switching to a safe mode when repeated failures occur.
Learn how to unlock JavaScriptCore's hidden debugger on iOS by locating the framework version, building the source with private headers, creating a custom Debugger subclass, and integrating it into an Xcode project, complete with code examples and configuration tips.
This article explains C macro fundamentals, covering object-like and function-like macros, advanced techniques such as variadic macros, token pasting, and practical examples like NSLog, singleton, and weak/strong patterns in ReactiveCocoa in iOS development.
This article explains the origin and concept of Objective‑C Blocks, details their internal structures and memory‑management mechanisms across MRR and ARC environments, demonstrates how to use and copy Blocks, and provides guidance on avoiding retain cycles through __block and __weak modifiers.
This article explains the concepts of shallow and deep copying in Objective‑C, detailing how pointers, memory regions, and collection types behave under copy and mutableCopy, introducing three copy levels (CL1‑CL3), and highlighting common pitfalls and best practices for safe memory management.
This article explains why using Swift or mixed Swift/Objective-C for business logic in componentized iOS projects is discouraged due to ABI compatibility issues, dynamic library loading overhead, and development complexity.
This article explores how JavaScript has become integral to client‑side development, introduces the JavaScriptCore framework that enables iOS apps to execute JavaScript, and provides detailed guidance on its architecture, core classes, concurrency model, object bridging, memory management, and error handling.
This article explains the iOS message‑sending and forwarding mechanisms—including dynamic, fast, and normal forwarding—and demonstrates how BlocksKit leverages these mechanisms to implement dynamic delegates using blocks, with detailed code examples and class descriptions.
This article examines the concept, benefits, and practical implementation of A/B testing in iOS development, covering design considerations, code organization patterns such as selector caching, strategy pattern, and protocol dispatchers, as well as related build‑time concerns like static‑library merging and CocoaPods subspecs.
The CAMediaTiming protocol defines a hierarchical time system for CALayer and CAAnimation objects, where each layer owns a nested time space whose beginTime, speed, and timeOffset combine to compute active and basic local times, enabling developers to pause, offset, speed up, repeat, or auto‑reverse animations with precise control.
The article explains ReactiveCocoa’s core concepts—RACSignal, subscribers, cold versus hot signals, and key transformations such as bind, map, flatten and throttle—while showing how RACCommand encapsulates actions and RACChannel enables two‑way binding, together illustrating how to build expressive, maintainable data pipelines in iOS apps.
In ReactiveCocoa, using RACObserve inside a flattenMap or applying map to a hot RACSubject can create retain cycles because the generated blocks capture self and the subject retains its subscribers, so employing @weakify/@strongify and ensuring signals send a completed or error event breaks these hidden memory leaks.
This article walks through the design and implementation of a voice‑controlled music iOS application using Siri SDK, Sketch and Principle for UI prototyping, and Xcode with Objective‑C and SpeechKit for speech recognition, culminating in a functional prototype that searches iTunes and plays song previews.
This article explains the concept of a software context, discusses design considerations such as nesting and thread‑safety, and provides a concrete Objective‑C implementation including a lightweight event‑bus library, helping developers apply context patterns in mobile applications.
This article explains how JSPatch leverages JavaScriptCore to let iOS developers dynamically update UI layouts and fix bugs by writing JavaScript that calls Objective‑C APIs, compares it with other hot‑update solutions, and offers practical usage guidelines.
This article explains what Objective‑C blocks are, how they function as objects, the three block types, the role of the __block keyword, differences between ARC and MRC, and best practices for managing block lifecycles to avoid memory leaks.
This article shares a detailed iOS interview journey—including Baidu, NetEase, and Alibaba rounds—along with algorithm questions, Objective‑C runtime insights, practical coding challenges, and actionable preparation strategies to help developers land their dream mobile development jobs.
Clang Static Analyzer, integrated in Xcode, provides static code analysis for C, C++ and Objective‑C, and this guide explains its core checkers, common warning types such as null‑pointer dereference and division‑by‑zero, and demonstrates how to run it via scan‑build on an iOS project to generate HTML reports.
From its 1960s origins in Simula and Smalltalk to its evolution through NeXT, Objective‑C introduced groundbreaking dynamic features, yet despite Swift’s rise, Apple continues to invest in the language, ensuring its ongoing relevance in the iOS/macOS ecosystem.
Cold signals in ReactiveCocoa emit a complete, independent sequence for each subscriber only after subscription, while hot signals continuously push shared events regardless of listeners, causing later subscribers to miss earlier values; understanding this distinction guides proper signal choice in FRP applications.
Understanding ReactiveCocoa’s cold and hot signals reveals that each subscription to a cold fetchData signal triggers a separate network request, causing duplicated calls, while converting the signal to hot with shareReplay or publish ensures a single request is shared across UI bindings and error handling.
The article breaks down RACSignal’s three‑step subscription flow, then explains how multicast and replay operators—built on RACSubject and RACReplaySubject—share a single source, buffer values, and ensure side‑effects like network requests execute only once regardless of how many subscribers attach.
This article explains how to convert rare, non‑reproducible Obj‑C wild‑pointer crashes into consistently repeatable crashes by delaying memory release, retaining freed memory in a custom queue, and safely managing it under memory‑pressure conditions.
The article explains Objective‑C categories by detailing their definition, compile‑time vs runtime differences, internal struct representation, how the compiler emits metadata, the loading and +load ordering process, method overriding mechanics, and the use of associated objects for adding state.
This article analytically compares web front‑end development and iOS mobile development, covering language choices, threading models, data storage strategies, framework ecosystems, compatibility challenges, performance optimization, compilation processes, security considerations, and the impact on user interaction and development workflow.
This article explains why the “Unrecognized selector sent to instance xxx” crash occurs in Objective‑C, outlines the three stages of the runtime message‑forwarding process, and provides concrete code examples for dynamic method resolution, fast forwarding, and standard forwarding to reliably prevent such crashes in iOS apps.
