iOS on Andrew Bancroft

SwiftUI Fundamentals

Mon, 08 Apr 2024 00:00:00 +0000

Developing for iOS is a valuable and in-demand skill, but if you haven’t developed in the Apple world before, it can be surprisingly different.

In this course, SwiftUI Fundamentals, you’ll quickly get up and running using Xcode 15, Swift, and SwiftUI to establish the foundational skills you need to build great user interfaces for iOS.

Resources

SwiftUI Fundamentals

Course Outline

First, you’ll see the tools and learn how to use SwiftUI to create single-screen applications with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to bring your own style to a SwiftUI user interface by customizing its appearance.

Finally, you’ll explore working with data-driven controls and understand navigation options for multi-screen applications.

When you’re finished with this course, you’ll know current best practices, iOS architecture, and the most important ideas you need to feel comfortable bringing your developer skills into the iOS and Apple developer world.

1 - Building Single-view Applications

Topics in this module include…

Version Check: What You Need to Get Started
The Night Watch Scenario
Creating a Single-view App
Understanding the SwiftUI Framework
Creating Xcode Previews
Understanding Views
Combining and Laying out Views
Understanding the SwiftUI Layout System
Aligning and Positioning Views

2 - Customizing UI Appearance

Topics in this module include…

Applying View Modifiers
Developing a SwiftUI Mindset
Using Icons and Symbols
Implementing Custom View Modifiers

3 - Creating Data-driven Lists

Topics in this module include…

Preparing to Work with Lists
Understanding Lists
Creating a List
Controlling a List with Data
Using Loops to Supply Content for Lists
Adding Sections and Headings
Creating Grid Layouts

4 - Building iOS Apps with Multiple Screens

Topics in this module include…

Defining Apps with Multiple Screens
Implementing Navigation Stacks
Adding Navigation to an Existing Project
Extracting Reusable Subviews
Creating a Tabbed Application
Recapping Multi-view Applications

5 - Adding Behavior and Working With Data

Topics in this module include…

Preparing to Add Basic Behavior
Extending the Data Model
Understanding the View Update Cycle in SwiftUI
Adding Basic Behavior
Connecting a Subview to a Parent View’s Data
Using Classes as Data Models
Sharing a Data Model through the SwiftUI Environment
Bringing the Data Model and Behavior to the Night Watch App

6 - Putting It All Together

Topics in this module include…

Applying What You’ve Learned
Integrating the Extended Data Model
Adding the Mark Complete Behavior
Adding a Toolbar and Toggle Control
Implementing Swipe and Move Actions for a List
Resetting the List
Showing an Alert
Adding Images to a SwiftUI Application
Continuing your iOS Developer Journey

iOS 17 Fundamentals

Sun, 10 Dec 2023 00:00:00 +0000

Developing for iOS is a valuable and in-demand skill, but it can be surprisingly different if you haven’t developed for Apple platforms before.

In this course, iOS 17 Fundamentals, you’ll quickly get up and running using Xcode 15, Swift 5, and SwiftUI to build great iOS apps and tap into the latest features of iOS 17.

Resources

iOS 17 Fundamentals

Course Outline

First, you’ll see the tools and learn the core principles for designing iOS apps with adaptive, accessible, and localized user interfaces that work on multiple devices.

Next, you’ll explore how to tackle some of the most common scenarios you’ll run into when you’re building an app for iOS 17, like performing common networking tasks, managing data, adding push notifications to your application, and implementing widgets.

Finally, you’ll learn how to take your app and publish it on the App Store. When you’re finished with this course, you’ll know current best practices, iOS architecture, and the most important ideas you need to feel comfortable bringing your app ideas to iOS 17.

1 - Preparing to Build iOS 17 Applications

Topics in this module include…

Version Check: What You Need to Get Started
How to Learn iOS Development
Introducing “Improvado” - An App for Continuous Improvement
Transitioning an App to iOS 17
Supporting Older Versions of iOS
What Every iOS 17 App Needs

2 - Designing Applications for iOS 17

Topics in this module include…

Introducing Apple’s Human Interface Guidelines
Making an Adaptive User Interface
Adding and Customizing Layout Variations
Supporting Dynamic Type
Implementing Dark Mode
Working with SFSymbols 5
Making Apps Accessible
Localizing an iOS Application

3 - Performing Common Networking Tasks

