During the second day of Microsoft Build 2016, Xamarin was showcased as a free, open‑source solution that lets Visual Studio users develop, test, and monitor Android and iOS applications on Windows, including an iOS simulator previously limited to macOS.
This article explains IPv6 socket programming fundamentals, focusing on NAT64/DNS64 transition mechanisms, handling various IP‑stack combinations, and detecting client support, with practical code examples and workflow diagrams relevant to iOS 9 and broader platforms.
This interview with Didi’s iOS platform lead reveals how the app evolved from a simple MVC design to a modular MVCS/MVVM architecture, adopted componentization, tackled real‑time data challenges, and leveraged hot‑fix technologies to support rapid growth.
This comprehensive guide reviews the essential elements of HTTP requests and responses, explains version differences, clarifies the distinctions between HTTP, Socket, and TCP, and provides practical iOS implementation details for developers seeking a deeper understanding of web communication.
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.
This article explains how to integrate Apple Pay’s in‑app payment feature into an iOS application, compares it with traditional third‑party payment SDKs, and provides detailed implementation steps, code samples, server‑side decryption, transaction handling, and practical tips for a seamless user experience.
This article summarizes a March 10 technical session on componentizing iOS and Android applications, describing the challenges of monolithic codebases, the benefits of modular architecture, communication patterns, lifecycle management, version control, CI integration, and practical lessons learned.
This article explains how to redesign an iOS app's network layer to fully exploit HTTP/2 by switching from NSURLConnection to NSURLSession, discusses centralized versus distributed API designs, data handling strategies, security with SSL pinning, and provides concrete code examples and batch request techniques.
This article breaks down the true cost of developing a native mobile app in China, covering developer salaries, team composition, timeline, low‑budget alternatives, template platforms, and when a company should choose a native app versus a Web‑App solution.
This guide introduces Google’s open‑source EarlGrey iOS UI testing framework, explains its key features, walks through environment preparation, shows both CocoaPods and manual installation methods, and demonstrates how to configure and run the first test case with detailed troubleshooting tips.
This article walks developers through the motivations, technical differences, and practical steps for creating, using, and publishing iOS frameworks, covering static vs. dynamic libraries, dependency managers, API design, versioning, CI, and release strategies to help produce robust, reusable components.
This article reviews the most popular iOS architectural patterns—MVC, MVP, MVVM, and VIPER—explaining their responsibilities, testability, and maintainability, and provides concise code examples so developers can decide which pattern best fits their project requirements.
This article explores the essential concerns of iOS client‑app architecture—including network API handling, page presentation, local persistence, and dynamic deployment—while offering a step‑by‑step methodology, insights on layer design, and a critical look at the drawbacks of using a generic Common folder.
This article explains how Baidu Maps' iPhone client enabled Bitcode and leveraged Apple's App Thinning to reduce binary size, detailing the 64‑bit transition, the bitcode enable process, analysis with otool, a custom Python check script, and post‑thinning validation steps.
This guide details the iOS App Store pre‑review process, covering text, image, video, UI, screenshot, preview video, account, IPA package, and third‑party license checks, along with common rejection clauses, real examples, and practical mitigation steps to ensure a smooth submission.
This article explains practical Swift optimization techniques—including enabling compiler optimizations, whole‑module compilation, reducing dynamic dispatch with final and private, using value types and ContiguousArray, unchecked arithmetic, generic specialization, unmanaged references, and class‑only protocols—to improve runtime speed and binary size for iOS apps.
This article explains iOS's view and animation rendering pipeline, identifies common performance pitfalls such as excessive layers, overdraw, off‑screen drawing, and image decompression, and provides practical optimization techniques using Core Animation and GPU Driver tools.
This tutorial explains how to build hybrid mobile apps by embedding web pages in native iOS UIWebView and Android WebView components, covering resource loading, JavaScript‑native communication, and bidirectional interaction techniques for cross‑platform development.
This article explains iOS’s event processing pipeline—from hardware events through the RunLoop’s observer, source, timer, and dispatch mechanisms—detailing why UI must run on the main thread, how CALayer and Core Animation render, and the roles of CADisplayLink, NSTimer, and async display techniques.
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.
This article reviews the five most popular open‑source mobile automation frameworks—Calabash, Appium, Robotium, Frank, and UIAutomator—detailing their key features, advantages, and drawbacks to help developers choose the right tool for iOS and Android testing.
This article outlines seven practical strategies—including monitoring, network upgrades, caching, task grading, lazy loading, page structure refinement, and image download optimization—to significantly improve the launch speed, home page responsiveness, and cart performance of the Mobile Taobao application.
The interview details how Alibaba's mobile Taobao app was re‑architected and heavily optimized—through network protocol tweaks, APK size reduction, power and data monitoring, extensive device compatibility testing, HTML5 rendering improvements, and game‑like marketing features—to sustain over 70% mobile sales during the massive Double 11 shopping festival.
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 explains that in ReactiveCocoa cold signals are plain RACSignal instances that start their work per subscriber, while hot signals are RACSubject (or subclasses) that broadcast a single execution to all observers, and demonstrates converting cold to hot using subjects, multicast operators, and replay helpers such as replayLazily to share network requests.
This article explains iOS man‑in‑the‑middle (MITM) attack levels, demonstrates practical exploits on a jail‑broken iPhone using Burp Suite, and reveals how the hidden TrustStore.sqlite3 file can be manipulated to add or remove trusted certificates beyond what iOS Settings displays.
This article reviews the various dynamic deployment techniques for iOS apps—Web App, Hybrid App, React‑Native, Lua/Javascript patches, and JSON‑described views—analyzes their pros and cons, and proposes a JSBridge‑based microservice architecture as the most practical solution.
JSPatch is an open‑source iOS dynamic‑update framework that leverages Objective‑C runtime and JavaScriptCore to let developers call and replace native methods via JavaScript, with detailed explanations of its core principles, method invocation, replacement, struct and C‑function support, and advanced implementation tricks.
This article explains how to choose and design persistence solutions for iOS apps, covering NSUserDefaults, Keychain, file storage, databases, isolation between persistence and business layers, multithreading, and the Virtual Record pattern implemented via DataCenter and CTPersistance.
This article compares the evolution of iOS and Android user interfaces, highlighting iOS's focus on simplicity and Android's shift toward Material Design, and concludes that elegant, user‑friendly design ultimately wins users' hearts across both platforms.
This article explains why the view layer is the most critical part of an iOS app’s architecture, outlines common pitfalls, proposes a clear code‑structure convention, discusses layout tools, and advises when to use storyboards, nibs, or pure code, while also recommending AOP over inheritance for shared controller behavior.
This article explains practical methods to reduce iOS app package size by removing unused resources, analyzing Xcode LinkMap files to identify dead code and selectors, slimming protobuf implementations, and applying compiler and build‑setting optimizations.
This article explains iOS 9's App Transport Security and App Thinning features, detailing how to configure ATS, use nscurl for diagnostics, and apply App Thinning mechanisms such as Slicing, On‑Demand Resources, and Bitcode to improve security and reduce app size.
This article explains the causes of UI stutters on iOS, outlines a thread‑stack‑dump monitoring approach, describes detection thresholds, classification methods, sampling strategies, and shares the practical results of deploying the solution in WeChat.
Discover how to replace cumbersome IP‑based connections with Apple’s Bonjour zero‑configuration networking, enabling iOS devices and printers to be automatically found and connected via service publishing, browsing, and resolution, while addressing power, stability, and dynamic IP challenges.
This article examines the requirements for small video playback and recording in WeChat 6.0, compares four implementation approaches—including MPMoviePlayerController, AVPlayer, and custom AVAssetReader/AVAssetWriter solutions—analyzes their pros, cons, performance and power consumption, and presents the optimal strategy for smooth, low‑latency mobile video handling.
Learn essential Xcode debugging techniques for iOS development, covering project creation, interface overview, running apps, various breakpoint types, common LLDB commands, multithreading strategies, UI inspection tools, crash analysis, and recommended resources, all illustrated with step‑by‑step screenshots.
This article explains how WeChat introduced a global font setting and configuration‑driven UI parameters to adapt iOS interfaces across iPhone, iPad and split‑screen devices, handling logical resolutions, proportional scaling, and webview font adjustments.
This article explains how to embed the Lua scripting engine into native C programs, Java applications via LuaJava, Android apps using JNI, and iOS projects, covering environment setup, bridge functions, compilation commands, and runtime examples for each platform.
This article explains why iOS apps experience lag due to main‑thread blocking, demonstrates the problem with sample code, and provides practical solutions using GCD and monitoring tools like Bugly to keep the UI responsive and improve user satisfaction.
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.
This article explains why Obj‑C wild‑pointer crashes appear random, analyzes various memory‑state scenarios after object deallocation, and shows how to force deterministic crashes by filling freed memory with inaccessible patterns using Xcode's Enable Scribble and a custom free‑hook implementation.
This article lists and explains ten Cisco IOS service subcommands—including service dhcp, service linenumber, service password-encryption, service nagle, and others—detailing their functions, typical usage scenarios, and security considerations for configuring routers and switches.
This article shares the author's insights on designing robust iOS app architecture, covering problem identification, module classification, dependency management, layering, common folder pitfalls, and practical steps for building maintainable, testable, and scalable mobile applications.
The QQ mobile team discovered that iOS 8.3 caused crashes when switching image quality or showing UIAlertView because the view controller returned an incorrect orientation type, and they resolved it by correcting the supportedInterfaceOrientations implementation and avoiding system‑internal classes.
This article outlines comprehensive iOS design best practices, covering content‑centric development, enhancing functional experience, improving visual clarity, using layout to prioritize content, optimizing launch experience, crafting onboarding and modal scenarios, and refining interaction feedback, branding, icons, and standard UI element usage.
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 guide explains how to slice graphics for iPhone and Android apps, covering baseline dimensions, px‑dp conversion, optimal design sizes, and recommended tools to streamline the workflow for beginner designers.
Apple’s Swift language, introduced at WWDC 2014, offers a modern, LLVM‑compiled syntax with playgrounds, optional typing, clear variable and constant declarations, robust control‑flow constructs, first‑class functions and closures, class inheritance, protocols, extensions, generics, and safe optional handling, making development for macOS and iOS both expressive and less error‑prone.
This article outlines six core iOS UI design standards—controls, layout, modal scenarios, gesture interactions, animations, and typography—providing practical sizing, spacing, and interaction recommendations for designers seeking to create consistent and user‑friendly mobile experiences.
