Apple unveiled recently their line of low end computers equipped with Apple Silicon M1 processors. The results are amazing.

Even being low end computers, these new machines decimate previous versions of the same devices powered with Intel processors. Tight integration of memory, CPU and GPU on the same chip plus high customization of these chips to the hardware Apple sell, makes them not just powerful but fast and power efficient.

We cannot wait to see what 2021 will bring us, as soon as the high end line of Macs come to light, powered by advanced versions of the M1 chip.

What happens to the PC Industry if Apple Computers become faster and faster?

Shut up and take my money! 😃

Apple M1 performance is insane! pic.twitter.com/3L5NpUlKtN

— Chris Maddern (@chrismaddern) November 27, 2020

A reminder from Apple:

The App Store will soon help users understand an app’s privacy practices before they download the app on Apple platform. On each app’s product page, users can learn about some of the data types the app may collect, and whether that data is linked to them or used to track them. If you haven’t already, enter your app’s privacy information in App Store Connect.

As a reminder, this information will be required to submit new apps and app updates to the App Store starting December 8, 2020. Existing apps will remain available for download.

Learn more about the details you’ll need to provide.

Learn how to provide app privacy information in App Store Connect.

Apple reminds developers that new apps and app updates will not be accepted December 23 through 27 (Pacific Time), due to holidays. Please ensure time for your releases to be scheduled, submitted, and approved in advance.

This is what you do when you want to create an interable enum with associated values:

enum Package:String, CaseIterable {    
  case package1 = "com.katkay.package1"
  case package2 = "com.katkay.package2"
  case package3 = "com.katkay.package3"
}

This is how you use it: let string = Package.package1.rawValue

Result: com.katkay.package1

If you need to iterate…

for package in Package.allCases {
  print("\(package)")
}

Result:

com.katkay.package1
com.katkay.package2
com.katkay.package3

Do you know you can associate closures to enum? Here we go:

enum MyEnum {
      typealias Logic = () -> (String)
      
      case typeA(Logic)
      case typeB(Logic)
      
      func processRule(rule:MyEnum) -> String {
        switch rule {
        case .typeA(let logic): return "Type A – logic: \(logic())"
        case .typeB(let logic): return "Type B – logic: \(logic())"
        }
      }
    }

Using it…

let logic0 : MyEnum.Logic = { return "Logic 0" }
let useLogic0 = MyEnum.typeA(logic0)
let test = MyEnum.processRule(useLogic0)
let final = test(MyEnum.typeA(logic0))
print(final)

Result:

Type A – logic: Logic 0

Do not miss the completely free, amazing Stanford SwiftUI Course. Paul Hegarty is your man! This is the first lesson:

Starting January 1, 2021, Apple is reducing their cut from the sales of apps, in the App Store, from the current 30% down to 15% for developers making less than one million dollars per year.

That is a fantastic news for small developers and will help them to grow their businesses

On the following video, you can watch an Apple M1 based MacBook Pro smoke an Intel version of the same computer and specs.

The Apple M1 chip is so optimized for the hardware that we have seen an M1 MacBook pro running Safari with 14 tabs open and playing videos, plus a front tab playing a 4K video and Final Cut Pro editing a 6K video, all at the same time with no effect whatsoever on the CPU load. As the cherry on top of the cake, a benchmark app was run on that Mac and showed just a slightest decrease on the performance.

By the way, the fan never kicked, the computer kept at room temperature the whole time and the whole thing was consuming just 25% of the power it would consume if it was Intel.

With the launch of Apple M1 for desktop/mobile computers, Apple changes the paradigm of how much memory do you really need to do most operations. Using the same amount of memory, Apple M1 computers can do a hell more compared to Intel based computers. This same tight integration and optimization between CPU and hardware can be seen on iPhones and this explains why top notch iPhones with “just” 4GB of memory can obliterate Android phones with 12GB in performance and power consumption.

Apple silicon is so efficient and fast that will make you cry.

1. Go over the ten view limit

All containers in SwiftUI must return no more than ten children. This works for most of the cases but not for all. If you need to bypass this limit, you can group controls using the Group container, like seen in the following code:

struct ContentView: View {
    var body: some View {
        List {
            Group {
                Text("Line 1")
                Text("Line 2")
                Text("Line 3")
                Text("Line 4")
                Text("Line 5")
                Text("Line 6")
                Text("Line 7")
                Text("Line 8")
                Text("Line 9")
                Text("Line 10")
            }

            Group {
                Text("Line 11")
                Text("Line 12")
                Text("Line 13")
                Text("Line 14")
                Text("Line 15")
                Text("Line 16")
            }
        }
    }
}

