We investigate neural nets, which form the foundation for moden machine learning algorithms.
https://talk.objc.io/episodes/S01E492-building-a-language-model-neural-nets
We implement tokenization using the byte pair encoding algorithm.
https://talk.objc.io/episodes/S01E491-building-a-language-model-tokenization
We implement n-grams as a first step to better understand language models.
https://talk.objc.io/episodes/S01E490-building-a-language-model-n-grams
We explore a technique to rewrite recursive expressions in order to abstract the recursion in a map function.
https://talk.objc.io/episodes/S01E489-rewriting-recursive-expressions
We review the differences between the different formatting APIs and how they interact with SwiftUI.
https://talk.objc.io/episodes/S01E488-the-formatstyle-api
We use layout values to specify relative widths in our layout and add support for system spacing.
https://talk.objc.io/episodes/S01E487-the-layout-protocol-part-4
We add support for alignment to our custom layout.
https://talk.objc.io/episodes/S01E486-the-layout-protocol-part-3
We make sure that our custom layout distributes the available space evenly and respects layout priorities.
https://talk.objc.io/episodes/S01E485-the-layout-protocol-part-2
We return to a five-year-old layout challenge that we can now solve using the layout protocol.
https://talk.objc.io/episodes/S01E484-the-layout-protocol-part-1
We animate the corner radius of View in combination with a matched geometry effect and learn a lot in the process.
https://talk.objc.io/episodes/S01E483-matched-geometry-and-corner-radius
We replicate our custom matched geometry implementation from an earlier episode using AI and then implement interpolation.
https://talk.objc.io/episodes/S01E482-interpolating-matched-geometry-effect
We use matched geometry effect to revisit an old problem and then give the LLM a shot at solving it.
https://talk.objc.io/episodes/S01E481-matched-geometry-effect-for-positioning-badges
We implement read, write, and bash tools for the agent and have it write and execute a simple Swift program.
https://talk.objc.io/episodes/S01E480-building-a-coding-agent-part-2
We build the basic structure of a coding agent using OpenAI's API.
https://talk.objc.io/episodes/S01E479-building-a-coding-agent-part-1
We clean up the code to make it more efficient and then create a macro to reduce the boilerplate code we have to write.
https://talk.objc.io/episodes/S01E478-solving-the-view-model-problem-part-3
We create a view model protocol and property wrapper to automate updating the view model when new values are passed to the view.
https://talk.objc.io/episodes/S01E477-solving-the-view-model-problem-part-2
We investigate the problem of creating and updating view models in SwiftUI and outline a potential solution.
https://talk.objc.io/episodes/S01E476-solving-the-view-model-problem-part-1
We try an alternative approach using SwiftUI's Grid to lay out the settings form.
https://talk.objc.io/episodes/S01E475-settings-form-layout-part-2
We implement a layout that's typical for setting screens on the Mac in SwiftUI.
https://talk.objc.io/episodes/S01E474-settings-form-layout-part-1
We transform the image into the LPQ colorspace before encoding it to get a better thumbnail with less data.
https://talk.objc.io/episodes/S01E473-thumbhash-part-6
We apply the discrete cosine transform to an RGB image, separating the image into three channels and putting them back together.
https://talk.objc.io/episodes/S01E472-thumbhash-part-5
We apply our 2D discrete cosine transform to image data for the first time.
https://talk.objc.io/episodes/S01E471-thumbhash-part-4
We extend our discrete cosine transform to work in two dimensions to be able to apply it to image data.
https://talk.objc.io/episodes/S01E470-thumbhash-part-3
We finish the one-dimensional discrete cosine transform and use it for some first compression experiments.
https://talk.objc.io/episodes/S01E469-thumbhash-part-2
We begin implementing the ThumbHash algorithm by creating a basic discrete cosine transform.
https://talk.objc.io/episodes/S01E468-thumbhash-part-1
We add a share feature with JSON, text, bitmap image, and PDF representations.
https://talk.objc.io/episodes/S01E467-visual-node-editor-part-9
We clean up the code and transform the project to a document-based app.
https://talk.objc.io/episodes/S01E466-visual-node-editor-part-8
We implement snapping when resizing the width of a node.
https://talk.objc.io/episodes/S01E465-visual-node-editor-part-7
We refactor our view state properties into a single struct to separate our logic from the view code.
https://talk.objc.io/episodes/S01E464-visual-node-editor-part-6
We continue to work on multi-select and make plans of how to simplify our views in the future.
https://talk.objc.io/episodes/S01E463-visual-node-editor-part-5
We introduce multi-select and have to rethink our focus architecture to make this work.
https://talk.objc.io/episodes/S01E462-visual-node-editor-part-4
We make the resize handles of the nodes functional and deal with some tricky boundary conditions in the process.
https://talk.objc.io/episodes/S01E461-visual-node-editor-part-3
We add focus state to the user interface elements of our node editor.
https://talk.objc.io/episodes/S01E460-visual-node-editor-part-2
We start building a visual node editor as a playground to experiment with focus state, selection, and more.
https://talk.objc.io/episodes/S01E459-visual-node-editor-part-1
We add Hummingbird as an HTTP server and implement live reload using WebSockets.
https://talk.objc.io/episodes/S01E458-swiftui-as-static-site-generator-part-6
We use SwiftUI views to automatically generate images within our static site generator.
https://talk.objc.io/episodes/S01E457-swiftui-as-static-site-generator-part-5
We use the environment to add nested templates and integrate the Swim library for easier HTML support.
https://talk.objc.io/episodes/S01E456-swiftui-as-static-site-generator-part-4
We add directory observation and use SwiftUI's preferences to our advantage.
https://talk.objc.io/episodes/S01E455-swiftui-as-static-site-generator-part-3
We use GCD to observe files and automatically regenerate their dependencies.
https://talk.objc.io/episodes/S01E454-swiftui-as-static-site-generator-part-2
We experiment with using SwiftUI's infrastructure to build a static site generator on top of it.
https://talk.objc.io/episodes/S01E453-swiftui-as-static-site-generator-part-1
We display an insertion point for dragging and dropping and use the Transferable protocol to actually perform a drop.
https://talk.objc.io/episodes/S01E452-building-a-token-field-part-5
We use SwiftUI's drag-and-drop APIs to add support for reordering to our token field.
https://talk.objc.io/episodes/S01E451-building-a-token-field-part-4
We add forward and backward deletion with and without an active selection to the token field.
https://talk.objc.io/episodes/S01E450-building-a-token-field-part-3
We work on the keyboard selection behavior of our custom SwiftUI token field.
https://talk.objc.io/episodes/S01E449-building-a-token-field-part-2
We lay the groundwork for a token field built using pure SwiftUI.
https://talk.objc.io/episodes/S01E448-building-a-token-field-part-1
We add gestures to our FaceTime-like screen and make sure that the gesture smoothly transitions to an animation.
https://talk.objc.io/episodes/S01E447-building-a-facetime-like-animation-part-2
We start building an interactive animation similar to the one of the picture-in-picture view in FaceTime.
https://talk.objc.io/episodes/S01E446-building-a-facetime-like-animation-part-1
We introduce priorities and custom sorting by view geometry to our staggered animations.
https://talk.objc.io/episodes/S01E445-staggered-animations-revisited-part-3
We refactor our staggered animations to use SwiftUI's transition protocol.
https://talk.objc.io/episodes/S01E444-staggered-animations-revisited-part-2
We revisit the topic of staggered animations, this time allowing staggering of views in different branches of the view tree.
https://talk.objc.io/episodes/S01E443-staggered-animations-revisited
We implement a custom format style and make it parsable as well.
https://talk.objc.io/episodes/S01E442-custom-format-styles
We explore the various formatting options that SwiftUI's text view provides for dates, numbers, and more.
https://talk.objc.io/episodes/S01E441-text-formatting
We explore the pitfalls of keeping local view state in sync using the date picker component from the last episode.
https://talk.objc.io/episodes/S01E440-keeping-local-view-state-in-sync
We explore different ways to create a binding to an optional value.
https://talk.objc.io/episodes/S01E439-optional-bindings
We implement a padding layout and revisit how we calculate view geometries.
https://talk.objc.io/episodes/S01E438-attribute-graph-part-10
We finish the layout modifier and implement a fixed frame layout on top of it.
https://talk.objc.io/episodes/S01E437-attribute-graph-part-9
We start implementing the View protocol to generate the attribute graph from view values.
https://talk.objc.io/episodes/S01E436-attribute-graph-part-8
We add the layout protocol and implement HStack on top of it.
https://talk.objc.io/episodes/S01E435-attribute-graph-part-7
We extend our attribute graph to compute a display list containing the frames of all views.
https://talk.objc.io/episodes/S01E434-attribute-graph-part-6
We construct the attribute graph for a simple SwiftUI example and step through the updates of the graph in response to changing inputs.
https://talk.objc.io/episodes/S01E433-attribute-graph-part-5
We use Graphviz to visualize the attribute graph and add snapshots to step through the evaluation process.
https://talk.objc.io/episodes/S01E432-attribute-graph-part-4
We make sure to recompute nodes in the graph that are marked dirty.
https://talk.objc.io/episodes/S01E431-attribute-graph-part-3
We automatically add edges in the attribute graph and invalidate edges and nodes when necessary.
https://talk.objc.io/episodes/S01E430-attribute-graph-part-2
We start to work on a reimplementation of SwiftUI's attribute graph.
https://talk.objc.io/episodes/S01E429-attribute-graph-part-1
We abstract all database accesses in a class to avoid switching isolating contexts all the time.
https://talk.objc.io/episodes/S01E428-swift-6-concurrency-part-5
We add a SQLite persistency layer to the project and, once again, run into several concurrency errors.
https://talk.objc.io/episodes/S01E427-swift-6-concurrency-part-4
We refactor the code to take a snapshot of the web view into the common SwiftUI reader pattern.
https://talk.objc.io/episodes/S01E426-swift-6-concurrency-part-3
We add a web view to the project and try two different methods to take a snapshot asynchronously.
https://talk.objc.io/episodes/S01E425-swift-6-concurrency-part-2
We start a new macOS project to explore Swift 6's concurrency features.
https://talk.objc.io/episodes/S01E424-swift-6-concurrency-part-1
We turn the specific spray effect into a generic particle system and add a second effect.
https://talk.objc.io/episodes/S01E423-particle-effects-part-6
We make sure to garbage collect old particles and to pause and resume the timeline view.
https://talk.objc.io/episodes/S01E422-particle-effects-part-5
We combine the canvas-based drawing from last episode with a keyframe timeline to control the particles.
https://talk.objc.io/episodes/S01E421-particle-effects-part-4
We improve the performance of the particle effect by rendering the particles in a canvas view.
https://talk.objc.io/episodes/S01E420-particle-effects-part-3
We make our particle effect more flexible by combining it with a keyframe timeline.
https://talk.objc.io/episodes/S01E419-particle-effects-part-2
We start building a particle effect, using transitions as the first approach.
https://talk.objc.io/episodes/S01E418-particle-effects-part-1
We make our lazy vertical stack implementation more generic to support other kinds of vertical layouts.
https://talk.objc.io/episodes/S01E417-lazy-container-views-part-4
We continue to work on our custom lazy stack implementation and add support for preferred spacing.
https://talk.objc.io/episodes/S01E416-lazy-container-views-part-3
We try to re-implement a lazy vertical stack based off last week's experiments.
https://talk.objc.io/episodes/S01E415-lazy-container-views-part-2
We investigate SwiftUI's new group APIs for building custom lazy container views.
https://talk.objc.io/episodes/S01E414-lazy-container-views-part-1
We finish the bento layout by adding spacing and fixing a crash.
https://talk.objc.io/episodes/S01E413-bento-layout-part-4
We reimplement our bento layout on top of SwiftUI's layout protocol.
https://talk.objc.io/episodes/S01E412-bento-layout-part-3
We use the new Group API to turn our bento view into a custom container.
https://talk.objc.io/episodes/S01E411-bento-layout-part-2
We start implementing a bento layout using two different approaches.
https://talk.objc.io/episodes/S01E410-bento-layout-part-1
We discuss some subtleties around SwiftUI's view updates with regard to environment and preference changes.
https://talk.objc.io/episodes/S01E409-environment-preference-updates
We automatically position the tooltips depending on the available space around the anchor view.
https://talk.objc.io/episodes/S01E408-tooltips-part-2
We implement a custom tooltip API that only shows one tooltip at a time.
https://talk.objc.io/episodes/S01E407-tooltips-part-1
We show how to detect which views in a lazy stack are currently onscreen.
https://talk.objc.io/episodes/S01E406-detecting-visible-cells
We use a custom animation to manually control the progress of animations using a slider.
https://talk.objc.io/episodes/S01E405-debugging-animations
We implement the picker animation from the last episode using three more preference-based techniques.
https://talk.objc.io/episodes/S01E404-picker-animation-part-2
We build a picker with an animated underline using alignment and the matched geometry effect.
https://talk.objc.io/episodes/S01E403-picker-animation-part-1
We implement a wobble animation using a phase animator and the Animatable API.
https://talk.objc.io/episodes/S01E402-wobble-animation
We use anchors and preferences to position the badges on top of all icons.
https://talk.objc.io/episodes/S01E401-positioning-badges-part-2
We implement a badge view that scales with the content and position it using alignment.
https://talk.objc.io/episodes/S01E400-positioning-badges-part-1
We reimplement SwiftUI's default button style to better understand its behavior.
https://talk.objc.io/episodes/S01E399-reimplementing-the-default-button-style
We add the fill content mode to our conditional aspect ratio layout and make sure it can handle nil proposals.
https://talk.objc.io/episodes/S01E398-conditional-aspect-ratio-modifier-part-2
We implement a custom version of SwiftUI's aspectRatio modifier that can be enabled or disabled.
https://talk.objc.io/episodes/S01E397-conditional-aspect-ratio-modifier-part-1
We add the ability to pass annotations, like syntax highlighting information, through the pretty printer.
https://talk.objc.io/episodes/S01E396-pretty-printing-annotations
We continue to work on our pretty printers to indent a Swift parameter list in various ways.
https://talk.objc.io/episodes/S01E395-pretty-printing-indentation
We add a choice operator to our pretty printing library to generate the best output for a given column width.
https://talk.objc.io/episodes/S01E394-pretty-printing-choices
We begin implementing a pretty printing library based on an old Haskell paper.
https://talk.objc.io/episodes/S01E393-pretty-printing-data-structure
Loading more posts...