Topics in this module include…

Understanding URL Sessions
Checking Network Connectivity
Sending HTTP Requests
Requesting Data from REST APIs
Inspecting HTTP Responses
Handling Networking Errors
Organizing Networking Code
Integrating Networking Tasks with SwiftUI

4 - Managing Data

Topics in this module include…

Understanding Data Management Scenarios
Encoding and Decoding Data
Managing Preferences with UserDefaults
Synchronizing Settings with iCloud Key-value Store
Configuring Apps with Property Lists
Performing File Management Tasks

5 - Adding Push Notification Support

Topics in this module include…

Understanding Notification Scenarios
Requesting Permission to Deliver Notifications
Sending Local Notifications
Sidebar: Understanding the Delegation Design Pattern
Responding to Local Notifications
Configuring an Xcode Project for Remote Notifications
Testing Remote Notifications
Making Notifications Actionable
Sending Silent Background Notifications
Setting Up a Remote Notification Server

6 - Implementing Widgets

Topics in this module include…

Adding a Widget to an Xcode Project
Configuring a Widget
Sharing Data between an App and a Widget
Making Widgets Configurable
Creating Interactive Widgets

7 - Publishing to the App Store

Topics in this module include…

Preparing to Publish Your App
Adding an App Icon
Creating an iOS App Launch Screen
Building a Release Version of Your App
Configuring an App in App Store Connect
Submitting an App for Review

Building iOS User Interfaces with SwiftUI

Sun, 22 Aug 2021 00:00:00 +0000

Designing efficient and dynamic apps is essential for taking your iOS developer skills to the next level.

In this course, Building iOS User Interfaces with SwiftUI, you’ll build upon the basic knowledge of iOS development you’ve already gained in order to build compelling iOS apps that engage your users.

Resources

Building iOS User Interfaces with SwiftUI

Course Outline

First, you’ll see the tools and learn how to create iOS apps with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to manage iOS projects and define the building blocks of your own iOS applications.

Finally, you’ll explore working with data-driven controls and understand navigation options.

1 - Designing Interfaces with SwiftUI

In this introductory module, we begin where the iOS Getting Started course left off and prepare you to handle next-level interface building with SwiftUI.

Topics in this module include…

Preparing to Design User Interfaces with SwiftUI
The Snowhaven Renovation Scenario
Defining SwiftUI Views
Creating Basic Designs and Layouts
Representing Data in User Interfaces
Customizing the Appearance of Views
Changing the Size and Scale of Views
Adding Effects to Views
Layering Views with ZStacks
Implementing Navigation and Displaying a Modal View

2 - Handling User Input

There’s no such thing as an app without data. In this module, I set you up for building dynamic, interactive applications by unpacking questions like:

How do we model real-world objects and concepts as data that SwiftUI can work with?
How do we integrate data into an app, so it’s usable in the right views at the right time?
And how do we load data that’s been saved… display it… and, most importantly, for this module…change it using different editing controls with SwiftUI…

Topics in this module include…

Working with Data in SwiftUI
Establishing an App’s Data Flow
Loading and Displaying Data
Editing Text Data with Text Fields
Persisting (or Cancelling) Data Changes
Working with Picker Views
Switching Between Binary Options with Toggles
Editing Numeric Data with Text Fields
Displaying Editing Controls in a Form

3 - Bringing Apps to Life with Drawing, Animation, and Gestures

SwiftUI provides you with all the tools necessary to make your apps even more dynamic by responding to user gestures like taps and swipes… The framework also gives you everything you need to express your creativity by drawing your own graphics, and adding animations throughout your apps to bring things to life.

Topics in this module include…

Understanding the SwiftUI Drawing System
Drawing with Paths
Using GeometryReader
Applying Transformations to Paths
Building Reusable Shapes
Understanding Animations
Adding Basic Animation
Animating View Hierarchy Changes with Transitions
Combining Multiple Animations and Transitions
Responding to Gestures

4 - Integrating SwiftUI and UIKit

By now, you know that SwiftUI is wonderful, but… it’s not the only Apple UI framework used in today’s Apple Developer world. UIKit is still very widely used and even includes some UI components that are not currently available in the SwiftUI framework.

As we wrap up the course, I explore the answer to this question: How can we, as developers, mix SwiftUI and UIKit to leverage the power of both frameworks?

