The best way I know to understand something is to build it, so I created a virtual HomeKit light in Go. And in this tutorial, I’ll walk you through how I went about it. We’ll pull back the curtain on smart home protocols so you understand how they work, in depth. Let’s dive in.

What we’ll cover:

1. What HomeKit Actually Is

2. The Smart Home Protocol Landscape

3. How HomeKit Discovery Works

4. The Pairing Process: What Happens When You Scan the QR Code

5. The Setup URI: What's in That QR Code?

6. What Happens When You Toggle the Light

7. The Accessory Database Model

8. Persisting Pairing Data

9. Event Notifications

10. The Complete Implementation

11. What I Learned

What You'll Need

Before we start building, let's make sure you have the right setup. This project requires two things:

1. Go 1.21 or later: We're using some modern Go features, and the brutella/HAP library works best with recent versions. You can check your version with go version. If you need to upgrade, grab the latest from go.dev

2. An Apple HomeKit environment: This means an iPhone or iPad running iOS 15+ with the Home app. You'll also want to be on the same WiFi network as the machine running your virtual light. HomeKit is entirely local, so your phone needs to be able to reach your development machine directly.

One thing that tripped me up initially is that if you’re running this on a Linux server or inside a container, make sure mDNS traffic isn’t being blocked. Your firewall needs to allow UDP port 5353 (for mDNS discovery) and whatever port your accessory runs on (we'll use 51826). On a Mac this usually just works.

What HomeKit Actually Is

HomeKit is Apple's smart home framework. It's comprised of three things:

1. a protocol (HAP) that defines how devices talk to each other,

2. a security model that encrypts and authenticates everything,

3. and an ecosystem (the Home app, Siri, automations)

Here, we’ll be focused on the protocol layer. We're building something that speaks HAP well enough that Apple's ecosystem accepts it as a real accessory.

The Smart Home Protocol Landscape

Before getting started, let's understand what we're dealing with. There are two protocols at play here:

1. HomeKit Accessory Protocol (HAP): Apple's original smart home protocol from 2014. It runs over your local WiFi network, uses mDNS for discovery, and encrypts everything with Curve25519 and ChaCha20-Poly1305. Every HomeKit device you've ever used speaks HAP.

2. Matter: The new industry standard (2022) backed by Apple, Google, Amazon, and others. Matter is actually built on many of the same cryptographic primitives as HAP. When Apple added Matter support, they essentially made HomeKit bilingual, as it can speak both protocols.

Here's what's interesting: Matter devices that connect to Apple Home still end up being controlled through HomeKit's infrastructure. Matter is the pairing and discovery layer, but once a device is in your Home, Apple's ecosystem takes over.

For this project, I'm using the HAP protocol directly via the brutella/hap library. This lets us see exactly what's happening without Matter's additional abstraction layer.

How HomeKit Discovery Works

When you run a HomeKit accessory on your network, it doesn't just sit there waiting. It actively announces itself using mDNS (multicast DNS), also called Bonjour on Apple platforms.

The accessory broadcasts a service record that looks like this:

_hap._tcp.local.
  name: Virtual Light._hap._tcp.local.
  port: 51826
  txt: 
    c#=1          // config number (changes trigger rediscovery)
    ff=0          // feature flags
    id=XX:XX:XX   // device ID (like a MAC address)
    md=Virtual Light  // model name
    pv=1.1        // protocol version
    s#=1          // state number
    sf=1          // status flag (1=not paired, 0=paired)
    ci=5          // category (5=lightbulb)
    sh=XXXXXX     // setup hash

Your iPhone is constantly listening for _hap._tcp.local. broadcasts. When it sees one with sf=1 (unpaired), it shows up in "Add Accessory" as available.

Let's see this in code. Here's the minimal server setup:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/brutella/hap"
    "github.com/brutella/hap/accessory"
)

func main() {
    light := accessory.NewLightbulb(accessory.Info{
        Name:         "Virtual Light",
        Manufacturer: "My Smart Home",
    })

    server, err := hap.NewServer(hap.NewFsStore("./data"), light.A)
    if err != nil {
        log.Fatal(err)
    }

    server.Pin = "00102003"
    server.Addr = ":51826"

    server.ListenAndServe(context.Background())
}

When ListenAndServe runs, it:

1. Generates a unique device ID if one doesn't exist

2. Starts listening on port 51826

3. Registers the mDNS service record

4. Waits for connections

At this point, your iPhone can discover it. But what happens when you try to pair it?

The Pairing Process: What Happens When You Scan the QR Code

This is where it gets interesting. HomeKit uses the SRP (Secure Remote Password) protocol for pairing. It’s the same protocol used in things like 1Passwords authentication.

When you scan the QR code or enter the PIN, here's the actual sequence:

Step 1: Pair Setup M1 (iOS → Accessory)

iOS sends: { method: "pair-setup", state: 1 }

Your phone initiates pairing, telling the accessory "I want to pair with you."

Step 2: Pair Setup M2 (Accessory → iOS)

Accessory sends: { 
  state: 2,
  salt: <16 random bytes>,
  public_key: <SRP public key B>
}

The accessory generates an SRP salt and public key. The PIN code you entered isn't sent over the network – instead, it's used to derive a verifier locally.

Step 3: Pair Setup M3 (iOS → Accessory)

iOS sends: {
  state: 3,
  public_key: <SRP public key A>,
  proof: <SRP proof M1>
}

Your iPhone uses the PIN to compute its own SRP values and sends a proof that it knows the PIN.

Step 4: Pair Setup M4 (Accessory → iOS)

Accessory sends: {
  state: 4,
  proof: <SRP proof M2>
}

The accessory verifies the proof. If the PIN was wrong, pairing fails here. If correct, it sends its own proof back.

Step 5-6: Key Exchange

Now both sides have a shared secret derived from SRP. They use this to establish an encrypted channel and exchange long term Ed25519 public keys. These keys are stored permanently. This is why your lights still work after rebooting your router.

The whole dance takes about 2 seconds. After this, sf in the mDNS record changes from 1 to 0 and the accessory disappears from "Add Accessory".

The Setup URI: What's in That QR Code?

The QR code contains a URI that encodes everything needed for pairing:

X-HM://0ABCDEFGH1234
        ^^^^^^^^^^^^
        |       |
        |       +-- Setup ID (4 chars)
        +---------- Encoded payload (9 chars, base-36)

The payload packs three things into 45 bits:

1. Category: what type of accessory this is (5 = lightbulb, 6 = outlet, 10 = thermostat, and so on)

2. Flags: how the accessory can pair (2 = supports IP ,wifi pairing , 4 = supports BLE pairing , 6 = supports both)

3. PIN code as integer

This lets your iPhone know what icon to show and the PIN to use, all from scanning a single QR code.

func generateSetupURI(pin, setupID string, category int) string {
    // PIN "00102003" becomes integer 102003
    var pinInt uint64
    for _, c := range pin {
        if c >= '0' && c <= '9' {
            pinInt = pinInt*10 + uint64(c-'0')
        }
    }

    // Bit layout:
    // [39:32] = category (5 = lightbulb)
    // [31:28] = flags (2 = IP pairing supported)
    // [26:0]  = PIN code
    payload := (uint64(category) << 32) | (2 << 28) | (pinInt & 0x7FFFFFF)

    // Encode as base-36 (0-9, A-Z)
    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    encoded := ""
    for payload > 0 {
        encoded = string(chars[payload%36]) + encoded
        payload /= 36
    }

    for len(encoded) < 9 {
        encoded = "0" + encoded
    }

    return "X-HM://" + encoded + setupID
}

When your iPhone camera sees X-HM://, it knows this is a HomeKit code. It decodes the payload to extract the category (so it can show the right icon) and the PIN (so you don't have to type it). The setup ID helps with identification when multiple unpaired accessories are on the network.

What Happens When You Toggle the Light

Now for the part I was most curious about. When you tap the light button in the Home app, what actually travels across your network?

Step 1: Encrypted Session

Your iPhone doesn't just send commands in plaintext. Every paired session uses the longterm keys exchanged during pairing to establish a session key. All communication is encrypted with ChaCha20Poly1305.

Step 2: HAP Request

Inside the encrypted channel, HomeKit uses a simple HTTP like protocol. A "turn on" command looks like this:

PUT /characteristics HTTP/1.1
Host: Virtual Light._hap._tcp.local
Content-Type: application/hap+json

{
  "characteristics": [{
    "aid": 1,        // accessory ID
    "iid": 10,       // instance ID (the "On" characteristic)
    "value": true    // new state
  }]
}

Step 3: Accessory Response

The accessory processes the request and responds like this:

HTTP/1.1 204 No Content

If something went wrong, it'll return a status object with an error code.

In our Go code, we hook into this with a callback:

light.Lightbulb.On.OnValueRemoteUpdate(func(on bool) {
    if on {
        fmt.Println("💡 Light ON")
    } else {
        fmt.Println("💡 Light OFF")
    }
})

This callback fires when the value in that PUT request changes. The brutella/hap library handles all the decryption, parsing, and response generation.

The Accessory Database Model

HomeKit organizes everything into a hierarchy:

Accessory (aid=1)
└── Services
    ├── AccessoryInformation (iid=1)
    │   ├── Name (iid=2)
    │   ├── Manufacturer (iid=3)
    │   ├── Model (iid=4)
    │   └── SerialNumber (iid=5)
    │
    └── Lightbulb (iid=9)
        ├── On (iid=10)           ← boolean
        ├── Brightness (iid=11)   ← int 0-100
        └── Hue (iid=12)          ← float 0-360

Each characteristic has an iid (instance ID). When you change brightness to 75%, the PUT request targets aid=1, iid=11, value=75.

This model is why HomeKit accessories are interoperable. Every lightbulb, regardless of manufacturer, has the same characteristic structure.

Persisting Pairing Data

When your accessory pairs with a controller (iPhone), it stores:

• The controller's Ed25519 public key

• A controller ID (36chars UUID)

• Permission level (admin or regular user)

The accessory also has its own keypairs that must persist across restarts. If you lose this, all paired controllers become orphaned – that is, they think they’re paired, but the accessory doesn't recognize them.

As mentioned earlier, we need to save pairing info so that if the app/device restarts, it can communicate with Homekit again. You could use a database, but for a single accessory, a JSON file works fine. If the process crashes mid-session, you won’t lose pairing data.

I wrote a simple JSON store to keep everything in one file:

type JSONStore struct {
    path string
    data map[string][]byte
    mu   sync.RWMutex
}

func (s *JSONStore) Set(key string, value []byte) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.data[key] = value
    return s.save()
}

func (s *JSONStore) Get(key string) ([]byte, error) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    if v, ok := s.data[key]; ok {
        return v, nil
    }
    return nil, fmt.Errorf("key not found: %s", key)
}

The HAP library stores several keys:

• uuid – accessory's unique identifier

• public / private – Ed25519 keypair

• *-pairings – paired controller keys

If you delete this JSON file, the accessory (our virtual-light) forgets all its paired controllers. Your iPhone still thinks it's paired, but the accessory doesn't recognize it anymore – you'll see "No Response" in the Home app. The fix removes the accessory from the Home app and pairs it fresh using the QR code again.

Event Notifications

One thing I didn't expect is that HomeKit supports push notifications from accessories. When our light state changes (maybe from a physical switch), we can notify all connected controllers:

light.Lightbulb.On.SetValue(true)  // This triggers notifications

Under the hood, the accessory maintains persistent connections with controllers. When a characteristic changes, it sends an EVENT message:

EVENT/1.0 200 OK
Content-Type: application/hap+json

{
  "characteristics": [{
    "aid": 1,
    "iid": 10,
    "value": true
  }]
}

This is how your Home app updates in realtime when someone else turns on a light.

The Complete Implementation

Here's everything together:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "os/signal"
    "sync"
    "syscall"

    "github.com/brutella/hap"
    "github.com/brutella/hap/accessory"
    "github.com/skip2/go-qrcode"
)

const (
    pinCode  = "00102003"
    setupID  = "VLTX"
    category = 5
    dbFile   = "data.json"
)

type JSONStore struct {
    path string
    data map[string][]byte
    mu   sync.RWMutex
}

func NewJSONStore(path string) *JSONStore {
    s := &JSONStore{
        path: path,
        data: make(map[string][]byte),
    }
    s.load()
    return s
}

func (s *JSONStore) load() {
    file, err := os.ReadFile(s.path)
    if err != nil {
        return
    }
    json.Unmarshal(file, &s.data)
}

func (s *JSONStore) save() error {
    file, err := json.MarshalIndent(s.data, "", "  ")
    if err != nil {
        return err
    }
    return os.WriteFile(s.path, file, 0644)
}

func (s *JSONStore) Set(key string, value []byte) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.data[key] = value
    return s.save()
}

func (s *JSONStore) Get(key string) ([]byte, error) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    if v, ok := s.data[key]; ok {
        return v, nil
    }
    return nil, fmt.Errorf("key not found: %s", key)
}

func (s *JSONStore) Delete(key string) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    delete(s.data, key)
    return s.save()
}

func (s *JSONStore) KeysWithSuffix(suffix string) ([]string, error) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    var keys []string
    for k := range s.data {
        if len(k) >= len(suffix) && k[len(k)-len(suffix):] == suffix {
            keys = append(keys, k)
        }
    }
    return keys, nil
}

func generateSetupURI(pin, setupID string, category int) string {
    var pinInt uint64
    for _, c := range pin {
        if c >= '0' && c <= '9' {
            pinInt = pinInt*10 + uint64(c-'0')
        }
    }

    payload := (uint64(category) << 32) | (2 << 28) | (pinInt & 0x7FFFFFF)

    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    encoded := ""
    for payload > 0 {
        encoded = string(chars[payload%36]) + encoded
        payload /= 36
    }

    for len(encoded) < 9 {
        encoded = "0" + encoded
    }

    return "X-HM://" + encoded + setupID
}

func main() {
    light := accessory.NewLightbulb(accessory.Info{
        Name:         "Virtual Light",
        Manufacturer: "My Smart Home",
    })

    light.Lightbulb.On.OnValueRemoteUpdate(func(on bool) {
        if on {
            fmt.Println("💡 Light ON")
        } else {
            fmt.Println("💡 Light OFF")
        }
    })

    store := NewJSONStore(dbFile)

    server, err := hap.NewServer(store, light.A)
    if err != nil {
        log.Fatal(err)
    }

    server.Pin = pinCode
    server.SetupId = setupID
    server.Addr = ":51826"

    fmt.Println("==============================================")
    fmt.Println("       Virtual HomeKit Light")
    fmt.Println("==============================================")
    fmt.Println("PIN: 001-02-003")
    fmt.Println()

    setupURI := generateSetupURI(pinCode, setupID, category)
    if qr, err := qrcode.New(setupURI, qrcode.Medium); err == nil {
        fmt.Println(qr.ToSmallString(false))
    }

    fmt.Println("Manual: Home app → + → More Options → Virtual Light")
    fmt.Printf("Data stored in: %s\n", dbFile)
    fmt.Println("==============================================")

    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        c := make(chan os.Signal, 1)
        signal.Notify(c, os.Interrupt, syscall.SIGTERM)
        <-c
        cancel()
    }()

    fmt.Println("Running... (Ctrl+C to stop)")
    server.ListenAndServe(ctx)
}

Run it, pair it, and watch the terminal as you toggle from your phone. Each "💡 Light ON" is the end of an encrypted request that traveled from your phone, through your router, to this Go process.

What I Learned

Building this cleared up several things I'd been fuzzy on:

1. HomeKit is entirely local. There are no cloud servers involved in controlling devices – your commands go directly from phone to device over your LAN. This is why HomeKit devices work when your internet is down.

2. The security model is solid. SRP for pairing means the PIN never crosses the network. Ed25519 + ChaCha20 for sessions means that even someone sniffing your WiFi sees only encrypted blobs.

3. Matter doesn't replace HAP. At least not in Apple's ecosystem. Matter handles discovery and pairing across ecosystems, but Apple Home still uses HAP concepts internally.

4. The protocol is HTTPish. Once you get past the encryption, it’s just PUT/GET requests with JSON bodies – surprisingly approachable.

Thanks for reading!

The code is here if you want to experiment yourself. You could try adding brightness control, or create a switch instead of a light. The best way to understand a protocol is to speak it ;)

Throughout this handbook, you will learn how to:

• Correctly establish and manage an app's unique identity.

• Understand the roles of different Apple developer certificates and how to create and manage them.

• Differentiate between various types of provisioning profiles and know when to use each one.

This guide is geared towards new developers who want to learn how the code signing process works, but it should also be useful experienced developers who want or need to refresh their memory.

Prerequisites

While there are no hard prerequisites to understanding the certificates, bundles, and provisioning profiles for distributing on Apple platforms, it helps to have an Apple developer account to follow along.

Table of Contents

• App IDs, Bundle IDs – Your App’s Identity

• Understanding Distribution: A Deep Dive into Certificates

• Bridge between everything: Provisioning Profiles

• Device management – Development and Ad Hoc Builds

• Possibilities: Enabling Capabilities and Services

• Conclusion

App IDs, Bundle IDs — Your App’s Identity

The Bundle ID and the corresponding App ID registered with Apple form the basis of an application’s identity. Establishing these correctly from the beginning is very important, as errors or misconfigurations here can lead to significant complications down the line, particularly once you’ve submitted your app to App Store Connect.

Understanding CFBundleIdentifier (Bundle ID)

What is the “Bundle ID”?

Think of the Bundle ID as a unique name or a fingerprint for your app. The CFBundleIdentifier, more commonly known as the Bundle ID, is a string that uniquely identifies your application.

This identifier is not just a name – it serves multiple crucial purposes.

• The operating system relies on it to apply specific preferences and settings to an app.

• This is used to launch the application from other apps etc.

