launching a new social network has always been difficult, because one needs to convince not just interested individuals, but also the communities that they are a part of.

the Fediverse, or more accurately the protocol that powers it, ActivityPub, has the potential to solve this problem by decoupling social network and social graph.
many networks (or more accurately servers), one shared graph.

there are roughly 2 million monthly active Mastodon users at the time of writing.
most of them are enthusiasts, who care deeply about the Fediverse' promise.

...but users of centralized social networks generally don't, otherwise they'd have switched already.
converting them by touting the benefits of decentralization, interoperability, or privacy won't work.
this isn't a dig against them, they just chose different battles.

Threads isn't pitching itself as a decentralized social network though. its "an app built by the Instagram team for sharing with text" (press statement).
the brand recognition of Instagram, combined with the ongoing instability at Twitter / X, makes it the easy choice for people to flock to.

...and boy are they flocking. Meta was claiming over 70 million sign-ups two days after launch. even if they are significantly exaggerating, it wouldn't be a surprise if their monthly active user count was to permanently surpass all Mastodon instances.
only this time, its not a zero-sum game.

once Threads starts federating, those users will become part of the shared social graph, growing it rapidly.

i believe a larger social graph to be desirable.
it will bring perceived legitimacy, that will attract users who would have otherwise ignored the Fediverse.
governments, institutions, public servants, journalists, academics, and others will join, ...but this time they aren't joining a US-owned, venture capital-funded, privacy-hostile, centrally-moderated social network, they'll be hosting their own servers.

• social.network.europa.eu
• social.bund.de
• social.overheid.nl

with ActivityPub being an open protocol and Mastodon being open source, becoming part of the Fediverse has become downright inexpensive.
and not only that, building a new social network is suddenly not prohibitively expensive anymore.

will this loosen the US' grip on social, and finally enable European companies to enter the market?
hopefully.

admittedly, there's a risk of this being the first chapter in the "embrace, extend, extinguish" playbook.
Threads will likely be the largest server in the network, a position that they could abuse to push for undesirable ActivityPub changes, while threatening to defederate if things don't go their way.
the only way to reduce that risk is by making defederation as painful as possible.

thankfully, Tumblr is talking about joining the network, Automattic offers an ActivityPub plugin for WordPress, and Lemmy might become a thing.

lastly, defederation is a two-way street. communities that do not wish to be associated with Meta, can selectively defederate from them, while still being part of the network.

i'm excited :)

Problem

Some built-in view modifiers like .shadow do not introduce any additional padding that would increase the intrinsic size of the view.
This can cause problems when views are placed within UIKit hierarchies that enable .clipsToBounds.
This is the case with ScrollView, which internally uses a UIScrollView.

Solution

>= iOS 17

Use scrollClipDisabled(_:)

< iOS 17

Extending UIScrollView works, because .clipsToBounds is not read-only.

import UIKit

extension UIScrollView {
  open override var clipsToBounds: Bool {
    get { false }
    set { }
  }
}

One should be aware that this is applied globally.

Problem

In the old days (cough SwiftUI 1) this could be accomplished by subclassing UIHostingController to override preferredStatusBarStyle, which is read-only by default, and using the newly created class as the rootViewController of the key window.

class HostingController<Content: View>: UIHostingController<Content> {
    override var preferredStatusBarStyle: UIStatusBarStyle {
        return .lightContent
    }
}

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?

    func scene(
      _ scene: UIScene, 
      willConnectTo session: UISceneSession, 
      options connectionOptions: UIScene.ConnectionOptions
    ) {
        guard let windowScene = scene as? UIWindowScene else { return }

        let rootView = RootView()

        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = HostingController(rootView: rootView)
        self.window = window
        window.makeKeyAndVisible()
    }
}

Said solution worked, because the now discouraged UIWindowSceneDelegate life cycle exposed the app's SceneDelegate.

This is not the case anymore.

There are still ways to swap out the UIHostingController during runtime, but these tend to break features that depend on the new app life cycle being used (e.g. onOpenURL).

Solution

>= iOS 16

Use toolbarColorScheme(_:for:)

< iOS 16

Since swapping in a custom UIHostingController isn't an option, a minimally invasive approach involves swizzling preferredStatusBarStyle to point to a computed variable which itself points to a writeable variable.

Method swizzling is a technique of last resort; you should only use it if you have no other options.

—  eskimo

extension UIViewController {
    fileprivate enum Holder {
        static var statusBarStyleStack: [UIStatusBarStyle] = .init()
    }

    fileprivate func interpose() -> Bool {
        let sel1: Selector = #selector(
            getter: preferredStatusBarStyle
        )
        let sel2: Selector = #selector(
            getter: preferredStatusBarStyleModified
        )

        let original = class_getInstanceMethod(Self.self, sel1)
        let new = class_getInstanceMethod(Self.self, sel2)

        if let original = original, let new = new {
            method_exchangeImplementations(original, new)

            return true
        }

        return false
    }

    @objc dynamic var preferredStatusBarStyleModified: UIStatusBarStyle {
        Holder.statusBarStyleStack.last ?? .default
    }
}

Some additional scaffolding is required to implement a .statusBarStyle view modifier.

import SwiftUI

enum Interposed {
    case pending
    case successful
    case failed
}

struct InterposedKey: EnvironmentKey {
    static let defaultValue: Interposed = .pending
}

extension EnvironmentValues {
    fileprivate(set) var interposed: Interposed {
        get { self[InterposedKey.self] }
        set { self[InterposedKey.self] = newValue }
    }
}

/// `UIApplication.keyWindow` is deprecated
extension UIApplication {
    var keyWindow: UIWindow? {
        connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .flatMap(\.windows)
            .first {
                $0.isKeyWindow
            }
    }
}

extension UIViewController {
    fileprivate enum Holder {
        static var statusBarStyleStack: [UIStatusBarStyle] = .init()
    }

    fileprivate func interpose() -> Bool {
        let sel1: Selector = #selector(
            getter: preferredStatusBarStyle
        )
        let sel2: Selector = #selector(
            getter: preferredStatusBarStyleModified
        )

        let original = class_getInstanceMethod(Self.self, sel1)
        let new = class_getInstanceMethod(Self.self, sel2)

        if let original = original, let new = new {
            method_exchangeImplementations(original, new)

            return true
        }

        return false
    }

    @objc dynamic var preferredStatusBarStyleModified: UIStatusBarStyle {
        Holder.statusBarStyleStack.last ?? .default
    }
}

struct StatusBarStyle: ViewModifier {
    @Environment(\.interposed) private var interposed

    let statusBarStyle: UIStatusBarStyle
    let animationDuration: TimeInterval

    private func setStatusBarStyle(_ statusBarStyle: UIStatusBarStyle) {
        UIViewController.Holder.statusBarStyleStack.append(statusBarStyle)

        UIView.animate(withDuration: animationDuration) {
            UIApplication.shared.keyWindow?.rootViewController?.setNeedsStatusBarAppearanceUpdate()
        }
    }

    func body(content: Content) -> some View {
        content
            .onAppear {
                setStatusBarStyle(statusBarStyle)
            }
            .onChange(of: statusBarStyle) {
                setStatusBarStyle($0)
                UIViewController.Holder.statusBarStyleStack.removeFirst(1)
            }
            .onDisappear {
                UIViewController.Holder.statusBarStyleStack.removeFirst(1)

                UIView.animate(withDuration: animationDuration) {
                    UIApplication.shared.keyWindow?.rootViewController?.setNeedsStatusBarAppearanceUpdate()
                }
            }
            // Interposing might still be pending on initial render
            .onChange(of: interposed) { _ in
                UIView.animate(withDuration: animationDuration) {
                    UIApplication.shared.keyWindow?.rootViewController?.setNeedsStatusBarAppearanceUpdate()
                }
            }
    }
}