Topics in this module include…

Preparing to Integrate SwiftUI and UIKit
Representing UIKit ViewControllers in SwiftUI
Making SwiftUI Views Compatible with UIKit
Representing UIKit Views in SwiftUI
Sharing State Between SwiftUI and UIKit
Coordinating User Interaction Between UIViewControllers and SwiftUI
Coordinating User Interaction Between UIViews and SwiftUI
Applying the Finishing Touches

Feedback Welcome!

From the beginning my unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

iOS 14 Getting Started

Fri, 04 Dec 2020 00:00:00 +0000

Developing for iOS is a valuable and in-demand skill, but if you haven’t developed in the Apple world before, it can be surprisingly different.

In this course, iOS 14: Getting Started, you’ll quickly get up and running using Xcode 12, Swift 5, and SwiftUI to build great iOS apps and tap into the latest features in iOS 14.

Resources

iOS 14 Getting Started

Course Outline

First, you’ll see the tools and learn how to create iOS apps with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to manage iOS projects and define the building blocks of your own iOS applications.

Finally, you’ll explore working with data-driven controls and understand navigation options.

1 – Preparing to Build iOS Applications

Prepare to implement iOS apps by understanding what’s involved from a big picture standpoint.

We begin at the beginning to bring you up to speed and set the foundation for the remainder of the course.

Topics in this module include…

What You Need for Building iOS Apps
Creating an iOS Project with Xcode
Exploring an iOS Project
How to Learn iOS
The Night Watch Scenario
Working with Xcode Projects
Grasping the Basics of the Xcode Development Environment
Summary

2 - Building Single View Applications

Building single view applications is the starting point for most of us who are learning to build iOS apps because they allow us a simplified architecture that focuses on a single screen performing a single responsibility.

Topics in this module include…

Preparing to Build Single View Apps
Understanding the SwiftUI Framework
Understanding Views
Combining and Laying out Views
Understanding the SwiftUI Layout System
Aligning and Positioning Views
Customizing UI Appearance
Developing a SwiftUI Mindset
Using Icons and Symbols
Managing Views with Groups

3 - Creating Data-driven Lists

Just about any day in which you use an iPhone or iPad for more than a few minutes, you’ll almost certainly end up in an app that uses a List View.

It’s the most common way to show a structured, scrollable series of items, and List Views are a core competency for an iOS developer working in SwiftUI, so it’s the first complex control we dive into.

Topics in this module include…

Preparing to Work with Lists
Understanding Lists
Creating a List
Controlling a List with Data
Using ForEach to Supply List Content
Adding Sections and Headings

4 - Building iOS Apps with Multiple Screens

Here I cover how to create apps multiple screens and how to think about and enable navigation between them.

Topics in this module include…

Defining Apps with Multiple Screens
Implementing Navigation Views
Adding Navigation to an Existing Project
Extracting Reusable Subviews
Creating a Tabbed Application
Recapping Multi-view Applications

5 - Adding Behavior and Working With Data

The thing that makes an app come alive is the behavior we add, and the dynamic responses to that behavior that get reflected in the user interface.

In any application, a user interface has one critical job: to accurately represent the data of our application in what it displays on the screen.

In SwiftUI, data and behavior go hand-in-hand, and I cover how to respond to user interaction in this module.

Topics in this module include…

Preparing to Add Basic Behavior
Extending the Data Model
Understanding the View Update Cycle in SwiftUI
Adding Basic Behavior
Connecting a Subview to a Parent View’s Data
Using Classes as Data Models
Sharing a Data Model through the SwiftUI Environment
Bringing the Data Model and Behavior to the Night Watch App

6 - Putting It All Together

There’s nothing like practicing your skills in new contexts to refine them and solidify what you’ve learned.

We go into some additional controls and techniques for building apps with SwiftUI before concluding the course.

Topics in this module include…

Applying What You’ve Learned
Integrating the Extended Data Model
Adding the Mark Complete Behavior
Adding a Toolbar and Toggle Control
Implementing Swipe and Move Actions for a List
Resetting the List
Showing an Alert
Creating an Adaptive UI
Adding and Customizing Layout Variations
Getting Ready for the App Store

7 - Publishing to the App Store

Finishing an app and getting it out the door to your users is one of the best feelings in the world.

Beyond the emotional aspect of publishing an app though, more and more employers want to see job candidates who have published at least one app to the App Store.