• It plays an essential role in the validation of an app's code signature, ensuring the app's integrity and authenticity.

• The Bundle ID defined in an app's Info.plist file must exactly match the Bundle ID registered for the app in App Store Connect for successful submission and distribution.

The Bundle ID string must adhere to specific character limitations: it can only contain alphanumeric characters A-Z, a-z, 0-9, hyphens -, and periods .. It's important to note that Bundle IDs are treated as case-insensitive by the system.

How to Choose and Format Your Bundle ID (Reverse-DNS and Best Practices)

Apple highly recommends, and it is standard practice, to use a reverse-DNS (Domain Name System) format for Bundle IDs.

A common example would be com.yourcompanyname.appname. This convention leverages the global uniqueness of domain names to help ensure the global uniqueness of Bundle IDs.

If an organization uses its unique domain name (for example, sravan.gg becomes gg.sravan ) as the prefix, and the app name is unique within that organization, the resulting Bundle ID (for example, gg.sravan.mycoolapp ) is highly likely to be unique worldwide.

Sidenote: While Xcode won’t stop you from creating something like com.google.mapping or something like that even if you don’t work at Google, this will most likely get rejected when it goes through the AppStore review process. This is because this implies ownership of that domain. So, while it’s technically possible when starting out, you shouldn’t use domains that don’t belong to you.

The fundamental nature of the Bundle ID as a unique, system-wide identifier – coupled with its immutability after an app is first uploaded to App Store Connect – means that you should treat its selection with the same seriousness as choosing a permanent, unchangeable identifier for a critical entity. A mistake in the Bundle ID after this point can necessitate creating an entirely new app listing on the App Store.

App IDs in the Apple Developer Portal: Explicit vs. Wildcard

Which One Do You Need?

In the Apple Developer Portal, developers register an "App ID." This App ID is a record that links one or more applications from a single development team to specific app services (capabilities) and is used in provisioning profiles. We’ll learn more about this in the following sections.

There are two main types of App IDs:

• Explicit App ID: This type is used for a single application. The Bundle ID specified within an explicit App ID must be an exact match for the CFBundleIdentifier in the app's Info.plist file (for example, com.mycompany.myapp). Explicit App IDs are required for apps that use many of Apple's specific services and capabilities, such as In-App Purchases (which are enabled by default for explicit App IDs), Push Notifications, iCloud, HealthKit, and Sign in with Apple.

• Wildcard App ID: This type can be used for a set of applications that share a common Bundle ID prefix. It contains an asterisk (*) as the last part of its Bundle ID string (for example, com.mycompany.*). This wildcard App ID would match any app whose Bundle ID starts with com.mycompany., such as com.mycompany.app or com.mycompany.utility. But you can’t use wildcard App IDs if the app requires services or capabilities that mandate an explicit App ID.

The choice between an explicit and a wildcard App ID has significant implications. The App ID acts as a central registration point, and the capabilities are "enabled" for this registration – more on capabilities later in this handbook.

You can think of an explicit App ID as a specific key designed to unlock extra "keyholes" (capabilities). A wildcard App ID, being more generic, might not fit these extra keyholes. If you choose a wildcard App ID initially for convenience, but you need a feature requiring an explicit App ID (like Push Notifications) later, you’ll be forced to create a new explicit App ID and reconfigure associated settings and provisioning profiles.

So, make sure you carefully consider your current and future app features when selecting an App ID type. The following table provides a quick comparison**.**

My personal recommendation is always go with explicit App Ids unless you need the flexibility of wildcard app ids.

Step-by-Step: How to Register Your App ID in the Apple Developer Portal

To register an App ID, an you’ll need an Apple Developer Program membership. Also, the actions must be performed by someone with an Account Holder or Admin role.

The process is as follows:

1. Sign in to the Apple Developer Portal and navigate to "Certificates, Identifiers & Profiles," then select "Identifiers" from the sidebar.

2. Click the “Add button (+)” to create a new identifier.

   

3. Select "App IDs" from the list of options and click "Continue."

   

4. Make sure that the "App" type is selected (it usually is by default) and click "Continue."

   

5. Enter a "Description" for the App ID. This is for your reference within the portal (for example, "My very cool App ID").

   

6. Choose the "App ID Type": "Explicit" or "Wildcard."

7. For an "Explicit App ID," enter the exact Bundle ID that will be used in your Xcode project (for example, com.yourcompany.yourapp). For a "Wildcard App ID," enter a Bundle ID suffix ending with an asterisk (for example, com.yourcompany.*).

8. Scroll down to the "Capabilities" section and select the checkboxes for any app services your app will use. Some capabilities might require further configuration at this stage or later. (Again, we’ll cover app capabilities in more detail later on).

9. Click "Continue," review all the details carefully, and then click "Register" to finalize the App ID creation.

   

How to Manage Your Bundle ID: Xcode, App Store Connect, and the Point of No Return

The Bundle ID specified in an Xcode project is critical. To set it:

1. In the Xcode project navigator, select the target for your app.

2. Open the "Signing & Capabilities" tab.

3. Expand the "Signing" section.

4. In the "Bundle Identifier" text field, enter the Bundle ID. This identifier must precisely match the Bundle ID associated with an explicit App ID registered in the Developer Portal, or conform to the pattern of a wildcard App ID if applicable.

It's important to understand the difference between the "Bundle ID" (or CFBundleIdentifier) in the Xcode project and the "App ID" registered in the Developer Portal. The "App ID" in the developer portal is an entity that contains a “Bundle ID” string (either explicit or wildcard). The string in your Xcode project's "Bundle Identifier" field must match this contained string.

When preparing for distribution via TestFlight or the App Store, you’ll need to create an app record in App Store Connect. The Bundle ID you enter during this app record creation must exactly match the Bundle ID in the Xcode project.

A Critical Warning: Immutability After First Upload

This is a point of no return: Once you upload a build of an app to App Store Connect, the Bundle ID for that app record cannot be changed.

In addition, after an upload, you can’t delete the associated explicit App ID registered in the Developer Portal. This immutability highlights the need for careful planning and verification of the Bundle ID before any uploads occur.

If you prefer programmatic management or automation, the App Store Connect API provides resources for managing Bundle IDs. You can read more on that here.

Understanding Distribution: A Deep Dive into Certificates

What are Certificates?

Certificates are digital credentials that verify a developer's identity – that is, you – to Apple and, by extension, to the app users.

They are fundamental to Apple's code signing process, which is mandatory for all apps to ensure they originate from a known source and have not been tampered with since being signed.

What is Code Signing: Ensuring Trust and Integrity

Code signing is you as a developer signing the app with your signature. It is the process of attaching a digital signature to an app's code. This signature assures users of two key things:

1. Authenticity: The app was created by an identified Apple developer (an individual or a team).

2. Integrity: The app's code has not been altered or corrupted since it was signed by the developer.

The process involves using a private key, securely held by the developer (you), to create the signature. The corresponding public key, embedded within the developer's certificate (issued by Apple), is used by the system to verify this signature.

This system of identity verification and integrity checking is crucial. The developer's certificate, issued by Apple as a Certificate Authority (CA), vouches for their identity. The code signing process, using hashing and encryption, ensures that any modification to the code after signing would invalidate the signature.

For app developers, benefits of code signing include removing warnings on macOS for apps distributed outside the Mac App Store, providing a smoother user experience. It is a mandatory requirement for listing applications on any of Apple's App Stores. It also enhances security of the app as it acts as a deterrent against malicious tampering.

Types of Certificates: Development, Distribution, and Developer ID

Apple provides different types of certificates for various stages of development and methods of distribution. Each of them has a distinct role to play throughout the app development process.

1. Development Certificates (for example, "Apple Development"):

• Purpose: Used to sign apps during the development phase, allowing them to be installed and run on a limited number of registered test devices and simulators for debugging and testing.

• Identifies: Typically identifies an individual developer through their developer ID.

• Used with: Development provisioning profiles – more on this later.

2. Distribution Certificates (for example, "Apple Distribution"):

• Purpose: Used to sign apps intended for distribution, either through Ad Hoc methods (to a limited set of registered testers) or for submission to the App Store.

• Identifies: The development team via the team identifier.

• Use Cases:

  1. App Store: For signing the final version of an app that will be uploaded to App Store Connect for TestFlight beta testing or release on the App Store (iOS, macOS, tvOS, watchOS). These are used with App Store provisioning profiles – more on this later.

  2. Ad Hoc: For signing apps that will be distributed to a limited number of registered test devices outside of the App Store or TestFlight. These are used with Ad Hoc provisioning profile. More on this later.

3. Developer ID Certificates (for Mac apps distributed outside the Mac App Store):

• Purpose: Specifically for macOS developers who wish to distribute their applications directly to users (for example, from their own website) rather than through the Mac App Store. Gatekeeper on macOS recognizes apps signed with a Developer ID certificate, assuring users that the app is from a known developer and has not been tampered with.

• Types:

  1. Developer ID Application: Used to sign the Mac application bundle (.app) itself.

  2. Developer ID Installer: Used to sign a Mac Installer Package (.pkg) that contains the signed application.

  3. Limit: Developers can create up to five Developer ID Application certificates and up to five Developer ID Installer certificates.

The following table summarizes these certificate types:

How to Create an Apple Certificate – An Overview

Here’s a general outline of how you create an Apple Certificate:

• Generate a Certificate Signing Request (CSR) on your Mac. (Yes you need a mac.)

• You upload this CSR in AppStoreConnect as a part of creating the certificate.

• Download the certificate from AppStoreConnect once it’s issued.

• Install the certificate into your Keychain.

Now we’ll go through each step in more detail. This part is very important, since we have to save some of the files generated locally or we lose the ability to transfer these certificates. This would mean revoking and re-issuing certificates (I have done this more times than I’d like to admit).

How to Create a Certificate Signing Request (CSR)

A Certificate Signing Request (CSR) is a fancy name for an encrypted block of text containing information about who’s requesting the certificate (like your name and the public key). These are widely used in the cryptography world.

For our purposes, you’ll generate a CSR on your Mac and then submit it to Apple to request a digital certificate. The CSR generation process also creates a new public/private key pair on the Mac – the private key is stored in Keychain Access and is used for the eventual code signing.

To create a CSR using Keychain Access on macOS:

1. Launch Keychain Access (you can find it at /Applications/Utilities/ or use spotlight).

2. From the menu bar, choose Keychain Access > Certificate Assistant > Request a Certificate From a Certificate Authority.... (Here the Certificate Authority would be Apple).

3. In the dialog, enter your email address and a common name for the key (for example, "My Mac Key" or "[Your Name] Dev Key"). This name is primarily for your identification in the Keychain.

4. Leave the "CA Email Address" field empty – we won’t email it to the Certificate Authority (Apple).

5. Select the "Saved to disk" option and click "Continue".

6. Save the file, which will have a .certSigningRequest extension. The corresponding private key is now stored in the login keychain. This private key is irreplaceable by Apple and you must store it yourself.

How to Generate and Download Your Apple Certificates

Once you’ve created a CSR, you can request a certificate from the Apple Developer Portal:

1. Navigate to "Certificates, Identifiers & Profiles" and select "Certificates".

2. Click the add button (+).

3. Choose the desired certificate type

4. Follow the prompts, and when asked, upload the .certSigningRequest file generated earlier.

5. After Apple processes the request, the certificate will be available for download as a .cer file.

   

To install the certificate, double-click the downloaded .cer file. It will be added to the Keychain Access application – usually appearing in the "login" keychain under the "My Certificates" category, where it should be paired with the private key generated during the CSR generation process earlier.

You can see my certificate and private key in the image below for reference.

To recap, the CSR certifies that you generated the request from your mac. The certificate certifies that Apple (in this case, an intermediary like the "Apple Worldwide Developer Relations Certification Authority") confirms that they verified the CSR and that it is indeed you who will sign with the certificate (.cer) file.

This is enforced by only you having access to the private key – if you lose it, you cannot use this certificate anymore.

So, if you use this certificate (and the private key) to sign an app, the app store / operating system knows that it is you for sure since Apple confirmed it.

How to Store Your Keys: What are .p12 Files?

As I mentioned in the previous section, to code sign an app you need your certificate (containing the public key) and the corresponding private key. This is created along with the CSR, and you can find it in the Keychain Access app.

We call the combination of the certificate and the private key a digital identity. This proves your identity when you sign an app with them.

.p12 Files (Personal Information Exchange):

A .p12 file is a password-protected archive format used to bundle a certificate along with its private key. Its primary purposes are:

• Backing up the digital identity in case you lose access to your Mac.

• Transferring the digital identity to another Mac (for example, for another team member or a new development machine).

• Providing the identity to automated build systems or third-party build services.

Historically, I have stored the .p12 file on a shared drive with my team and shared the password to it verbally – you can also store it in a local backup disk.

Great. So how do you create one?

To export a .p12 file from Keychain Access:

1. Open Keychain Access, select the "login" keychain, and go to the "My Certificates" category.

2. Locate the desired certificate. It should have an expandable disclosure triangle indicating an associated private key (look at the image of my certificate above).

3. Select both the certificate and its private key (or right-click the certificate and choose "Export").

4. Right-click and choose "Export [X] items...".

5. In the save dialog, choose the "Personal Information Exchange (.p12)" file format.

6. Assign a strong password to protect the .p12 file. This password will be required when importing the file elsewhere. It is crucial for security.

7. Save the file to a secure location.

   

Bridge Between Everything: Provisioning Profiles

Provisioning profiles are the final link between an App ID, developer certificates, and, in some cases, a list of specific test devices. They act as a permission slip, authorizing an app signed with a particular certificate to be installed and run either on designated devices or to be submitted to the App Store.

What Exactly is a Provisioning Profile?

A provisioning profile is a .mobileprovision (for iOS / VisionOS) or .provisionprofile (for macOS) file that holds several key pieces of information:

• The App ID: Specifies which application (or set of applications, if using a wildcard App ID) the profile applies to.

• Certificates: Contains one or more developer or distribution certificates that can be used to sign the app.

• Device UDIDs (for Development and Ad Hoc): For profiles intended for testing on specific devices, it includes a list of the Unique Device Identifiers (UDIDs) of those authorized devices – more on devices in the next section.

• Entitlements: A list of app services or capabilities (like Push Notifications, iCloud, App Groups) that the app is permitted to use. These are derived from the capabilities enabled for the associated App ID.

You can open the file using vim or any editor to see parts of the content which include the App Id, Operating Systems, Certificates, and so on.

The operating system checks the provisioning profile at app launch to ensure the app is authorized to run on the current device and use the requested services. If the profile is missing, invalid, or doesn't match the app's signature or the device, the app will not launch.

They are difference from certificates, because certificates are tied to you as a developer. But provisioning profiles are to a specific app – with specific capabilities to a specific developer and maybe on specific devices.

If any of these change (let’s say you added a capability or your certificate expired, for example), you’ll need to generate the provisioning profile again. These are the files you will work with the most out of all the above, and any change can cause your profile to become invalid.

Types of Provisioning Profiles: Development, Ad Hoc, App Store, (and Enterprise)

Types of Provisioning Profiles: Development, Ad Hoc, App Store, (and Enterprise)

Just like certificates, we have multiple types of provisioning profiles. Similar to certificates, there can be development and distribution provisioning profiles.

Since we also keep track of the devices a profile is supposed to run, we have several kinds of distribution profiles based on which devices it should run on.

We also have special profiles like “Enterprise” which will add additional capabilities (like main camera access on the Vision Pro) but will restrict your app distribution methods to enterprise only.

We will go over each of these types now. Feel free to skip to the one that you’re looking for.

Development Provisioning Profile:

• Allows an app to be installed and debugged on specific devices registered in the developer's account during the active development phase. More on device registration later.

• Contains an App ID, one or more development certificates, and a list of registered device UDIDs.

• Created manually in the Apple Developer Portal or generated automatically by Xcode if Automatically manage signing is enabled.

Ad Hoc Provisioning Profile:

• Allows distribution of an app to a limited number of registered test devices without requiring Xcode for installation. This is ideal for distributing builds to QA teams, beta testers, or clients for feedback.

• Contains an App ID (often an explicit App ID, or an Xcode-managed one like XC Wildcard or XC), a single distribution certificate, and a list of registered device UDIDs.

• Created manually in the Developer Portal or managed by Xcode's automatic signing.

App Store Connect Provisioning Profile:

• Required to sign an app for submission to App Store Connect. This is the pathway for distributing apps via TestFlight for broader beta testing and for official release on the App Store.

