Jacob’s Tech Tavern

Jacob's Tech Tavern is a Substack by the Lead Mobile Engineer at Gener8, offering insights into iOS software engineering, startup dynamics, career guidance, and mobile app development. It combines practical advice on app creation, career development, and technical deep dives into software and hardware architecture, with personal anecdotes and humor.

Software Engineering Startups Career Development Mobile App Development iOS Development User Experience Design Venture Capital Technology Trends Methodologies and Design Patterns Programming Languages Software Testing and Quality Assurance Productivity and Tools Technology History

The hottest Substack posts of Jacob’s Tech Tavern

And their main takeaways
576 implied HN points • 26 Feb 24
  1. The blog post compares the Twitter and X iOS app binaries, revealing insights like extra app icons and heavy use of dynamic libraries.
  2. Emerge Tools offers valuable solutions for mobile engineers to monitor their app's size and performance.
  3. The author recommends subscribing to Jacob's Tech Tavern for more insightful posts and to show support for the work.
1304 HN points • 27 Nov 23
  1. The idea for the app came from the author's toddler's fascination with planes, leading to the creation of a radar app.
  2. The app was built to be engaging and fun for kids, with features like showing nearby flights and being oriented correctly.
  3. The author went through user testing with their toddler to ensure the app was enjoyable and successful before launching it on the App Store.
Get a weekly roundup of the best Substack posts, by hacker news affinity:
194 HN points • 30 Oct 23
  1. Apple has undergone multiple CPU architecture migrations throughout its history, showcasing a unique ability to adapt and innovate.
  2. Intel's x86 architecture dominance was driven by innovations like CPU caches, branch prediction, and superscalar architecture.
  3. The M1 chip from Apple Silicon stands out due to its specialized heterogeneous computing approach, unified memory architecture, out-of-order execution, and physical proximity of components for efficient performance.
192 implied HN points • 12 Sep 23
  1. In 2007, Apple introduced Core Animation, revolutionizing how animations were implemented on Mac OS X.
  2. Core Animation streamlined animation implementation by providing a declarative framework that leveraged the GPU for smooth transitions.
  3. Developers could easily create animations with Core Animation properties like frame, border, filters, and opacity.
16 HN points • 19 Feb 24
  1. The app's creator derived inspiration for the 2FA app from spotting interesting patterns in the codes, like counting sequences and repeated numerical patterns.
  2. The concept was proven through a proof of concept demonstrating local code generation and push notifications for rare interesting codes.
  3. The app development process included tackling challenges like storing multiple 2FA accounts securely, implementing interestingness features, and improving performance with optimized processing tasks and notifications.
3 HN points • 15 Jan 24
  1. Mobile DevOps for Enterprise can be challenging due to the unique requirements and constraints of mobile development.
  2. Appcircle offers a more streamlined and user-friendly approach to setting up CI/CD pipelines, especially for mobile projects.
  3. Appcircle provides advantages such as simplified infrastructure management, faster build speeds, comprehensive permissions management, and features like tester management and enterprise app store.
1 HN point • 04 Mar 24
  1. Testing on a real device to identify user-facing problems is crucial for improving app performance.
  2. Profiling the app using Instruments to identify bottlenecks and implementing targeted code improvements based on the findings can significantly enhance performance.
  3. Improving processing speed, utilizing parallelism, and optimizing code to run earlier during app launch are key strategies for enhancing the performance of Swift apps.
2 HN points • 13 Nov 23
  1. Unit testing @Observable view models is crucial for ensuring reliability and stability in iOS development.
  2. The Observation Framework provides a solution for testing @Observable properties using withObservationTracking, improving the unit testing process.
  3. By leveraging the ObservationTestUtils package, developers can streamline unit testing of @Observable view models with less boilerplate code.
2 HN points • 10 Oct 23
  1. Understanding Swift actors is crucial for managing re-entrancy and interleaving in your code.
  2. Building an optimal authentication service involves utilizing Swift actors to minimize duplicate work and network overhead.
  3. Swift concurrency model utilizes cooperative threading, executors, and actors to create an illusion of single-threadedness and prevent data races.
3 HN points • 01 Aug 23
  1. Unstructured concurrency introduces a different approach to handling asynchronous code compared to structured concurrency like async/await.
  2. When dealing with unstructured concurrency like Tasks, testing can become challenging and may require using XCTestExpectation to handle closure-based asynchronous operations.
  3. To overcome testing challenges with unstructured concurrency, leverage mocks, the defer keyword, and XCTestExpectation to ensure precise test execution.
3 HN points • 06 Jun 23
  1. Unit testing helps in writing maintainable code by separating concerns and breaking code into manageable chunks.
  2. Modern language features like async/await and functional reactive programming provide great coding ergonomics but require careful testing to avoid flakiness.
  3. Dependency Injection separates the tasks of gathering ingredients and cooking, making code more testable and maintainable.
1 HN point • 18 Jul 23
  1. Unit Testing with async/await allows for writing robust and maintainable software using modern language features.
  2. Async tests focus on checking interactions with dependencies, successful function calls, and handling error states.
  3. By making code testable through dependency injection, it becomes cleaner and easier to reason about, with encapsulated logic and separated responsibilities.
0 implied HN points • 20 Mar 23
  1. Jacob is an experienced iOS Engineer with a passion for technology.
  2. He started his own technical blog to share knowledge and improve his writing skills.
  3. Expect well-structured engineering topics, hot iOS takes, and humor on his blog.
0 implied HN points • 26 Sep 23
  1. Apple's animation journey evolved through NeXTSTEP, Mac OS X, Core Animation, and SwiftUI, showcasing advancements in UI development.
  2. SwiftUI's declarative approach makes animation easier than ever by treating UI as a function of state.
  3. The latest SwiftUI release introduces keyframe animations, providing fine-grained control over animations with advanced new APIs.
0 implied HN points • 14 Oct 23
  1. A demo video for Aviator is available on the given link.
  2. The video is intended for Apple Store Review on 14 October 2023.
  3. Jacob Bartlett is the author of the post.
0 implied HN points • 22 Aug 23
  1. Combine and async/await can be used together to write robust and maintainable software with modern language features.
  2. Testing @ObservableObject view models, Combine publishers in async methods, and Combine publishers converted to AsyncSequence are key in achieving unit test mastery.
  3. Understanding the interoperation between Combine and async/await is a powerful skill for writing unit tests and marrying the two concurrency approaches.
0 implied HN points • 19 Sep 23
  1. In 2014, Apple introduced Metal as a high-performance graphics API for iOS, catering to graphics-intensive applications like mobile games.
  2. Metal provided low-level access to GPU hardware, aiming to improve performance by reducing bottlenecks caused by OpenGL ES drivers running on the CPU.
  3. Developers using Metal had to work more closely with the hardware, writing shaders and managing rendering pipelines for efficient graphics processing.