So in this final module, I complete the journey by setting you up to get an app into the App Store and bolster your resume!

Topics in this module include…

Preparing to Publish Your App
Adding Images and App Icons
Responding to Dark Mode
Creating an iOS App Launch Screen
Submitting an App for Review
Continuing Your iOS Developer Journey

Feedback Welcome!

From the beginning my unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

Implementing In-App Purchases on iOS

Tue, 09 Jun 2020 10:03:33 +0000

Monetizing apps is challenging. In this course, Implementing In-App Purchases on iOS, you’ll learn to offer digital products and services directly within your app as in-app purchases.

Resources

Implementing In-App Purchases on iOS

Course Outline

First, you’ll explore how to translate business requirements into digital products and configure them in App Store Connect and Xcode.

Next, you’ll discover how to build and test a store within your app using StoreKit.

Finally, you’ll learn how to make sure purchases made within your app are authentic, and unlock content that’s been purchased by your users.

When you’re finished with this course, you’ll have the skills and knowledge needed to implement in-app purchases on iOS!

1 – Preparing to Implement In-App Purchases

Prepare to implement in-app purchases by understanding what’s involved from a big picture standpoint.

You will learn to configure digital products in App Store Connect and Xcode to kick off your in-app purchase learning adventure.

Topics in this module include…

The Perks (And the Work) Ahead of You
First Things First - Checking off the Prerequisites
Matching Product Types to Business Requirements
Setting Up Products in App Store Connect
Setting Up an Auto-Renewable Subscription
Configuring an Xcode Project for In-App Purchases

2 – Building In-App Purchase Functionality with StoreKit

The focus of this module is on the StoreKit APIs for working with digital products and App Store Connect.

You will learn to build and test a fully-working store view that will support in-app purchases.

Topics in this module include…

Using StoreKit to Build In-App Purchase Functionality: A Roadmap
Retrieving a Set of Products for Purchase from the App Store
Displaying Products in a User Interface
Implementing a “Buy” Button
Preparing to Test Purchases by Setting up a Sandbox Tester Account
Making Test Purchases
Implementing a “Restore Purchases” Button

3 – Protecting Your Revenue by Verifying Purchase Authenticity

After all your hard work to implement in-app purchases, how awful would it be if malicious users stole the content you’ve labored to create?

In this module, you will learn to implement measures to protect revenue generated through in-app purchases by validating App Store receipts.

Receipt validation is a notoriously burdensome hassle. But it doesn’t have to be!

I will teach you how to implement server-side receipt validation from end-to-end with no third-party libraries, no complicated server setup, and no platform-specific proprietary tools.

Here’s the roadmap of topics incluced:

Verifying Purchase Authenticity by Validating App Store Receipts
Weighing Strategies for Receipt Validation
Charting the Course for Server-side Receipt Validation
Sending the Receipt from Your App to Your Server
Writing Server-side Code to Forward the Receipt to the App Store for Validation
Handling the Response from the App Store on Your Server
Accounting for the Sandbox Environment on Your Server
Handling the Response from Your Server in Your App
The Case of the Missing Receipt: Requesting a Refresh

4 – Unlocking Purchased Content

After a user makes a valid purchase, you’ve got to unlock the content they legitimately bought!

Each product type has its own nuances for how to unlock and provide the associated content though.

What do you need to think about, and what code do you need to write to make it happen?

To find out, you will explore these topics:

Analyzing Content-providing Logic by Product Type
Persisting Purchased Products Securely
Using the iOS Keychain
Keeping Track of Consumable Product Inventory
Managing Non-Renewing Subscriptions
Synchronizing Purchases Across Devices
Handling Auto-Renewable Subscriptions
Saving Non-Consumable Transactions
Preparing for App Store Review

Feedback Welcome!

From the beginning I set out to make the course I wish I had when I started learning to implement in-app purchases for my apps. My unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

iOS Debugging Fundamentals

Thu, 26 Dec 2019 10:03:33 +0000

Bugs are bound to happen. Getting rid of them is an essential skill if you want to keep your sanity when building apps.

In this course, you will learn a set of thinking skills to couple with the fundamental tools that Xcode provides you for finding and fixing flaws in your apps.

🐞1.5 hours 🦟To the point 🐛Engaging storyline 🐜Relevant demos