2. Control padding precisely

Padding lets you control how much space you need to apply around views. If you need fine control over the amount of padding to apply to each direction, use the following syntax:

.padding(EdgeInsets(top: 5, leading: 30, bottom: 5, trailing: 30))

3. Use a lazy stack to increase efficienty

HStack and VStack load their contents at once. This may cause slowness and high memory use, specially if you have a list with a lot of items. Instead you can use LazyHStack or LazyHStack, as shown in the following code:

struct ContentView: View {
  var body: some View {
    ScrollView {
      LazyHStack {
        ForEach(1...500, id: \.self) { value in
          Text("Line \(value)")
        }
      }
    }
  }
}

struct ContentView: View {
  var body: some View {
    List {
      ForEach(1...500, id: \.self) { value in
        Text("Line \(value)")
      }
    }
  }
}

Starting this year, the Swift course created by Stanford University, is entirely based on Swift UI, as UIKit is being relegated to legacy technology. The course, as always, has as the spectacular Paul Hegarty, in our opinion one of the best Swift instructors out there, as the main instructor.

The full course, called CS193p, can be found here.

In the following video, you can see the power of synthesis of Swift, where a code like,

private var model: MemoryGame<String> = 
  MemoryGame<String>(numberOfPairsOfCards: 2, 
    cardContentFactory: (pairIndex: Int) -> String {
      return "😃"
})

can be simplified into,

private var model: MemoryGame<String> = MemoryGame<String>(numberOfPairsOfCards: 2) { _ in "😃" }

You cannot miss that course.

All you need to know if you want to sponsorship this newsletter, in the following link.

One of the constraints of Intel chips are of thermal nature. Intel CPUs do very little work per Watt compared to Apple ARM Silicon, meaning that they heat a lot and require huge fans to dissipate. Apple Silicon chips are designed to generate more work per Watt, therefore, generating less heat. Hence, Apple can design very lightweight and thin computers, that don’t require fan, run faster, do more work per watt, and cost less. Have you noticed that iPhones and iPads have no fans?

This is exactly what this week’s rumors are all about: Apple will launch a super-lightweight 12-inch MacBook with Apple Silicon, this year.

Read all about it on the following link:

A new US Patent, granted to Apple, was discovered this week. The document contains the following introduction:

“With the advent of an increased number a portable computing devices, the need for integration between various devices has become increasingly important. For example, a user may have access to multiple types of devices at a given time (e.g. smartphone, laptop, etc.), and accordingly, these devices may communicate amongst each other to provide an enhanced user experience. This enhanced user experience may include sharing resources amongst devices in order to increase capabilities such as processing capacity, battery usage, network bandwidth, storage, and the like. Accordingly, these devices may form part of a distributed computing environment”.

In short, what Apple proposes is to connect all devices a user may have around idle, to combine CPU power that can be used by the user when needed.

The patent can be found on the following link.

According to Apple:

You typically store and process data in your app using a data model that’s separate from your app’s user interface and other logic. The separation promotes modularity, improves testability, and makes it easier to reason about how your app works.

Traditionally, you use a view controller to move data back and forth between the model and the user interface, but SwiftUI handles most of this synchronization for you. To update views when data changes, you make your data model classes observable objects, publish their properties, and declare instances of them using special attributes. To ensure user-driven data changes flow back into the model, you bind user interface controls to model properties. Working together, these features help you to maintain a single source of truth for your data.

Remember how hard it is to change a code style like bold, italic, etc., on a text using UIKit? This is how you make a term italic in SwiftUI;

let string = Text("This is how you make a \(Text("term bold").fontWeight(.bold)) in SwiftUI")

Result: This is how you make a term bold in SwiftUI

Other styles are available like .foregroundColor() and .background(), to adjust text’s foreground and background colors, .linespacing(), .font(), and many more.

Check the following page for more examples:

All you need to know if you want to sponsorship this newsletter, in the following link.

If you care about the size of the images you include in your app, you need ImageOptim. This tiny and powerful app, removes EXIF information and compresses PNG and JPEG images to the smaller sizes possible, so they load fast, without losing quality. ImageOptim is completely free.

You are probably familiar with the following question: “should I buy an i5, i7, or even i9 processor for iOS/macOS development?”. XcodeBenchmark project benchmarks a large project to compare the performance of new iMacs 2020 and answer that question.