• Contains an explicit App ID (or an App ID that matches the app's bundle ID, including Xcode-managed App IDs), and a single distribution certificate. Device UDIDs are not included in this profile type since this is meant for broader distribution.

• Created manually in the Developer Portal or managed by Xcode's automatic signing.

Enterprise Provisioning Profile:

• Exclusively for members of the Apple Developer Enterprise Program. It allows developers of these orgs to distribute proprietary, in-house applications directly to their employees, bypassing the public App Store.

• Note: This program has stringent enrollment criteria and is strictly for internal distribution within the enrolled organization – these apps cannot be pushed to AppStore.

Developer ID Provisioning Profile:

• Required to utilize certain Apple services or advanced capabilities like Push Notifications, CloudKit, Sign in with Apple, or specific iCloud services.

• Contains an App ID, a Developer ID distribution certificate, the entitlements authorized for the app.

• Created manually in the Developer Portal – will not be added automatically by Xcode’s automatic signing.

How to Create and Manage Provisioning Profiles

Creating and managing provisioning profiles usually requires an Account Holder or Admin role in the Apple Developer Program. You also need a configured App ID, the appropriate certificate(s), and for Development or Ad Hoc profiles, a list of registered device UDIDs.

If you are new developer, my recommendation is to read this article completely, then get back to this section once you have your devices setup.

General steps for manual creation in the Developer Portal:

1. Navigate to "Certificates, Identifiers & Profiles" and select "Profiles".

2. Click the add button (+).

3. Select the type of provisioning profile to create (for example, "iOS App Development," "Ad Hoc," "App Store").

4. Choose the App ID you’re targeting from the dropdown list.

5. Select the certificate(s) to include in the profile. Development profiles can include multiple development certificates – so you can include all the team member certificates here. Ad Hoc and App Store profiles include a single distribution certificate.

6. If creating a Development or Ad Hoc profile, select the registered devices to include.

7. Provide a name for the provisioning profile (this is for identification in the portal and Xcode).

8. Click "Generate" and then "Download" the .mobileprovision or .provisionprofile file.

You need to make downloaded profiles available to Xcode. You can often do this by double-clicking the downloaded file or by refreshing profiles within Xcode's account settings (Preferences > Accounts).

I really like Xcode's "Automatically manage signing" feature and it can simplify profile management by a lot. It creates and updates profiles as needed. But, understanding the manual process is crucial for troubleshooting because when things go wrong, it is straightforward to debug the issue with this knowledge.

Provisioning profiles will become invalid and require regeneration if:

• The capabilities of the associated App ID are changed – let’s say you added a new capability.

• An included certificate expires or is revoked.

• For Development/Ad Hoc profiles, if devices are added or removed from the registered list in a way that affects the profile's device set, or if the profile's own expiration date is reached. When such changes occur, you have to edit the profile (if possible) or delete it and recreate it in the Developer Portal, then re-download it and install it again. While this may seem like a complicated step, it’s straightforward if you do it a couple of times.

Device Management — Development and Ad Hoc Builds

For testing applications on physical Apple hardware outside of Testflight or AppStore, you’ll need to register the Unique Device Identifiers (UDIDs) of your test devices with your Apple Developer account. This registration is a necessary step for creating Development and Ad Hoc provisioning profiles.

Why You Need to Register Test Devices

Development and Ad Hoc provisioning profiles are specifically tied to a list of registered devices. An app signed with this profile can be installed directly without going through App Store process. This means that you need to register devices you intend to develop on. This restricts bad faith actors from releasing apps widely without developer and App Store supervision.

The UUID of a device is like a physical address (think Mac Address). If you don’t include this in the provisioning profile you used to sign an app package, it cannot be installed on that device.

Let’s go over the steps to do that.

How to Find Your Device's UDID (Unique Device Identifier)

A UDID is a unique 40-character hexadecimal string (for older devices) or a 25-character string (format XXXXXXXX-XXXXXXXXXXXXXXXX) that uniquely identifies a specific iPhone, iPad, Apple Watch, Apple TV, Vision Pro or Mac.

There are several ways to find a device's UDID:

• Xcode: Connect the device to a Mac running Xcode. Open Xcode and navigate to Window > Devices and Simulators. Select the connected device from the list on the left. The UDID will be displayed as the "Identifier" in the device information panel.

• Finder (macOS Catalina and later): Connect the iOS or iPadOS device to a Mac. Open Finder and select the device from the sidebar under "Locations." The UDID may be displayed directly, or it might be necessary to click on the line of text beneath the device's name (which shows model, storage, and OS version) to cycle through to display the UDID.

• iTunes (older macOS versions): For Macs running macOS Mojave or earlier, connect the device and open iTunes. Select the device icon when it appears. In the "Summary" tab, click on the "Serial Number" field; this will change to display the UDID.

• Apple Silicon Macs: When registering an Apple Silicon Mac, it's important to look for the "Provisioning UDID," which can be found in System Information under Hardware > Provisioning UDID.

• Other Ways: There are some websites that will install a profile on to your device to get the UUID – so as an absolute last resort, you can do this. But I highly recommend doing it in the one of the official ways to avoid any potential issues.

How to Register Devices in the Apple Developer Portal

Device registration is managed through the "Certificates, Identifiers & Profiles" section of the Apple Developer Portal (developer.apple.com) and typically requires an Account Holder or Admin role.

To manually register a single device:

1. Sign in to the Apple Developer Portal and navigate to "Certificates, Identifiers & Profiles," then select "Devices" from the sidebar.

2. Click the add button (+) to register a new device.

3. Select the correct platform for the device (for example, iOS, macOS, tvOS, watchOS).

4. Enter a descriptive "Device Name" (this is for your reference, for example, "Sravan’s iPhone 11 Pro") and the device's UDID obtained in the previous step.

5. Click "Continue," review the information to make sure everything is correct, and then click "Register".

For registering multiple devices, the portal supports uploading a specially formatted text file (a .txt or a .deviceids file) containing device names and UDIDs.

If "Automatically manage signing" is enabled in Xcode, Xcode can automatically register a connected device when it's selected as a build target. This is the way I managed all of my personal projects and devices. On the other hand, the file upload was really useful at my workplace to keep track of all the devices and add them at once.

Understanding Device Limits and Annual Resets

The Apple Developer Program imposes limits on the number of devices that can be registered for testing:

• Annual Limit: Each membership year, a development team can register up to 100 devices for each product family (iPhone, iPad, Apple Watch, Apple TV, Apple Vision Pro, Mac). If you are a large team, this can potentially bottleneck you. When we ran into this issue, we created a new development team that could be split so that it didn’t have too much interdependence. There is no other way as far as I know, other than asking Apple and appealing them.

• Disabling Devices: While a device can be disabled in the portal during the membership year, doing so does not free up its slot or increase the number of available devices for that year. This part is frustrating but I think this is the only way they can enforce the 100 device limit to avoid people swapping devices. They should just provide a pathway to increase the limit, really. Disabling a device will, however, invalidate any provisioning profiles that include it, requiring those profiles to be regenerated.

• Resetting Device List (Start of New Membership Year): At the beginning of a new membership year, Account Holders, Admins, and App Managers are given a one-time option when they first sign in to "Certificates, Identifiers & Profiles" to remove devices from their list. This allows them to "reset" their available device count back to 100 for each product family. You can choose to remove specific devices or all registered devices. This is your one chance per year to remove unused devices completely and free up slots for new devices.

• Membership Expiration: If a developer program membership is nearing expiration and is not planned for renewal, the Account Holder will have an option, starting 30 days before expiration, to download a copy of their registered device list. They can also opt to have all devices removed from the account immediately upon membership expiration. If no action is taken, devices are typically removed automatically 180 days after membership expiration.

Possibilities: Enabling Capabilities and Services

App Capabilities (or App Services) are features provided by Apple that we (as developers) can integrate into our applications to extend functionality and provide richer user experiences. Examples include iCloud storage, Push Notifications, Sign in with Apple, Apple Pay and HealthKit integration. Enabling these often requires explicit configuration for an app's App ID in the Apple Developer Portal and within the Xcode project.

Why You Should Use Capabilities

Making full use of these App capabilities can set your app apart from other apps in a very noticeable way. You can use Apple Wallet integration if you want users to scan a membership card. You can use journaling suggestions if you want to prompt them to journal something. You can use iCloud Storage to lean further into inter-device synchronization.

When you enable a capability for an App ID, it results in specific entitlements being added to the app's provisioning profile. These entitlements are permissions that the operating system checks at runtime to ensure the app is authorized to use the requested service.

How to Configure Capabilities for Your App ID (Apple Developer Portal)

Enabling and configuring capabilities is typically done by an Account Holder or Admin in the Apple Developer Portal (developer.apple.com).

1. Navigate to "Certificates, Identifiers & Profiles" and select "Identifiers."

2. Choose the App ID for which capabilities need to be configured.

3. In the App ID's settings, there will be a "Capabilities" tab. Select the checkboxes for the capabilities the app requires.

4. Many capabilities require additional configuration steps. For these, a "Configure" or "Edit" button will usually appear next to the capability once selected. Examples include:

• App Groups: Requires creating or selecting an app group identifier to allow data sharing between a main app and its extensions, or between different apps from the same developer.

• Apple Pay: Requires associating one or more Merchant IDs with the App ID.

• iCloud: May require choosing Xcode version compatibility and creating or assigning iCloud containers for Key-Value or Document storage

• Sign in with Apple: May require configuring the App ID as a primary app or grouping it with an existing primary App ID, and optionally providing a server-to-server notification endpoint URL.

5. After configuring all selected capabilities, click "Save." A warning dialog may appear, which needs confirmation to finalize the changes.

Enabling a capability in the Developer Portal is only one part of the process. You’ll also need to add and configure it within the app's target in the Xcode project, under the "Signing & Capabilities" tab.

1. Navigate to the project settings and select “Signing & Capabilities”.

2. Press the “+ Capability” button to select the capability.

3. Once selected, the capability should appear in the pane. Depending on the capability, you might want to configure it further.

This Xcode step integrates the necessary frameworks, adds entitlements files to the project, and adjusts build settings.

How Enabling Capabilities Affects Your Provisioning Profiles

Changes to an App ID's enabled capabilities have a direct and significant impact on its associated provisioning profiles.

• Invalidation: When a capability is enabled, disabled, or its configuration is modified for an App ID, all existing provisioning profiles that use that App ID immediately become invalid.

• Regeneration Required: These invalidated provisioning profiles must be regenerated (either by editing and re-saving them in the Developer Portal or by having Xcode's automatic signing handle it). The regenerated profiles will then include the updated set of entitlements corresponding to the newly configured capabilities.

• Platform Impact: Enabling a capability for an App ID that is used across multiple platforms (for example, an iOS app and its watchOS companion) will affect the provisioning profiles for all eligible platforms that use that App ID.

This is something to keep in mind. Especially when it comes to distribution profiles since those are usually manually managed.

Conclusion

While all of these might seem daunting, Apple’s automatic process should handle most of it. But I highly recommend learning how everything works so that you can debug it in case something goes wrong. I also highly recommend using manually created profiles for distribution.

While signing and handling certificates is not the most exciting part of the App development process, it is a necessary skill to have. In my next article, I will go over distributing an app from start to finish (which includes these processes and more restrictions).

You can follow me at Sravan Karuturi for my other posts.

The Swift programming language was created by Apple in 2014. It's the official language that works with the whole Apple Operating Systems lineup: iOS, iPadOS, watchOS, macOS, and tvOS.

Swift is an open source, general purpose, compiled programming language that's statically typed.

Every value has a type assigned. The type of a value is always checked when used as an argument or returned, at compile time. If there is a mismatch, the program will not compile.

Swift's compiler is LLVM, and it is included within Xcode, the standard IDE you use for Apple software development.

Swift is a modern programming language that was designed to "fit" in an ecosystem that was previously designed for a different programming language called Objective-C.

Most of the software running on the iPhone and Mac today is based on Objective-C code, even for official Apple apps. But Swift usage is gaining traction year after year. While Objective-C will be used for years to maintain and improve existing apps, new applications are likely going to be created with Swift.

Before Apple introduced Swift, Objective-C was heavily developed to introduce new capabilities and features. But in the recent years this effort has decreased a lot in favor of Swift development.

This does not mean Objective-C is dead or not worth learning: Objective-C is still an essential tool for any Apple developer.

That said, I am not going to cover Objective-C here, because we're focusing on Swift – the present and future of the Apple platform.

In just 6 years, Swift has gone through 5 major versions, and we're now (at the time of writing) at version 5.

Swift is famously Apple's products language, but it is not an Apple-only language. You can use it on several other platforms.

It is open source, so porting the language to other platforms does not require any permission or licensing, and you can find Swift projects to create Web servers and APIs (https://github.com/vapor/vapor) as well as projects to interact with microcontrollers.

Swift is a general-purpose language, built with modern concepts, and it has a bright future.

What We'll Cover Here

The goal of this book is to get you up and running with Swift, starting from zero.

If you have a Mac or an iPad, I recommend you to download the Playgrounds application made by Apple from the App Store.

This app lets you run snippets of Swift code without having to create a full app first. It's a very handy way to test your code, not just when you start learning, but whenever you need to try some code.

It also contains a series of awesome examples and tutorials to expand your Swift and iOS knowledge.

Note: You can get a PDF and ePub version of this Swift Beginner's Handbook

• Introduction to Swift
• Variables in Swift
• Objects in Swift
• Operators in Swift
• Conditionals in Swift
• Loops in Swift
• How to Write Comments in Swift
• Semicolons in Swift
• Numbers in Swift
• Strings in Swift
• Booleans in Swift
• Arrays in Swift
• Sets in Swift
• Dictionaries in Swift
• Tuples in Swift
• Optionals and nil in Swift
• Enumerations in Swift
• Structures in Swift
• Classes in Swift
• Functions in Swift
• Protocols in Swift
• Where to Go From Here

Variables in Swift

Variables let us assign a value to a label. We define them using the var keyword:

var name = "Roger"
var age = 8

Once a variable is defined, we can change its value:

age = 9

Variables that you do not want to change can be defined as constants, using the let keyword:

let name = "Roger"
let age = 8

Changing the value of a constant is forbidden.

You can't change the value of a constant or you'll get this error

When you define a variable and you assign it a value, Swift implicitly infers the type of it.

8 is an Int value.

"Roger" is a String value.

A decimal number like 3.14 is a Double value.

You can also specify the type at initialization time:

let age: Int = 8

But it's typical to let Swift infer it, and it's mostly done when you declare a variable without initializing it.

You can declare a constant, and initialize it later:

let age : Int

age = 8

Once a variable is defined, it is bound to that type. You cannot assign to it a different type, unless you explicitly convert it.

You can't do this:

var age = 8
age = "nine"

Cannot assign value of type 'String' to type 'Int' error

Int and String are just two of the built-in data types provided by Swift.

Objects in Swift

In Swift, everything is an object. Even the 8 value we assigned to the age variable is an object.

In some languages, objects are a special type. But in Swift, everything is an object and this leads to one particular feature: every value can receive messages.

Each type can have multiple functions associated to it, which we call methods.

For example, talking about the 8 number value, we can call its isMultiple method, to check if the number is a multiple of another number:

isMultiple method

A String value has another set of methods.

A type also has instance variables. For example the String type has the instance variable count, which gives you the number of characters in a string:

instance variable count

Swift has 3 different object types, which we'll see more in details later on: classes, structs and enums.

Those are very different, but they have one thing in common: to object type, we can add methods, and to any value, of any object type, we can send messages.

Operators in Swift

We can use a wide set of operators to operate on values.

We can divide operators in many categories. The first is the number of targets: 1 for unary operators, 2 for binary operators or 3 for the one and only ternary operator.

Then we can divide operators based on the kind of operation they perform:

• assignment operator
• arithmetic operators
• compound assignment operators
• comparison operators
• range operators
• logical operators

plus some more advanced ones, including nil-coalescing, ternary conditional, overflow, bitwise and pointwise operators.

Note: Swift allows you to create your own operators and define how operators work on your types you define.

Assignment operator in Swift

You use the assignment operator to assign a value to a variable:

var age = 8

Or to assign a variable value to another variable:

var age = 8
var another = age

Arithmetic operators in Swift

Swift has a number of binary arithmetic operators: +, -, *, / (division), % (remainder):

1 + 1 //2
2 - 1 //1
2 * 2 //4
4 / 2 //2
4 % 3 //1
4 % 2 //0

- also works as a unary minus operator:

let hotTemperature = 20
let freezingTemperature = -20

You can also use + to concatenate String values:

"Roger" + " is a good dog"

Compound assignment operators in Swift

The compound assignment operators combine the assignment operator with arithmetic operators:

• +=
• -=
• *=
• /=
• %=

Example:

var age = 8
age += 1

Comparison operators in Swift

Swift defines a few comparison operators:

• ==
• !=
• >
• <
• >=
• <=

You can use those operators to get a boolean value (true or false) depending on the result:

let a = 1
let b = 2

a == b //false
a != b //true
a > b // false
a <= b //true

Range operators in Swift

Range operators are used in loops. They allow us to define a range:

0...3 //4 times
0..<3 //3 times

0...count //"count" times
0..<count //"count-1" times

Here's a sample usage:

let count = 3
for i in 0...count {
  //loop body
}

Logical operators in Swift

Swift gives us the following logical operators:

• !, the unary operator NOT
• &&, the binary operator AND
• ||, the binary operator OR

Sample usage:

let condition1 = true
let condition2 = false

!condition1 //false

condition1 && condition2 //false
condition1 || condition2 //true

Those are mostly used in the if conditional expression evaluation:

if condition1 && condition2 {
  //if body
}

Conditionals in Swift

if statements in Swift

if statements are the most popular way to perform a conditional check. We use the if keyword followed by a boolean expression, followed by a block containing code that is run if the condition is true:

let condition = true
if condition == true {
    // code executed if the condition is true
}

An else block is executed if the condition is false:

let condition = true
if condition == true {
    // code executed if the condition is true
} else {
    // code executed if the condition is false
}

You can optionally wrap the condition validation into parentheses if you prefer:

if (condition == true) {
    // ...
}

And you can also just write:

if condition {
    // runs if `condition` is `true`
}

or

if !condition {
    // runs if `condition` is `false`
}

One thing that separates Swift from many other languages is that it prevents bugs caused by erroneously doing an assignment instead of a comparison. This means you can't do this:

if condition = true {
    // The program does not compile
}

The reason is that the assignment operator does not return anything, but the if conditional must be a boolean expression.

switch statements in Swift

Switch statements are a handy way to create a conditional with multiple options:

var name = "Roger"

switch name {
case "Roger":
    print("Hello, mr. Roger!")
default: 
    print("Hello, \(name)")
}

When the code of a case ends, the switch exits automatically.

A switch in Swift needs to cover all cases. If the tag, name in this case, is a string that can have any value, we need to add a default case, mandatory.

Otherwise with an enumeration, you can simply list all the options:

enum Animal {
    case dog
    case cat
}

var animal: Animal = .dog

switch animal {
case .dog:
    print("Hello, dog!")
case .cat:
    print("Hello, cat!")
}

A case can be a Range:

var age = 20

switch age {
case 0..<18:
    print("You can't drive!!")
default: 
    print("You can drive")
}

Ternary conditional operator in Swift

The ternary conditional operator is a shorter version of an if expression. It allows us to execute an expression if a condition is true, and another expression if the condition is false.

Here is the syntax:

`condition` ? `value if true` : `value if false`

Example:

let num1 = 1
let num2 = 2

let smallerNumber = num1 < num2 ? num1 : num2 

// smallerNumber == 1

The syntax is shorter than an if statement, and sometimes it might make more sense to use it.

Loops in Swift

for-in loops in Swift

You can use for-in loops to iterate a specific amount of times, using a range operator:

for index in 0...3 {
  //iterate 4 times, `index` is: 0, 1, 2, 3
}

You can iterate over the elements of an array or set:

let list = ["a", "b", "c"]
for item in list {
  // `item` contains the element value
}

And on the elements of a dictionary:

let list = ["a": 1, "b": 2, "c": 2]
for (key, value) in list {
  // `key` contains the item key
  // `value` contains the item value
}

while loops in Swift

A while loop can be used to iterate on anything, and will run while the condition is true:

while [condition] {
    //statements...
}

The condition is checked at the start, before the loop block is executed.

Example:

var item = 0
while item <= 3 { //repeats 3 times
    print(item)
    item += 1
}

repeat-while loops in Swift

A repeat-while loop in Swift is similar to the while loop. But in this case the condition is checked at the end, after the loop block, so the loop block is executed at least once. Then the condition is checked, and if it is evaluated as true, the loop block is repeated:

repeat {
    //statements...
} while [condition]

Example:

var item = 0
repeat { //repeats 3 times
    print(item)
    item += 1
} while item < 3

continue and break statements in Swift

Swift provides you 2 statements that you can use to control the flow inside a loop: continue and break.

You use continue to stop the current iteration, and run the next iteration of the loop.

break ends the loop, not executing any other iteration.

Example:

let list = ["a", "b", "c"]
for item in list {
  if (item == "b") {
    break
  }
  //do something
}

How to Write Comments in Swift

A comment in Swift can take 2 forms: a single-line comment, and a multi-line comment.

A single-line comment looks like this:

//this is a comment

and and you can put it at the end of a line of code:

let a = 1 //this is a comment

A multi-line comment is written using this syntax:

/* this
 is
    a multi-line
 comment
*/

Swift allows you to nest multi-line comments:

/* this
 is
    a /* nested */ multi-line
 comment
*/

This is handy especially when commenting out large portions of code that already contain multi-line comments.

Semicolons in Swift

In Swift, semicolons are generally optional.

You can write statements on separate lines, and you don't need to add a semicolon:

let list = ["a", "b", "c"]
var a = 2

You can add a semicolon, but it adds nothing meaningful in this case:

let list = ["a", "b", "c"];
var a = 2;

But if you want to write more than one statement on the same line, then you need to add a semicolon:

var a = 2; let b = 3

Numbers in Swift

In Swift, numbers have 2 main types: Int and Double.

An Int is a number without decimal point. A Double is a number with decimal point.

Both use 64 bits, on modern computers that work with 64 bits, and 32 bit on 32-bit platforms.

The range of values they can store depends on the platform used, and can be retrieved using the int property of each type:

Range of int values

Then, in addition to Int and Double, we have lots of other numeric types. These were mostly used to interact with APIs built in the past and that needed to interact with C or Objective-C, and you must be aware that we have them:

• Int8 is an integer with 8 bits
• Int16 is an integer with 16 bits
• Int32 is an integer with 32 bits
• Int64 is an integer with 64 bits
• UInt8 is an unsigned integer with 8 bits
• UInt16 is an unsigned integer with 16 bits
• UInt32 is an unsigned integer with 32 bits
• UInt64 is an unsigned integer with 64 bits
• UInt is like Int, but unsigned, and it ranges from 0 to Int.max * 2.
• Float is a decimal number with 32 bits.

Then using Cocoa APIs you might use other numeric types like CLong, CGFloat, and more.

You will always use Int or Double in your code, and use those specific types only in particular cases.

Remember that you can always convert any of those types to Int and Double types, instantiating a number passing the value inside parentheses to Double() or Int():

let age : UInt8 = 3
let intAge = Int(age)

You can also convert a number from Double to Int:

let age = Double(3)
let count = Int(3.14)

How to convert a number from Double to Int

Strings in Swift

Strings are one of the most popular tools in programming.

In Swift, you can define a string using the string literal syntax:

let name = "Roger"

We use double quotes. Single quotes are not valid string delimiters.

A string can span over multiple lines using 3 double quotes:

let description = """
    a long
      long 
          long description
    """

You can use string interpolation to embed an expression in a string:

let age = 8

let name = """
    Roger, age \(age)
    Next year he will be \(age + 1)
    """

You can concatenate two strings with the + operator:

var name = "Roger"
name = name + " The Dog"

And you can append text to a string with the += operator:

var name = "Roger"
name += " The Dog"

Or using the append(_:) method:

var name = "Roger"
name.append(" The Dog")

You can count the characters in a string using the count string property:

let name = "Roger"
name.count //5

Any string comes with a set of useful methods, for example:

• removeFirst() to remove the first character
• removeLast() to remove the last character
• lowercased() to get a new string, lowercased
• uppercased() to get a new string, uppercased
• starts(with:) which returns true if the string starts with a specific substring
• contains() which returns true if the string contains a specific character

and many, many more.

When you need to reference an item in the string, since strings in Swift are unicode, we can't simply reference the letter o in let name = "Roger" using name[1]. You need to work with indexes.

Any string provides the starting index with the startIndex property:

let name = "Roger"
name.startIndex //0

To calculate a specific index in the string, you calculate it using the index(i:offsetBy:) method:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name[i] //"g"

You can also use the index to get a substring:

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
name.suffix(from: i) //"ger"

//Or using the subscript:

name[i...] //"ger"

When you get a substring from a string, the type of the result is Substring, not String.

let name = "Roger"
let i = name.index(name.startIndex, offsetBy: 2)
print(type(of: name.suffix(from: i))) 
//Substring

Substrings are more memory efficient, because you do not get a new string, but the same memory structure is used behind the scenes. But you need to be careful when you deal with strings a lot, as there are optimizations you can implement.

Strings are collections, and they can be iterated over in loops.

Booleans in Swift

Swift provides the Bool type, which can have two values: true and false.

var done = false
done = true

Booleans are especially useful with conditional control structures like if statements or the ternary conditional operator:

var done = true

if done == true {
    //code
}

Arrays in Swift

We use arrays to create a collection of items.

In this example we create an array holding 3 integers:

var list = [1, 2, 3]

We can access the first item using the syntax list[0], the second using list[1], and so on.

Elements in an array in Swift must have the same type.

The type can be inferred if you initialize the array at declaration time, like in the case above.

Otherwise the type of values an array can include must be declared, in this way:

var list: [Int] = []

Another shorthand syntax is:

var list = [Int]()

You can also explicitly declare the type at initialization, like this:

var list: [Int] = [1, 2, 3]

A quick way to initialize an array is to use the range operator:

var list = Array(1...4) //[1, 2, 3, 4]

To get the number of items in the array, use the count property:

var list = [1, 2, 3]
list.count //3

If an array is empty, its isEmpty property is true.

var list = [1, 2, 3]
list.isEmpty //false

You can append an item at the end of the array using the append() method:

var list: [Int] = [1, 2, 3]
list.append(4)

or you can insert an item at any position of the array using insert(newElement: <Type> at: Int):

var list: [Int] = [1, 2, 3]
list.insert(17, at: 2)
//list is [1, 2, 17, 3]

An array must be declared as var to be modified. If it's declared with let, you cannot modify it by adding or removing elements.

To remove one item from the array, use remove(at:) passing the index of the element to remove:

var list: [Int] = [1, 2, 3]
list.remove(1)
//list is [1, 3]

removeLast() and removeFirst() are two handy ways to remove the last and first element.

To remove all items from the array, you can use removeAll() or you can assign an empty array:

var list: [Int] = [1, 2, 3]
list.removeAll()
//or
list = []

The sort() method sorts the array:

var list = [3, 1, 2]
list.sort()
//list is [1, 2, 3]

There are a lot more methods, but those are the basic ones.

Arrays are equal when they contain the same elements, of the same type:

[1, 2, 3] == [1, 2, 3] //true

Arrays are passed by value, which means if you pass an array to a function, or return it from a function, the array is copied.

Arrays are collections, and they can be iterated over in loops.

Sets in Swift

You use sets to create collections of non-repeated items.

While an array can contain many times the same item, you only have unique items in a set.

You can declare a set of Int values in this way:

let set: Set<Int> = [1, 2, 3]

or you can initialize it from an array:

let set = Set([1, 2, 3])

You can add items to the set using insert():

var set = Set([1, 2, 3])
set.insert(17)

Unlike arrays, there is no order or position in a set. Items are retrieved and inserted randomly.

The way to print the content of a set so it's ordered is to transform it into an array using the sorted() method:

var set = Set([2, 1, 3])
let orderedList = set.sorted()

To check if a set contains an element, use the contains() method:

var set = Set([1, 2, 3])
set.contains(2) //true

To get the number of items in the set, use the count property:

let set = Set([1, 2, 3])
set.count //3

If a set is empty, its isEmpty property is true.

let set = Set([1, 2, 3])
set.isEmpty //false

To remove one item from the array, use remove() passing the value of the element:

var set = Set([1, 2, 3])
set.remove(1)
//set is [2, 3]

To remove all items from the set, you can use removeAll():

set.removeAll()

Sets, like arrays, are passed by value. This means that if you pass it to a function, or return it from a function, the set is copied.

Sets are great to perform set math operations like intersection, union, subtracting, and more.

These methods help with this:

• intersection(_:)
• symmetricDifference(_:)
• union(_:)
• subtracting(_:)
• isSubset(of:)
• isSuperset(of:)
• isStrictSubset(of:)
• isStrictSuperset(of:)
• isDisjoint(with:)

Sets are collections, and they can be iterated over in loops.

Dictionaries in Swift

We use dictionaries to create a collection of key-value pairs.

Here is how to create a dictionary with 1 key-value pair, where the key is a String and the value is an Int:

var dict = ["Roger": 8, "Syd": 7]

In this case the type is inferred. You can also explicitly set the type at declaration time:

var dict: [String: Int] = ["Roger": 8, "Syd": 7]

In this example we create an empty dictionary of Int keys and String values:

var dict = [String: Int]()

//or

var dict: [String: Int] = [:]

You can access the value assigned to a key using this syntax:

var dict = ["Roger": 8, "Syd": 7]

dict["Roger"] //8
dict["Syd"] //7

You can change the value assigned to a key in this way:

dict["Roger"] = 9

A dictionary must be declared as var to be modified. If it's declared with let, you cannot modify it by adding or removing elements.

Use the same syntax to add a new key/value pair:

dict["Tina"] = 4

To remove a key/value pair, assign the value to nil:

dict["Tina"] = nil

Or call the removeValue(forKey:) method:

dict.removeValue(forKey: "Tina")

To get the number of items in the dictionary, use the count property:

var dict = ["Roger": 8, "Syd": 7]
dict.count //2

If a dictionary is empty, its isEmpty property is true.

var dict = [String: Int]()
dict.isEmpty //true

There are a lot of methods related to dictionaries, but those are the basic ones.

Dictionaries are passed by value, which means if you pass it to a function, or return it from a function, the dictionary is copied.

Dictionaries are collections, and they can be iterated over in loops.

Tuples in Swift

You use tuples to group multiple values into a single collection. For example you can declare a variable dog containing a String and an Int value:

let dog : (String, Int)

And you can initialize them with a name and an age

let dog : (String, Int) = ("Roger", 8)

But as with any other variable, the type can be inferred during initialization:

let dog = ("Roger", 8)

You can use named elements:

let dog = (name: "Roger", age: 8)

dog.name //"Roger"
dog.age //8

Once a tuple is defined, you can decompose it to individual variables in this way:

let dog = ("Roger", 8)
let (name, age) = dog

and if you need to just get one of the values, you can use the special underscore keyword to ignore the other ones:

let dog = ("Roger", 8)
let (name, _) = dog

Tuples are an awesome tool for various needs.

The most obvious one is that they're a short way to group similar data.

Another one of those needs is returning multiple items from a function. A function can only return a single item, so a tuple is a convenient structure for that.

Another handy functionality allowed by tuples is swapping elements:

var a = 1
var b = 2

(a, b) = (b, a)

//a == 2
//b == 1

Optionals and nil in Swift

Optionals are one key feature of Swift.

When you don't know if a value will be present or absent, you declare the type as an optional.

The optional wraps another value with its own type. Or maybe not.

We declare an optional by adding a question mark after its type, like this:

var value: Int? = 10

Now value is not an Int value. It's an optional wrapping an Int value.

To find out if the optional wraps a value, you must unwrap it.

You do so using an exclamation mark:

var value: Int? = 10
print(value!) //10

Swift methods often return an optional. For example the Int type initializer accepts a string, and returns an Int optional:

Int type initializer takes in a string and returns an int optional

This is because it does not know if the string can be converted to a number.

If the optional does not contain a value, it evaluates as nil, and you cannot unwrap it:

Evaluating to nil

nil is a special value that cannot be assigned to a variable. Only to an optional:

You can only assign nil to an optional (not an int)

You typically use if statements to unwrap values in your code, like this:

var value: Int? = 2

if let age = value {
    print(age)
}

Enumerations in Swift

Enumerations are a way to group a set of different options under a common name.

Example:

enum Animal {
    case dog
    case cat
    case mouse
    case horse
}

This Animal enum is now a type.

A type whose value can only be one of the cases listed.

If you define a variable of type Animal:

var animal: Animal

you can later decide which value to assign it using this syntax:

var animal: Animal
animal = .dog

We can use enumerations in control structures like switches:

enum Animal {
    case dog
    case cat
    case mouse
    case horse
}

let animal = Animal.dog

switch animal {
case .dog: print("dog")
case .cat: print("cat")
default: print("another animal")
}

Enumeration values can be strings, characters, or numbers.

You can also define an enum on a single line:

enum Animal {
    case dog, cat, mouse, horse
}

And you can also add type declaration to the enumeration, and each case has a value of that type assigned:

enum Animal: Int {
    case dog = 1
    case cat = 2
    case mouse = 3
    case horse = 4
}

Once you have a variable, you can get this value using its rawValue property:

enum Animal: Int {
    case dog = 1
    case cat = 2
    case mouse = 3
    case horse = 4
}

var animal: Animal
animal = .dog

animal.rawValue //1

Enumerations are a value type. This means they are copied when passed to a function, or when returned from a function. And when we assign a variable pointing to an enumeration to another variable.

Structures in Swift

Structures are an essential Swift concept.

Structures are everywhere in Swift. Even the built-in types are structures.

We can create instances of structures, which we call objects.

In most languages, objects can only be created from classes. Swift has classes, too, but you can create objects also from structures. The official documentation actually advises that you should prefer structures because they are easier to use.

Structures are a light versions of classes.

A struct can:

• have properties
• have methods (functions)
• define subscripts
• define initializers
• conform to protocols
• be extended

One important thing classes allow is inheritance, so if you need that, you have classes.

A struct is defined using this syntax:

struct Dog {

}

Inside a structure you can define stored properties:

struct Dog {
    var age = 8
    var name = "Roger"
}

This structure definition defines a type. To create a new instance with this type, we use this syntax:

let roger = Dog()

Once you have an instance, you can access its properties using the dot syntax:

let roger = Dog()
roger.age
roger.name

The same dot syntax is used to update a property value:

roger.age = 9

You can also create a struct instance by passing the values of the properties:

let syd = Dog(age: 7, name: "Syd")
syd.age
syd.name

To do so, properties must be defined variables with var, not as constants (with let). It's also important to respect the order those properties are defined.

Structures can have instance methods: functions that belong to an instance of a structure.

struct Dog {
    var age = 8
    var name = "Roger"
    func bark() {
        print("\(name): wof!")
    }
}

And we also have type methods:

struct Dog {
    var age = 8
    var name = "Roger"
    func bark() {
        print("\(name): wof!")
    }
    static func hello() {
        print("Hello I am the Dog struct")
    }
}

This is invoked as Dog.hello().

Structures are a value type. This means they are copied when passed to a function, or when returned from a function. And when we assign a variable pointing to a structure to another variable.

This also means that if we want to update the properties of a structure we must define it using var and not let.

All types in Swift are defined as structures: Int, Double, String, arrays and dictionaries, and more are structures.

Classes in Swift

Classes are a bit similar to structures, but they have some key differences.

A class is defined using this syntax:

class Dog {

}

Inside a class you can define stored properties:

class Dog {
    var age = 0
}

A class definition defines a type. To create a new instance with this type, we use this syntax:

let roger = Dog()

Once you have an instance, you can access its properties using the dot syntax:

let roger = Dog()
roger.age

You use the same dot syntax to update a property value:

roger.age = 9

One big difference is that classes are reference types. Structures (and enumerations) are value types.

This means that assigning a class instance to another variable does not copy the instance. Both variables point to the same instance:

class Dog {
    var age = 0
}

let roger = Dog()
let syd = roger

roger.age = 9
//syd.age == 9

This also means we can define a reference to a class using let, and we can change its properties, as you saw in the example above.

We can create instances of classes, and we call them objects.

As with structs, classes can have properties, methods, and more.

Contrary to structs, we must define an initializer in order to initialize the values when we create an instance:

class Dog {
    var age : Int

    init(age: Int) {
        self.age = age
    }
}

let roger = Dog(age: 9)

You can only declare properties without initializing them if you have an initializer.

See the use of self. We need it because age is both an instance property and the init(age:) method parameter. self.age references the age instance property.

Classes can have instance methods: functions that belong to an instance of a class.

class Dog {
    var age = 8
    var name = "Roger"

    func bark() {
      print("\(name): wof!")
    }
}

And we also have type methods:

class Dog {
    var age = 8
    var name = "Roger"

    func bark() {
        print("\(name): wof!")
    }
    static func hello() {
        print("Hello I am the Dog struct")
    }
}

Invoked as Dog.hello().

One important thing classes allow is inheritance.

A class can inherit all the properties and methods from another class.

Say we have a class Animal. Every animal has an age:

class Animal {
    var age: Int
}

Not every animal has a name. Dogs have a name. So we create a Dog class extending from Animal:

class Dog: Animal {
    var name: String
}

Now we must add an initializer for both classes. In the Dog case, after we do the class-specific initialization, we can call the parent class initializer using super.init():

class Animal {
    var age: Int

    init(age: Int) {
        self.age = age
    }
}

class Dog: Animal {
    var name: String

    init(age: Int, name: String) {
        self.name = name
        super.init(age: age)
    }
}

var horse = Animal(age: 8)
var roger = Dog(age: 8, name: "Roger")

Animal is now a superclass, and Dog is a subclass.

There's more to say about classes, but this is a good introduction.

Functions in Swift

Your program's code is organized into functions.

You can declare a function using the func keyword:

func bark() {
    print("woof!")
}

Functions can be assigned to structures, classes and enumerations, and in this case we call them methods.

A function is invoked using its name:

bark()

A function can return a value:

func bark() -> String {
    print("woof!")
      return "barked successfully"
}

And you can assign it to a variable:

let result = bark()

A function can accept parameters. Each parameter has a name and a type:

func bark(times: Int) {
    for index in 0..<times {
        print("woof!")
    }
}

The name of a parameter is internal to the function.

We use the name of the parameter when we call the function to pass in its value:

bark(times: 3)

When we call the function we must pass all the parameters defined.

Here is a function that accepts multiple parameters:

func bark(times: Int, repeatBark: Bool) {
    for index in 0..<times {
        if repeatBark == true {
            print("woof woof!")
        } else {
            print("woof!")
        }            
    }
}

In this case you call it in this way:

bark(times: 3, repeat: true)

When we talk about this function, we don't call it bark(). We call it bark(times:repeat:).

This is because we can have multiple functions with the same name, but different set of parameters.

You can avoid using labels by using the _ keyword:

func bark(_ times: Int, repeatBark: Bool) {
    //...the function body
}

So you can invoke it in this way:

bark(3, repeat: true)

It's common in Swift and iOS APIs to have the first parameter with no label, and the other parameters labeled.

It makes for a nice and expressive API, when you design the names of the function and the parameters nicely.

You can only return one value from a function. If you need to return multiple values, it's common to return a tuple:

func bark() -> (String, Int) {
    print("woof!")
      return ("barked successfully", 1)
}

And you can assign the result to a tuple:

let (result, num) = bark()

print(result) //"barked successfully"
print(num) //1

You can nest functions inside other functions. When this happens, the inner function is invisible to outside the outer function.

Protocols in Swift

A protocol is a way to have different objects, of different types, have a common set of functionalities.

You define a protocol like this:

protocol Mammal {

}

Structs and classes can adopt a protocol in this way:

struct Dog: Mammal {

}

class Cat: Mammal {

}

A protocol can define properties and methods, without providing values and implementations, and a struct/class must implement them:

protocol Mammal {
    var age: Int { get set }
    func walk()
}

The property can be defined as get or get set. If it's get, the property must be implemented as read only, with a getter.

Any type that adopts the protocol must conform to the protocol by implementing those methods or providing those properties:

struct Dog: Mammal {
    var age: Int = 0
    func walk() {
        print("The dog is walking")
    }
}

class Cat: Mammal {
    var age: Int = 0
    func walk() {
        print("The cat is walking")
    }
}

Structs and classes can adopt multiple protocols:

struct Dog: Mammal, Animal {

}

class Cat: Mammal, Animal {

}

Notice that for classes, this is the same syntax used to define a superclass. If there is a superclass, list it as the first item in the list, after the colon.

Where to Go From Here

I hope this little handbook was useful in shining a light on how to get started with Swift. And I hope you are now interested to learn more about it!

I can now point you to a few places to learn more:

• The official Swift Language Guide
• The Swift Standard Library
• WWDC Swift videos

You can get a PDF and ePub version of this Swift Beginner's Handbook here.

In this article we will talk about why and how to implement the GameCenter's Leaderboard within your app.

Why GameCenter is Making a Huge Revival

You can make iPhone games without a scoreboard, but leaderboards can help make the game feel more competitive, like people are competing against one another around the World.

Instead of creating and managing your own backend, the GameCenter Leaderboard allows you to scale with traffic infinitely, skip an entire login page for authorization, get the Image, Name, and friends playing the same game – all without your users having to enter anything.

Especially with iOS 16, Apple is investing more in improving it, and driving more app usage, like through Push Notifications when your friend beats your score in the game.

In my journey of learning SwiftUI, I have been creating and publishing apps, because IMO that's the best way to learn.

There wasn't much updated documentation on how to do a lot of this, especially none with SwiftUI nor with the advent of async and await in Swift. So I consolidated and simplified it for everyone to build amazing apps. So feel free to invite me to test your apps too!

Pre-Requisites:

• You'll need to have an Apple Developer paid account
• You have to create the App Id for your app in the provisioning profiles section of the Apple Developer Portal
• You have to create the App in the iTunes Connect Connect portal

How to Implement Your iOS Leaderboard in 6 Steps

Most of the code logic for the leaderboard is in this file if you want to skip ahead. Here's the steps as follows:

1. How to Create the App Store Connect Leaderboard

Screenshot from the Apple iTunes Connect Portal

Once you have created the app in the App Store Connect portal successfully, go to the Services tab for the app -> and make sure you're in the GameCenter page.

Then add a new leaderboard using the "+" sign, which can either be "Classic" (scores never reset) or "Recurring" (scores reset based on your frequency settings).

Most games prefer a recurring leaderboard so that the leaderboard isn't cluttered with older impossible to reach high scores.

The LeaderboardID you input there is the one that you need to use in all the places in the code that ask for it.

Details required to create a new Leaderboard

2. How to Set Up GameCenter Authentication

First, you'll need to authenticate users to GameCenter in order for any of this functionality to work.

So we'll use this code to do that, which basically makes sure that you (GKLocalPlayer.local) are authenticated, or prints an error if there is one:

func authenticateUser() {
    GKLocalPlayer.local.authenticateHandler = { vc, error in
        guard error == nil else {
            print(error?.localizedDescription ?? "")
            return
        }
    }
}

If the user is authenticated, you will see a little popup in the UI. If not, the user will be taken to a page to login to their GameCenter account.

A sign that displays when a user is logged in

3. How to Display Leaderboard Items in the UI

In order to get the data away from the GameCenter ViewController leaderboards (GKLeaderboard), you need to use the loadLeaderboards .

You can switch up the loadEntries function from .global to .friends in order to only pull your friends.

You can also retrieve the image for each player by iterating over each player and performing a loadPhoto.

Using NSRang(1...5), you can choose how many players to display. This pulls the users with the highest 5 scores from the leaderboard and returns none if there's no users, such as in the case when the cycle refreshes for a recurring Leaderboard.

This is what pulling data from a leaderboard could look like if you take advantage of async-await:

func loadLeaderboard() async {
    playersList.removeAll()
    Task{
        var playersListTemp : [Player] = []
        let leaderboards = try await GKLeaderboard.loadLeaderboards(IDs: [leaderboardIdentifier])
        if let leaderboard = leaderboards.filter ({ $0.baseLeaderboardID == self.leaderboardIdentifier }).first {
            let allPlayers = try await leaderboard.loadEntries(for: .global, timeScope: .allTime, range: NSRange(1...5))
            if allPlayers.1.count > 0 {
                try await allPlayers.1.asyncForEach { leaderboardEntry in
                    var image = try await leaderboardEntry.player.loadPhoto(for: .small)
                    playersListTemp.append(Player(name: leaderboardEntry.player.displayName, score:leaderboardEntry.formattedScore, image: image))
                                print(playersListTemp)
                    playersListTemp.sort{
                        $0.score < $1.score
                    }
                }
            }
        }
        playersList = playersListTemp            
    }
}

You can get leaderboard data into your app

4. How to Call Functionality in SwiftUI as the View/Page Appears

You can take advantage of the onAppear lifecycle function of the view to actually make the calls to authenticate and load, but you can also do it on the tap of a button if you prefer that:

.onAppear(){
    if !GKLocalPlayer.local.isAuthenticated {
        authenticateUser()
    } else if playersList.count == 0 {
        Task{
            await loadLeaderboard()
        }
    }
}

5. How to Load the Submitted Scores

In order to load the scores, you need to submit them as well. The submitScore function can help you with that.

• The flightsClimbed variable should contain the score that you would like to submit.
• GameKit makes sure to only display your best score for the life of the leaderboard.
• The leaderboardId contains the value that you manually enter in your App Store Connect account:

func leaderboard() async{
    Task{
        try await GKLeaderboard.submitScore(
            flightsClimbed,
            context: 0,
            player: GKLocalPlayer.local,
            leaderboardIDs: ["com.tfp.stairsteppermaster.flights"]
        )
    }
    calculateAchievements()
}

6. How to display the GameCenter ViewController Portal

When you're logged into GameCenter, a little annoying icon appears in the top right of your screen. When you tap on it, you are taken to the GameCenter ViewController. Luckily you can hide it if it's not part of your design, using GKAccessPoint.shared.isActive = false.

Since the GameCenter UI is a UIKit ViewController and not a simple SwiftUI View, you need to create this UIViewControllerRepresentable first (as you can see here), to launch GameCenter using a different button,

Once you add that file to your project, you can display the GameCenter portal simply using this: GameCenterView(format: gameCenterViewControllerState) where gameCenterViewControllerState can be help you go to a detail page in GameCenter.

GameCenter's Leaderboard View

Things to Keep in Mind While using GameCenter's Leaderboards:

• Simulator Debugging – For some reason the authenticate to GameCenter is extremely slow on a simulator, so it might make sense to even create a mock of data when using the simulator.
• Challenges – You can't programmatically issue GameKit Challenges to your friends anymore due to deprecation. Instead, you have to do those manually within the user's GameCenter dashboard against GameKit Achievements. Also, there's no way to view challenges you have sent.
• Achievements – Leaderboards are different from the GameKit Achievements, which is calculated and displayed differently, but a lot easier. Those can also be pulled into the app as well, as you can see below:

GameKit Challenges and Achievements

Wrapping Up

You can try out the free open-source Stair Master Climber iPhone Health & Fitness app that I shared above. I would love to know what you think so that we can learn together.

Feel free to reach out to me on social media or by email if you have any questions.

In this tutorial for beginners, you will learn the basics of using SwiftUI to make API calls using the popular Internet Chuck Norris DataBase (ICNDB) as an example. It will display a joke quickly and easily using Swift and SwiftUI.

You'll see how the cross-platform framework SwiftUI lets us use the exact same code across iOS, iPadOS, macOS, watchOS, App Clips and tvOS, which otherwise would have been impossible.

Along with that, you will use async-await that was introduced in Swift 5.5, which works for newer operating systems including iPhones running iOS > v15.0. This really simplifies our work of making data network calls asynchronously on click of a button without freezing the UI thread.

I will share the code changes you'll need to make first. Then in the following section, I will share a brief analysis of the code so beginners can understand what's going on as well.

tvOS app running the code displays a button that retrieves the joke on click

How to Make API Calls in Swift and SwiftUI

First, you'll need a Mac to install Xcode. Once it's installed, open Xcode and create a new project. Then select "App" for iOS, macOS, tvOS, or watchOS.

ContentView

Just update your existing ContentView SwiftUI file to add a Button and use the State variable to refresh the text displayed as the joke returns from ICNDB API:

import Foundation
import SwiftUI
struct ContentView: View {
    @State private var joke: String = ""
    var body: some View {
        Text(joke)
        Button {
            Task {
                let (data, _) = try await URLSession.shared.data(from: URL(string:"https://api.chucknorris.io/jokes/random")!)
                let decodedResponse = try? JSONDecoder().decode(Joke.self, from: data)
                joke = decodedResponse?.value ?? ""
            }
        } label: {
            Text("Fetch Joke")
        }
    }
}
struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}
struct Joke: Codable {
    let value: String
}

Fetch a joke!

If you press build/play, the app will build in whatever platform you selected above:

Screenshots of watchOS, macOS, and iOS apps running the same exact code

Code Analysis

If you go to the random joke URL, you'll notice that the data is in JSON format. You can copy that and use a JSON Linter to view its structure to figure out what property of the Joke object is needed.

Based on that, you determine the code above. You use the Codable protocol (aka interfaces) to go from a JSON data object to an actual Swift class or struct, and you create properties for the data you want to store (value in our case).

JSONDecoder helps us parse the JSON string using the Codable object. This works regardless of platform because the page that loads on launching the app has the same name ContentView regardless of platform.

App Clips

App Clips are Apple's latest way of using native app functionality using an "App Clip Code" without having to download the whole application from the App Store.

App Clips work similar to an iOS app – the only difference is that you don't create a new App Clip project. You just need to add the App Clip as a target to an existing iOS app by going to File->New->Target->iOS->App Clip when an existing iOS app is open in Xcode.

If you you wondering about iPhone/iPad Widgets, well they don't animate. So button clicks will just open the corresponding app and can't update text through an external API independently.

Conclusion

In this article, you learned how to make RESTful GET API calls from SwiftUI in the simplest possible way!

Feel free to reach out to me if you have any questions. I figured this out using another article and I thought of simplifying it further. So for more details and ways to make this code more complex, check out that article:

Here is what the Quick Notes feature looks like when you move your cursor to the lower right hand corner of the screen:

The New Quick Note feature in the lower right hand screen of MacOS Monterey

I like a lot of MacOS Monterey's features, but I didn't like this popping up so frequently when I was moving my mouse around. So I disabled it. You can do this, too, and it only takes a few seconds.

How to Disable the New Quick Note Feature in MacOS Monterey

First of all, navigate to your MacOS preferences.

Step #1: Open System Preferences

The fastest way to do this is to press Command + Space to open up Spotlight.

Then type "pref" and you should see a System Preferences option.

MacOS Spotlight is a helpful way to open up applications quickly. You can open it by pressing Command + Space

Step #2: Open Mission Control Preferences

Click the Mission Control icon pointed to above

Step #3: Click the "Hot Corners..." button

The Hot Corners button is in the lower left-hand corner

Step #4: Disable the Quick Note Hot Corner Gesture

You can now disable the Quick Note hot corner. If you prefer, you could instead assign this hot corner to something else. I personally find these hot corners more distracting than helpful, and turn all four of them off.

Remember: anything you can do with a hot corner, you can do with the MacOS built-in Spotlight feature.

Click the drop down for the lower-right hand corner and set it to "–" which means nothing will happen when you move your cursor to the lower right hand corner of your screen.

Step #5: Click the OK Button and Close Mission Control

Congratulations. You have disabled the Quick Note hot corner. It shouldn't pop up anymore.

I hope this has been helpful. Have a fun, productive day.

Apple provides a complete development environment for programmers named Xcode. If you are developing software for macOS, iOS, tvOS, and watchOS, you must install the full Xcode application.

It's not pre-installed, but you can install it from the Apple developer website or the App Store on your Mac.

What are Xcode Command Line Tools?

If you're not developing software for an Apple device, you won't need the full Xcode application (it requires over 40GB of disk space!).

Instead, you'll install Xcode Command Line Tools. It's a smaller package for software developers with tools that run on the command line, that is, in the Terminal application.

Programmers have used these tools on Unix operating systems since computing's beginnings, and they serve as the foundation of almost all software development.

Luckily, the Xcode Command Line Tools package only requires 1.2GB of space on your disk.

You have three choices to install Xcode Command Line Tools on a Mac:

• install the full Xcode package
• install Xcode Command Line Tools when triggered by a command
• install Xcode Command Line Tools as part of a Homebrew installation.

I don't recommend installing the full Xcode package unless you're developing software for an Apple device. The download will take too long and it will consume unnecessary disk space. Instead, try either of two faster methods.

How to Install Xcode Command Line Tools from a Command Prompt

Apple has made it easy to install Xcode Command Line Tools because certain commands will prompt you to begin installation.

Here are examples of commands that will trigger a prompt to install Xcode Command Line Tools:

• clang – a compiler that turns source code into an executable program
• gcc – the GNU compiler
• git – the save-as-you-go version control system

Running any of these commands in the terminal will bring up a prompt to install Xcode Command Line Tools. I've written elsewhere about How to Open Terminal on MacOS – just click the Spotlight icon in the menu bar and type “terminal.”

You can also enter the command xcode-select --install in the terminal to begin the installation process. You'll see a panel that asks you to install Xcode Command Line Tools.

Click 'Install' to begin the download and installation process.

Installation takes 8 minutes on a 2021 Mac M1 Mini, with a 100Mbps Internet connection. It's significantly slower on Mac Intel over a slow Internet connection.

You'll see a confirmation message when installation is complete.

Verify that you've successfully installed Xcode Command Line Tools:

$ xcode-select -p

You should see the following:

/Library/Developer/CommandLineTools

How to Use Homebrew to Install Xcode Command Line Tools

As easy as it is to use the command prompt to install Xcode Command Line Tools, I recommend an even easier method: using Homebrew.

This option was only recently added to Homebrew, so many developers are not aware of it.

Homebrew is the popular Mac package manager. Most developers need programming languages and utilities that don't come installed on macOS and are not included in the Xcode Command Line Tools package. Homebrew can install almost any open-source tool for developers.

Since you'll probably need Homebrew, you might as well let Homebrew install Xcode Command Line Tools for you.

First, check if Homebrew is already installed.

$ brew

If Homebrew is not installed, you will see:

zsh: command not found: brew

Homebrew provides an installation script you can run with a single command (check that it hasn't changed at the Homebrew site).

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

The Homebrew installation script will ask you to enter your Mac user password. This is the password you use to sign in to your Mac.

Password:

You won't see the characters as you type. Press enter when you are done.

If you haven't already installed Xcode Command Line Tools, you'll see a message that "The Xcode Command Line Tools will be installed." Press return to continue when prompted by the Homebrew installation script.

You’ll see diagnostic and progress messages. Homebrew installation takes 2 to 15 minutes on a 2021 Mac M1 Mini, with a 100Mbps Internet connection. It's significantly slower on Mac Intel over a slow Internet connection.

On Mac Intel machines, that's all you need to do – Homebrew is ready to use. On Mac Intel, Homebrew installs itself into the /usr/local/bin directory, which is already configured for access by the shell with the macOS default $PATH.

On Apple Silicon machines, there's one more step. Homebrew files are installed into the /opt/homebrew folder. But the folder is not part of the default $PATH. Follow Homebrew's advice and create a ~/.zprofile file that contains a command which sets up Homebrew. Homebrew shows instructions at the end of the installation process:

- Add Homebrew to your PATH in ~/.zprofile:
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

After you've installed Homebrew, check that Homebrew is installed properly.

$ brew doctor

You should see this:

Your system is ready to brew.

If Homebrew is successfully installed, there will be Homebrew files in /usr/local (for macOS Intel) or /opt/homebrew (for Apple Silicon).

Now you have both Xcode Command Line Tools and Homebrew installed. If you want to learn more about adding Homebrew packages to set up your development environment, see Install a Homebrew Package.

More information

I've written an in-depth guide to Install Xcode Command Line Tools that goes beyond these basics.

In the guide, I explain how to check if Xcode Command Line Tools Are Already Installed. I go into more detail about how to Install Xcode Command Line Tools with Homebrew. Finally, I explain how to Uninstall Xcode Command Line Tools, Reinstall Xcode Command Line Tools, and provide a List of Xcode Command Line Tools that you can use.

There's also a complete guide to Install Homebrew for Mac that explains how to Update Homebrew, Uninstall Homebrew, and keep up with other Housekeeping for Homebrew.

Your development environment

MacOS is the most popular platform for software development because the operating system is based on Unix, the longtime standard for software development.

With Xcode Command Line Tools installed, you'll have a solid foundation for adding almost any open source development tool.

Add Homebrew and you have a package manager that can install version managers, programming languages, and almost any other tool you may need.

Combined with a text editor and terminal application, you'll be prepared for any tutorial you'll find on freeCodeCamp.

With the release of iOS14, there have been major changes in the way applications can gather information about a user. One of them deals with the Identifier For Advertisers (or IDFA) and how applications can access it.

But for those that don't know, let's first explain what the IDFA is and why it's important.

What is an IDFA?

Each iOS device owner can decide whether they want to be tracked by advertising companies. This allows those companies to supplying that user with content that is tailored towards them (based on their online browsing habits).

Companies can do this with what’s known as an IDFA (Identifier For Advertisers). This is a [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#:~:text=A%20universally%20unique%20identifier%20(UUID,%2C%20for%20practical%20purposes%2C%20unique.) string that lets advertisers match the user with their behavior.

Here's an example of a UUID string : 123e4567-e89b-12d3-a456–426614174000.

So, what are those changes we talked about earlier?

In short, applications will now be required to show a dialog to the user, asking them if they want to allow the application to track them or not.

The Tracking Authorization Dialog

Looks pretty ominous, right?

This is in contrast with how things worked before iOS14, where you only had to check if the device had limited advertising tracking enabled or disabled.

The newest version of Apple’s operating system (iOS14) is already available (has been since September 16th). Developers who use the IDFA have to make changes in their applications in order to be compatible for iOS14.

On September 3rd, Apple made an update and pushed the deadline to complete these updates to the start of next year:

“To give developers time to make necessary changes, apps will be required to obtain permission to track users starting early next year”

Now that we have some time to regain our composure and breathe again, let’s start preparing ourselves for what’s going to be the new normal in 2021.

In this article, we'll present some background about the IDFA and see how we can get its value from iOS14 and onwards.

How does the IDFA Get Used By Advertisers?

Let’s take a scenario (pre COIVD-19) where you are browsing the web on your iPhone and are looking for a hotel for your next vacation.

Each ad that you see will send a pixel with your IDFA attached to it. An advertiser can see that you are looking at a lot of ads promoting hotels by matching your IDFA and conclude that you are looking to book a hotel room.

From there, it won’t be long until you will be shown a lot of ads for hotel rooms.

This simple yet profound technology came into our lives back in 2012 with iOS6. Since then a lot has changed, and iOS14 is flipping the industry on its head, yet again.

✋ Note: To use these new APIs you must have upgraded/downloaded XCode 12.

Advertising Tracking And Getting The IDFA

Before iOS14, getting the IDFA was pretty simple.

You had to check whether Advertising Tracking was enabled or not, by doing this:

[[ASIdentifierManager sharedManager] isAdvertisingTrackingEnabled]

And if it was disabled, that meant you could acquire the IDFA through the ASIdentifierManager class, like so:

[[[ASIdentifierManager sharedManager] advertisingIdentifier] UUIDString];

Simple enough, right?

☝️ Beginning with iOS10, if the user disabled advertising tracking, the method above would return a UUID string filled with zeros.

One of the changes in iOS14 is the deprecation of the method that checks whether advertiser tracking is enabled or not. So how can applications get the coveted IDFA from iOS14 and onward?

They will have to use a new API that presents a dialog to the user. A few words of wisdom regarding this dialog:

• It can only be presented to the user once
• The only thing that can be altered in the dialog’s UI are the two lines above the Allow Tracking option (“Do you want to be tracked?”)

This means that developers will need to think long and hard about how and when they will present the message to the user.

Authorization Status

With iOS14, a new framework has been created called App Tracking Transparency. This framework contains a class called ATTrackingManager, which provides an API to:

1. Present a dialog to the user requesting permission to track them
2. Query the authorization status (regardless of showing or not showing the dialog)

We’ll first learn how to get the authorization status. To do so, you need to call the trackingAuthorizationStatus method.

ATTrackingManagerAuthorizationStatus status = [ATTrackingManager trackingAuthorizationStatus];

It will return an NSUInteger with one of the following values:

• ATTrackingManagerAuthorizationStatusNotDetermined = 0
• ATTrackingManagerAuthorizationStatusRestricted = 1
• ATTrackingManagerAuthorizationStatusAuthorized = 3
• ATTrackingManagerAuthorizationStatusDenied = 2

The first three results are pretty self explanatory, so we will focus for a minute on the last one.

You can get an authorization status that is restricted when the screen for enabling/disabling advertising tracking is locked and this option is set to enabled.

Apple has acknowledged this in devices that are identified as belonging to children (for example).

Asking For Permission To Track

Before looking into the code needed to present the dialog, you must first include the NSUserTrackingUsageDescription key inside your info.plist file.

What you add as the value for this key will appear as the two lines mentioned earlier, in the dialog.

NSUserTrackingUsageDescription in the info.plist file

To present the dialog, we need to call requestTrackingAuthorizationWithCompletionHandler:

[ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
        if (status == ATTrackingManagerAuthorizationStatusDenied) {
            //Logic when authorization status is denied
        } else if (status == ATTrackingManagerAuthorizationStatusAuthorized) {
            //Logic when authorization status is authorized
        } else if (status == ATTrackingManagerAuthorizationStatusNotDetermined) {
            //Logic when authorization status is unknown
        }  else if (status == ATTrackingManagerAuthorizationStatusRestricted) {
            //Logic when authorization status is restricted
        }
    }];

In the first picture of this article (where you see the dialog) you can see that the lines we wrote in the info.plist file show up as the two lines in the dialog.

Wrapping up

In conclusion, it's important to remember that these changes, while daunting, are not happening immediately.

You should also make sure to follow all of the steps detailed in this article so as not to come across crashes/errors in your applications.

Over the past year, I've received many messages asking how I got into WWDC 2019 as a scholar. And I've finally decided to write this post to answer those questions.

So chances are, if you're wondering how to apply for the scholarship, your questions will be answered in this article.

What is the Apple WWDC Scholarship?

First things first, WWDC is Apple's World-Wide Developer Conference held every year in June. There, Apple announces recent software (and hardware) updates to some of its products including MacBooks, iPhones, and iMacs.

If you want to attend WWDC these are the associated costs:

1. Event ticket price: $1600
2. One week stay in San Jose, California: $1000-$1500 (depends)
3. Travel and other expenses - $400-$500 (again, depends)
4. Plane ticket: $1500-$2000 (again, depends, but from India, this is a fair price)

As a student, you likely can't afford this much. But Apple offers a scholarship to students, where they sponsor your plane ticket, event ticket price, and one week stay. That's about $5000 in savings if you manage to get selected as a WWDC Scholar.

Who am I?

I'm a web developer who was an Apple WWDC '19 scholar. To sum up, I was probably the only person in the WWDC crowd who knew JavaScript better than Swift.

But if I can get the scholarship, so can you. So now let's discuss the WWDC scholarship in more depth.

WWDC Scholarship 101

This is a scholarship which Apple offers to people enrolled in STEM programs around the world. If you're enrolled in a college or you're in school, chances are that you can apply for this scholarship.

To apply for the scholarship you have to build a simple project that the Apple review team can use and experience in under 3 minutes. More or less, these are the ONLY requirements of your WWDC app:

1. Size limit (20 MB)
2. You should be enrolled in STEM organization
3. You have to use Apple technologies (Xcode, Swift, MacBooks, etc.)
4. Make it a small app, something that can be used and understood within 3 minutes

Now, let's start in on how I did it, and then I'll give you a few pointers to help you out with your application next year.

How I cracked the WWDC19 scholarship in 10 days

To begin, I literally learned everything about WWDC: the Swift programming language, and the tech around it all in 10 days. No lies. And this helped me get the scholarship (I was one of the few from India that year).

But I don't want to confuse you with some clickbaity thing - it is not possible to crack that scholarship application from a complete beginner state in just 10 days.

I was able to do it because I had a little programming experience before, mostly with Node. The general concepts in programming remain the same, and after a while you're just hopping through syntax and documentation for the most part.

Here is what I submitted for WWDC 2019:

Trust me, I had no idea either how to build this whole thing. I learned the required Apple APIs and frameworks in 10 days.

So here's how you can approach WWDC '21 in 5 steps:

#1: Learn Swift, and Apple frameworks

Apple loves to see students using their technology - Swift, SwiftUI, ARKit, , and so on. The more you can use, the better. Don't force or bloat your app, but try to showcase what you know.

If you're creating a simple game, try to introduce some AR version of the game too. If you're creating a project for WWDC which could use some ML, do that. You'll get points for it.

#2: Pick difficult ideas

When I started to create my project for WWDC, I had no idea how would I do it. Not gonna lie, my final version wasn't really what I had imagined, but it was pretty close.

The more ambitious the idea you pick, the better are your chances. But balance your ambition with your timeframe – you don't want to have an incomplete app before submissions close.

For me, it was a very close call (I had my submission ready just about an hour before the deadline). Plus I had to work a lot to learn all this new Apple tech as I didn't know anything beforehand.

So make sure you have an estimate of what you need to learn and what you want to build. But like I said, go for shiny and ambitious ideas that stand out.

#3: Write your ideas down, then build them in 10 days

This is more of personal opinion. But I've seen people who prefer to build something over the course of 2, 3, or 4 months before the scholarship kicks off. Trust me, you'll get a 500% productivity boost when the countdown starts ticking.

I would say keep a list of unique or innovative ideas you have with you. Learn the skillset, but develop projects which you intend to submit in the provided 10 days only. Honestly, it is enough time to pull off something decent which the Apple staff can experience in under 3 minutes (their direct instructions).

I recommended focusing on ideas that really impact the world – education, the health of the planet, making technology more accessible to people, and so on.

These are ideas that the Apple scholarship panel values a lot (at least that's what I've observed in most accepted submissions). And if you are interested in any of these fields, it would be a fun and good match for you.

#4: Try going for Swift Playgrounds on iPad

If possible, I would recommend NOT going with MacBook-based Xcode playground submissions.

I know there have been people who have won with their Xcode playgrounds. But I believe that if you go with a MacBook-based playground, you miss out on a ton of things.

I say this for two main reasons:

1. iPad has a better camera and API support for things like ARKit and a better CPU for ML models/intensive apps
2. Swift Playground Books (available only on iPad) are beautiful to use and interact with (as a user)

For quite some time, Apple has not changed its guidelines for the scholarship much. So it should be safe to assume that Swift playgrounds will be a choice next year too.

They're easy to work with (just like Swift playgrounds on Mac), and are highly engaging. iPads really enable a lot of useful things. So give iPad submission a try for the scholarship if possible.

#5: Focus on your responses, too

The Apple panel also reads your responses to basic questions about what technology you've used and built your project with.

Make sure you mention everything and anything you've used, from the best Apple frameworks to external assets if you have used any.

Proofread your paragraphs – the only thing worse than a little bug in your code could be a little bug in your paragraph.

Apart from this, stay focused for 10 days, (I remember I pulled all-nighters for almost all 10 days), and most importantly do it for fun. There are a lot of ways to go one step forward in life, and this is just one of them.

Don't stress out too much over what the result might be. Because if you're attempting this, you're probably in your early 20s which means you have a full life in front of you. You'll have plenty of time to do more amazing things, irrespective of the result. So just go get it!

My Experience with WWDC

In short: mind-blowingly amazingly super cool!

Although I wanted to keep this article focused on helping you out, I also wrote this section to motivate you to work hard for this scholarship. It unlocks a TON of networking opportunities, and you meet and make a bunch of cool friends (MKBHD included haha). Plus you'll have a lot of fun.

I shared some of my moments in the full vlog last year, see if you like what I did there.

If you still have questions, or this article helped you out, feel free to reach out to me on Twitter or Instagram and tell me :) I'm also working on codedamn, a platform for developers to learn and connect, feel free to give it a visit too.

What do you do?

iCloud Photos to the rescue!

If you need to get into your photos but don't have any of your trusty devices on hand, this guide will show you how.

Getting started

You're probably familiar with the photos app on your iPhone. I know I visit it multiple times a day when I'm taking or looking for a photo of my adorable boxer.

But what if you're in that unfortunate situation mentioned above and don't have access to your phone (or tablet or laptop)? There's a simple answer: iCloud Photos. And you can access those photos from any computer or device, as long as you have an internet connection and your Apple login info.

So let's go find your photos.

Go to iCloud.com and sign in

Open any web browser and go to icloud.com. If you're not signed in you'll be prompted to do so:

Locate the photos app

Once you're signed in you'll be brought to a screen full of apps. And somewhere in there you'll see the photos app icon:

Look for the colorful photo app

The first time you access your photos this way they might take a while to load. Especially if you have over 19,000 of them like I do. Just sit tight while iCloud prepares them (and feel free to go do something else while you wait).

Browse, share, and have fun!

Once they're all loaded, it'll look a little something like this (with your own photos, of course):

Voilà! Your photos are there for the taking.

Now you can show your eager family that 45 minute slide show you prepared on the plane ride home...which probably killed your phone battery.

Getting to know iCloud Photos

But what else can you do now that you have access to your photos again? You can organize them, create favorites, delete unflattering or duplicate captures, and more. Let's have a look.

Managing favorites

Ah, that last evening at the beach/mountain/your favorite bar. Remember that super sweet photo you are just dying to show everyone to make them jealous? You can make it a favorite so you never have to search through all your photos for it again.

Just select that photo by double-clicking it so it opens. A little menu of icons will become selectable in the upper right:

Click the heart. Now that photo is in your favorites.

If you want to further manage your favorite photos just click on the "Favorites" tab in the left sidebar menu.

Under favorites, you can do all sorts of fun things

When you click once on any of those photos (as you can see, the last photo is highlighted blue), that upper right menu will become available again.

Those menu icons allow you to upload photos, add your selected photo to an album, share that photo, download it, or delete it.

Tip: just be careful when deleting items. You're not just deleting that photo from your favorites - you're deleting it from all your devices.

Delete carefully!

Just in case you mistakenly delete a photo, however, you can recover it. Just visit the "Recently Deleted" tab in the left sidebar menu. There, you'll see your just-deleted photo and how many days it has left before it disappears. Forever.

So you're tellin' me there's a chance...

Creating a new album

What if you want to share specific photos with your family but keep certain others private?

You can do that, too! Just look for the "My Albums" tab in the left sidebar menu:

Just click once on "My Albums" and your albums (if you have any) shall appear.

If you want to create a new album, just click the "+" in the upper right corner:

You'll be asked to give the album a name, and once you do, you can add photos by clicking the upload photos icon in the upper right:

Upload away!

You can also add photos to your new album while you're browsing your pics. Just select a photo (or drag to select multiple photos) and click on the "+" in the upper right corner.

Add one or many photos to the album of your choice.

Then just select the album where you want the photos to go, and presto! Your album is populated with adorable dog photos (or whatever photos you've selected. Are there any other kinds of photos?).

Managing your albums

Within your albums you can manage your photos the same ways as you can in your favorites. Just double-click on an album, select (click on) a photo, and edit away.

So many options, so little time...

And now all you need to do is put together that next stunning slideshow.

What if I don't see any photos?

If you login to iCloud and don't see any photos, it could be that you haven't opted for your photos to be saved to iCloud.

To fix that, just go to Settings in your phone, select Photos, and toggle iCloud Photos on:

This will automatically upload and store your photos in iCloud so they're there when you need them.

Tip: if you can't toggle on that switch, it could be that your phone/device doesn't have enough space to store them. If that's the case you'll just need to upgrade your iCloud storage plan.

Now you'll never be without your photos again.

Apple launched the much-awaited iOS 13 updates globally on September 19 across all iPhones launched within the past 4 years (back to the iPhone 6s).

One of the biggest features of this update was the system-wide iOS 13 dark mode. It's expected to help with eye-strain caused by white light emitted by smartphone displays.

While this feature is a joy to end-consumers using Apple devices, it's a task for iOS developers to prepare an app ready for iOS 13 dark mode.

How to Set up your App for iOS 13 Dark Mode?

To help developers with this issue, here is useful info and steps showing how they can prep up an existing iOS app for iOS 13 dark mode.

• It’s not too hard to implement iOS 13 dark mode despite its system-wide scale.
• Enabling iOS 13 dark mode on your existing app is also simple mostly thanks to the latest iOS 13 SDK.

When using the latest version to build apps for iOS 13 dark mode, the OS will automatically update switches, buttons, and table views among other system controls. Though do note that images and text colors won’t adjust for dark mode automatically.

However, it’s still amazing to see that a system-wide change such as dark mode is so easy to implement. There are smaller code changes and more work that you'll be able to get done with the iOS 13 dark mode in that saved time.

How to Adapt Colors For iOS 13 Dark Mode

First, let’s start with changing system colors iOS 13 dark mode:

Now there are new system colors added in UIColor, one of which is a label color. Using these new colors helps support dark mode and other high contrast modes in iOS 13.

label.color = UIColor.secondaryLabel

Generally, you should use system colors for iOS 13 dark mode, which automatically adapts to changes in the interface for maintaining consistency across apps. However, developers can also choose to implement dark mode with custom colors.

The asset catalog colors introduced with iOS 11 make it much easier to support dark mode by adding dark versions of a custom set of colors.

You only have to select a preferred color from the catalog, then change Appearances to Any, Dark from the Attributes Inspector.

That's it! Now you have a custom iOS 13 dark mode ready for your mobile app.

Troubleshooting iOS 13 Dark Mode

Let's say your app is not following iOS 13 dark mode. What will you do? Here are some easy steps to solve this issue.

Step 1

You will need to know if the app is updated or not.

If the app is not working with iOS 13 Dark Mode or does not support it, simply update the app via Apple Store.

Step 2

Check whether the Dark Mode of your iOS app has been enabled or not.

If not, go to Settings - Display & Brightness - check whether "Dark" is enabled or not.

Step 3

If your app is fully updated, but isn't working with iOS 13 Dark Mode, then check the in-app settings. See the image:

If you want more help on setting up your iOS 13 Dark Mode, get it from the dedicated development teams. And, that is how I'm going to help you.

Also read tips for mobile app development on iOS. Hope all this information will be helpful for you.

Let's see what you have to do next.

Adapt Images For iOS 13 Dark Mode

Most images look great in iOS 13 dark mode, and at times they pop out in a way that really highlights details. However, you may still end up finding some images which look a bit off or unsuitable for dark mode.

The good news is that you can adjust images for dark mode in the same way text is adjusted.

All you need to do is select the image in the catalog and as done previously, and change attributes to Any, Dark in the Attributes Inspector. Now add the dark appearance of the image and we’re done.

Programmatically Detecting Changes in iOS 13 Dark Mode

Developers could face situations where they need to implement appearance changes in iOS 13 dark mode programmatically. This is how it's done:

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) 
{
    super.traitCollectionDidChange(previousTraitCollection)

    let userInterfaceStyle = traitCollection.userInterfaceStyle // Either .unspecified, .light, or .dark
    // Update your user interface based on the appearance
}

Overriding traitCollectionDidChange helps in detecting appearance changes.

Then we only have to open traitCollection.userInterfaceStyle.

You can also verify if the existing appearance is using a new method you just implemented:

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
    super.traitCollectionDidChange(previousTraitCollection)

    let hasUserInterfaceStyleChanged = previousTraitCollection.hasDifferentColorAppearance(comparedTo: traitCollection) // Bool
    // Update your user interface based on the appearance
}

Overriding the User Interface Style

Complete App

The system automatically opts-in any app linked against the iOS 13.0 or later SDK to both light and dark appearances.

If you need extra time to work on your app’s Dark Mode support or want to keep your app in a single style, you can opt-out by including the UIUserInterfaceStyle key (with a value of Light or Dark) in your app’s Info.plist file.

Setting this key causes the system to ignore the user’s preference and always apply the specific appearance to your app.

Note: Supporting iOS 13 Dark Mode is strongly encouraged. Use the UI UserInterfaceStyle key to opt-out only temporarily while you work on improvements to your app’s Dark Mode support.

Specific Screens

In iOS 13, you can now override the user interface style on specific views or view controllers. For example, you may want only a certain view controller to be in iOS 13 dark mode, while the rest of your app is in light mode.

To override the user interface style, just override this variable in the top view or view controller and it will propagate down to sub-views:

// Inside a UIViewController
override func viewDidLoad() 
{
    super.viewDidLoad()

    // Always adopt a dark interface style.    
    overrideUserInterfaceStyle = .dark
}

Closing Notes

Thanks for reading the article! Here we've explored how to set up an app for iOS 13 dark mode.

iOS 13 dark mode brings with it a unique stress-free way to use a smartphone. Perhaps we’ll see a future where dark mode replaces the default mode with the whiter backgrounds.

By following these coding guidelines and tips you can easily set up your app for dark mode on iOS 13.

If you need some expert help, feel free to get in touch with iOS developers for iOS 13 dark mode related queries.

Follow on Twitter for more updates: https://twitter.com/ValueCoders**

The Apple team has a strict vision concerning the quality of mobile applications. This is really great for the users, because the Apple team works hard to make the App Store a trustworthy ecosystem. The App Store has a high threshold and tough requirements, not only for the app’s performance but for the implementation of appropriate security measures. The user can be sure that iOS applications are reliable.

However, meeting all the requirements can become a real hell for developers. Just to compare, the development of the application can take only a few weeks, while the time spent passing the App Store review can be up to a month (or even months if the developer disregards Apple’s developer guidelines).

I'm working at Dashdevs as a Client Engager. My main duty is to create applications from scratch so they pass the review. I work with clients’ requirements. We have more than 9 years of expertise in the development of iOS applications. We’ve worked with various markets, industries, and different companies.

The complexity of the applications varies, too. We submitted 250+ apps for review during 2018. Not all of them passed the review the first time. But sometimes we felt real unbridled joy from a good review.

In this article, I want to share our experience so you can avoid common mistakes and easily pass the review stage.

How to apply to the App Store

A shiny brand-new iOS application has been developed, tested, and is ready to see the world. A binary file is already uploaded to the iTunes Connect panel. But what else is needed?

• You need to add basic information (description, tags, contacts) about your application, add screenshots, and credentials of a demo user account (if your application requires the authorization).
• You need to include detailed explanations of non-obvious features (like native gesture usage) and in-app purchases in the App Review notes.
• Then you need to press the button “Submit for Review” to inform Apple that your application is ready for the App Store.

You’ll be notified if something important in the description is missing. Then the application status review will be changed to “Waiting for review”. It can take a few days before the real check begins. When the verification team actually starts the review, the status of the application will be changed to “In Review”.

Hint: You will save some effort by installing the iTunes Connect application on your iPhone to receive immediate notifications about all the status changes.

App Store review is a mandatory step for all applications. The process of app verification sticks to the Apple Guidelines ensuring the best and the safest user experience.

They also review the primary information about the application. A part of the verification is done automatically using scripts, and people perform the other one. If your application has an issue, you will receive a notification with a precise description of what should be fixed. The timeframe for the first stage of review runs between 3 to 7 days. The inspection of the application updates is quicker — from 1 to 3 days.

Over the last few years, I’ve had some problems with applications submitted for review. Some of them were easy to fix, and some took many hours.

So, why didn’t your applications pass on the first try?

Here’s what you need to take into account.

Use Human Interface Guidelines (HIG) for the design

Your designers should follow the HIG from the very beginning. Sizes and positions of the buttons, the correct usage of the basic UI elements, and navigation must comply with Apple Guidelines. Fixing issues with HIG can cost you a lot if you find these issues at the end of the development.

Hint: Do not create an application that appears confusingly similar to an existing Apple product or any other application (no copycats). The Apple team is very strict about this.

Check the functionality list

Your application must include features, content, and a UI that elevate it beyond a repackaged website. The Apple team cares about the usefulness and benefits to the user.

There was a case when one of our applications was rejected because the Apple review team assumed that our app didn’t need to have the Sign up/Sign in functionality. So, we sent a notice of appeal with the evidence of the relevancy of this functionality.

Another case was a little bit different — the application was too simple for the AppStore (just a funny calendar). The application needed additional functionality. We improved it by adding a sharing feature, and it passed the review.

One more significant rule to refer to is that your application must not require the installation of other applications.

Provide a demo account with full functionality to the Apple team

The App Store reviewing team will definitely try to register your app, but they will need to verify the rest of the features as well. For example, to review the functionalities of a bank application, they need to have an account with an activated card and some transactions on it. You need to be sure that the account accesses full functionality and all the back-end features are turned on.

Hint: do not provide this account to your QA team for usual testing, especially during the review period. Once, we sent an application for review, and at the same time our Quality Assurance engineer was testing the blocking functionality and occasionally banned a new user.

No “test”, “coming soon”, “beta”, “trial”, “Testflight” in the app.

All your future, unfinished, demo functionality must not be used in the app. Do not use these words for your application content at all, even for in-app screenshots and descriptions. If you need to test your application, you can join Testflight services.

We once made a ridiculous mistake with another one of our applications. As you might know, to prepare a submission to review, developers sometimes take screenshots of the application right from the TestFlight. These pictures are posted as the screenshots of the real app for the App Store. If you do so, check twice, as there can be the “Testflight” label in the status bar. When this happens, your application is rejected. This itty-bitty thing may block the submission of your application.

Performance

No crashes, no slow performance, no memory leaks are allowed for App Store applications. Incomplete app bundles and binaries that crash or perform with obvious technical problems in applications are rejected at once.

Describe only the existing functionality

No advertisement for future features should be in the description of the app.

Terms and Conditions / Privacy Policies.

These documents or the links to them must be added to the app. You need to explain to the user how their sensitive data is processed and what data is shared by the app with third parties and for what purposes (e.g., analytics tools, advertising networks, and third-party SDKs, etc.). A user needs to know the deletion and retention policies of your application.

Intellectual Property

You need to have permissions to use all materials in the app (copyright issue). Do not use third-party trademarks, copyrighted works, or patented ideas in your app if you have not obtained the necessary license. Remember about the restrictions against using sexual or pornographic content, marijuana, tobacco, controlled substances, misleading quotations of religious texts, and violence in mobile applications.

Licenses

If some regulations within your business area demand a license for providing your services, such as FinTech, Medicine, Healthcare, etc., you need to attach a copy of those documents to the application review. If an app requires specific hardware, you need to provide a corresponding certificate or license for this hardware.

Another case from our experience: an application used a special sticker printer. At first, the application was rejected, and we needed to get a certificate to use those printers. It took us a month to get the official approval from the producer of the hardware.

Another example was a digital bank application. We needed to provide the App Store review team with the E-money License. This also applies to the cryptocurrency-industry.

“Apps facilitating Initial Coin Offerings (“ICOs”), cryptocurrency futures trading, and other crypto-securities or quasi-securities trading must come from established banks, securities firms, futures commission merchants (“FCM”), or other approved financial institutions and must comply with all applicable law”.

Ask user for permissions

Your application must ask permissions for using a camera, microphone, location, access to contacts, Camera Roll, and user locations. The permissions must be relevant to the application’s functionality. The App Store team cares that the information collected in the application is stored in the right way and prevents its unauthorized use, disclosure, or access by third parties.

Hint: don’t forget to add a description of these permissions to the .plist file. This is another common reason for rejections.

No mock-up data in the app

If your application has no content for some forms you need, hide this element or add a placeholder for it with an explanation how the user can get the necessary data.

Sometimes developers hardcode to show the maximum user functionality. For example, your application has a section with charts displaying the user’s activity statistics in the app. In this case, there must be a placeholder with a prompt text that the chart will be available when the user starts to use the app on an everyday basis.

With advertisements, things are the same — you can not submit the app with empty ad banners or test adverts.

Ability to moderate user’s content

“Block a user/content”, “report a user/content”, “blacklist for users” are required functionalities for the app if it provides multi-user communication (e.g. feeds, chats, groups). As a product owner, you need to be conscious that different people will use your application and some of them may disturb others. You need to provide your users with the ability to manage the content and the community they’re interacting with.

Options for release

With every submission for review, my team gains new experience. My main advice is to submit your application to the App Store review as soon as you have developed the MVP of your application. Keep in mind that even if you pass the review, it does not mean that the app will be released.

There are three different actions you can take after a successful review:

• Manually release this version: as a developer or an application manager, you need to go to the iTunes Connect panel and press the button to release the app.
• Automatically release this version: that means that the application will be published as soon as it passes the review.
• Automatically release this version after App Review, no earlier than…: you can select the time/date for the release. If your application passes the review, it will be published at that time.

These options can help developers and product owners/managers to pass the review and wait for the marketing campaign to start. You need to know that the first app review is the most critical, and so the App Store team verifies the application for a much longer period and more thoroughly. Every further update is reviewed as well, but it takes less time for the verification. Sometimes can take just a few hours.

The App Store may reject your application. That’s OK. Do not panic. If you understand the reason, you just fix the issue and resubmit the application for review again. If you have questions or would like to provide additional information, you can use the Resolution Center to communicate with the App Review team. They are supportive and ready to help you with your application. We have fixed a lot of issues with their help.

I hope my examples mentioned in this article will be helpful for you and all your IOS applications will pass App Store verification on the very first attempt.

P.S. Useful links:

• App Programming Guide
• App Extension Programming Guide
• iOS Data Storage Guidelines
• Human Interface Guidelines
• Marketing Resources and Identity Guidelines
• Guidelines for Using Apple Trademarks and Copyrights

Recently Kirby Version 3.0 was released. As I have worked with Version 2 for quite some time in the past, I figured why not give it a try?

Just before Christmas, I bought a brand new MacBook Air, so it was obvious that I would like to try Kirby right away on it. I stumbled upon a great article on how to set up CaddyServer and PHP on MacOS. But I changed some of it.

CaddyServer, PHP and Kirby

Let’s get started with a brief overview of what software I’m talking about.

PHP

I don’t think I have much to say about PHP. It’s probably one of the oldest Scripting Languages out there in the WebWorld. PHP was “the” language for making your website “dynamic”. And it was also the first language I discovered and learned to play around with.

CaddyServer

Is a small but very powerful Web-Server which I discovered a few months ago. It has some really nice features like automatic SSL / HTTPs and a really easy configuration file (which you will see later). And it’s blazing fast. :)