Resources

iOS Debugging Fundamentals

Course Outline

First, you will learn to approach debugging situations with a set of principles for strategic problem solving.

Next, you will discover how to configure breakpoints and inspect view hierarchies effectively.

Finally, you will explore how to interpret a backtrace, glean valuable information from the Xcode debug area and console, locate changes in your codebase and simulate conditions that happen in the wild.

When you are finished with this course, you will have the skills and knowledge to strategically and methodically reason about probable causes of defects that you experience at runtime.

1 – Debugging as Strategic Problem Solving

Debugging means a lot of things to a lot of people.

In this module, I will define the scope of debugging for you so that you’re clear on the skills you’ll walk away from this course with.

You will begin to develop a problem solving mentality and learn a useful mnemonic for R.E.P.A.I.R.-ing broken apps.

Learn how to categorize bugs into buckets for strategic resolution.

Explore some of the most common sources of bugs to complete this module.

2 – Correcting Unmet Expectations

Probabilistic thinking is the key component of a debugging mindset.

Topics in this module include…

Pausing an App to Gather Clues With Breakpoints
Combining Problem Solving with Xcode Tools
Managing Your Project’s Breakpoints
Controlling Breakpoints by Defining Trigger Conditions
Executing Actions When Breakpoints Are Triggered
Inspecting User Interface Issues

3 – Addressing App Crashes

When an app crashes, it’s because of a critical problem that can’t be recovered from.

In this module you will work on the following:

Understanding Exceptional Issues
Inspecting the Crash Scene with the Backtrace and Console Output
Pausing before Errors and Exceptions Cause Crashes
Avoiding Errors that Cause Crashes

4 – Alleviating Anomalies

Have you ever found yourself saying, “Something weird is going on” or “It used to work - what’s going on now??”

Have you ever experienced one of those “intermittent” bugs that seem to present themselves rarely or inconsistently and are hard to even reproduce?

Anomalous bugs can feel like they occur “out of nowhere”… but do they?

To find out, you will explore these topics:

Reasoning About Anomalous Bugs
Inspecting App Changes
Simulating Real-World Conditions With Xcode

Feedback Welcome!

My unwavering goal is to help you filter the noise and learn as efficiently as possible.

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

iOS Data Persistence: The Big Picture

Tue, 30 Apr 2019 10:03:33 +0000

We’ve all been there. Do a search on the topic of “saving data in iOS” and you’ll get dozens of search results mentioning at least six different frameworks and platforms, and a month’s worth of reading.

Wouldn’t it be nice to distill the possibilities down into just what you need in order to start down a path for persisting data in your app?

“iOS Data Persistence: The Big Picture” will be worth the hour of your time.

Resources

iOS Data Persistence: The Big Picture

Course Outline

During this one hour course, you will learn the reasons for saving data to help ground you as you begin to traverse the data persistence landscape.

You will discover how to use technologies like User Defaults and Property Lists, and I will guide you on how to work with Swift’s Encodable and Decodable protocols.

You will understand what you’re getting into if you choose to work with SQLite, Core Data, or Realm Database for local data persistence.

You will know how it feels to reach for a remote data storage option like CloudKit, Realm Platform, or Firebase.

Finally, you will see a clear picture of what it’s like to design a document-based application and integrate your app’s data with the iOS Files app.

When you’re finished with this course, you will have the skills and knowledge you need to make an informed decision about putting a reliable data storage plan for your iOS app into action.

1 – Establishing the Data Persistence Landscape

During the course, you will have the opportunity to experience a variety of data persistence scenarios and technologies.

You’ll get general feel for setup requirements and a taste of what it’s like to work with each solution in code.

To start you off on the right footing, this module will establish the data persistence possibilities and focus in on the reasons for saving data so that you’re persisting with a purpose.
You will be introduced to a player profile matrix to help you analyze your data persistence options from a number of angles.
Finally, you will get the feel for working with the Swift Encodable and Decodable protocols.

2 – Saving Settings and Configuration

Users are picky, aren’t they? Everybody has preferences though, so it’s no wonder that you as a developer are often tasked with letting your users to customize their experience within your app.

You will learn how to manage user preferences with the UserDefaults system that’s built in to iOS
Next, you will explore synchronizing settings with iCloud Key-Value Store
Finally, you will understand how to ship configuration for your app with Property Lists that are included in your application bundle