extension View {
    func statusBarStyle(
        _ statusBarStyle: UIStatusBarStyle,
        animationDuration: TimeInterval = 0.3
    ) -> some View {
        modifier(StatusBarStyle(statusBarStyle: statusBarStyle, animationDuration: animationDuration))
    }
}


@main
struct YourApp: App {
    @Environment(\.scenePhase) private var scenePhase

    /// Ensures that interposing only occurs once
    private var interposeLock = NSLock()

    @State private var interposed: Interposed = .pending

    var body: some Scene {
        WindowGroup {
            VStack {
                Text("Hello, world!")
                    .padding()
            }
            .statusBarStyle(.lightContent)
            .environment(\.interposed, interposed)
        }
        .onChange(of: scenePhase) { phase in
            /// `keyWindow` isn't set before first `scenePhase` transition
            if case .active = phase {
                interposeLock.lock()
                if case .pending = interposed,
                   case true = UIApplication.shared.keyWindow?.rootViewController?.interpose() {
                    interposed = .successful
                } else {
                    interposed = .failed
                }
                interposeLock.unlock()
            }
        }
    }
}

The .\interposed environment value can used to detect swizzling failure. A potential fallback could involve filling the safe area beneath the status bar with an adaptive color.

struct Fallback: View {
  var body: some View {
    GeometryReader { reader in
      Color(uiColor: .systemBackground)
        .opacity(0.4)
        .frame(height: reader.safeAreaInsets.top)
        .edgesIgnoringSafeArea(.top)
    }
  }
}

I've recently been playing around with SwiftUI and HealthKit.
Naturally, the first thing I wanted to try out was to display a list of all workouts and their respective types.

Can't be that difficult, right?

🧪 Discovery

SF Symbols contains some health-related icons, but none that depict workout types (except walking).
The HealthKit documentation also doesn't mention anything in regards to workout icons or even localized names.

After a bit of searching I stumbled across references to FitnessUI.framework, which I assumed to be responsible for presentational aspects of Apple's own HealthKit apps.

This was coincidentally also the first time I found out about private frameworks, which one can theoretically use, but only if violating App Store guidelines isn't a concern.
FitnessUI is one such framework, but because there's at least one app that not only uses the official icons, but also displays them on its store page, I figured that icons might be an accepted gray-area.

FitnessUI.framework is not included in macOS builds, therefor I took apart an iOS .ipsw to extract it from the contained root filesystem.
I discovered an Assets.car file contained within the framework, which I managed to extract with @_inside's Asset Catalog Tinkerer.

After extracting all icons it became apparent that there were a few outliers in Apple's naming scheme.

[
    "_112_Normal@3x.png",
    "_112px-1_Normal@3x.png",
    "_112px_Normal@3x.png",
]

Some workout types also had different names than their HKWorkoutActivityType counterparts.

{
    "australianFootball": "australian_rules_football",
    "cardioDance": "dance",
    "cycling": "outdoorcycle",
    "danceInspiredTraining": "dance_insp_training",
    "discSports": "disk_sports",
    "fitnessGaming": "gaming_sports",
    "functionalStrengthTraining": "func_strength_training",
    "highIntensityIntervalTraining": "hiit",
    "mixedCardio": "mixed_meta_cardio_training",
    "mixedMetabolicCardioTraining": "mixed_meta_cardio_training",
    "preparationAndRecovery": "prep_and_recovery",
    "running": "outdoorrun",
    "socialDance": "social-dance",
    "stairClimbing": "stairs",
    "surfingSports": "surfing",
    "swimming": "swimopen",
    "traditionalStrengthTraining": "trad_weight_training",
    "walking": "outdoorwalk",
    "wheelchairRunPace": "wheelchairrun",
    "wheelchairWalkPace": "wheelchairwalk",
}

There are quite a few workout types, and new once are introduced frequently, which is why I ended up automating the process of generating an HKWorkoutActivityType extension that correlates workout types and their respective icons.

⚙️ Process

1. Download a recent iOS update .ipsw
2. Change its file extension to .zip and consequently extract it
   

   

3. Open the largest contained .dmg
   

   

4. Navigate to System/Library/PrivateFrameworks/FitnessUI.framework
   

   

5. Extract Assets.car
6. Open extracted asset catalog with Asset Catalog Tinkerer
7. Profit!

🪜 Usage

That covers the extraction aspect, but one should ideally be able to correlate the icons with their respective HKWorkoutActivityType variants.

import Foundation
import HealthKit

extension HKWorkoutActivityType {
    var name: String {
        switch self {
        case .americanFootball: return "American Football"
        case .archery: return "Archery"
        case .australianFootball: return "Australian Football"
        case .badminton: return "Badminton"
        case .barre: return "Barre"
        case .baseball: return "Baseball"
        case .basketball: return "Basketball"
        case .bowling: return "Bowling"
        case .boxing: return "Boxing"
        case .cardioDance: return "Cardio Dance"
        case .climbing: return "Climbing"
        case .cooldown: return "Cooldown"
        case .coreTraining: return "Core Training"
        case .cricket: return "Cricket"
        case .crossCountrySkiing: return "Cross Country Skiing"
        case .crossTraining: return "Cross Training"
        case .curling: return "Curling"
        case .cycling: return "Cycling"
        case .dance: return "Dance"
        case .danceInspiredTraining: return "Dance Inspired Training"
        case .discSports: return "Disc Sports"
        case .downhillSkiing: return "Downhill Skiing"
        case .elliptical: return "Elliptical"
        case .equestrianSports: return "Equestrian Sports"
        case .fencing: return "Fencing"
        case .fishing: return "Fishing"
        case .fitnessGaming: return "Fitness Gaming"
        case .flexibility: return "Flexibility"
        case .functionalStrengthTraining: return "Functional Strength Training"
        case .golf: return "Golf"
        case .gymnastics: return "Gymnastics"
        case .handCycling: return "Hand Cycling"
        case .handball: return "Handball"
        case .highIntensityIntervalTraining: return "High Intensity Interval Training"
        case .hiking: return "Hiking"
        case .hockey: return "Hockey"
        case .hunting: return "Hunting"
        case .jumpRope: return "Jump Rope"
        case .kickboxing: return "Kickboxing"
        case .lacrosse: return "Lacrosse"
        case .martialArts: return "Martial Arts"
        case .mindAndBody: return "Mind and Body"
        case .mixedCardio: return "Mixed Cardio"
        case .mixedMetabolicCardioTraining: return "Mixed Metabolic Cardio Training"
        case .other: return "Other"
        case .paddleSports: return "Paddle Sports"
        case .pickleball: return "Pickleball"
        case .pilates: return "Pilates"
        case .play: return "Play"
        case .preparationAndRecovery: return "Preparation and Recovery"
        case .racquetball: return "Racquetball"
        case .rowing: return "Rowing"
        case .rugby: return "Rugby"
        case .running: return "Running"
        case .sailing: return "Sailing"
        case .skatingSports: return "Skating Sports"
        case .snowSports: return "Snow Sports"
        case .snowboarding: return "Snowboarding"
        case .soccer: return "Soccer"
        case .socialDance: return "Social Dance"
        case .softball: return "Softball"
        case .squash: return "Squash"
        case .stairClimbing: return "Stair Climbing"
        case .stairs: return "Stairs"
        case .stepTraining: return "Step Training"
        case .surfingSports: return "Surfing Sports"
        case .swimming: return "Swimming"
        case .tableTennis: return "Table Tennis"
        case .taiChi: return "Tai Chi"
        case .tennis: return "Tennis"
        case .trackAndField: return "Track and Field"
        case .traditionalStrengthTraining: return "Traditional Strength Training"
        case .volleyball: return "Volleyball"
        case .walking: return "Walking"
        case .waterFitness: return "Water Fitness"
        case .waterPolo: return "Water Polo"
        case .waterSports: return "Water Sports"
        case .wheelchairRunPace: return "Wheelchair Run Pace"
        case .wheelchairWalkPace: return "Wheelchair Walk Pace"
        case .wrestling: return "Wrestling"
        case .yoga: return "Yoga"
        default: return "Unknown"
        }
    }