Kirby

Another great tool I discovered a few years ago. Basically, it’s a CMS (Content Management System) based on a simple FileStructure. Even if you don’t know much about PHP, it’s relatively simple to get into creating templates for pages and extending the whole functionality.

Why?

Now that you know about all three projects, you might be asking why you should use them together. Well, there are multiple reasons for it:

• MacOS comes with a default apache2 installation, but as you might know, Apache is one of the biggest HTTP servers out there. It’s widely adopted, but it has one downside. It eats memory and CPU like no other web-server out there. So if you’re on the go, it also eats battery like crazy and I don’t like that.
• Caddy is very lightweight and doesn’t really use much Memory / CPU / Battery.
• Kirby, as I’ve said is easy to customize and extend. As it’s a CMS, you don’t need to worry about a database or application-specific logic from the beginning. That way you can prototype pretty fast, which leads to faster results and more satisfaction as you get things done. :)

Without further ado, let’s get into setting it up:

First of all

It’s essential to have homebrew installed, as package management get’s a whole lot easier with it.

You can install it with a simple command:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

PHP

Now that we have a package manager, it’s time to install the correct PHP-version. Kirby needs at least PHP7.1 so I installed 7.2 :)

brew install php@7.2

There are also some extensions which are needed:

brew install freetype jpeg libpng gd