Also in the last issue, we wrote about how Apple changed several items on their App Review policies and guidelines, this time pro developers. And they are also accepting criticism and suggestions for future changes.

As announced at WWDC20, App Store product pages will feature a new privacy information section to help users understand an app’s privacy practices.

In the following page, Apple publishes more details for developers on what will be covered by this new privacy section.

Later this year, you’ll be able to acquire, retain, and win back subscribers with subscription offer codes: unique, alphanumeric codes that provide free or discounted prices for auto-renewable subscriptions.

All you need to know if you want to sponsorship this newsletter, in the following link.

We have developed this Class Extension while ago to create UIBezierPah circles and squares the easy way. You can use this on your projects.

/*
 Created by Magno Urbano (www.katkay.com)
 Distributed under Attribution 4.0 International License (CC BY 4.0)
*/

import Foundation
import UIKit

extension UIBezierPath {
  
  class func circlePathWith(center: CGPoint, radius: CGFloat) -> UIBezierPath {
    let circlePath = UIBezierPath()
    circlePath.addArc(withCenter: center, radius: radius, startAngle: -CGFloat(Double.pi), endAngle: -CGFloat(Double.pi/2), clockwise: true)
    circlePath.addArc(withCenter: center, radius: radius, startAngle: -CGFloat(Double.pi/2), endAngle: 0, clockwise: true)
    circlePath.addArc(withCenter: center, radius: radius, startAngle: 0, endAngle: CGFloat(Double.pi/2), clockwise: true)
    circlePath.addArc(withCenter: center, radius: radius, startAngle: CGFloat(Double.pi/2), endAngle: CGFloat(Double.pi), clockwise: true)
    circlePath.close()
    return circlePath
  }
  
  class func rectanglePathWith(center: CGPoint, side: CGFloat) -> UIBezierPath {
    let squarePath = UIBezierPath()
    let startX = center.x - side / 2
    let startY = center.y - side / 2
    squarePath.move(to: CGPoint(x: startX, y: startY))
    squarePath.addLine(to: squarePath.currentPoint)
    squarePath.addLine(to: CGPoint(x: startX + side, y: startY))
    squarePath.addLine(to: squarePath.currentPoint)
    squarePath.addLine(to: CGPoint(x: startX + side, y: startY + side))
    squarePath.addLine(to: squarePath.currentPoint)
    squarePath.addLine(to: CGPoint(x: startX, y: startY + side))
    squarePath.addLine(to: squarePath.currentPoint)
    squarePath.close()
    return squarePath
  }
}

How to use it:

let circle = UIBezierPath.circlePathWith(center: centerPoint, radius: radius)
let solidSquare = UIBezierPath.rectanglePathWith(center: centerPoint, side: sideLength)

Suppose you want to check if all members of an collection satisfy a given condition.

Imagine we have this array describing the distance, in light-years, to specific stars:

let stars = [8.6, 4.4, 11.9, 18.8, 10.5]

If you want to check if all elements are 10 light-years or higher you can use:

let result:Bool = stars.allSatisfy { $0 >= 10.0 }

Here are 15 tips from Savvy Apps Development Team to help improve your Swift style and make your code clean and blazingly fast. Tips go from improving code readability to avoiding using @objc as much as possible to make code run faster. It is a must read.

Boop is an interesting free macOS app that performs some functions to plain text. Examples:encode text to Base64 or decode from it, count characters, words or lines, convert date to timestamp, convert CSV to JSON, URL encode or decode, convert JSON to CSV, minify JSON, minify CSS, sort text, and much more. Completely free.

This week started with a lot of interesting news. The first one is Apple changing some guidelines used during App Reviews, in favor of developers, an unprecedented move.

To have an app approved for the App Store, an app has to be approved against some set of rules that many find to be Draconian, authoritarian, and not fair. This week, for the first time since the App Store went live, Apple reviewed some of these rules and improved them. In fact Apple is accepting suggestions for changes to the guidelines. According to Apple, for apps that are already on the App Store, bug fixes will no longer be delayed over guideline violations except for those related to legal issues. You’ll instead be able to address guideline violations in your next submission. If you have an app on the App Store, you must read this

You can now watch the Special Event Keynote, Platforms State of the Union, and over 200 sessions from this year’s Apple Worldwide Developers Conference with Japanese and Simplified Chinese subtitles. Available on the web, iPhone, iPad, Mac, and Apple TV.