4 – Saving Objects and Object Graphs

What if you only wanted to load a subset of the data into memory instead of being locked in to an all-or-nothing situation with UserDefaults or Property Lists?

What if you needed to save a more complex data model that includes relationships?

For that, you’ll need to know about saving and sharing objects and object graphs…

Six Technologies/Frameworks will be featured in this module:

SQLite
Core Data
Realm Database
CloudKit
Realm Platform
Firebase

The goal is to help you answer two questions:

“What am I getting myself into if I pick one persistence technology over another?”
“How does it feel to work with this persistence technology in code?”

You will answer these questions by…

Scanning the arena of persistence options and explore what sets these technologies apart from UserDefaults and Property Lists.
Surveying the setup process to see what it takes to get up and running with each technology in the list
Exploring the data modeling process to wrap your head around what the data structure design process is like for each technology in the list
Getting the feel for working with data so that you understand what it’s like to create objects, update them, delete them, query and filter them, and watch for data changes so that you can update your user interface appropriately

5 – Saving Data as Documents and Files

What if you need to encapsulate chunks of content together and save it all as a packaged up file…as a single unit with a custom file extension?

For that, you need to know about saving data as documents and files.

You will explore the use-case for building a “document-based application”
Next you will walk through designing a document as a subclass of UIDocument
You will learn to create and load documents from a Document Browser
Customizing your app’s file extension is a key step that you will work through
You will spend some time understanding how to interact with document data in code as users interact with the user interface
Finally, you will answer the question, “How do I get my app’s files to show up in the iOS Files app?”

Feedback Welcome!

My goal is to help you filter the noise… to help you distill an overwhelming amount of information down into the big picture possibilities so that you’re on a trajectory for being able to make an informed decision about putting a reliable data storage plan for your iOS app into action.

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

Journey in iOS Development Series – In the Beginning…

Sat, 16 Mar 2013 19:51:59 +0000

Today I’m starting a series related to my journey in learning to develop iOS apps. As lightbulbs come on for me, I plan to write up what I’m learning, if nothing else for my own reference. But I do hope my readers enjoy the discoveries I make along the way.

These first few blogs will be somewhat autobiographical, so hopefully I don’t bore you to death. I’ll try and make them quick. More technical stuff will appear very soon. I thought to write a short article about how I got started. If I had an “In the beginning…” moment, what would that be?

The Early Days

It seems like just yesterday I was a little boy visiting my Grandpa’s house in Lawton, OK, eager to play on Grandpa’s computer. Computers in the early 90’s were still not quite the commodity they are in 2013. We didn’t own one yet, but Grandpa did.

If I had to point to an “In the beginning…” stage, it’d be the times when Grandpa sat down with me and taught me about computers. Not just games (although I did enjoy Submarine and Wheel of Fortune for DOS a lot) – he taught me the basics of how to instruct a computer. He taught me to program. He was a Master of DOS and a QBasic Guru. If I had to guess, he still prefers elements of both today. :]

He is, quite simply, an amazing man. He is now a retired entrepreneur, but when he was running his music store there were always those “things that needed to be done”. He viewed the “gotta do it’s” as an opportunity to automate by programming a computer to do it for __him, rather than do it by hand. He’s showed me how he programmed apps to produce his financial statements, track his budget, print invoices, and all kinds of other “by hand” stuff that he was able to make “automagically” with a computer. It was (and still is) fascinating to me.

In addition to those early years of influence, I’ve learned from Grandpa that even though “there’s an app for that” already, it doesn’t mean it’ll work for you how you want it to work. Grandpa could be happy with 99% of an app’s functionality, but there’d always be that one thing that bugged him. What did he do? He wrote his own. He made it work how he wanted it to work. He may not have been inventing a new wheel every time, but because he could program, he could improve the existing wheel to his liking.

All of this has served to motivate me in my pursuit of programming in general. I love my Grandpa. My Grandpa loves computers. The little kid inside of me is yelling, “Me too! Me too!” to this day.

My Grandpa just turned 81 and he still loves the computing world. It’s been great fun to watch him use his latest computer: his iPhone. It’s been even more fun to show him the little apps I’m making as I learn to program for iOS.

Next up will be a post on how I’ve approached learning to program for iOS. What’s my strategy and how is it going so far? See you again soon with all that and more.