CaddyServer

Now that we have PHP and some dependencies installed we can now install CaddyServer.

Simply download the suitable Version from https://caddyserver.com/download.

You will receive a zip file. Extract it and copy the executable to a path inside your $PATH (in my case /Users/phaidenbauer/bin/):

unzip caddy_v0.11.2_darwin_amd64_personal.zipcp caddy /Users/phaidenbauer/bin/caddy

Kirby

Next one is Kirby. Again download the zip from https://getkirby.com/try.
Extract it somewhere you have your projects. In my case that’s /Users/phaidenbauer/development/.

The next essential thing to get this whole thing running is the Caddyfile which tells Caddy what to do :)

localhost:8080tls offroot ./gzip

rewrite {    r .*    to {path} {path}/ /index.php?{path}&{query}}

fastcgi / 127.0.0.1:9000 phpon startup launchctl load -w /Users/phaidenbauer/Library/LaunchAgents/homebrew.mxcl.php@7.2.pliston shutdown launchctl unload -w /Users/phaidenbauer/Library/LaunchAgents/homebrew.mxcl.php@7.2.plist

Let’s go through it:

localhost:8080 tells it on which Port it should listen. If you don't want to run it as root (or via set_cap) you should use something above 1024.

tls off disables the built-in SSL / HTTPS feature, as we are only working locally.

