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 01 Jan 24
  1. Architectural discussions should focus on how modules fit together and organizational structures.
  2. Different modular architecture approaches offer benefits like clear responsibilities and reduced build times.
  3. As apps become more complex, modularization becomes necessary for managing team, complexity, and build time challenges.
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.
1 HN point 11 Dec 23
  1. String Catalogs in Xcode 15 make internationalizing Swift apps easier
  2. Prior to Xcode 15, managing strings in Objective-C era using .strings files was error-prone
  3. String Catalogs simplify internationalization for different languages, including handling pluralization
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 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.
0 implied HN points 02 Feb 23
  1. Jacob Bartlett is launching something soon on his substack
  2. It's called Jacob's Tech Tavern
  3. Stay tuned for more updates
0 implied HN points 13 Feb 24
  1. The app Check 'em doesn't collect any data and doesn't even use the internet, ensuring user privacy.
  2. Users of Check 'em are not required to provide any personal information or create an account, emphasizing user anonymity.
  3. The app ensures high security by storing data securely on the iOS keychain and following best practices in generating 2FA codes.
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 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.