    static let allCases: [HKWorkoutActivityType] = [
        .americanFootball,
        .archery,
        .australianFootball,
        .badminton,
        .barre,
        .baseball,
        .basketball,
        .bowling,
        .boxing,
        .cardioDance,
        .climbing,
        .cooldown,
        .coreTraining,
        .cricket,
        .crossCountrySkiing,
        .crossTraining,
        .curling,
        .cycling,
        .dance,
        .danceInspiredTraining,
        .discSports,
        .downhillSkiing,
        .elliptical,
        .equestrianSports,
        .fencing,
        .fishing,
        .fitnessGaming,
        .flexibility,
        .functionalStrengthTraining,
        .golf,
        .gymnastics,
        .handCycling,
        .handball,
        .highIntensityIntervalTraining,
        .hiking,
        .hockey,
        .hunting,
        .jumpRope,
        .kickboxing,
        .lacrosse,
        .martialArts,
        .mindAndBody,
        .mixedCardio,
        .mixedMetabolicCardioTraining,
        .other,
        .paddleSports,
        .pickleball,
        .pilates,
        .play,
        .preparationAndRecovery,
        .racquetball,
        .rowing,
        .rugby,
        .running,
        .sailing,
        .skatingSports,
        .snowSports,
        .snowboarding,
        .soccer,
        .socialDance,
        .softball,
        .squash,
        .stairClimbing,
        .stairs,
        .stepTraining,
        .surfingSports,
        .swimming,
        .tableTennis,
        .taiChi,
        .tennis,
        .trackAndField,
        .traditionalStrengthTraining,
        .volleyball,
        .walking,
        .waterFitness,
        .waterPolo,
        .waterSports,
        .wheelchairRunPace,
        .wheelchairWalkPace,
        .wrestling,
        .yoga
    ]

    var url: URL? {
        switch self {
        case .americanFootball: return Bundle.main.url(forResource: "american_football_112px_Normal@3x", withExtension: "png")
        case .archery: return Bundle.main.url(forResource: "archery_112px_Normal@3x", withExtension: "png")
        case .australianFootball: return Bundle.main.url(forResource: "australian_rules_football_112px_Normal@3x", withExtension: "png")
        case .badminton: return Bundle.main.url(forResource: "badminton_112px_Normal@3x", withExtension: "png")
        case .barre: return Bundle.main.url(forResource: "barre_112px_Normal@3x", withExtension: "png")
        case .baseball: return Bundle.main.url(forResource: "baseball_112px_Normal@3x", withExtension: "png")
        case .basketball: return Bundle.main.url(forResource: "basketball_112px_Normal@3x", withExtension: "png")
        case .bowling: return Bundle.main.url(forResource: "bowling_112px_Normal@3x", withExtension: "png")
        case .boxing: return Bundle.main.url(forResource: "boxing_112px_Normal@3x", withExtension: "png")
        case .cardioDance: return Bundle.main.url(forResource: "dance_112px_Normal@3x", withExtension: "png")
        case .climbing: return Bundle.main.url(forResource: "climbing_112px_Normal@3x", withExtension: "png")
        case .cooldown: return Bundle.main.url(forResource: "cooldown_112px_Normal@3x", withExtension: "png")
        case .coreTraining: return Bundle.main.url(forResource: "core_training_112px-1_Normal@3x", withExtension: "png")
        case .cricket: return Bundle.main.url(forResource: "cricket_112px_Normal@3x", withExtension: "png")
        case .crossCountrySkiing: return Bundle.main.url(forResource: "cross_country_skiing_112px_Normal@3x", withExtension: "png")
        case .crossTraining: return Bundle.main.url(forResource: "cross_training_112px_Normal@3x", withExtension: "png")
        case .curling: return Bundle.main.url(forResource: "curling_112px_Normal@3x", withExtension: "png")
        case .cycling: return Bundle.main.url(forResource: "outdoorcycle_112px_Normal@3x", withExtension: "png")
        case .dance: return Bundle.main.url(forResource: "dance_112px_Normal@3x", withExtension: "png")
        case .danceInspiredTraining: return Bundle.main.url(forResource: "dance_insp_training_112px_Normal@3x", withExtension: "png")
        case .discSports: return Bundle.main.url(forResource: "disk_sports_112px-1_Normal@3x", withExtension: "png")
        case .downhillSkiing: return Bundle.main.url(forResource: "downhill_skiing_112px_Normal@3x", withExtension: "png")
        case .elliptical: return Bundle.main.url(forResource: "elliptical_112px_Normal@3x", withExtension: "png")
        case .equestrianSports: return Bundle.main.url(forResource: "equestrian_sports_112px_Normal@3x", withExtension: "png")
        case .fencing: return Bundle.main.url(forResource: "fencing_112px_Normal@3x", withExtension: "png")
        case .fishing: return Bundle.main.url(forResource: "fishing_112px_Normal@3x", withExtension: "png")
        case .fitnessGaming: return Bundle.main.url(forResource: "gaming_sports_112px-1_Normal@3x", withExtension: "png")
        case .flexibility: return Bundle.main.url(forResource: "flexibility_112px_Normal@3x", withExtension: "png")
        case .functionalStrengthTraining: return Bundle.main.url(forResource: "func_strength_training_112_Normal@3x", withExtension: "png")
        case .golf: return Bundle.main.url(forResource: "golf_112px_Normal@3x", withExtension: "png")
        case .gymnastics: return Bundle.main.url(forResource: "gymnastics_112px_Normal@3x", withExtension: "png")
        case .handCycling: return Bundle.main.url(forResource: "hand_cycling_112px_Normal@3x", withExtension: "png")
        case .handball: return Bundle.main.url(forResource: "handball_112px_Normal@3x", withExtension: "png")
        case .highIntensityIntervalTraining: return Bundle.main.url(forResource: "hiit_112px_Normal@3x", withExtension: "png")
        case .hiking: return Bundle.main.url(forResource: "hiking_112px_Normal@3x", withExtension: "png")
        case .hockey: return Bundle.main.url(forResource: "hockey_112px_Normal@3x", withExtension: "png")
        case .hunting: return Bundle.main.url(forResource: "hunting_112px_Normal@3x", withExtension: "png")
        case .jumpRope: return Bundle.main.url(forResource: "jump_rope_112px_Normal@3x", withExtension: "png")
        case .kickboxing: return Bundle.main.url(forResource: "kickboxing_112px_Normal@3x", withExtension: "png")
        case .lacrosse: return Bundle.main.url(forResource: "lacrosse_112px_Normal@3x", withExtension: "png")
        case .martialArts: return Bundle.main.url(forResource: "martial_arts_112px_Normal@3x", withExtension: "png")
        case .mindAndBody: return Bundle.main.url(forResource: "mind_and_body_112px_Normal@3x", withExtension: "png")
        case .mixedCardio: return Bundle.main.url(forResource: "mixed_meta_cardio_training_112px_Normal@3x", withExtension: "png")
        case .mixedMetabolicCardioTraining: return Bundle.main.url(forResource: "mixed_meta_cardio_training_112px_Normal@3x", withExtension: "png")
        case .other: return Bundle.main.url(forResource: "other_112px_Normal@3x", withExtension: "png")
        case .paddleSports: return Bundle.main.url(forResource: "paddle_sports_112px_Normal@3x", withExtension: "png")
        case .pickleball: return Bundle.main.url(forResource: "pickleball_112px_Normal@3x", withExtension: "png")
        case .pilates: return Bundle.main.url(forResource: "pilates_112px_Normal@3x", withExtension: "png")
        case .play: return Bundle.main.url(forResource: "play_112px_Normal@3x", withExtension: "png")
        case .preparationAndRecovery: return Bundle.main.url(forResource: "prep_and_recovery_112px_Normal@3x", withExtension: "png")
        case .racquetball: return Bundle.main.url(forResource: "racquetball_112px_Normal@3x", withExtension: "png")
        case .rowing: return Bundle.main.url(forResource: "rowing_112px_Normal@3x", withExtension: "png")
        case .rugby: return Bundle.main.url(forResource: "rugby_112px_Normal@3x", withExtension: "png")
        case .running: return Bundle.main.url(forResource: "outdoorrun_112px_Normal@3x", withExtension: "png")
        case .sailing: return Bundle.main.url(forResource: "sailing_112px_Normal@3x", withExtension: "png")
        case .skatingSports: return Bundle.main.url(forResource: "skating_sports_112px_Normal@3x", withExtension: "png")
        case .snowSports: return Bundle.main.url(forResource: "snow_sports_112px_Normal@3x", withExtension: "png")
        case .snowboarding: return Bundle.main.url(forResource: "snowboarding_112px_Normal@3x", withExtension: "png")
        case .soccer: return Bundle.main.url(forResource: "soccer_112px_Normal@3x", withExtension: "png")
        case .socialDance: return Bundle.main.url(forResource: "social-dance_112px-1_Normal@3x", withExtension: "png")
        case .softball: return Bundle.main.url(forResource: "softball_112px_Normal@3x", withExtension: "png")
        case .squash: return Bundle.main.url(forResource: "squash_112px_Normal@3x", withExtension: "png")
        case .stairClimbing: return Bundle.main.url(forResource: "stairs_112px_Normal@3x", withExtension: "png")
        case .stairs: return Bundle.main.url(forResource: "stairs_112px_Normal@3x", withExtension: "png")
        case .stepTraining: return Bundle.main.url(forResource: "step_training_112px_Normal@3x", withExtension: "png")
        case .surfingSports: return Bundle.main.url(forResource: "surfing_112px_Normal@3x", withExtension: "png")
        case .swimming: return Bundle.main.url(forResource: "swimopen_112px_Normal@3x", withExtension: "png")
        case .tableTennis: return Bundle.main.url(forResource: "table_tennis_112px_Normal@3x", withExtension: "png")
        case .taiChi: return Bundle.main.url(forResource: "tai_chi_112px_Normal@3x", withExtension: "png")
        case .tennis: return Bundle.main.url(forResource: "tennis_112px_Normal@3x", withExtension: "png")
        case .trackAndField: return Bundle.main.url(forResource: "track_and_field_112px_Normal@3x", withExtension: "png")
        case .traditionalStrengthTraining: return Bundle.main.url(forResource: "trad_weight_training_112px_Normal@3x", withExtension: "png")
        case .volleyball: return Bundle.main.url(forResource: "volleyball_112px_Normal@3x", withExtension: "png")
        case .walking: return Bundle.main.url(forResource: "outdoorwalk_112px_Normal@3x", withExtension: "png")
        case .waterFitness: return Bundle.main.url(forResource: "water_fitness_112px_Normal@3x", withExtension: "png")
        case .waterPolo: return Bundle.main.url(forResource: "water_polo_112px_Normal@3x", withExtension: "png")
        case .waterSports: return Bundle.main.url(forResource: "water_sports_112px_Normal@3x", withExtension: "png")
        case .wheelchairRunPace: return Bundle.main.url(forResource: "wheelchairrun_112px_Normal@3x", withExtension: "png")
        case .wheelchairWalkPace: return Bundle.main.url(forResource: "wheelchairwalk_112px_Normal@3x", withExtension: "png")
        case .wrestling: return Bundle.main.url(forResource: "wrestling_112px_Normal@3x", withExtension: "png")
        case .yoga: return Bundle.main.url(forResource: "yoga_112px_Normal@3x", withExtension: "png")
        default: return nil
        }
    }
}