root ./ sets the root-path of the serving directory.

gzip enables the gzip-compression for responses.

rewrite { r .* to {path} {path}/ /index.php?{path}&{query} } rewrites all incoming URLs to suite Kirby’s needs. (It’s probably not the best solution but it works fine for my development environment.)

fastcgi / 127.0.0.1:9000 php tells caddy to forward requests to a FastCGI-server. Which is, in our, case PHP.

Now we have two special functions.

on startup launchctl load -w /Users/phaidenbauer/Library/LaunchAgents/homebrew.mxcl.php@7.2.pliston shutdown launchctl unload -w /Users/phaidenbauer/Library/LaunchAgents/homebrew.mxcl.php@7.2.plist

As I mentioned earlier it is just a MacBook Air, so I don’t want to have PHP running all the time. Especially when I don’t need it. The great thing is caddy can run commands on events. In this case, we use the startup and shutdown event to start and stop PHP. Great! No more waste of RAM and CPU while checking emails.

Start the whole thing :)

Now we are pretty much set. The last thing to do is start them all together and start working:

cd /Users/phaidenbauer/development/fly.phaidenbauer.comcaddy

You should see something like this:

Activating privacy features... done.http://localhost:8080WARNING: File descriptor limit 4864 is too low for production servers. At least 8192 is recommended. Fix with `ulimit -n 8192`.

