Tag: Architecture

Point-Free Pointers started working Composable Architecture (opinionated approach on SwiftUI application development) quite a long time ago. And now they're preparing the first release of the architecture.

Library is free to use and distributed under MIT license.

GitHub: swift-composable-architecture (discussion)

Reference: Composable Architecture 1.0 Preview

The weekend is coming so we have some reads for you:

SIMPLE IS NOT EASY

Unfortunately, most of the examples showing Clean Architecture and Hexagonal Architecture show that this is the model way. Abstraction on top of abstraction and next abstraction. But still, writing simple and easy to read code is not easy. It requires multiple iterations and effort. Read more in this article.

Mastering Android Dialogs: Don’t follow official Google Guides

This article explains why Google Guides for Dialogs are bad and what risks you and your apps may face if you follow them.

Performance Considerations for Memory Leaks: An Android Cookbook

Memory leaks can be found everywhere, in application code, dependencies, the Android operating system, and even in the JVM. It is difficult to come up with a complete list of the reasons why these problems occur, but showing a broad range can help us better characterize what they may be like. This great article gives you a better understanding of what memory leaks are.

Declarative UI — What, How, and Why?

This short but succinct post perfectly explains Declarative programming paradigm.

Library of the week:

https://github.com/touchlab/xcode-kotlin

The xcode-kotlin plugin allows debugging of Kotlin code running in an iOS application, directly from Xcode.

Have a nice Weekend!

This week we introduce authors from our own Mobile People community! Hope to see more articles soon!

• Elina Semenko writes great guide on Password AutoFill feature – iOS Password AutoFill — how and why?;
  
  
• Sarun W. publishes several small short guides on SwiftUI – How to scale custom fonts with Dynamic Type in SwiftUI, How to dismiss sheet in SwiftUI, SwiftUI List Style examples, How to show badge on Tab Bar Item in SwiftUI, How to change TabView color in SwiftUI;
  
  
• Developer guide on the iOS file system by Natascha Fadeeva is good article to get familiar with iOS file management;
  
  
• Krzysztof Zabłocki writes another great article on Composable Architecture – TCA Performance and Multi-Store;
  
  
• Wanted to add multiple icons for your app – Alternate App Icon Configuration in Xcode by Antoine van der Lee will help you;
  
  
• Ole Begemann shares his takes on concurrency – Where View.task gets its main-actor isolation from and Xcode 14.0 generates wrong concurrency code for macOS targets;
  
  
• Good guide on basic screen creation in SwiftUI – Creating a Login Screen in SwiftUI by Leonardo Maia Pugliese;
  
  
• Building a Recommendation App With Create ML in SwiftUI  by Saeed Taheri provides real-world example on CreateML usage;
  
  
• Marco Eidinger explains SPI concept in Swift – System Programming Interfaces (SPI) in Swift Explained and another interesting take on subclassing limitations – Subclassing an open Swift class is not always possible.

That's it for today! Have a great weekend!

Hello Android funs, here are some articles for you:

Optimizing Android Performance

I have read hundreds articles about performance and this one can be very useful if you need to play with optimization.

Gotchas in Jetpack Compose Recomposition

Recomposition in Jetpack Compose is the mechanism in which state changes are reflected within an app’s UI. To accomplish this, Compose will rerun a composable function whenever its inputs change. Unfortunately it may break performance optimisations built into Compose and trigger unnecessary work, which have the potential to slow down an app’s UI and waste precious device resources.

AutoSize TextField in Android Jetpack Compose

I think that one of the latest struggles we had with Jetpack Compose was the implementation of the input field that resizes its font when the text is wider than the input field.

Different Kinds of Channels in Kotlin

Quite old article but interesting. The Author described different types of channels in Kotlin.

After some break, we back with weekend good reads for Android and news

Here are some interesting articles for you for the coming weekend:

Kotlin Multiplatform Parameterized Tests and Grouping Using The Standard Kotlin Testing Framework

Aleksander shared his knowledge about writing parametric tests in Kotlin Multiplatform. This article explains how to achieve this using the standard kotlin.test testing library.

ViewModel: One-off event antipatterns

This article has sparked a heated discussion in the Android developer community recently. The author proposes that any one-off events should be represented as the state of a specific view. I strongly recommend reading it.

Implementing Android App Architecture

Manuel Vivo summed up his Droidcon presentation.

BONUS: Performance Improvements in .NET MAUI

Microsoft has released its long-awaited successor to Xamarin, dubbed .Net MAUI. In this article, you can find a lot of information about their performance improvements.