from dataclasses import dataclass
from itertools import chain
from pathlib import Path
from string import Template
from typing import List
from typing import Optional
from shutil import copy

from httpx import get
from inflection import titleize
from inflection import underscore
from jmespath import search


def removesuffixes(text: str, suffixes: List[str]) -> str:
    for suffix in suffixes:
        applied = text.removesuffix(suffix)
        if applied != text:
            return applied
    return text


HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_TEMPLATE = Template(
    """
import Foundation
import HealthKit

extension HKWorkoutActivityType {
    var name: String {
        switch self {
$name
        default: return "Unknown"
        }
    }

    static let allCases: [HKWorkoutActivityType] = [
$all_cases
    ]

    var url: URL? {
        switch self {
$url
        default: return nil
        }
    }
}
""".lstrip()
)

HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_NAME_TEMPLATE = Template(
    '        case .$case: return "$humanized"'
)
HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_ALL_CASES_TEMPLATE = Template("        .$case")
HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_URL_TEMPLATE = Template(
    '        case .$case: return Bundle.main.url(forResource: "$resource", withExtension: "$extension")'
)


HK_WORKOUT_ACTIVITY_TYPE = "https://developer.apple.com/tutorials/data/documentation/healthkit/hkworkoutactivitytype.json"
WORKOUT_ASSET_SUFFIXES = [
    "_112_Normal@3x.png",
    "_112px-1_Normal@3x.png",
    "_112px_Normal@3x.png",
]
WORKOUT_ASSETS_BASE_PATH = Path("assets/all/FitnessUI/")
WORKOUT_ASSETS_OUTPUT_PATH = Path("assets/reduced/FitnessUI/")
WORKOUT_ASSETS = chain(
    *[
        WORKOUT_ASSETS_BASE_PATH.glob(f"*{pattern}")
        for pattern in WORKOUT_ASSET_SUFFIXES
    ]
)
WORKOUT_ASSET_LOOKUP = {
    removesuffixes(asset.name, WORKOUT_ASSET_SUFFIXES): asset
    for asset in WORKOUT_ASSETS
}
WORKOUT_SPECIAL_CASES = {
    "australianFootball": "australian_rules_football",
    "cardioDance": "dance",
    "cycling": "outdoorcycle",
    "danceInspiredTraining": "dance_insp_training",
    "discSports": "disk_sports",
    "fitnessGaming": "gaming_sports",
    "functionalStrengthTraining": "func_strength_training",
    "highIntensityIntervalTraining": "hiit",
    "mixedCardio": "mixed_meta_cardio_training",
    "mixedMetabolicCardioTraining": "mixed_meta_cardio_training",
    "preparationAndRecovery": "prep_and_recovery",
    "running": "outdoorrun",
    "socialDance": "social-dance",
    "stairClimbing": "stairs",
    "surfingSports": "surfing",
    "swimming": "swimopen",
    "traditionalStrengthTraining": "trad_weight_training",
    "walking": "outdoorwalk",
    "wheelchairRunPace": "wheelchairrun",
    "wheelchairWalkPace": "wheelchairwalk",
}