And that's it. Take your favorite browser and surf to http://localhost:8080. Depending on if you downloaded the Kirby-Plainkit or Kirby-Starter kit you should see a simple “Hello” or a simple gallery.

And that’s it. Happy hacking :)

A short history of Swift

I remember how pivotal it was when Swift was introduced at Apple’s 2014 WWDC (Worldwide Developers Conference). It was the talk of the town and all the devs I worked with couldn’t wait to try it out. The iOS community was buzzing and there was a lot of excitement around the new language.

It was developed in order to carry on some concepts we saw in Objective-C such as extensible programming. But it pushed towards a different approach to coding with the protocol-oriented design and increased safety with static typing.

It was a huge hit and saw its growth sky rocket in the years after introduction. It was the most loved programming language in 2015, the second most loved in 2016, the 11th most popular programming language in 2017, beating out Objective-C, and it also beat out Objective-C in 2018.

Swift is also a bet by Apple on winning over novices to become iOS developers. The hope is that new developers will learn the language and use it to build iOS apps. This then increases the ecosystem of the app store. Since Swift is optimized to work with iOS apps, this ensures the apps being written are of high quality.

Swifts popularity only continues to increase, especially for smaller apps and start-ups. The gap between Swift and Objective-C will only continue to grow. The future is bright for this young language.