iOS 13.7 lets you opt-in to the COVID-19 Exposure Notifications system without the need to download an app. System availability depends on support from your local public health authority.

All you need to know if you want to sponsorship this newsletter, in the following link.

If you are developing an open source project and trying to obtain details about the license model you have chosen, you will love this website.

Here is a quick way to capture a demo video from iOS simulator:

• Run the app in the simulator,
• Open Terminal.app,
• type the following command and press ENTER,

xcrun simctl io bootted recordVideo -codec h264 demoVideo.mp4 -f

The following page has more details about this command and how to take screenshots from iOS simulator from terminal.

If you organize parts of your code in separate modules, you can reuse that code later in other situations. For example, a module that records video from the rear camera. Using modules lets you build apps faster a reuse code.

To do that, Swift contains an element called Packages. Packages declared under Swift version 5.3 or later can now store resources, as texts, images, sounds, videos, storyboards, etc., what makes them way more powerful.

The following link is a repository which contains thousands of Swift packages for your projects.

In the last issue, we have described a class extension which could add SF Symbols inline with attributed text. This is something you can already do in iOS 13.

This time, we show how to do the same thing using regular text instead of attributed, something that will be available with the forthcoming iOS 14.

Text("\(Image(systemName: "photo"))! = OK")

Result:

Paste JSON as Code is a nifty app for those who work with JSON files. This free app converts JSON files into Swift code instantly.

We have created this newsletter to cover interesting aspects and the best links we have found online, every week, related to iOS, iPadOS, macOS, watchOS, and tvOS development.

This newsletter is delivered weekly through email to our subscribers and can be read online here.

If you have any interesting links you would like to suggest, please send them using this form.

Enjoy!

Magno Urbano

iPads and tablets for that matter, are devices to be operated by fingers. Because these devices are more powerful every year, all companies decided to provide them with mouse support. One thing is simply enabling mouse support without any thought about the consequences, as all companies, except Apple, did. Without guidelines, is up to developers creating interfaces as they please. The final result is a poor user experience. Another thing is bringing an insane team together and brainstorming how mice should operate on the iPad, creating a complete revolution, as Apple did. The following video from WWDC 2020 is a masterpiece and shows exactly this. It shows how far Apple goes to get something right. The video is a monument to Human Interface Design and a borderline case between mental brilliance and total madness. You cannot miss that!

SwiftIO is the first programmable microcontroller board that runs Swift natively and can be used to control all kinds of electronic projects. Comes with a NXP i.MX RT1052 Processor with Cortex-M7 core @600MHz, 8MB SPI Flash, and 32MB SDRAM.

All you need to know if you want to sponsorship this newsletter, in the following link.

The following Class Extension is very useful when you need to create a NSMutableAttributedString containing a SF Symbol:

/*
 Created by Magno Urbano (www.katkay.com)
 Distributed under Attribution 4.0 International License (CC BY 4.0)
*/

import Foundation
import UIKit

extension NSMutableAttributedString {

  class func createTextFromSFIcon(named:String, tintColor:UIColor) -> NSMutableAttributedString {
    let imageAttachment = NSTextAttachment()
    let imageIcon = UIImage(systemName: named)?.withTintColor(tintColor, renderingMode: .alwaysOriginal)
    imageAttachment.image = imageIcon
  
    return NSMutableAttributedString(attachment: imageAttachment)
  }
}

How to use:

let sfString = NSMutableAttributedString.createTextFromSFIcon(named: "photo", tintColor: .black)
let ok = NSMutableAttributedString(string: " = OK")
sfString.append(ok)
print (sfString)

Result:

The following document is a collection of tips and tricks for writing high-performance Swift code.

Ole Begemann explains why he thinks Swift documentation is not as good as it should be and why he thinks Swift open source project should host and maintain the official documentation for Swift, independent from Apple.

Xcode is the complete developer toolset used to create apps for all Apple devices. iOS 14, and all new versions of the diverse operating systems used by Apple – iOS, iPadOS, macOS, watchOS, and tvOS –, are about to be launched, bringing with them a new version of Xcode; version 12. In this article, Vineet Chouldhary explains what is new in Xcode 12.

If you your apps contain web views like WKWebview and you are using custom fonts of any kind ( .ttf or .otf) these fonts may be slowing down your app. It is not rare for such types to reach sizes of 4MB or more. If this is the case, I cannot recommend enough this online tool called Font Squirrel. Font Squirrel will convert any ttf or otf font to woff and woff2 and generates a CSS style. The final fonts are in generally 1 million times smaller than the original!