@dataclass
class Workout:
    case: str
    asset_path: Optional[Path]

    @property
    def humanized(self) -> str:
        return Workout.humanize_by_case(self.case)

    @staticmethod
    def match_asset_by_case(case: str) -> Optional[Path]:
        case_override = (
            case if case not in WORKOUT_SPECIAL_CASES else WORKOUT_SPECIAL_CASES[case]
        )

        for name in (
            case_override,
            underscore(case_override),
            underscore(case_override).replace("_", ""),
        ):
            if name in WORKOUT_ASSET_LOOKUP:
                return WORKOUT_ASSET_LOOKUP[name]

    @staticmethod
    def humanize_by_case(case: str) -> str:
        return titleize(underscore(case)).replace("And", "and")

    @staticmethod
    def from_enum_case(case: str):
        return Workout(case, Workout.match_asset_by_case(case))

    @property
    def template_mapping(self):
        return {
            "case": self.case,
            "humanized": self.humanized,
            "resource": self.asset_path.stem,
            "extension": self.asset_path.suffix.removeprefix("."),
        }


r = get(HK_WORKOUT_ACTIVITY_TYPE)
json = r.json()


# Only include non-deprecated workouts:
# references.* | [?kind==`symbol`&&deprecated==null].fragments[?[0].text==`case `][1].text
workouts_variants = search(
    "references.* | [?kind==`symbol`].fragments[?[0].text==`case `][1].text", json
)
workouts = sorted(
    [Workout.from_enum_case(workout) for workout in workouts_variants],
    key=lambda workout: workout.case,
)

# Only copy resources that are referenced by workouts
for workout in workouts:
    asset_path = workout.asset_path
    if asset_path is not None:
        copy(asset_path, WORKOUT_ASSETS_OUTPUT_PATH)

print(
    HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_TEMPLATE.safe_substitute(
        name="\n".join(
            (
                HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_NAME_TEMPLATE.substitute(
                    workout.template_mapping
                )
                for workout in workouts
            )
        ),
        all_cases=",\n".join(
            (
                HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_ALL_CASES_TEMPLATE.substitute(
                    workout.template_mapping
                )
                for workout in workouts
            )
        ),
        url="\n".join(
            (
                HK_WORKOUT_ACTIVITY_TYPE_EXTENSION_URL_TEMPLATE.substitute(
                    workout.template_mapping
                )
                for workout in workouts
            )
        ),
    )
)

httpx = "^0.16.1"
jmespath = "^0.10.0"
inflection = "^0.5.1"

Every once in a while, a revolutionary product comes along, that rids its users of some annoying little time-waste that stands between them and productivity.

— Steve Jobs (possibly altered to fit the narrative of this review)

In my mind, Thunderbolt 3 docks are one such kind of product. Plug in one cable, and immediately pick up where you left off... that's the concept, at least.

Let's see if the Elgato Thunderbolt 3 Pro Dock delivers on that promise.

Design

The dock looks and feels premium. It has some heft to it (it weighs roughly half a kilogram), so it won't easily slide off ones desk because of stiff cabling and such. The aluminum chassis is aesthetically pleasing and the whole device looks very similar to the back of a Mac Mini (which is good).

I/0

• Back
  • Gigabit Ethernet
  • 3.5mm headphone jack (line out)
  • 2 x USB 3.1 Gen 2 Type C connector (10GB/s; 1.5A)
  • 2 x Thunderbolt 3
  • DisplayPort 1.2

• Front
  • SD card reader
  • Micro SD card reader
  • 3.5mm headphone jack (line in / out)
  • 2 x USB 3.1 Gen 2 Type A connector (5GB/s; 1.5A)

The port selection is overall solid, but a second DP port certainly wouldn't have hurt, as there's only 2 Thunderbolt 3 ports, one of which will always be occupied by the connected computer.

Price

All Thunderbolt 3 docks are pretty expensive, and this one is no exception coming in at around 350 USD / EUR, but it still manages to be the most expensive out of the bunch. This can largely be attributed to the fact that Elgato has a very specific target audience in mind: Apple customers.

That's not just an assumption though, as basically all their marketing material only depicts Apple hardware, and the fact that they do not provide a Windows version of their Thunderbolt Dock Utility.

Software

The Dock Utility provides two optional pieces of functionality:

1. High-power USB support
2. An eject all menu bar application (for storage devices attached to the dock)

High-power USB support is achieved through two kernel modules (ElgatoThunderbolt2DockChargingSupport.kext, ElgatoThunderboltDockChargingSupport.kext) which basically tell IOKit that 15 Watts are available instead of 5.

A third module is thrown into the mix (ElgatoThunderboltDockAudioRename.kext) that updates the internal name of the USB audio devices that the dock exposes (to Elgato Thunderbolt Dock Audio / Elgato Thunderbolt 2 Dock Audio).

If neither feature is desired there is no point in installing the Dock Utility, as blindly installing kernel extensions of dubious quality is a great way to cause system instability.

Audio quality

No setup is complete without epic sound. Thanks to a maximum sample rate of 96 kHz, and sample size of 24 bits, [...] you can plug in your high-fidelity headset without disconnecting your desktop speakers.

— Elgato marketing blurb

Fecal matter of male cattle. Both 3.5mm socket emit a quiet but still incredibly annoying static hiss. The fact that an Apple USB-C to 3.5mm headphone jack adapter produces better results is honestly staggering.
That being said, its only really problematic for headphones, as the hiss practically isn't noticeable on most speakers, ... which doesn't change the fact that such poor audio quality is simply not acceptable.

Conclusion

Its alright, but certainly not worth the asking price. I won't be returning my unit, as its basically the only good-looking Thunderbolt 3 dock out there, and because a USB-C to 3.5mm headphone jack adapter sufficiently solves the audio quality issues.

tldr: If design is the deciding factor, go with this one. If it isn't then the CalDigit TS3 Plus is probably a better investment.

If a container is brought up with machinectl start instead, the console-getty override has no effect for consequent machinectl login invocations, as container-getty@.service is in charge of the pseudo terminals that login attaches to instead.

    State: running
     Jobs: 0 queued
   Failed: 0 units
    Since: Sat 2019-03-16 17:11:26 CET; 16min ago
   CGroup: /
           ├─init.scope
           │ └─1 /lib/systemd/systemd
           └─system.slice
             ├─console-getty.service
             │ └─48 /sbin/agetty --noclear --keep-baud console 115200,38400,9600 vt220
             └─system-container\x2dgetty.slice
               └─container-getty@0.service
                 ├─53 /bin/login -f
                 └─58 -bash

Logging into the container without a password can still be achieved by using the shell subcommand of machinectl, though the login subcommand remains the only option for Linux distributions that ship with older versions of systemd, which do not include shell (before v224).

An ExecStart override for container-getty@.service can be used to replicate the behaviour of shell with login.

systemctl edit container-getty@.service

[Service]
ExecStart= 
ExecStart=-/sbin/agetty --noclear --autologin root --keep-baud pts/%I 115200,38400,9600 $TERM 

• The empty space after the first ExecStart is there on purpose, as it tells systemd to clear the pre-existing ExecStart content.
• Substituting root with another user name will instead enable automatic login for the specified user.

Notes

• systemd as well as dbus should be installed in the container root file-system, otherwise both login and shell will fail (Failed to get shell PTY: Protocol error).
• The override doesn't necessarily have to be created with the edit subcommand of systemd. Creating and subsequenly populating the contents of /etc/systemd/system/container-getty@.service.d/override.conf also works just as well.

>>> def foo():
...     pass
...
>>> print(foo())
None

To ensure that this is the case, instructions that are equivalent to a return None statement are appended to the inner-most code block by the bytecode compiler if no return statement is present.

>>> from dis import dis
>>> dis(foo)
  2           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE

Enforcing this requirement on an individual function level instead of inside the evaluation main loop necessitates that all functions follow this protocol. Let's explore what happens when they don't.