That's all for now. Have a nice weekend!

It’s Friday, it’s time for a new pack of articles to go over the long (for some of you) weekend.

Composable metrics

Jetpack Compose 1.2 introduces a lot of new features. One of them is the ability to analyze created Composables in terms of various metrics and measurements of their performance. Please review the article to check the details.

Migrating Architecture Blueprints to Jetpack Compose

Probably each of us knows the Android Blueprints projects and in this article, Manuel Vivo presents how they migrate them to Jetpack Compose.

Android — 9 Useful Kotlin Flow Operators You Need to Know

Operators are key elements of any reactive framework, including Kotlin Flow. They enable various operations to be performed on the data stream elements. In this article, you will find 9 of them which are the most useful during daily basis work.

Resilient use cases with kotlin.Result, coroutines and annotations

When creating software, it is extremely important to consider cases where something may go wrong this article shows you how to implement fault-tolerant UseCase classes.

Android App Excellence Summit

In this article, you can find a summary of App Excellence Summit 2022.

It's Friday, it's time for new pack of articles to go over the weekend.

• Great guide Using SpriteKit in a SwiftUI Project by Tiago Gomes Pereira merges two frameworks together;
  
  
• Expand your APIs capabilities with Opaque Types in Swift by Leonardo Maia Pugliese covers Swift opaque types usage;
  
  
• Date parsing is hard and important, simplify it with article by Sarun W. – How to parse ISO 8601 date in Swift;
  
  
• John Sundell covers usage of protocols in Swift – Combining protocols in Swift;
  
  
• Debugging SwiftUI views: what caused that change? by Antoine van der Lee covers debugging practices for SwiftUI;
  
  
• VoiceOver For Frequently Updating Data by Keith Harrison dives into accessibility aspects of frequently updating data;
  
  
• SwiftUI Search: Getting Started by Mina H. Gerges covers search capabilities of SwiftUI views;
  
  
• Let's recap "old" concurrency approaches with two-parter by David Piper – Grand Central Dispatch Tutorial for Swift 5 and part 2;
  
  
• Danijela Vrzan covers popupar Clean architecture implementation in Getting Started with the VIP Clean Architecture Pattern.

And that is it for today. Have a nice weekend!

Every Composable deserves a ViewModel

The ability to reuse your own UI components is a big power of Jetpack Compose. However, how to connect a specific view element with domain logic that is responsible for controlling its state? The author of this post comes up with a solution to this problem.

How to Securely Implement TLS Certificate Checking in Android Apps

Developers often modify HTTPS connection configurations in Android apps to support use cases like certificate pinning, but custom implementations often lead to security issues that can be exploited by malicious actors. Learn how to securely implement TLS certificate checking to avoid these risks.

Everything you need to know about Remote Config’s latest personalization feature

Jon Mensing takes a close look at Remote Config personalization, how it differs from A/B testing. Consider it for your app and business.

Your Deep Links Might Be Broken: Web Intents and Android 12

The author takes a look at changes that started in Android 12 that alter how generic web intents resolve.

Good reads for Apple developers is back! This would be a long weekend – we have some much to catch up with.

• Cascading Environment actions in SwiftUI by Magnus Jensen shows how to use Environment to pass actions to views;
  
  
• Interesting take on Java Script injection in Web Views by Lee Kah Seng – Injecting JavaScript Into Web View In iOS;
  
  
• How to customize automatic synthesizing Codable for enums with associated values by Sarun W. digs into customization points for Codable;
  
  
• Continuing Codable improvements with Encoding and decoding references to other types with Codable by Guilherme Rambo;
  
  
• Majid Jabrayilov digs into SwiftUI architecture approaches – Microapps architecture in Swift. SPM basics.;
  
  
• Unobtrusive runtime warnings for libraries by Point-Free covers interesting aspect of showing runtime warnings;
  
  
• Noah Martin covers performance implications of protocol checking via as? – The Surprising Cost of Protocol Conformances in Swift;
  
  
• A guide to NSButton styles by Kuba Suder is VERY detailed guide on macOS buttons;
  
  
• Natascha Fadeeva publishes Public-key cryptography with CryptoKit for iOS with basics on cryptography using CryptoKit;
  
  
• John Sundell covers great API design tips in Creating Combine-compatible versions of async/await-based APIs;
  
  
• Vision Tutorial for iOS: What’s New With Face Detection? by Tom Elliott digs into iOS computer vision framework.

Have a nice weekend!