A short history of Objective-C

Objective-C is an object-oriented programming language that is a superset of C, as the name of the language might reveal. This means that any valid C program will compile with an Objective-C compiler. It derives all its non-object oriented syntax from C and its object oriented syntax from SmallTalk. It was developed in 1984, so it has had time to mature as a language and is much more stable than Swift.

Most people know Objective-C as the language that is used to develop apps for the iPhone, but the history goes much deeper than that. I’d recommend reading this article for a more in-depth look.

The strengths of Swift

Swift has grown tremendously in popularity for a few key reasons. First off, there are a lot of great development tools Apple has provided to work in conjunction with Swift. One of my personal favorites is the Playground, which is only compatible with Swift. Apple introduced Playgrounds in 2016. They were introduced as a way to learn how to code, but I loved them for a different reason.

Mobile development has always had more roadblocks than web development. You need a simulator, you usually need a proprietary Integrated Development Environment (IDE), and you need to set up a whole project just to test some small prototype. In Apple’s case, you also need a developer account. The nice thing about Playgrounds is you get around some of this. You do need Xcode or the Playgrounds app, but that is all. And you can get started with coding and compiling your code right away.

Yet, another huge advantage of Swift is the fact that it is open source. If you have ever wondered how a programming language worked under the hood, then you can go see for yourself! This is a great way to understand the programming language you work with daily on a deeper level.

An honorable mention goes to a nice utility only available to Swift, the Swift Package Manager. The Swift Package Manager is simply a dependency manager that is integrated with the Swift build system. It isn’t a game changer by any means, since CocoaPods and Carthage were doing this job a long time ago, but it’s another solution available if needed.

A lot of evidence here supports the fact that Apple is doing a lot to make Swift more desirable as the programming language of choice for iOS developers. They are creating nice utilities and auxiliaries to entice people to start using the language. This shows that Apple is pushing for Swift in full force.

Language features

Let’s get into some of the details of the language itself. Swift is safer due to its static typing and the use of optionals. In Swift, if your code requires a string, the features of Swift will guarantee that your code gets a string and not another type, such as an int. This of course depends on if you’re using the language as it is intended and not force unwrapping everything.

Another great feature of Swift is its syntax. Especially compared to Objective-C. The best word to describe the syntax would be “succinct”. There is no need for semi-colons, calls to self or parentheses around if statements. It feels like you are skipping a lot of things that you don’t really need anyway. It can make the process of typing a lot of code “flow” better.

Some people say this leads to development velocity improvements, but I wouldn’t exactly say that myself. The continual need to unwrap objects to comply with Swifts type-safety offsets the development gains that come with the succinctness.

Swift also has a lot of great control flow options with guard, if-let, advanced switch statements, repeat-while and defer. I like all the different options because it lets people control the flow of their code in a way that makes sense to them. A lot of people hate defers but love guards and vice versa. It doesn’t really matter what you like or dislike, but the options are there and you can code in the way that feels best to you.

I can’t forget all the functional programming features such as filter, map and reduce. This is great for handling collections and comes in handy quite often.

The weaknesses

Swift is a young language, and with that, comes some shifting. The migrations between versions are simply a pain. At a small company, the migration tool provided by Apple can be helpful and cover most cases. It becomes less helpful the more code you have. It’s even worse if your codebase contains both Objective-C and Swift code that interoperate.

At my last company, the migration effort took a dedicated group a whole weekend to do. They had to do it on the weekend so that they wouldn’t run into merge conflicts from other devs pushing code. This was incredibly painful for everyone involved.

A reason for these migrations is the fact that Swift isn’t ABI stable. That means newer versions of Swift cannot work with older versions of Swift. That also means that the language cannot be packaged with the OS. This is a big deal for companies with large apps that actively combat app size because Swift is being bundled with the app and increasing the size.

Another issue is that Swift does not play well with Xcode. Xcode feels very choppy when working with Swift and autocomplete simply doesn’t work sometimes. This is strange given how hard Apple is pushing Swift. You would think that they would want make the experience of using Swift with Xcode a delight.

Swift also has problems with string handling, see the code example above. It is clunky as hell. In your day to day, this isn’t too bad. Where this comes into play the most is during interviews. Unfortunately for Swift devs, interviewers love asking questions that involve string manipulation. This is compounded by the fact that the way strings are handled has changed between versions of Swift.

The strengths of Objective-C

Objective-C is a highly dynamic, object oriented language. It is dynamic to the point that you can swap out method invocations at runtime using techniques like Swizzling. It is able to do these kinds of thing due to its message sending paradigm. This lets objects send messages to other objects at run time to determine the invocation of the method being called.

In practical purposes, what does this mean? Well, one big advantage is adaptability at runtime. This means accessing private APIs or doing things like mocking objects at runtime become possible. This can be especially useful when it comes to unit testing. Libraries like OCMock make this even easier and allow for very elaborate test set ups. Having good unit tests will make your app more stable and reliable.

Speaking of stability, Objective-C has been around for a long time which makes it a very stable language. With Swift, you’ll run into bugs that are pretty surprising and would be disruptive to the stability of your app. In the example I linked above, this crash would be caused by the actual language you are using to code your app, not due to any error created by the code you wrote. This can be frustrating.

The last point, which is more important to certain companies, is compatibility with C and C++ libraries. Being that Objective-C is a superset of C, it is easy to use C and C++ code with Objective-C. You can even use Objective-C++ if you feel so inclined. This is important if your are dependent on third party C and C++ libraries.

The weaknesses

The first main complaint I hear about Objective-C is syntax. I started my professional career using Objective-C so I have no issues with it. It is verbose and a bit unconventional with the use of square brackets. But opinions on syntax are just that, opinions. I figured I would list this point though since it is one of the first things that comes up when you mention Objective-C.

One thing I do agree with though is that block syntax is frustrating. There is even a website dedicated to decoding the mysteries of blocks in Objective-C. I actually use this website pretty often as a reference.

The biggest issue Objective-C faces right now is the fact that one day Apple may drop support for Objective-C with Cocoa and other common libraries used to create iOS apps. Since Objective-C is primarily used to create iOS apps, this would be a death knell for the language. It also means that newcomers to the iOS community are afraid to commit to learning Objective-C right now since it may no longer be used in the future.

Let’s get back to the language itself. It is prone to having hard to debug issues due to the dynamic nature of the language. The ability to send messages to nil and not crash on top of the lack of strict typing are some examples of things that lead to these hard to debug issues.

Objective-C does not hold your hand when it comes to these things either. Though it is nice that the app doesn’t crash when you send a message to nil, it may put your app in a weird state. It is very hard to debug issues like these. The fact that Swift has strict typing and the use of unwrapping optionals prevents these things at compile time.

Should I learn Swift or Objective-C?

The answer for most people will be Swift. Apple is clearly pushing Swift as the language of choice for its iOS application development community. Swift will only continue to become more performant as ABI stability is introduced and Swift becomes packaged with the OS itself.

If you’re looking to get a job as an iOS developer, Swift will be the language you want to learn. Most startup to mid-level companies will have their iOS apps written completely in Swift. This means you’ll be able to apply and interview for more jobs if you learn Swift.

Even at larger companies where Objective-C is still used heavily, interviews can still be done in Swift. So you can learn Objective-C once you join the company and not worry about burdening yourself with more things to learn before the interview.

You will want to learn Objective-C if you are already working at a start up or mid-level company and want to jump to a larger company. Skills with Objective-C will give you specialized knowledge and an edge over other interview candidates.

Liked what you read? Take a look at some of my other articles:

Tips for your first tech interview.

Starting a tech career from nothing.

Should you get a computer science degree?

When Apple announced this September that its newest Series 4 Apple Watch includes EKG functionality, I imagined millions of hearts worldwide fluttering with delight.

The news was significant for several reasons. The chief reason is it is the first time a mainstream consumer wearable device will perform a sophisticated medical procedure. This same procedure we need to see the doctor for today.

To understand the significance, you need first to set aside the fact that health and fitness are already key reasons why consumers currently use wearables. Fitness trackers have had heart rate sensors for many years now.

(Heart rate sensors are convenient for fitness purposes, to be sure. But, they’re also primitive. Anyone with a finger can feel for a pulse and calculate a heart rate if necessary.)

An EKG (or ECG/electrocardiogram) is different than a heart rate measurement. For one, because an EKG looks at the heart’s electrical impulses to monitor for and identify specific heart anomalies. These anomalies are the immediate precursor to serious medical conditions. Conditions like strokes or heart attacks.

The technology can and will save lives.

By adding new and substantial medical features, Apple (and others) could be paving the way to a future in which wearables serve as the frontline for the diagnosis, treatment, and even prevention of serious medical conditions.

Hold your finger on the crown of the Series 4 Apple Watch, and you’ll get an EKG reading on the spot.

The Apple Watch is a class II medical device.

Adding an EKG to the Apple Watch wasn’t just an engineering task.

It also required the attention and cooperation of the notoriously finicky Food and Drug Administration (FDA). The FD has cleared Apple’s use of two medical-grade features in the new Apple Watch: 1) the EKG, and 2) the Apple Watch’s ability to identify and notify users of an irregular heart rhythm.

It’s important to note that, with the FDA, “clearing” a device is not the same as “approving” one. The latter is much harder to do and requires much significant collaboration and testing to mitigate potential risks. Clearing the Apple watch took just one month from application to decision. Class II devices like the new Apple Watch don’t require FDA approval because the associated health risks aren’t deemed great enough to warrant a more rigorous vetting process.

It’s also important to understand that the FDA clearance letters came with language stating that the cleared features are not intended for users under the age of 22, and are “not intended to replace traditional methods of diagnosis or treatment.”

Regarding the latter, what this means is that after your Apple Watch tells you it has detected a mild heart arrhythmia, you’ll probably want to follow up with your doctor to get a proper diagnosis.

On the other hand, if your Apple Watch tells you you’ve just had a heart attack, immediate urgency (and common sense) dictates that you’re going to go straight to the ER or call an ambulance, skipping the “traditional method of diagnosis” referenced in the FDA’s letter.

A beachhead for new medical functionality

With the regulatory precedent established, Apple product managers are undoubtedly considering more medical functionality, to double down on this growing notion of the Apple Watch as a medical device.

If so, what might we see from Apple down the road?

Well, as it turns out, Apple has for years been working on developing a blood glucose tracker that ties to the Apple Watch. Such a tracker could help with diagnosis, treatment, and perhaps even prevention of type 2 diabetes.

Diabetes currently affects an estimated 30 million people in the United States alone. The challenge has been creating noninvasive technology that doesn’t require permeating the skin you to get a reading, as current glucose trackers must do. According to a CNBC report last year, Apple has assembled a new team to pursue this “holy grail” breakthrough.

Here’s Apple CEO Tim Cook on the opportunity with glucose trackers:

“It’s mentally anguishing to stick yourself many times a day to check your blood sugar. There is lots of hope out there that if someone has constant knowledge of what they’re eating, they can instantly know what causes the response… and that they can adjust well before they become diabetic.”

Apple CEO Tim Cook appears to be gung-ho about enabling the Apple Watch as a medical device, with CNBC reporting last year that he was personally testing a blood glucose tracker for the Apple Watch.

Impact on healthcare practices and insurance costs

Cook’s predecessor, the legendary visionary Steve Jobs, reportedly first envisioned the popularization of consumer wearables that could provide blood glucose readings and other health vitals.

If Jobs’ vision of a versatile wearable health tracker comes to fruition, what effect might this have on the time-tested practice of the “annual physical?” For one, we might very well see formal doctor checkups give way to daily or even hourly automated testing through wearables like the Apple Watch.

And if this happens, what implication might widespread use of the device have beyond users’ health, for instance, on healthcare costs and the healthcare system itself? North American healthcare provider United Healthcare is an example of one insurance provider that is already offering financial incentives to customers that use wearable fitness trackers to meet daily fitness goals.

When customers get ahold of devices that also address the medical component of wellness and longevity, I’d certainly expect to see such financial incentives increase and healthcare premiums decrease.

Wearable medical technology is not a one-horse race

FitBit, the other big player in health and fitness wearables, has had a blood oxygen sensor built into its Ionic watch for more than a year. The sensor can be used to detect common breathing related disorders such as asthma, sleep apnea, and even heart arrhythmia conditions such as atrial fibrillation.

There’s a problem, though. At the time of this story’s publication, Fitbit has not yet publicly released software that makes use of the hardware sensor.

Samsung is another company that has demonstrated a commitment to adapting its wearable technologies to support medical use cases.

For instance, Samsung’s Gear VR headset is used by California-based IrisVision to allow legally blind users to see clearly in all aspects of life. Using custom IrisVision software, the IrisVision headset uses proprietary visual acuity algorithms to amplify any remaining useful vision a user still has. The result is clear vision and, for many users, the restoration of independence in their daily lives. IrisVision has the financial support of the National Institute of Health (NIH) and was developed by leading vision experts from Johns Hopkins University, UC Berkeley, Stanford, and UCLA.

Medical wearables will empower clinical researchers

Beyond consumer healthcare, clinical researchers stand to benefit from these recent developments in wearables, too. When doing any sort of clinical research, getting reliable data can be an enormous challenge, especially when a study depends on self-reported data or recollections.

Even for clinical studies that do use lab results, gathering data collection can be a challenge — costly, impractical, or even impossible.

In clinical testing and research, data collection can be a considerable challenge without sophisticated wearables.

But, if these measurements can be taken automatically by a wearable device, that largely addresses the issue, providing rich, reliable, and (perhaps) actionable data to researchers whose work depends on the availability of data they can trust.

Case in point, Johns Hopkins University has for the past three years been conducting a clinical study that allows participants to use their Apple Watches and the university’s EpiWatch app to provide clinical data (heart rate and accelerometer data) to further their understanding of epilepsy.

And, just last September, the NIH granted $2.5M to BioSensics to develop wearable sensors to monitor the symptoms of Huntington’s disease. A pilot study in collaboration with The University of Rochester is now underway.

Wearables provide the sensors and hardware, but user experience is paramount.

The hardware engineering associated with integrating medical sensors into small wearables is just one aspect of the challenge.

Another aspect of the challenge is inventing non-invasive or otherwise “user-friendly” sensors that can provide readings equivalent to what we, for example, currently need to draw blood to obtain. Frankly speaking, consumers will not buy a device that causes them pain or even startles them on a regular basis.

The regulatory hurdles (à la FDA) are another aspect of challenge, albeit one that seems promising based on the recent Apple clearances.

The final challenge is the software and user experience, which bring meaning to the data collected by the sensors. Sure, you can have an EKG provide readings — a line graph of electrical impulses — but how do you deliver that to your end user in a way that is not just useful, but is also intuitive and even enjoyable?

According to CitrusBits CEO, Harry Lee, apps are often the biggest competitive differentiator for wearables companies.

“In the wearables space, the hardware aspect is already somewhat commoditized. Everyone, more or less, has access to the same sensors, microprocessors, and chips. Where companies like Apple, Fitbit, and CitrusBits stand apart is in their ability to design intuitive and robust apps for smartwatches and other devices, given inherent screen-size and control constraints. This is absolutely key to adoption, and we’ve already seen once-promising wearables companies such as Pebble forced to shut down in recent years, in part due to weak app offerings.”

Looking ahead, the realization of Steve Jobs’ vision is clearly upon us: a future in which medical wearables will play a big role, perhaps even reducing the strain on existing healthcare systems.

It just may very well depend on a harmonious blend of computing hardware, non-invasive medical sensors, progressive regulatory oversight, and thoughtfully-crafted applications.