📚 Incomprehensive overview of Python bytecode

The bytecode of existing functions can be examined by looking at their __code__.co_code attribute.

>>> foo.__code__.co_code
b'd\x00S\x00'

Each instruction is 2 bytes long (BB) and consists of an opcode and an optional argument value. struct.unpack can be used to decode individual instructions, and a human readable representation can be obtained through dis.opmap (re-export of the undocumented opcode.opmap), which maps the opcode names to their respective numerical values. Swapping key and value subsequently provides a numerical value to text mapping.

from struct import unpack
from dis import opmap

reverse_opmap = {v: k for k, v in opmap.items()}


def foo():
    pass


foo_code = foo.__code__.co_code
for pos in range(0, len(foo_code), 2):
    inst = unpack("BB", foo_code[pos : pos + 2])
    print(f"{reverse_opmap[inst[0]]}: {inst[1]}")

LOAD_CONST: 0
RETURN_VALUE: 0

The bytecode section that instructs the VM to return None is 4 bytes long:

1. LOAD_CONST(0)

   Loads the constant stored at index 0 of __code__.co_consts (which is None in this case) into memory.

2. RETURN_VALUE(0)

   Returns the previously loaded constant (argument-less).

🤞 Crossing fingers

Stripping out the 4 bytes, replacing the __code__ attribute of the foo function, and executing the resulting function does not crash the VM (surprisingly). Instead, a SystemError is raised and an accompanying error message is printed to stderr.

from types import FunctionType, CodeType


def foo():
    pass


foo_code = foo.__code__
foo.__code__ = CodeType(
    foo_code.co_argcount,
    foo_code.co_kwonlyargcount,
    foo_code.co_nlocals,
    foo_code.co_stacksize,
    foo_code.co_flags,
    foo_code.co_code[:-4],
    foo_code.co_consts,
    foo_code.co_names,
    foo_code.co_varnames,
    "",
    foo_code.co_name,
    1,
    b"",
)

foo()

XXX lineno: 1, opcode: 0
Traceback (most recent call last):
  File "/Users/philip/Developer/testing/python-implicit-return.py", line 25, in <module>
    foo()
  File "", line 1, in foo
SystemError: unknown opcode

SystemError is a regular runtime error (despite its name), and can therefor be caught with a regular try / except clause.

>>> try:
...     foo()
... except SystemError:
...     pass

The accompanying error message (XXX lineno: 1, opcode: 0) can't be silence from within Python, because the output stream to which it is written is hard-coded to stderr. That doesn't mean that its impossible, though.

python3 <file> 2> >(sed "/^XXX lineno: [^,]*, opcode: [^\n]*/d" >&2)

🏁 Conclusion

Don't do this.

While this property is generally beneficial, they also bring along some ergonomic problems:

• No index operator support
• Cloning is problematic (see itertools.tee)
• Results have to be stored in an auxiliary collection if caching is desired
• Debugging misbehaving generators is non-trivial

The most common way to deal with these shortcomings is to just unroll the generator into a collection if the element count yielded by the generator is manageable. There are many ways to accomplish this, but all of them have different strengths and shortcomings.

from timeit import timeit
from functools import partial
from array import array
from sys import getsizeof

RUNS = 1000
RANGE = 10000

for exprs, desc in (
    (lambda gen: list(gen), "List constructor"),
    (
        lambda gen: (lambda gen, list: [list.append(num) for num in gen])(gen, list()),
        "List append",
    ),
    (lambda gen: [num for num in gen], "List comprehension"),
    (lambda gen: tuple(gen), "Tuple constructor"),
    (lambda gen: set(gen), "Set constructor"),
    (lambda gen: frozenset(gen), "Frozenset constructor"),
    (lambda gen: {num: None for num in gen}, "Dictionary nonsense"),
    (lambda gen: array("h", gen), "Array constructor"),
    (
        lambda gen: (lambda gen, arr: arr.extend(gen) or arr)(gen, array("h")),
        "Array extension",
    ),
    (
        lambda gen: (lambda gen, arr: [arr.append(num) for num in gen])(
            gen, array("h")
        ),
        "Array append",
    ),
):
    bound_expr = partial(exprs, (lambda: range(RANGE))())
    print(f"{timeit(bound_expr, number=RUNS):.5f}s: {desc} ({getsizeof(bound_expr())})")

Conclusion

• The list constructor is the definitive all-rounder and the best choice in most cases.
• Typed arrays shine when memory usage is key.
• The tuple constructor is about 20% slower than the list constructor, while taking up ~10% less space.

from types import FunctionType

foo_code = compile('def foo(): return "bar"', "<string>", "exec")
foo_func = FunctionType(foo_code.co_consts[0], globals(), "foo")

print(foo_func())

bar

Dissection

Stepping through the code line-by-line reveals how thin the language / interpreter barrier really is.

>>> from types import FunctionType

The Python docs often do not list the signatures of classes that aren't meant to be created manually (which is completely reasonable).
There are three ways to work around this: help(), inspect (which can't examine built-in functions), and the fallback solution of looking at the CPython source code.
In this instance both help() and inspect do the job, but looking at the actual source code reveals additional details in regards to data-types.

>>> from inspect import signature
>>> signature(FunctionType)
<Signature (code, globals, name=None, argdefs=None, closure=None)>

1. code
   Internally a PyCodeObject, which is exposed as a types.CodeType.
   Non-built-in functions have a __code__ attribute which holds their corresponding code object.
   types.CodeType objects can be created at runtime by utilizing the compile() built-in.
2. globals
   If a variable that is being referenced in a function isn't defined locally, passed in as a parameter, provided by a default argument value, or supplied through a closure context, it is looked up in the globals dictionary.
   The globals() built-in function returns a reference to the global symbol table of the current module, and can therefor be used to supply a dictionary that is always up-to-date with the current state of said table. Passing in any other dictionary works as well (FunctionType((lambda: bar).__code__, {"bar" : "baz"}, "foo")() == "baz").
3. name (optional)
   Controls the __name__ attribute of the returned function. Only really useful for lambdas (due to their anonymous nature they normally don't have names), and renaming functions.
4. argdefs (optional)
   Provides a way to supply default argument values (def foo(bar="baz")) by passing in a tuple that contains objects of arbitrary type. (FunctionType((lambda bar: bar).__code__, {}, "foo", (10,))() == 10).
5. closure (optional)
   (Probably shouldn't be touched if execution in any Python VM other than CPython (PyPy, Jython, ...) is desired, as it heavily relies on implementation details)
   A tuple of cell objects. Creating cell objects isn't exactly straight forward, because calling into CPython internals is required, but there is a library that makes this more convenient: exalt (shameless advertisement).

>>> foo_code = compile('def foo(): return "bar"', "<string>", "exec")

compile() is a built-in function, and therefor also well documented.

exec mode is utilized, because multiple statements are necessary to define a function.

>>> foo_func = FunctionType(foo_code.co_consts[0], globals(), "foo")

Bringing it all together and assigning the dynamically created function to a variable.
The function that was compiled in the previous statement becomes the first constant of the generated code object, therefor just referring to foo_code is insufficient. This is a direct consequence of exec mode, because the resulting code object can contain multiple constants.

>>> print(foo_func())

The dynamically created function can be called just like any other function.

Conclusion

• There are very few use-cases for dynamic function creation outside of experimentation.
• Toying around with Python internals is a great way to learn more about the language.
• The interpreter / language boundary can be crossed rather effortlessly if desired.

And as always: Don’t abuse the language (well, a little can’t hurt, right?)

The crippled nature of Python's lambdas are a big weakness of Python. They sit in a no-mans land of providing half a solution but being too crippled to actually to improve clarity / improve programming style.

— zmmmmm

Comments like this one about Python's lambdas are very, very, very common. Even Guido himself isn't particularly fond of lambdas, as demonstrated by his suggestion to remove them outright.

With all the negativity surrounding this admittedly underpowered language feature it is worth exploring why the capabilities of lambdas are so limited, and how to make use of them.

History lesson

About 12 years ago, Python aquired acquired lambda, reduce(), filter() and map(), courtesy of (I believe) a Lisp hacker who missed them and submitted working patches.

— Guido van Rossum (2005)

lambda_input was first introduced into the grammar on October 26th 1993. At this point lambda wasn't a keyword yet, but instead a function that would consume a vararglist (parameter list) and testlist (basically an expression) as a string.

lambd​a('x: x + 1')

About one month later it finally became a keyword and has remained largely unchanged to this day.

Pythonic?

For example, today someone claimed to have solved the problem of the multi-statement lambda.
But such solutions often lack "Pythonicity" [...]

— Guido van Rossum (2006)

Technical feasibility is not really a concern when it comes to possible lambda improvements. The main issue is that Guido will not accept a solution that introduces indentation within expressions on the grounds of lacking "Pythonicity". This effectively rules out multi-statement lambdas.

foo(
    (
        lambda a, b:
            print(a)
            print(b)
    ), 
    "bar",
) 

foo((
    lambda a, b:
        print(a)
        print(b)
    ), 
    "bar",
) 

If both variants were to be deemed valid, the concept of significant whitespace for indentation would be defeated, because the sparse syntax would require an optional extra level of indentation. If only one variant was to be allowed, there would be endless bike-shedding over which one should be chosen.

Patterns

Function binding

from functools import partial

for fun in (partial(lambda number, exp: number ** exp, number) for number in range(RUNS)):
    print(fun(2))

(Nested) lambdas can be used instead of partial for binding values to functions.

for fun in ((lambda number: lambda exp: number ** exp)(number) for number in range(RUNS)):
    print(fun(2))

Readability is questionable is both cases, but benchmarking (10^6*5 runs) reveals some noticeable speed improvements when using list comprehensions, which are eagerly evaluated. Generator expressions, which evaluate lazily, exhibit a smaller performance gain. The overhead of lambda binding is generally smaller, because a wrapper function is created instead of a partial object.

from functools import partial
from time import time

ENTRIES = 5000000
RUNS = 2
FUNCTION_ARG = (2,)


def bench(generator_expression, expand):
    start_bind = time()
    callables_ = list(generator_expression) if expand else generator_expression
    end_bind = time()

    start_exec = time()

    for fun in callables_:
        fun(*FUNCTION_ARG)

    end_exec = time()

    return (end_bind - start_bind) if expand else None, (end_exec - start_exec)


def format_result(result, expand):
    return "%sExecuting time: %fs\nOverall time: %fs" % (
        "Binding time: %fs\n" % result[0] if expand else "",
        result[1],
        (result[0] + result[1]) if expand else result[1],
    )


for expand in (True, False):
    print((" eager " if expand else " lazy ").center(20, "-"))
    for _ in range(RUNS):
        print(" partial ".center(20, "-"))
        print(
            format_result(
                bench(
                    (
                        partial(lambda number, exp: number ** exp, number)
                        for number in range(ENTRIES)
                    ),
                    expand,
                ),
                expand,
            )
        )

        print(" lambda ".center(20, "-"))
        print(
            format_result(
                bench(
                    (
                        (lambda number: lambda exp: number ** exp)(number)
                        for number in range(ENTRIES)
                    ),
                    expand,
                ),
                expand,
            )
        )

Computed sort key

>>> from math import tan
>>> sorted(range(10, 20), key=lambda number: tan(number))
[11, 18, 15, 12, 19, 16, 13, 10, 17, 14]

Conclusion

• List comprehensions are often faster and always more "Pythonic" than map(), filter(), and reduce().
• Improving upon lambdas while preserving "Pythonicity" is hard.
• There are some legitimate use-cases for lambdas... just not that many.

Apple might seriously change up it's MacBook Pro lineup relatively soon and High Sierra left a sour taste in my mouth, so I don't feel comfortable investing a decent chunk of money into a software and hardware ecosystem that is either going to deteriorate in quality even further or is going to be changing quite drastically in the near future. Either way, I need a new laptop pronto, as my previous Mac is starting to show its age.

That's the situation lots of people, including me, are currently finding themselves in. My plan to escape this dilemma was simple: Buy a beefy and aesthetically pleasing Windows laptop, install my Linux distro of choice, and hope for the best when it comes to driver support.

After lengthy research (and being influenced by HN comments) I finally decided to go with a Dell XPS 15 (9570).

As you'll see, that plan didn't quite pan out the way I had hoped it would.

Day 1

The laptop arrived at my home address after about two weeks in transit. Upon opening the cardboard box it came in, I was treated to a stench that no other electronics product I ever purchased reeked of (a mix of cheap plastic and glue). Thankfully that unit itself was not suspect to the same smell.

Hardware

The design of the XPS series hasn't really changed much since the introduction of the InfinityEdge display back in 2015, and that's good for once because the understated look that the laptop is going for is definitely nice. It generally looks and feels premium.

My particular unit exhibited noticeable backlight bleed on the bottom left and right corner of the screen. This problem seems to be quite common, but Dell does at least offer replacements if they deem the backlight bleed unacceptable. Coil whine was also present, but I wasn't able to reproduce it consistently.

One-handed operation of the display hinge is definitely out of the question, as pressing down on the chassis is required to open up the laptop, but that's more of a minor nitpick than actual criticism.

Initial setup

Before wiping the Windows partition I performed a "critical" BIOS upgrade. Dell does upload firmware updates to the Linux Vendor Firmware Service which can then be installed with fwupd, but the most recent BIOS version (1.3.0) was not yet available at the time of writing.

With all that out of the way I was finally able to start the installation process of my Linux distribution of choice, which is Debian testing — or so I thought.

The built-in Killer wireless networking adapter (Qualcomm Atheros QCA6174) requires a non-free driver to operate, which in turn necessitates a non-free Debian installer image. Additionally, I had to modify a slew of BIOS settings to successfully boot from a USB drive and subsequently install Debian.

• Secure Boot → Secure Boot Enable → Uncheck

Only a few Linux distributions support Secure Boot, and Debian isn't one of them yet.

• System Configuration → SATA Configuration → AHCI

Intel Rapid Storage isn't supported on Linux particularly well (at least out of the box). Configuring SATA for AHCI (Advanced Host Controller Interface) is necessary to make the Debian installer recognize the built-in NVMe drive.

• System Configuration → Thunderbolt Auto Switch → Native Enumeration

I don't own any Thunderbolt devices, so I was unable to test the difference between Native Enumeration and BIOS Assist Enumeration, but I disabled Auto Switch because the actual switching takes place every time the laptop powers on and therefor negatively impacts startup-time.

• Intel(R) Software Guard Extensions → Intel(R) SGX Enable → Enabled

Intel SGX is a set of central processing unit (CPU) instruction codes from Intel that allows user-level code to allocate private regions of memory, called enclaves, that are protected from processes running at higher privilege levels.

"Sounds terrible and incredibly vague", I thought. So I disabled it and quickly realized that the built-in Killer wireless networking adapter vanished from lspci's output. Don't disable it if you want to use WiFi, I guess.

After performing these changes, the Debian installation proceeded without any further interruptions.

After the installation was finished, I was presented with a completely empty boot order list. After lengthy troubleshooting I discovered that boot entries have to be added manually. Why?

By that point it was already getting late and I decided to continue the next day.

Day 2

With Debian installed it was time to run my trusty setup scripts to make the machine feel like home, but issues arose pretty much immediately.

Installing any desktop environment / window manager (in my case i3) pulls in xserver-xorg-video-nouveau on Debian. After the first reboot, nothing seemed out of the ordinary, until my system froze up after about a minute of very light usage (sitting idle on the lightdm login screen).

Turns out that nouveau currently doesn't play well with the XPS 15's GTX 1050 Ti and also lacks the courtesy to crash early and predictably. To temporarily get the system up and running again, a simple nomodeset is not sufficient. Instead, nouveau.modeset=0 has to be appended to the kernel arguments.

But that's just a temporary fix. Thankfully, there are still two other more longterm solutions remaining:

1. Install the official NVIDIA drivers (ugh) and utilize bumblebee to switch between integrated and dedicated graphics.
2. Disable the dedicated graphics card outright by removing xserver-xorg-video-nouveau.

I went with the first option. My workflow isn't really enhanced by a dedicated graphics card, but because I involuntarily purchased the 1050 Ti I didn't want the money to go to waste, so I figured that I should at least setup bumblebee to be able to switch between both graphics solutions.

There's just one problem minor problem: bbswitch, which is what bumblebee uses to power down the graphics card when it is not in use, does not work properly on Linux 4.17. It claims that it does (/proc/acpi/bbswitch → 0000:01:00.0 OFF), but digging around in sysfs (/sys/class/pci_bus/0000:01/power/runtime_enabled → enabled) and occasional fan spin-ups that are not tied to CPU usage tell us a different story. It also fails to properly power on the card when prompted to by optirun or primusrun (Although there appears to be a partial fix that forgoes bbswitch usage on startup).

Surprisingly, upgrading to Linux 4.18-rc4 fixed the graphics card shutdown on boot, but now bbswitch re-enables the graphics card every time the computer leaves lid-sleep, upon which the card can not be shut down anymore. This effectively renders bumblebee useless and absolutely destroys battery life. i3-bar suggests a drop from 11 hours to just three.

bbswitch: loading out-of-tree module taints kernel.
bbswitch: version 0.8
bbswitch: Found integrated VGA device 0000:00:02.0: \_SB_.PCI0.GFX0
bbswitch: Found discrete VGA device 0000:01:00.0: \_SB_.PCI0.PEG0.PEGP
bbswitch: detected an Optimus _DSM function
bbswitch: disabling discrete graphic

As the troubleshooting commenced I was feeling less and less satisfied with my purchase decision. Thankfully, it was already getting late, which I used as an excuse to go to bed.

Day 3

After some graphics card related nightmares I still had some fight left in me and continued on.

I wanted to tackle the lack of tap-to-click first, as it had already gotten on my nerves the day before. Debian utilizes libinput to handle input devices like touchpads. It performs admirably overall, although it is certainly lacking in the configuration department when compared to mtrack and synaptics. Tap-to-click can be enabled though, and from my experience it works significantly better than the two alternatives, as once enabled there is basically no pointer jitter. With all of that being said, I was still thoroughly disappointed as I was used to the excellent trackpad handling on macOS. It seems that I'm not the only one feeling this way, but nobody has taken the initiative to do something about it yet.

Anyway, next I decided to look into ways to improve the abysmal battery life.
The ever helpful Arch Linux Wiki suggests a tool called tlp specifically for ThinkPads, but nowadays it basically work on any laptop.

"Sounds great!", I thought, until I noticed that I was unable to establish WiFi connections after installing it. Even after a apt-get purge tlp the Killer wireless networking adapter stubbornly refused to participate in any key-exchanges. After rigorous troubleshooting I realized that tlp had pulled in network-manager without me noticing, which perfectly explains basically every kind of networking anomaly, as network-manager doesn't play well with systemd-networkd.

Another potential issue I avoided thanks to the Arch Linux Wiki was a conflict between bbswitch and the PCI power management functionality of tlp. The PCI address of the NVIDIA graphics card has to be excluded from tlp's runtime power management, otherwise bad things might happen.

# Exclude PCI(e) device adresses the following list from Runtime PM
# (separate with spaces). Use lspci to get the adresses (1st column).
RUNTIME_PM_BLACKLIST="01:00.0"

All things considering, I probably wouldn't have run into the issue in the first place as bbswitch still wasn't working properly anyway.

After another round of extensive troubleshooting with the goal of permanently disabling the graphics card I decided to give up. I scrubbed the drive, and contacted Dell support to arrange a refund. The support agent was very accommodating and I was surprised to find out that Dell even offers to send someone to retrieve the laptop for free.

Conclusion

If you can handle pretty terrible battery life, don't mind installing the closed-source NVIDIA graphics driver, want to carry around a mouse, can ignore the coil-whine and the backlight-bleed, and are willing to put in a few days to get everything up and running, then you probably won't regret your purchase. Otherwise the only solution I can offer you is to bite the bullet and buy another overpriced MacBook that thermal-throttles even worse than the XPS 15. Its what I did, and its also probably what you'll do too.

# I'm a comment.

"""
I'm also a comment.
"""

"I'm a comment too!"

87_104_121_32_97_109_32_73_32_97_32_99_111_109_109_101_110_116_63

["I'm", "also", "a", "comment", ("surprisingly.",)]

Only one of these “comments” is a real one.
Well, technically speaking all of them are comments, the real difference between them is speed and functionality.

Let's generate some code to find out what the actual differences between them are.

from time import time

# style comments
real_comments_code = ""
"string literal style comments"
fake_comments_code = ""

for comment_id in range(500000):
    comment = "I'm comment number %i" % comment_id

    real_comments_code += "# %s\n" % comment
    fake_comments_code += '"%s"\n' % comment

start_time = time()
compile(real_comments_code, "<string>", "exec")
print("Real comments took: %s" % (time() - start_time))

start_time = time()
compile(fake_comments_code, "<string>", "exec")
print("Fake comments took: %s" % (time() - start_time))

Real comments took: 0.08859992027282715
Fake comments took: 1.4969751834869385

The “#” comment variant is clearly favorable over the isolated string literal one in this completely unrealistic scenario, so if you ever wanted to include 500000 comments in your code, they are clearly the way to go.

But what's actually happening here, and because this is Python, can we somehow abuse this behavior? Let's examine the AST of our two automatically generated programs to find out.

Module

Module
  Expr
    Str
  Expr
    Str
  Expr
    Str
  Expr
    Str
  Expr
    Str
  ...

Real comments are simply left out of the final Python AST, just as one would expect. That's exactly where the speed difference is taking place, string literals still need to be evaluated on program runtime and you should never abuse them for comments. But that doesn't mean that they are useless.

def documented_function():
    # I'm __doc__
    "No, I'm __doc__!"
    """
    Shut up you two, I'm the real __doc__ here! (well, maybe not)
    """
    print("I'm a documented function.")


print(documented_function.__doc__)

Citing PEP-0257:

A docstring is a string literal that occurs as the first statement in a module, function, class, or method definition. Such a docstring becomes the doc special attribute of that object.

Python not only supports isolated strings literals, it essentially supports isolated anything. What's interesting here is, that all statements are evaluated. In combination with properties this behavior allows for some very “Ruby-esque” code.

class ClassWithProperty:
    def __init__(self, lazy=True):
        self._instance_property = None

        if not lazy:
            self.instance_property

    @property
    def instance_property(self):
        if self._instance_property == None:
            print("Working hard, but I'm still lazy.")
            self._instance_property = "I was born lazy."
        return self._instance_property


ClassWithProperty(lazy=False)
ClassWithProperty()

In conclusion: Don’t abuse the language (well, a little can’t hurt, right?)