• Introduction
• How We Got Here
• Inside the New Wishlist
• What's Next?
• Thanks for following along

Introduction

Today I'm excited to share the final blog post on my Apple wishlist—because it now has a permanent home! I've launched a living, breathing site at https://apple.lukezilioli.com/wishlist/ that combines all of my past wishlist posts with a dynamic interface for new ideas and tips.

How We Got Here

Over the years, I've tinkered with long form wish lists:

• My iOS 15 and macOS 12 Wish List
• Top iOS 15 Feature Wishlist
• iOS 17 App Library Concept

Each of these posts captured ideas for iOS, iPadOS, macOS, watchOS and beyond. But maintaining separate blog posts was a pain—updating them when Apple implemented features, keeping track of what I'd already suggested, and organizing everything coherently. That's why I never made it an annual thing like I originally planned. Now they're all under one roof, categorized by platform and feature.

Inside the New Wishlist

On the new site you can:

• Browse requests by platform (iPhone, iPad, Mac, Watch, etc.)
• Search or filter by keyword and status
• Submit your own ideas for Apple to consider

I've replicated every suggestion from my old posts, and you'll notice some new surprises too. It's my one-stop hub for everything Apple-feature-related.

What's Next?

Now that the wishlist site is live, I'll continue adding new ideas over time.

Thanks for following along

This is something I've wanted to do for years, and I finally got around to it. Head over to https://apple.lukezilioli.com/wishlist/ and let me know which of my ideas you would love to see Apple work on.

• AI Function Calling: an Introduction
  • What is function calling?
• AI's Biggest Strength
• Post Overview
• The Approach
  • Clever Prompting and System Message
  • My Approach vs. Function Calling Paradigm
    • Expanded Function Calling Example
    • Sample Task: Fetch Weather Conditions and Notify My iPhone
  • Pseudocode for the Runner
    • Pros and Cons
  • Future with Tool Calling

This post is from my drafts. I wrote the bulk of this post in June 2024, but am now getting around to publishing it.

AI Function Calling: an Introduction

OpenAI made a significant leap in AI capabilities when they introduced function calling on June 13, 2023.

I can't pinpoint my first exposure to AI function calling, but it was either: AutoGPT, which I discovered & played with as soon as I saw this post on hackernews in April 2023, or TypingMind, which added official support for plugins (which uses function calling) on June 26, 2023. TypingMind had unofficial support for plugins before that, and I suspect I first saw it while poking around TypingMind settings.

What is function calling?

Function calling allows developers to connect AI models like GPT directly with tools and APIs through a clearly defined JSON schema. Refer to OpenAI's function calling docs for a deeper understanding. In short, its like teaching an AI to know when to fetch data or perform an action, and letting the AI tell the developer's code to perform the action and with what parameters.

What this means in layman's terms is that developers can now define tasks—like fetching weather data or sending an email—and have the AI determine when to call those tasks and how to do it smartly. Instead of having the AI just give you information, it can now take action on your behalf.

Function calling opens the door for AI models to interface hands-on with external systems by understanding input as actions. For instance, an AI could automatically convert, “Email Luke to see if he wants to get coffee next Friday” into an actionable function call like send_email(to: string, body: string). Similarly, a question like “What’s the weather like in Boston?” becomes get_current_weather(location: string, unit: 'celsius' | 'fahrenheit').

AI's Biggest Strength

Function calling is the perfect use for AI. Remember that GPT stands for "generative predictive text" and LLM stands for "large language model". The key is in the names: AI is good at language!

Function calling... that is–taking natural language input like "find my favorite contacts and send them an email inviting them over for dinner Friday night" and converting it into a series of steps that a machine can take to achieve this goal–leans heavily on AI's greatest strength–taking natural language and "understanding" how to translate it into a machine-readable language.

Post Overview

Once I became privy to function calling in early 2023, I baked support for it into my Shortcuts Toolbox Project by adding a new /ai/perform/?task= endpoint.

Because OpenAI hadn't yet added function calling to their API, I had to get clever and achieve the same thing with some clever system prompting.

Now in June 2024, I am rewriting that code to integrate the function calling API. I figured I'd write a post explaining my previous approach before I delete that code forever.

The Approach

My approach was inspired by TypingMind. In the early days of TypingMind, you could see the full system prompt, and while inspecting it, I noticed that it contained instructions saying something like "if you want to use the search tool, respond with json: {search: string} containing your query". A lightbulb immediately went off in my head. This was brilliant!

Clever Prompting and System Message

The system message I crafted for Shortcuts Toolbox:

The user will tell you what goal they wish to achieve, and optionally, the context in which you are to respond.
Pay special attention to the context when constructing the plan, and make sure that the final output will adhere
to the desired context. E.g. if the user asks for an html webpage, and you ask GPT for it, make sure to tell GPT
that it should respond with html, and nothing extra. Sometimes the context will mention an existing User Tool.
If this is the case, you should use that tool and send it what would otherwise be your final output.
If the response is unspecified, use your best judgement. A text response is usually most appropriate.

If the user asks you to access their data, do not hallucinate or make up data.
If you are unable to fetch the data using the tools, state as such in your response.
If you defer to GPT, relay the message to not halluicate or make up data to GPT so that
it can provide a more appropriate response.

YOUR JOB
Return a list of steps that can be run, in sequence to piece together the available
tools to accomplish the user's goal.

At the bottom of this message is a list of User Tools that are available to you.
Your response (the steps) will be passed to a runner that executes the tools in
sequence and with the inputs that you specify.
The runner's code is below. Follow the RunnerSpecification format in your response.

STICK TO THIS SPEC:

${runnerContents}

Special Tools:
HANDLEBARS_RENDERER
Description:
This is a special tool that we ALWAYS run when processing the input and output properties.
Rules:
1. This does not exist as its own tool, it is automatically applied to all inputs and outputs, refer to the processInput implementation for a deep understanding of how the input and output properties are processed
2. When processing the input for a tool, or the output for the spec, its value may be a string or an object. For an object, we will recursively render each string as a handlebars template.
3. In a lot of cases, if a shortcut returns JSON, and the user wants you to use GPT to summarize the results, you do not need to map the response before passing it to GPT, you can simply pass along the json response from the previous step.
4. If you need to combine JSON from two actions, or pass a response as json, you can do so using a handlebars template.
   e.g. step 1: fetchWeather step2: fetchCalendar output: \`{"weather": {{{json fetchWeather}}}, "calendar": {{{json fetchCalendar}}}}\`
5. Generally, use {{{data}}} instead of two {{data}}. We want double quotes as double quotes, not " etc.
6. If a tool outputs JSON and you want to pass it as input or output, you MUST do so via the handlebars json helper e.g.: {{{json fetchWeather}}}
ALWAYS REMEMBER THE ABOVE RULE
If your goal is to send a notification and return the response:
INCORRECT APPROACH, DO NOT DO THIS
  step 1: sendNotification
  output: '{{sendNotification}}'
CORRECT APPROACH
  step 1: sendNotification
  output: {{{json sendNotification}}}
Input:
This tool will always render a steps input as a handlebars template.
The context for the template will be {[stepID]: <output from step with id stepID>}.
Handlebars helpers:
  There is only a single handlebars helper. You can use if, etc. but you can compare using eq. etc. handlebars only lets you check for truthiness.
  - \`json\` - which render data directly as json in the results
    Example usage: {{{json weatherConditions}}} or {{#each weatherConditions.daily}}{{{json this}}}{{/each}}
Output:
The resulting rendered template–either a string or a JSON object
The runner will attempt to parse the results as JSON, and if successful, will pass the resulting object, instead of a string, to the step's input.
---
ASK_GPT
Description:
Another special tool that queries GPT with the given prompt.
Input:
  object of format { system: string, user: string, jsonMode?: boolean }
  // jsonmode defaults to false, USE THIS IF YOU WANT JSON FROM GPT
Output: The AI assistant's response
---
User Tools:
${toolSummary}

Tips and Tricks:
The tool summary is passed along when running ASK_GPT. If you need it to configure inputs for tool for you, use JSON mode and reference the tool by name.
e.g. if you need it to configure a notification for you, tell GPT to configure a notification for <notification tool name> about: blah

This guidance ensures the AI grasps user goals in context, converting them into actionable plans.

Note that for the ${runnerContents}, I inserted the contents of the typescript file that I created which runs the spec that the AI returns. This file contains the explicit type definitions and code for the runner, and gives GPT an intimate understanding of what my code will do with its output.

My Approach vs. Function Calling Paradigm

What's interesting is how my solution deviates from the function calling approach:

• Function Calling API: You make an API call to trigger a function call, execute it, make another call to GPT, and iterate until the AI determines it's done.
• My Method: The entire plan is laid out up front, then each step is executed in sequence. This ensures everything stays on track and everything's tight from the start, allowing fluid task handling and adaptability.

Expanded Function Calling Example

Sample Task: Fetch Weather Conditions and Notify My iPhone

Let's dive into a detailed look at how everything functions together with this expanded example:

Goal: Get the current weather and alert the iPhone.

Tool Descriptions:

• FetchWeather: Retrieves weather data for a designated locale.
• SendNotification: Alerts a selected device, such as an iPhone.

After passing the above to GPT with the system prompt, it might come up with the following plan:

• Plan:
  1. Use FetchWeather to grab the latest weather conditions.
  2. Use SendNotification to ping the iPhone with a weather update.

Plan as JSON:

{
  "goal": "Fetch Weather Conditions and Notify My iPhone",
  "steps": [
    {
      "id": "step1",
      "tool": "FetchWeather",
      "input": {
        "location": "New York"
      }
    },
    {
      "id": "step2",
      "tool": "SendNotification",
      "input": {
        "device": "iPhone",
        "message": "The current weather in New York is {{step1.weatherDescription}} with a temperature of {{step1.temperature}}."
      }
    }
  ],
  "output": "{{step2}}"
}

Pseudocode for the Runner

Here's a simplified version of the pseudocode for driving this method, connecting planned steps with execution:

function runner(spec) {
    initialize context = {};
    for each step in spec.steps do {
        processInputForStep();
        if step.tool is 'ASK_GPT' then {
            response = queryGPT(step.processedInput);
            context[step.id] = response;
        } else {
            // Mock tool execution without a formal API call
            context[step.id] = executeTool(step.tool, step.processedInput);
        }
    }
    return processOutput(spec.output, context);
}

Pros and Cons

Pro: Fewer calls to ChatGPT = lower costs. My approach uses a single call to Chat GPT to create the plan and then executes that plan. The plan can make additional calls to GPT, but for most requests will only do so once or twice. These calls are not used to revise the plan, just to get a response for a given step.

Con: The plan isn't always good. With my approach, the AI has one chance to come up with a plan, and no opportunity to modify that plan once it is set in motion. Sometimes it gets it wrong, and the whole task fails.

Con: Verbose system prompts. As you can see in the system message, I had to do a lot of coaching to get this right. Since GPT's official function calling support means the model was explicitly trained to understand functions, your system prompt can be much cleaner if you use the official API.

Con: Sometimes, but not every time, Open AI keeps flagging my prompts

Task: Build a pretty, responsive webpage containing... my tasks from things on a chartjs scatter plot plotted by impact vs effort you will need to determine impact and effort yyourself before plotting please list tasks under the chart Don't forget to use tools to fetch the relevant data

Context: stylized html webpage

Response:

BadRequestError: 400 Invalid prompt: your prompt was flagged as potentially violating our usage policy. Please try again with a different prompt: https://platform.openai.com/docs/guides/reasoning#advice-on-prompting

Future with Tool Calling

Though this method relied on clever system prompting, function calling is the future of AI agent software.

I'm eager to transition and grow alongside these emerging possibilities.

Thanks for reading! Hopefully you learned something new about building software with AI.

Note to Redditors: After I posted this on /r/travel, the moderators banned me. I haven't been able to respond to comments, or make posts in that subreddit.

Please open a Github Issue here if you are having issues. I am happy to help you resolve it.

TripCase, the trip tracking app that I have been using for over 10 years announced that they are shutting down on 2025-04-01.

Per chance, just a couple of months ago, I spent the time to figure out how to export my data from TripCase data so that I could import it into Flighty.

Because of the shutdown, I decided to share this code (even though it's quick and dirty) on GitHub for others to use.

Find my TripCase repo here. This code pulls all data from TrioCase and writes flights to an ics file, and other data to a json file for safe keeping.

Hopefully this helps some folks out there! Please do not feel obligated, but if you wish to show support, you can buy me a Coffee.

With iOS 18.2 beta 3, Apple introduced a new setting. In Settings > Display & Brightness > Camera Control > Require Screen On. If you disable this setting, the camera control will behave consistently regardless of if your screen is locked or not.

I've changed my settings to single click, and let's hope I can update my muscle memory.

You Should Switch Your iPhone 16 Camera Control to Launch the Camera With a Double Click

Hey there, iPhone 16 users! Today, I've got a tip that’s going to save you a lot of frustration. So, you got your shiny new iPhone 16 and started playing around with that fancy new Camera Control button, right? But here’s something I’ve noticed after some hands-on experience – you might want to consider changing the button’s setting to launch the camera from a single click to a double click setting.

Why the Default Single-Click Setting is a Mess

Alright, here’s the deal. When your iPhone 16's screen is locked or dimmed (requires a tap or a raise to wake), the Camera Control button behaves inconsistently compared to when the screen is awake. Let me break it down:

• Locked/Dimmed Screen: The first click wakes the phone, and the second click actually launches the camera. So yeah, you end up needing to chick twice, despite the setting being "Single Click"
• Awake Screen: Only one click is needed to launch the camera, and a second click takes a picture.

Imagine thinking you’re about to capture a quick moment, but you end up just waking the phone. By the time you realize you need a second click… the moment’s gone. Brutal, right?

Why Double Click Setting is the Way to Go

Switching to a double click setting creates much-needed predictability. Whether your screen is awake or asleep, you’ll always perform the same action—a double click—to launch the camera. No surprises, no missed moments.

You know, I can't help but think about how the Apple under Steve Jobs would have meticulously thought through this kind of user experience nuance. It disappointing to see such an oversight in UX from a brand I look up to, as a UI engineer myself. But hey, improvements can still be made (though after everyone builds up their muscle memory is too late)! In the meantime...

Here's how to make the switch:

1. Open Settings: Dive into the Settings app on your iPhone.
2. Navigate to Camera Settings: Scroll and find the Camera section.
3. Change Button Behavior: Find the Camera Control Button settings and switch from Single Click to Double Click.
4. Test It Out: Lock your phone and give it a whirl. Enjoy that sweet, sweet consistency.

By doing this, you’re set for a more predictable and reliable photography experience with the iPhone 16.

Happy snapping! 📸

Apple’s high-yield savings account reportedly drew $1 billion in deposits in just four days

Luke's take: Apple doing big numbers, as always. I’m one of them.

Introducing storage on Vercel – Vercel

Luke's take: This is like the total opposite of "separation of concerns". But I'm not mad at it. Seems like it might be a quick way to spin up an app.

Uber Eats delivering order tracking on iPhone with Live Activities and Dynamic Island

Luke's take: I'm a huge fan of dynamic island. I use it for flights, sports, maps, music, shortcuts. It's great! I love seeing it come to more and more third party applications.

Apple, Google propose ‘unwanted tracking’ standard ↦

Luke's take: This is cool. Tile was never gonna step up and address this problem on its own.

Did You Know That the Option Key…

Luke's take: This is a good thing for Mac users to browse through the option key is an unsung hero on Mac.

Google's 'Godfather of AI' is afraid of the dangers that AI poses to humanity

Luke's take: More AI headlines. Where is it headed?

Apple Bank: Ten years on, the idea seems a lot less out-there

Luke's take: As a big Apple fan, I love thinking about possibilities like this. Anticompetitive nightmares aside.

farizrahman4u/loopgpt: Modular Auto-GPT Framework

Luke's take: Looks to be a bit more user friendly than autogpt. Might be worth playing with.

Urbit

Luke's take: Nobody said Web 2.0 NEEDED to be centralized, but aws and other companies popularized that paradigm. I love to see projects that attempt to shift that status quo.

Let’s talk about subscription pricing for Logic and Final Cut Pro for iPad

Luke's take: The subscription pricing model here is a shame.

This Week, I dive into the rapid rise of AI in various industries and the potential for user fatigue. How will the music industry and AI advancements change the human aspect of music creation? As AI becomes more prevalent, what does that mean for equality of access? I ponder the implications of Apple shutting down online services for older software, and I put AutoGPT to the test. Join me as we explore these captivating stories and more.

The music industry wants Apple Music & Spotify to block AI music training

Luke's take: AI Drake briefly topped the charts. Will companies like UMG circumvent artists altogether, or work to preserve the human aspect of music? So far UMG is taking Artist's side, but will that only last until they get ahold of their own AI Drake?

Snapchat users are furious over recent My AI update, flooding the App Store with 1-star reviews

Luke's take: AI is everywhere. Users will quickly grow accustomed to it.

Survey says 80% of Mac developers will integrate ChatGPT soon

Luke's take: More proof of the impending AI Fatigue

The ubiquity of generative text AI is going to come very fast, so unless software companies find novel and truly valuable ways to integrate it with their products, it may not be a strong product selling point due to AI fatigue

AutoGPT: Automating GPT Model for Natural Language Generation

Luke's take: I played with this for a few days. It's definitely got a ton of potential. In its current state it's more of a proof of concept. Lots of the YouTube videos are click bait and don't actually achieve anything. (See below)

AutoGPT just OBLITERATED all Traders

Luke's take: My ass! Total click bait! At the end his AutoGPT is stuck in a loop doing nothing of value. Good tutorial to get up and running, though. Props to the YouTuber.

GitHub Next

Luke's take: All the hating on AI I've been doing in this post, it's very useful in my day to day as well. I can't deny that. I'm excited for these features from GitHub.

A developer exploited an API flaw to provide free access to GPT-4 | TechCrunch

Luke's take: The importance of universal access to AI cannot be emphasized enough. gpt-4 is an excellent AI model that everyone should have access to at minimal cost. Those without access will be less efficient than those with, making it an equality issue.

Apple to shut down its online services for some older software

Luke's take: This sucks! First they killed 32 bit apps, now they're killing the server that provides old iPhones access to them. I hope you have your old games on an old iOS device, they won't be accessible soon. Maybe worth money one day. Apple is making the early days of the App Store that made the iPhone so dear to many a thing of the past.

My approach involves incorporating Git repositories to streamline the sharing and distribution process of shortcuts and their dependencies. This simplifies the process and makes it more efficient for both developers and users alike.

Sharing a complex shortcut often requires other subsidiary shortcuts to provide functionality building blocks. This reliance on dependencies can make sharing updates quite cumbersome, as clicking multiple iCloud links becomes necessary to install the updated shortcut and its dependencies.

This is where my SC Pllr ⬇️ (Shortcut Puller) solution comes in, offering a seamless and accessible solution to this problem. Upon running the shortcut, it quickly prompts for a Git repository URL and installs all the shortcuts present within the repository.

To make this process possible, I utilized a shortcuts technique for extracting shortcuts as JSON and XML, generously shared by Federico from MacStories. This allows for more straightforward PR reviews and collaboration by allowing users to store shortcuts in repositories. I also used the excellent Working Copy app, a Git client designed for iOS devices.

Please feel free to navigate my GitHub repository, download the shortcuts by installing and running the SC Pllr ⬇️ shortcut, and check out the README in the repository for a comprehensive overview of the shortcuts and their functionalities.

By adopting these iOS Util Shortcuts, we can revolutionize the way we develop, share, and work collaboratively on Apple Shortcuts – taking automation capabilities to new heights. I hope that my solution inspires you and future developers to reimagine how creative automations are shared.

Enjoy your shortcutting!

This idea was TOO cute not to share, so I asked Jordan if we would be willing to write a guest post about it. Read it below.

Red Light, Green Light

I’m pretty new to both programming, and parenting. Although I don’t have any life hacks to make potty training a breeze, I do have one that can turn your HomeKit enabled smart bulbs into a fun game of “Red Light Green Light” for you and your littles to enjoy.

All you need is an iOS device with the HomeKit and Shortcuts apps. You’ll also need a HomeKit compatible color changing-bulb. I’m using Phillips Hues and the MSL450 from Meross, but any compatible color-changing bulb will work fine.

Next, setup 2 scenes in HomeKit. The first scene will change your light bulbs red. Simply select the desired bulbs, set their desired brightness and save. Do the same thing for the color green.

Next, add this shortcut to your Shortcuts app and click the 3 dots on the upper right hand corner of the tile to get into the settings. Once insIde you‘ll need to change a few things to ensure your shortcut functions properly. See where Siri says “Red light”? Well right under that your HomeKit app will need to run the scene that turns your lights red. Lock that setting in and then do the same for your scene that turns your lights green after Siri says “Green light.” You can modify Siri’s speaking prompts by selecting the text you’d like to change. I’d recommend some kind of sign off so that everyone knows the game has ended and the lights are going back to normal.

Download the Shortcut: Red Light Green Light Game

And that’s it! Have fun playing along with your littles!

Keep following for more ways to integrate iOS into your home address.

Jordan Webb Husband/Father Correspondent

Update 2025: This concept is now part of my live wishlist at apple.lukezilioli.com/wishlist. Check out my blog post about Apple Wishlist Website is Live for more details and all my latest Apple requests.

iOS 14 introduced the App Library, a new page on the far right side of the iPhone Home Screen. If you are like the vast majority of my friends and family, you have no idea what the App Library is.

From Apple's support page on App Library:

From your Home Screen, swipe left until you see the App Library. Your apps are automatically sorted into categories. For example, you might see your social media apps under a Social category. The apps that you use most frequently will automatically reorder based on your usage. When you install new apps, they'll be added to your App Library

I have some ideas for how Apple could improve upon it in iOS 17, discussed below.

App Library iOS 17 Concept

First, a video.

This new concept for App Library migrates existing Home Screen folders over to Custom Groups in the App Library, so you will already have some custom App Groups as soon as you upgrade from iOS 16. Home Screen folders are still a thing, but now they are placed on the Home Screen as App Library Widgets, rather than the traditional Home Screen folders we are used to.

This iOS 17 prototype also introduces a new small Home Screen widget size. Perfect for Shortcuts, Photos, Home, or App Library widgets,.

All in all, this App Library redesign is intended to make it easier for users to manage the apps that are installed on their iPhone.

You can play with the Figma prototype below.

When I explain iOS Shortcuts to people, I tell them that simple Shortcuts are straightforward, but the Shortcuts App is an interface for coding via drag-and-drop. Like any programming language, the Shortcuts App provides constructs for while loops, if statements, text parsing, etc.. Similar to code, Shortcuts can grow in complexity fast.

One of the coolest features of Shortcuts is that they can take input and return output. If you've run a Shortcut from the Share Sheet, you've passed input (the thing you were sharing) into a Shortcut. A lesser known feature of Shortcuts is that, using the "Run Shortcut" action, you can run one Shortcut from another. "Run Shortcut" accepts input which it passes to the Shortcut you are running, and it returns the output from the Shortcut that you run. You can do anything you want with the output. This should sound familiar to anybody with coding experience. In the context I am describing, Shortcuts are essentially... functions.

As you develop your own Shortcut library, making a folder full of functional Shortcuts is a good idea. It will save you time in the future by encapsulating functionality that you can re-use in your other Shortcuts–akin to functions in a codebase. If you've found yourself duplicating actions from Shortcut #1 into Shortcut #2, you probably could have broken those actions out into a functional Shortcut, Shortcut #3 that Shortcut #1 and #2 both utilize via the "Run Shortcut" action.

Sidebar: Calling one Shortcut from another is great for your own Shortcuts library. This practice breaks down if you want to publish your Shortcuts for others to use–you need to instruct people to install all required Shortcuts and their dependencies. There are utilities (such as ActionCuts), which embed one Shortcut into another on your behalf, but they are outside the scope of this blog post.

Paginator

The purpose of this post is to share a specific "Function Shortcut" I have created which I use in my other Shortcuts.

What's it do?

With the iOS 14 redesign, Apple changed the way lists are presented to users when using the "choose from list" Shortcut action. If you are presenting the user with lots of choices, the list is slow and choppy to scroll.

I fixed this by chunking the list into pages of 7 items each, and prompting the user with 7 items plus a next and a back button for navigating between pages.

Download it here.

• Input: List of items
• Output: A single item which the user selected from the list

Note: If this is your first shortcut, you might run into issues installing "Untrusted Shortcuts". I provide instructions for that here.

Usage Example

I created a sample Shortcut called Shortcut Picker which fetches all of your Shortcuts, has you choose one with the Paginator, and runs the selected shortcut (with no input). It is a quick illustration of how to leverage the Paginator Shortcut from another one of your Shortcuts.

Download it here.

• Overview
• Additional Privacy Enhancements
• Home Screen
• App Library
• Contexts & Automated Context Switching
• U1-Enabled Room-Level Automations
• Shortcuts
• Misc.

Overview

Update 2025: This wishlist is now outdated! I've created a live, continuously updated version at apple.lukezilioli.com/wishlist. Check out my blog post about Apple Wishlist Website is Live for more details.

Last year, I shared a huge wishlist for iOS 15 and macOS 12. I'm holding out hope for many of those features to be announced at next week's WWDC.

We have had a whole year to play with iOS 14. In that time, Apple has released the HomePod Mini, AirTag, among other products. What's that mean? My wishlist has grown.

The purpose of this post is to share my top new wishlist entries since last year's post.

Additional Privacy Enhancements

Last year, Apple did a lot to enhance user privacy in iOS. Despite Facebook pouting about it all year, Apple's new anti-tracking features were very well received.

Last year, Apple introduced fine-grained control of access to user photos. I wrote up an overview of that feature here. Apple desperately needs to do the same thing for contacts! Some apps refuse to function if you don't grant contact access, which is all or none in iOS 14. Social media websites like Facebook and Clubhouse upload and store your entire address book to their servers the moment you grant this access, and there is nothing you can do about it.

Granting an app access to your contacts grants access to all of your contact data. As of iOS 13, this excludes notes data, but Facebook likely has your neighbor's garage code if you stored it in the notes field and granted them contact access prior to iOS 13. Yeah, you read that right, any personal information your friends and family had stored in the notes field for their version of your contact very likely lives on Facebook's servers and has been sold and distributed to countless third parties. Companies can cross-reference your contact across all of their users who uploaded a version of it, aggregate a list of all of of your possible nicknames, addresses, etc. based on those contact fields, and use that data to strengthen their profile of you. It's fun to think about, really. 🙃

In my opinion, this is a privacy nightmare of unconscionable proportion. Apple needs to fix this by introducing fine-grained address-book privacy controls that function analogously to iOS 14's Photos access settings. They also need to strongly discourage users from granting unfettered contact access to third party apps, since this is leaking other people's data to them.

Home Screen

I love the new Home Screen Pages feature. The ability to hide and show pages is great, and super helpful when it comes to keeping a tidy home screen.

I want a few enhancements here:

• We should be able to pinch to zoom out from the home screen into the grid view of Pages. It is absurd that we can only access this feature while in "Jiggle Mode".
• We should be able to give each home screen a name such as "Work", "Smart Home", "Games", etc.
  • We should be able to hide and show home screens via Shortcuts actions
• We should be able to drag to reorder pages in this "Edit Pages" view. We are up to iOS 14 and we still have no easy way to reorder our home screen pages. Come on, yo.
• We should be able to give each Apple Watch Face a custom name. This would make Shortcuts automation for Watch Faces way more straightforward.

App Library

The new App Library feature is nice, but could be made more useful:

• There should be an entry in App Library labeled "Not in Home Screen" so that I can easily see all of the apps that only exist within my App Library.
• Merge home screen folders with App Library
  • We should be able to add my existing home screen folders to the App Library
  • Conversely, I want an App Library Folder widget that we can place anywhere on our Home Screen, which can be configured to display any category from App Library, including our own folders.

Contexts & Automated Context Switching

In my last wish list post, I mentioned:

Switch up which app pages are active based on location, time, or via a Shortcut

Allow me to elaborate.

Today, I have a few different watch faces with different complications depending on what I am doing. When home, I like having HomeKit scenes, Music Control, etc. at my fingertips, but when out and about, I want quick access to shazam, maps, etc. When working, I want slack, jira, mail, and other work-related complications.

I am able to create personal automations based on time of day, location, presence in the car, etc. to automatically switch my watch face. The ability to rename watch faces would greatly improve this process. But I want to introduce the concept of "contexts", which expands the idea of automated context switching far beyond watch faces.

Similar to the watch faces I mention above, I have Home Screens that are only relevant to me based on what I'm doing.

1. Home
   • Apple Remote App
   • Home App
   • Philips Hue
   • App Store
   • Music Widgets and Shortcuts for my Home AirPlay environment
2. Work
   • Slack
   • BitBucket
   • Jira
   • Work Notes Widget
   • Work-specific calendar Widget
3. Out and About
   • Find My
   • Maps
   • Music
   • FourSquare
   • Shortcut to open the Gate in my Apartment
   • Activity Widget
   • Workout
   • Slopes

In addition, I have HomeKit scenes and shortcuts that are only relevant to me based on time of day or location. These exist on different Home Screens for quick access. Today, I swipe between Home Screens to get to the page that's relevant to me. It isn't worth the effort required to manually edit pages and hide and show them as I go about my day. This means that many times during my work day, I swipe past multiple irrelevant Home Screens when trying to view my Work home screen.

Zooming out and revisiting the Edit Pages View:

I think this view can be enhanced to support a proper concept of "Contexts":

• Pinch anywhere on Home Screen to activate this view outside of "Jiggle Mode"
• Add a tab switcher that allows us to switch between active sets of pages (contexts)
• Each context should have its own name and set of visible pages
• Ability to associate a particular watch face with each context
• Ability to automatically switch your phone's active context via a Shortcut Action

U1-Enabled Room-Level Automations

AirTags precision finding is cool as hell, and super accurate. It would be great if I could place AirTag in various rooms of my house, and create personal or home automations that trigger as my iPhone or Apple Watch enter and exit various rooms (this feature should also work with the HomePod Mini, no need for AirTag).

Music should follow me as I move around the house, cuz why not?

Shortcuts

• With iOS 13, Apple introduced Parameters for Shortcuts, and strictly type their outputs. This greatly enhanced the utility of app-provided shortcut actions. We should be able to create our own Shortcuts that are parameterized in the same way, for reuse in other Shortcuts.
  • This would allow us to create utility Shortcuts that are specifically designed for invocation from other Shortcuts
  • When sharing a Shortcut, all required utility Shortcuts should be automatically bundled with the shared Shortcut.
    • This will make life easier for maintainers of public Shortcuts.
• HomeKit automation needs a complete overhaul. Setting up scenes and automations requires far too many taps. I should be able to list all accessories by type from a single action, iterate over that list, and perform an action against each Repeat Item in the list.
• Shortcuts should have their own persistent data store. DataJar is a great application, but iCloud syncing across devices is not the most reliable. This should be an OS-level feature.
• There is currently no way to append a photo to note via a Shortcut. This is an oversight and should be fixed. Shortcut support was added to Notes in a dot release, and has yet to be fully fleshed out by the Shortcuts team.
• Permission for a Shortcut to access more of iCloud Drive. We should be able to perform path-based scripting like we can with the Dropbox integration. iCloud Drive is not a competitive product without this feature.

Misc.

• We should be able to mark episodes as unwatched in TV app... like seriously...
• When tapping a color with Apple Pencil, switch back to pen tool if the eraser is currently active
• Delete activity awards
• Quickly toggle AirPods mute with gesture
• AirPods Max microphone should work over the wire
• AirPods spatial audio with Apple TV
• AirPods Pro as hearing aids (we're getting closer!)
• Bring back cover flow in the Music app! PLEASE!
• Toothbrushing detection for Apple Watch
• Restore ability to customize tab bar in music app.... Apple Music has too prominent of a placement
• Home-wide timers for HomePod. All HomePods should know the answer to questions about timers. It's super frustrating knowing that you set a timer, but the HomePod with the timer running refuses to respond.
  • If I set a laundry timer in the basement, it should also go off upstairs, otherwise I don't hear it.

After some investigating, I determined this is actually a bug in the Shortcuts app on iOS 14. The "Find Notes" action is completely unreliable when searching for hashtags, that is, anything starting with a #. I created a simple shortcut that illustrates the bug and reported it to Apple, so hopefully they resolve it sometime soon.

Unfortunately, the best workaround for now, is to just not use hashtags. I updated Note Taker to work with the shortcuts-thoughts tag instead of #thoughts. You can download the updated shortcut here.

If you have been using this shortcut, be sure and change any of the #thoughts tags in your notes over to shortcuts-tag-thoughts in order for the notes to be found.

In the future, if I update this Shortcut, it will prompt you to install the update using UpdateKit. If you don't have the UpdateKit Shortcut installed, it will skip this step. You can download UpdateKit and learn more about it here.

• Introduction
  • Audience
  • Overview
• Example
• Same Example, in TypeScript
• Diving Deeper
  • Avoid any Like the Plag... ahem Coronavirus
  • Why any?
  • With any, Type Safety is Lost
  • Improvement #1 (Still using any)
  • Improvement #2 (Using unknown in place of any)
  • Issues with unknown and Casting
    • Properly Casting
    • Hastily Casting
• Template Types
  • Avoiding any and casting with Template Types
  • Query Example, in TypeScript Using Template Types
  • Now let's type the variables argument...
  • What the Hell is up With the T and U?
• Unnecessary Examples
  • Normalizing a Crappy database.query Method
    • Same Example, With Normalized Return Type
    • Same Example, Taken to an Unnecessary Level of Detail
• Conclusion

Introduction

Audience

This is a technical post intended for software developers. If you don't code, you can skip it. If you are new to TypeScript, this post may be dense for you, but you may find value in reading it.

Overview

TypeScript is powerful and expressive. Typically we are able to reference the types we are using in our classes and functions directly. Sometimes we want to write a generic function that can work with multiple types, without losing type safety. This post helps explain how to do that.

This post starts with a vanilla JavaScript example and slowly builds it up to a full-fledged utility method that leverages type safety insofar as possible. Along the way, we spend a lot of time exploring alternative implementations to the example code, and caveats we may run into with those implementations.

It's not until the later half of the post that I even mention template types, but try to bear with me until I get there–a lot of the background leading up to it will help provide necessary context toward describing their usefulness.

Example

TypeScript is great, even in simple use cases. Lets start with a code snippet in plain-old JavaScript.

function databaseQueryWrapper(variables) {
    return database.query(variables);
}

Simple enough, right? This function takes an argument: query variables, and returns the results of querying the database with those variables. But what is variables? What variables do I need to pass to the query method? This is something we can't answer without more context.

This is where TypeScript can help.

Same Example, in TypeScript

function databaseQueryWrapper(variables: QueryVariables): any {
    return database.query(variables);
}

This is an improvement. By reading the same code, we can now infer: pass in QueryVariables, get back anything. When starting out with TypeScript, this change alone enhances your codebase with type safety. But let's go deeper.

Diving Deeper

The above example is overly simplistic for illustration purposes. Let's talk about what it's doing. The method queries the database, which is a low level operation. In any language, when you query a database, you pass in a query and get back a list of... <the thing that you queried for>. In the example above, we typed the return to any, which is less than ideal.

Avoid any Like the Plag... ahem Coronavirus

I am about to spend a loooong time convincing you that any, used in the above examples is dangerous and ought to be avoided.

Why any?

Typing the method's return value to any, (equivalent to bypassing TypeScript entirely), while problematic, has a single benefit: we can proceed with writing typed code where we consume databaseQueryWrapper. See:

// query the database for a list of contacts
const variables: QueryVariables = {...};
const queryResults: Contact[] = databaseQueryWrapper(variables);

If you don't explicitly use they type any in your code, any time you are working with vanilla (non TypeScript) JavaScript, all function arguments and return values are assumed to be any. The caveats I discuss below are worth understanding because as you convert your codebase over to stronger typings, you will run into issues of this nature.

We will explore our options for typing the return value to something other than any later in this post.

With any, Type Safety is Lost

TypeScript will allow us to assign the any type returned from databaseQueryWrapper to the Contact[] type in the above example. But consider the following issue one could inadvertently introduce during development:

// oops, we forgot the `[]` in our queryResults type
const queryResults: Contact = databaseQueryWrapper(variables);

TypeScript is happy, but if we try to work with the queryResults: Contact variable from the above example:

console.log(queryResults.address);
// undefined
console.log(queryResults.address.city)
// throws Cannot read property address of undefined

The first line of code logs undefined because we are referencing queryResults.address when we should be referencing queryResults[<array index>].address. The second line throws an error because we (both the developer, and TypeScript) think we are accessing the city property on the address object of a Contact, but in reality we are attempting to reference the city property of what the previous line of code already let us know... is undefined.

Improvement #1 (Still using any)

If we know database.query will always return an array, we can make an enhancement and return any[] instead of any to improve type safety:

function databaseQueryWrapper(variables: QueryVariables): any[] {
    return database.query(variables);
}

If we try to use it, we get an error before the code even compiles:

const queryResults: Contact = databaseQueryWrapper(variables);

Type 'Contact[]' is not assignable to type 'Contact'.

That's whats up. While this is progress, it still requires us to use any. any is evil. So we are clear: If you eliminate no other TypeScript error from your codebase, eliminate this one:

Type declaration of 'any' loses type-safety. Consider replacing it with a more precise type. (no-any)tslint(1).

Improvement #2 (Using unknown in place of any)

How do we get rid of that any? Let's try typing the return to unknown[]:

function databaseQueryWrapper(variables: QueryVariables): unknown[] {
    return database.query(variables);
}

...but when we try to use it:

const queryResults: Contact[] = databaseQueryWrapper(variables);

Type 'unknown[]' is not assignable to type 'Contact[]'. Type 'unknown' is not assignable to type 'Contact'.ts(2322)

To bypass this, we have to cast it:

const queryResults: Contact[] = databaseQueryWrapper(variables) as Contact[];

Issues with unknown and Casting

We got that any out of the way, but can we do better? This solution requires us to cast the return value of databaseQueryWrapper everywhere that it is used, fuck that. Casting is sometimes necessary, but designing an API that requires it is a terrible starting point. What if you work with "cast happy" TypeScript developers? You know the type, their attitude is usually: "Oh? It won't compile? That's alright, just cast a return value here... a variable over there... and boom... ok TypeScript is happy." How do you prevent people like this from shooting themselves in the foot?

Revisiting the example mistake from above, which now throws a type error:

// oops, we forgot the `[]` in our queryResults type
const queryResults: Contact = databaseQueryWrapper(variables);

Type 'Contact[]' is not assignable to type 'Contact'.

There are two ways someone might try to fix it.

Properly Casting

If you recognize your mistake, you'll fix the variable typing to include []:

const queryResults: Contact[] = databaseQueryWrapper(variables);

Which will give the following type error:

Type 'unknown[]' is not assignable to type 'Contact[]'. Type 'unknown' is not assignable to type 'Contact'.ts(2322)

Which you will (correctly) fix with:

const queryResults: Contact[] = databaseQueryWrapper(variables) as Contact[];

Hastily Casting

If you don't recognize the mistake, and you're feelin' a lil cast happy, you'll trust your queryResults variable's typing and cast the function return as your first fix:

const queryResults: Contact = databaseQueryWrapper(variables) as Contact;

Fortunately, TypeScript will throw an error in this case.

Conversion of type 'unknown[]' to type 'Contact' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.ts(2352)

This is progress. The last time we had this bug we didn't find out about it until runtime–now TypeScript is catching it for us at compile time. If you scrutinize the message, it helpfully says 'unknown[]' to type 'Contact', which should tip you off that your variable, which is typed to Contact should actually be typed to Contact[]. But who reads error messages amirite? (I do, and you should) Unfortunately, the second half of this error message is actively unhelpful. TypeScript encourages the cast happy approach when it advises "convert the expression to 'unknown' first". Someone following TypeScript's recommendation would be inclined to fix the errors thusly:

const queryResults: Contact = databaseQueryWrapper(variables) as  unknown as Contact;

TypeScript is happy, but we have introduced the same bug we had from when our return was typed to any:

console.log(queryResults.address);
// undefined
console.log(queryResults.address.city)
// throws Cannot read property address of undefined

The takeaway? Casting introduces bugs in the same class as bugs you had when your codebase was full of any types. Be smart about when you use it, if at all, and definitely don't require it when designing your API.

Template Types

Avoiding any and casting with Template Types

Can we stop here? Should we even worry about the "cast happy" developer who might shoot themselves in the foot while consuming our API? Probably not, who do we think we are, God? If "cast happiness" is a consistent issue with any one person on the team, let them know like "hey, types are cool, honor them and stop casting shit left and right". Don't waste your own time writing code to protect people from themselves.

But, I will continue for two reasons:

1. On our bad days, we are all that "cast happy" developer. As engineers we are placed under deadlines and pressure all the time. All engineers are gonna cut corners–it comes with the territory. Good engineers cut the right corners at the right time (and document the fact that they cut the corner, why they cut the corner, and the potential impact of their decision to cut the corner, but I digress)
2. I haven't even mentioned template types yet in this incredibly long winded and verbose TypeScript example. I can't end the blog post before I discuss template types. And this is still a useful illustration for doing that.

Are we convinced template types might be useful yet? Cool. Let's use them.

Query Example, in TypeScript Using Template Types

function databaseQueryWrapper<T>(variables: QueryVariables): T {
    return database.query(variables);
}

const queryResults: Contact[] = databaseQueryWrapper<Contact>(variables);

While the consuming code is slightly less intuitive, and requires a shallow understanding of template types, it eliminates casting, removes the any keyword, and is less error prone. This is great.

Now let's type the variables argument...

Up until now, we have used a vague QueryVariables type for the variables argument for purposes of simplicity. But in practice, what is variables going to be? This example was inspired by a wrapper that I wrote for apollo-client which we use to query our GraphQl API at my job. In my case, the variables that we use to query for an entity depends on the entity that we are querying for, so what we are able to pass to the query method needs to change based on what we are expecting to get back. Just like we used template types to allow the consumer of databaseQueryWrapper to specify its own return type, we can use template types to allow the consumer to specify the type for the parameters it wants to pass to the method:

function databaseQueryWrapper<T, U>(variables: T): U {
    return database.query(variables);
}

const variables: ContactQueryParams = {};
const queryResults: Contact[] = databaseQueryWrapper<ContactQueryParams, Contact>(variables);

Now we are really flying. We have implemented a great low level helper that helps us query our database. We can define some helpers for our consumers to use:

export function queryForContacts(variables: ContactQueryParams): Contact[] {
  return databaseQueryWrapper<ContactQueryParams, Contact>(variables);
}

export function queryForEvents(variables: EventsQueryParams): Event[] {
  return databaseQueryWrapper<EventsQueryParams, Event>(variables);
}

What the Hell is up With the T and U?

I was trained in C++, which has the same exact concept of template types as TypeScript. To my knowledge, convention has always used letters of the alphabet, starting with T (I assume for "Template") when naming template types.

What most examples on the internet never tell you, is that T and U are just variables, and can be named anything. Readers of these internet tutorials would be better served if descriptive names for T and U were used. You are advised to never name variables stuff like a and b, so why doesn't the same thing apply to template variable names? I think everyone is afraid the programming gods will strike them down if they break convention here, but imma do it anyway:

function databaseQueryWrapper<TypeForQueryVariables, TypeForQueryResults>(variables: TypeForQueryVariables): TypeForQueryResults {
    return database.query(variables);
}

This example removes the ambiguity from T and U and captures some of the original developer's intent when creating the templatized method to begin with.

At the risk of talking out of my ass: Once you are so far off the deep end that you are finding value in using template types within your functions or class implementation, you won't be bothered by the fact that your templatized types have super abstract names like T and U. You're already thinking so far in the abstract it will be the least of your concerns. I would venture to say that most examples don't bother giving T and U more meaningful names because once this whole concept clicks for you, T and U will prove to me more than sufficient descriptors.

Unnecessary Examples

If I hadn't already convinced you of the value in avoiding casting and unknown types as reason enough to dive into template types, let me give you two more concrete and less contrived examples of when you may need them.

Normalizing a Crappy database.query Method

What if the database.query method is inconsistent and returns a single object if the query only returned a single entity, but an array of objects if the query matched multiple entities? This is a low-level oddity that you might want to smooth over within databaseQueryWrapper so that future consumers wouldn't need to check if the item(s) returned from databaseQueryWrapper is an array or not.

Let's fix it:

Same Example, With Normalized Return Type

function databaseQueryWrapper<T, U>(variables: T): U[] {
    const results: U | U[] = database.query(variables);
    if (!Array.isArray(results)) {
        results = [results];
    }
    return results;
}

Cool, you just saved the rest of your team from having to accidentally discover that your third-party database package sucks ass.

Same Example, Taken to an Unnecessary Level of Detail

What if your database.query method might throw an error if the database is not initialized or properly authenticated, but returns an object containing an error if the query was malformed? Thats inconsistent (in this example, this particular inconsistency might be okay)! Maybe your database package doesn't return the number of entities that match your query, but you want to encapsulate that and return a count along side your results? tl;dr, what if you want to normalize your return value to the following:

{
  success: boolean;
  error?: string;
  results: Contact[];
  count: number;
}

This is something you would want to encapsulate within the databaseQueryWrapper method, and template types can help:

interface DatabaseQueryResults<T> {
  success: boolean;
  error?: string;
  results: T[];
  count: number;
}

function databaseQueryWrapper<T, U>(variables: T): DatabaseQueryResults<U> {
    let success: boolean = true;
    let results: U | U[] = [];
    let error: string = '';
    try {
        results = database.query(variables);
    } catch(e) {
        // don't follow my lead here, I am swallowing the error's
        // stack in this example... don't be like me
        error = e.message;
        success = false;
    }
    const results: U | U[] = database.query(variables);
    if (!Array.isArray(results)) {
        results = [results];
    }

    return {
        success,
        results,
        count: results.length,
        error,
    }
}

Conclusion

Thats it! I hope you found value in this post. Thanks for reading it.

Click for an article that I stumbled on while researching this post. It's a great read and full of TypeScript tips.

In this post, I'll provide a quick overview of iOS 14's new privacy controls. iOS 14 introduces fine-grained settings to give you tighter control over your privacy. Without a doubt, Apple is doing something right; the advertising industry is pissed off at them because of these changes.

There are two new privacy settings that I want to highlight in this post:

1. Precise/imprecise location setting
2. Ability to grant applications access to "Selected Photos". (Pre iOS 14, photos access was all or none)

Precise Location Setting

Before iOS 14, you had 3 options when granting an application access to your location: "allow once", "always allow", or "allow while using the app". These are useful settings that provided a necessary level of privacy controls, but in 2020, when advertisers are running amok with our data, we need more. With iOS 14, Apple came thru.

Apps like Snapchat (which request location access for purposes of users sharing their location on a map) can use that precise location data however they see fit; they could learn that you visit Target every Friday and start showing you Target ads on Thursday evenings. Nefarious developers with access to your location could glean your home address, your work address, and your frequently visited locations just from having access to your location.

I have heard tales of companies with internal dashboards that show where all of their app's users are at on a map at any given time. In the age of ubiquitous technology, lots of "creepy" practices are emerging. By default, companies should NOT be trusted with your data. Engineers are asked to implement solutions that violate user's best interest on the daily. Many comply.

In iOS 14, Apple has taken steps to mitigate developers' access to your precise location. The new location prompt on iOS 14 allows you to toggle whether the app can see your precise location. There are very few applications that need access to your precise location. Other than navigation apps, the majority of apps should be able to function just fine without precise location access.

All vs. Selected Photos

In iOS 13, Instagram has access to your full photo library. Swiping left from the camera illustrates this–you are presented with a list of ALL of your photos thru the Instagram interface.

No way in hell do I trust Instagram (owned by Facebook) with unfettered access to my photos. For all I know, they could be uploading my entire photo library to their server, running image processing on them, and using what they learned to serve targeted ads to me on Facebook. Photos that I have never posted to Instagram could have been used for nefarious purposes by the company. For all we know, we are unwittingly feeding a facial recognition database–simply by granting an application access to our photos. We have no control of what an application does with our photos after we grant access–and this is an issue.

In iOS 14, Apple has mitigated this. When an application requests access to your photos, you are presented with a new option: "Selected Photos". Tapping this option presents you with your photo library, and allows you to select specific photos that the app will have access to. As far as that application is concerned, your photo library contains the photos you have selected, nothing more. If you use the "Selected Photos" permission level, it's impossible for a developer to see photos that you don't explicitly select when granting access.

Significant Locations

Significant Locations isn't a new feature to iOS 14, but now is as good a time as any to educate people about the feature's existence.

By default, iOS is tracks your location to a surprising level of detail. Take a look at Settings > Privacy > Location Services > System Services, scroll down and tap on "Significant Locations". You'll see a detailed log and map of the places you frequent, along with timestamps of when you visited those locations.

This can be startling the first time you see it. Your iPhone is collecting A LOT of your location history. If you'd like, you can disable this feature within the "Significant Locations" setting screen. I keep the feature enabled. The Significant Locations feature is what enables the iPhone to predict where I may want to drive when I get in the car, and suggest directions to those locations when pertinent. These locations are stored on my device, and are locked behind FaceID. I trust Apple to not use my location history for nefarious purposes.

I've noticed a pattern among online activists: people are creating directories containing small and/or black-owned businesses that need our support. Some have likened these directories to a modern-day green book. In a lot of cases, people are taking the quick & dirty approach: creating a google spreadsheet or document, and sharing a view-only link. In other cases, people like my good friend Kristle (@kristhecreative on Instagram) are manually maintaining PDFs and publishing updates on a semi-regular basis. This is a time-consuming, repetitive, and arduous process.

Any time I observe time consuming or repetitive processes, my mind goes straight to automation. Computers are great at performing repetitive tasks.

I asked myself: what if someone could create a Google Spreadsheet and, with the press of a button, convert the spreadsheet into a website? In theory, it was a simple thing to create, so I set out to create it. This is an example of where I feel my software skills can be applied toward the greater good–and I can have my own positive impact on the movement.

I know myself. I need a tangible deliverable and deadline if I'm going to get something done. To that end, I reached out to Kristle and asked her if I could work with her to convert her Small Business Directory PDF into a website. I explained how this could save her time and enable her to focus on the content of the directory rather than the presentation. She was into it.

We did it. Check out Kristle's Small Business Directory here. Big ups to Kristle for the excellent design and the Small Business Directory she's been maintaining manually for most of the year. Shoutout to @migreva for chipping in on some of the code. This project would have taken me significantly longer to complete without his help.

Now that I have reached my first goal: to prove out the idea and leverage it to make a single business listings website, I am setting my sights higher. My friend Precious lives in D.C. and maintains a spreadsheet containing black-owned businesses in her area. I am going to work to open source the code that I wrote for Kristle's Small Business Directory so that I can reuse it for Precious's website. Look out for a future post once that's complete. At that point, I plan to provide step-by-step instructions for anyone to create their own business directory in a few easy steps.

I created a shortcut that I wanna share with y'all. I think of new ideas at the most random times. An idea might be something I want to incorporate into an existing project, a new project, a topic I want to research, or anything in-between. Before this shortcut, I would file away new ideas by saying "hey Siri, note to self ".

The problem with this was that each new idea ended up in its own note. Then, at some point in the future, I have to comb through my notes and figure out what to do with each of them. This is an unnecessary step that builds up a backlog of ideas. It would be preferred if I took the time up-front to add the idea to its pertinent note. The problem: half the time, by the time I finish hunting down which note I want to put the idea into, I forgot the idea I wanted to capture. I've lost many good ideas because I forgot them before writing them down.

That mean I forgot better shit than you ever thought of

To help remedy this, I created a shortcut, Note Taker. When you run it, you will be prompted for text. After you enter the idea, it will let you pick from any note with a shortcuts-tag-thoughts tag and add the idea to the end of that note.

Download Note Taker here.

If this is your first shortcut, you might run into issues installing "Untrusted Shortcuts". I provide instructions for that here.

After you install it, you can run it from the Share Sheet or the Shortcuts app to take a new note. It will create a "My Thoughts" note for you on the first run, and you can add the shortcuts-tag-thoughts tag to any other notes into which you might want to file an idea. You can also select "Note Taker" from the share sheet to capture anything the phone lets you share into a note.

Advanced Usage

As explained above and by default, Note Taker searches for notes that contain the text shortcuts-tag-thoughts. But you might want to create a customized version that searches a different tag. I do exactly that for work so that I can capture notes for things I need to bring up in a 1:1 or upcoming meeting. Download my shortcuts-work-note version of this note here. Note: You will need to install the Note Taker shortcut for the customized shortcuts-work-note version to work.

For more documentation for this shortcut, check out the RoutineHub listing.

This is where the concept of "Mind Mapping" comes in. Mind Mapping is a popular concept among productivity enthusiasts. You can find countless videos and articles online about Mind Mapping, I won't repeat their content in this post. Take a look at the photo at the top of this post for an example mind map. You get the idea.

After I discovered the concept of Mind Mapping, I set out to find the best Mind Mapping app for iPhone, iPad and macOS.

IMO, Good Mind Mapping software must do a few things:

1. Work on macOS, iOS, and iPadOS–syncing your documents across devices with ease
2. It should support the same features on iOS and iPadOS as it does on Mac. It shouldn't be dumbed down for mobile devices.
3. Support exporting your Mind Map as outlines
4. Support drag and drop, and split screen on iPad for importing and exporting content to and from the app
5. Make it super easy to move items on the map from one place to another via drag and drop
6. Allow you to create weak connections between nodes, so that you can indicate a relationship between items on different branches of the tree
7. Provide a high-level expand and collapsible outline view of your mind map
8. Provide task support–where you can treat select items in the mind map as a task to complete
9. Integrate with the Shortcuts app for maximum automation
10. Support tagging of individual items

Mind Node checks all of these boxes. Visit their website to download the app today. Here's a blog post of theirs that highlights some of its more advanced features.

It costs money, but it's worth it if you have ideas to organize. Unfortunately, they are moving to a paid subscription, but they have proven to be capable developers who frequently update the app. Apple leaves them with very little choice (find my rant on that here).

Update 2025: My thoughts on App Store policies are now part of my live wishlist at apple.lukezilioli.com/wishlist. Check out my blog post about Apple Wishlist Website is Live for more details and all my latest Apple requests.

Have y'all noticed the upward trend of subscription-based apps? They're EVERYWHERE. We have Apple to thank for that. While I think Apple does a lot of good, this is one place they have prioritized profits and have failed both developers and consumers alike in the process.

The US Government spent a day probing Apple and other tech companies about monopolistic practices a couple of weeks ago. I was disappointed to see the issue of subscription-based apps not get addressed. This is an area of the App Store where I genuinely feel Apple has misused its power. The government should put regulations in place to right this wrong. Get this–Apple loves subscriptions sooo much, they offer developers a 50% discount on the fee they take from subscriptions when compared to apps. Apple takes a 30% cut of App Sales, but only a 15% cut of subscription fees for year-long subscriptions. If making one model of app pricing financially superior to another isn't considered monopolistic and anti-competitive behavior, I don't know what is.

Before the App Store, the upgrade pricing model for software was straightforward. You'd buy an app for a set amount of money, and you knew you could use that app until it is no longer compatible with your operating system. Think of Microsoft Office back in the day: you could buy the disc and not have to buy another copy until you upgraded your computer or you needed a feature that was only available in a new version (lookin' at you, .docx files). This pricing model is great! As users, we get to decide if we want to continue using the old version of the app we already paid for, or if we want to pay to buy the new version of the app with the new features. Developers can invest time into creating a new version of their software knowing that they can sell that new version to users once they release it. Everybody wins.

No such thing exists on Apple's App Store, despite the fact that developers have been requesting, and finding clever ways of offering paid upgrades to their apps for YEARS. Savvy developers have found ways around this by creating new App Store listings for new versions of their apps, but that comes with drawbacks. Namely that they lose their app store rankings and reviews from old versions. Other developers have offered one time unlocks of available features, and lock down new features behind another one-time fee in the future. In my opinion, the Working Copy app for iOS has one of the most fair pricing models around. I commend the developer for not succumbing to Apple's subscription model.

For some apps like Netflix, or others with ongoing server costs, a subscription-based model makes a lot of sense. Its great that the option is available–I am not advocating for subscription-based-pricing to be removed. However, apps within Apple's ecosystem with no server backing and no ongoing costs have been moving to a subscription-based model. Apps that should theoretically work forever if the user never updated their software again are starting to get locked behind paid subscriptions. Mind Node (a favorite app of mine that I have been using for years) is the latest such app. Look at the backflips they have to do in that blog post to convince us that subscriptions are worthwhile. We all know they aren't ideal.

Subscriptions have other issues, none of which are consumer-friendly. Developers can sell their app based on promises of future features. Users might sign up for a subscription on good faith that developers will deliver the promised features. That day could never come. Worse: Apple's policies don't make it easy to get a refund for a subscription to an app that is updated to no longer function as promised. Users might pay for an app only to find that its next major release is something they want nothing to do with. Fantastical is one such app. They radically reinvented the app and its interface as part of their shift to subscription pricing... and it is not an improvement. Lots of people jumped ship from Fantastical as a result, myself included. Look at their recent App Store reviews. A PR nightmare.

Take the time to read the "Roadmap" blog post from one of my favorite task management apps, 2Do (I've been using 2Do since '09). This is a developer who feels it is unfair to charge a subscription for a simple to do list, but feels Apple has given him few alternatives if he wants to make a living off of his software. He rightly understands that users are less inclined to sign up for a subscription for a task manager than they are to shell out 4 or 5 dollars every few years for the latest and greatest version of that same app. Compounding the 2Do app's problems, iOS 13 abandoned the CalDav syncing API the app was relying on to integrate with the iOS Reminders. As a result, the application has been stuck in a limbo for a year as he assesses the best path forward. Apple shouldn't be allowed to play with people's livelihood in this way.

• My work meetings get announced out loud from my desk speakers 5 minutes before they start and again when they begin
• When I get out of bed, Siri reads my schedule for the day, including any reminders I have set for myself
• When I walk in the door, Siri greets me with "what up doe"
• If it gets too cold in my apartment, the AC turns off (even tho its a dumb AC that plugs into the wall)

The latest thing I have used Pushcut for is to send notifications to my phone and iPad when I start watching something thru Plex. The notification comes with a few different options that let me dim the lights or activate other Home scenes, depending on what I'm feelin' at the time.

I have a few goals:

1. I want to get different notifications depending on which room I was watching TV in.
2. I want different notifications for if I play or pause a show.
3. I don't want a notification every time I play or pause, that's too noisy.

To give myself maximum customization options, and meet these goals, I wrote a little node app.

It receives Plex webhooks and maps them to Pushcut endpoints. It can send notifications, or for more advanced users, forward the webhook payload to a Shortcut running on a Pushcut automation server. Check out the repo, plex-to-pushcut on my GitHub.

If you're trying to install a shortcut and running into problems with the "Allow Untrusted Shortcuts" setting, you're in the right place.

Overview

A few years ago, Apple added the Shortcuts app to the iPhone and iPad. Shortcuts is a super powerful app. It lets you automate repetitive tasks. Its like coding but you don't type out the code, you drag and drop it into place. It's fun.

Most people won't ever create their own Shortcut. Thats okay! Apple enables shortcut authors to share them with others. Thanks to this, everybody can take advantage of Shortcuts' power.

The only problem? Apple makes it difficult to install your first "Untrusted" shortcut. Not only do they make you turn on a setting, they disable that setting for no apparent reason.

When you try to add a Shortcut to your iPhone that wasn't from the Shortcut gallery, you'll see the following error message:

Shortcut can't be opened. This shortcut cannot be opened because your Shortcuts security settings don't allow untrusted shortcuts.

If you're lucky, you might have found the the "Allow Trusted Shortcuts" setting. If this is your first shortcut, the setting will be completely disabled. You won't be able to turn it on, even if you wanted to. Its inexplicable why Apple made it this way, it really is dumb as hell, but I explain how to fix it in this post.

Disclaimer

While it ought to be easier to flip the switch, the setting itself exists for good reason. I would be remiss if I didn't explain the reason for the setting's existence before providing instructions on how to disable it.

Shortcuts, like apps, are powerful. If you don't understand what a shortcut you installed does, you could be giving your personal data to the shortcut author without knowing it. Don't get scammed.

Apple has done a solid job of making sure that, even if you don't read and understand the whole shortcut, you'll know and can control what data it has access to.

Like the first time you run an app and get prompted to let it access your location, the first time you run a shortcut you will be prompted for EVERYTHING it tries to access. Take care to read these prompts, and say no if you don't understand what or why you are being asked for something. Don't worry, the nightmare scenario of a shortcut stealing your nudes and uploading them to a private server is unlikely, just read the prompts and don't grant the same shortcut access to your photos AND to some random server you don't trust.

At any time, you can access the shortcut's details to view and manage a list of everything it has requested access to.

Who knows–maybe Apple made it unnecessarily difficult to enable this setting so that people like me would write disclaimers like this before explaining how to enable the "Allow Untrusted Shortcuts" setting. OK... on to the instructions.

Instructions

Please take the time to understand why this setting exists before blindly enabled it. I explain it above. You've been warned.

All you gotta do is enable the "Allow Untrusted Shortcuts" setting in Settings > Shortcuts.

If the Setting is Disabled

To enable the "untrusted" shortcuts switch when its totally disabled, you need to first install and run at least one shortcut from the gallery.

Note: A video of this process can be found at the end of this post.

Note: If you are running iOS 14 instead of 12 or 13, you can skip steps 2-5 and instead run one of the "Starter Shortcuts" from the shortcuts tab. That alone should enable the "Allow Untrusted Shortcuts" switch in settings.

1. Launch the Shortcuts app
2. Tap "Gallery" on the bottom navigation bar
3. Install any shortcut from the gallery (I have one in there!)
4. Switch to the "My Shortcuts" tab in the navigation bar
5. Run the shortcut you just installed
6. Launch the Settings App
7. Scroll down to the "Shortcuts" section and tap on it
8. The "Allow Untrusted Shortcuts" setting should no longer be greyed out.
9. Turn it on

You should be able to install the untrusted shortcut this time around. Go back and click the link to install the shortcut.

Here's the viddy:

It's a repetitive task when you keep an updated todo list. Stand up is just regurgitating:

1. The tasks you completed yesterday
2. The tasks you intend on completing today
3. The blockers–those tasks you can't get done because someone who isn't you has to do something first, and
4. Your schedule for the day so people know to get at you when you're free.

Daily stand ups are super useful, but I'm not about to sit down every morning and re-type my to-do list for my team. That's not a good use of my time. You already know where this is going... When we were doing chat stand ups, I wrote a shortcut to do it for me, and published it to RoutineHub in case anybody else wanted to use it. It saved me a bunch of time. It stores the previous day's standup to iCloud drive, and uses that as the starting point for "Yesterday's" tasks. It also integrates with your "Work" Reminders list and pre-populates with pertinent tasks.

That's cool and all, but the reason for this post is because I just stumbled across a "Daily Standup" shortcut in Apple's Shortcuts gallery–its looks to be a stripped down version of the shortcut I posted to RoutineHub–the structure and variable names are similar. It even uses the same icon.

Above: My shortcut on the right, Apple's on the left. My version is a little smarter about preceding - characters for each line item. Apple removed that logic, and puts a - in front of each line without exception.

To be clear, I think this is dope. I shared the shortcut in the spirit of helping people save time, and I am happy to see Apple pick it up and elevate it to a level I couldn't on my own. A little credit wouldn't hurt tho...

There... I fixed it 😂.

Rewind to the Windows 98 days, child Luke built a Pokémon site using Microsoft Publisher. All I did was compile lots of links and pictures of Pokémon from all over the internet, and with my Dad's help, got it hosted.

One of my biggest regrets in life is not putting Google Ads on this site. Over the years it has accumulated millions of hits from Pokémon fans everywhere.

I recently moved the site from its original domain to host it under lukezilioli.com, so that it can live for eternity.

Find it here.

Update 2025: This wishlist is now outdated! I've created a live, continuously updated version at apple.lukezilioli.com/wishlist. Check out my blog post about Apple Wishlist Website is Live for more details.

I am a heavy user of my iPhone, iPad, MacBook, all of that. I push 'em to their limits. As such, I find myself wishing Apple would add a lot of new features.

For the last few years, I've kept a running list in my Notes app of things I wanna see Apple add. This year I'm publishing that list. I've updated it by moving stuff added this year in iOS 14 into the "Completed" section. That's why the list is called iOS 15 and macOS 12 Wish List–this stuff's gonna have to wait 'till next year.

This list is only gonna grow once I get my hands on this year's betas. I'm not sure if imma update this post as I think of new ideas, or do another post with new ideas.

If you're interested in seeing everything Apple did announce this year, there's a post for that.

Table of Contents

• Luke's Apple Wishlist
• Platforms
  • iPhone
  • iPad
  • iPhone & iPad
  • macOS
  • AppleTV
  • Apple Watch
  • AirPods
  • Continuity
  • Apps & Services
    • Files App
    • Apple Card
    • Shortcuts
    • Music
    • TV
    • Home
    • Notes
    • Voice Memos
    • Reminders
    • Settings
    • App Store
    • Calendar
    • Mail
    • iMessage
    • Photos
  • Misc.
• Completed
  • iOS 14
  • iOS 13 and Earlier

Platforms

iPhone

• The current audio player in Messages and Files is trash
• Paste button on keyboard
• More icons in dock
• Split View
• Apple Pencil support

iPad

• HDMI display mode for iPad Pro to be used as as external monitor for any device–this would be so dope for playing Switch or PlayStation with friends on the go.

iPhone & iPad

• Ability for Apple to update native apps separate from OS so that they can release new features quicker
• iPhone app storage under app details in Settings
• Switch up which app pages are active based on location, time, or via a Shortcut
• Screen sharing with FaceTime
• Shared video watching with FaceTime
• Find My optional in Family Sharing
• Temporarily disable night shift while videos play
• Change default apps
  • Maps
  • Calendar
  • Text Editor
  • Browser
  • Mail

macOS

• View Live Photos in Finder–Its inexcusable that the only way to view Live Photos is from inside of an app
• show menubar in fullscreen apps
• Bring back Spaces & Exposé–Mission Control is insultingly dumbed down from what we had back in the Leopard days
• 4x4 and more advanced full screen window support
• TouchID finger identification when you rest a finger on the TouchId sensor in System Preferences
• FaceID on Mac
• Grouped notifications on MacOS
• Magic Keyboard/Trackpad/Mouse should switch between devices with ease the same way AirPods do

AppleTV

• I want to be able to plug another HDMI device into my AppleTV and picture in picture my PlayStation

Apple Watch

• Change watch face based on time of day or location
• Raise To Siri is unusable... fix it
• Third party watch faces

AirPods

• Volume control without using Siri, touching phone, or watch

Continuity

• Optional phrase to specify which device should respond to a Hey Siri request–"hey Siri on Watch"
• Reminders for "on my Mac" or "on my iPad" to be reminded of a thing when you pick up a different device
• When placing/making a phone calls, offer button to pause anything thats playing on other devices

Apps & Services

Files App

• Cleaner "Open In..." experience

Apple Card

• Change Apple Card bill cycle date
• Syncing with Quicken and Mint–csv export ain't it

Shortcuts

• Control orientation lock
• Control all settings with shortcuts. Such as keyboard click, etc.
• Allow user-created Shortcuts to parameterize inputs just like app Shortcuts can
• Shortcut bundles that embed referenced Shortcuts so that we can share complex Shortcuts that call one another without requiring users to install multiple Shortcuts
• Multiple speaker destinations from AirPlay action
• Handoff between all AirPlay 2 devices–this is restricted to HomePods and AppleTV’s
• Wait fractions of seconds in the Shortcuts wait action
• Music action to fetch a list of all of the user's Music playlists
• OCR from a Shortcuts action
• NFC from a Shortcuts action
• NFC invoked Shortcuts should receive encoded tag data as input
• Native support for prettier menus in Shortcuts
• Message to existing threads via Shortcut
• Collapsible control flow in Shortcuts
• Switch blocks in Shortcuts that behave like Menus but switch on a variable
• Persistent Shortcut data–like DataJar
• Delete Shortcut permissions for apps whose actions are no longer in use within the Shortcut
• Multi-window support for Shortcuts app
• Unlock device rotation via Shortcut
• While loop
• Shortcut version history
• Play ambient sounds via Shortcut
• Contextual shortcuts. When I launch an app let me prompt at the top of the ui without disrupting the user.
• Full access to iCloud Drive from Shortcuts, including the ability to list and iterate over files
• Functions/subroutines
• Read and modify file tags
• Query Notes by folder
• Run Shortcuts on an interval–shoutout to Pushcut for enabling this today
• User-defined smart folders

Music

• UI for rating single song sucks
• Spotify like cross platform music control
• Offer to resume Music after a meeting ends
• Sync ALL Smart Playlists with macOS–smart playlists that reference other smart playlists do not sync today
  • ability to modify Smart Playlists on iOS
• Drag and drop and multi-select in Music app

TV

• Keep AppleTV paired with AirPlay2 device after sleep/wake
• allow Plex to surface user's own content in TV app
• Sling and Philo in TV app
• Netflix in TV app
• Season 2 of Defending Jacob

Home

• Home app wallpaper sync across devices
• Device-specific permissions in the Home app

Notes

• Ability to put lock notes that contain pdf and audio file attachments
• User-defined smart folders synced with macOS

Voice Memos

• Convert my voice memo to text

Reminders

• Save any notification as a Reminder
• Calendar view in reminders app so you can drag to change the due date of a reminder
• User-defined smart lists synced with macOS

Settings

• Sound profiles–home, work, switch based on location–I guess we can do this with Shortcuts at this point, but an optimized UI would be nice
• WiFi network preferred order

App Store

• Why is it so hard to see the price of purchased apps...?
• Specify what device to download an app to
• Wish List

Calendar

• easy alarm setting like Calvetica used to have
• Copy and paste events
• Improved drag and drop support (drag to change calendar)

Mail

• Sync macOS user-defined smart folders with iOS
  • ability to change smart folders on iOS
• Gmail-like message snoozing

iMessage

• Mark as unread
• Schedule messages
• Arrow key support when choosing who to send a message to
• Bubble unreads to the top

Photos

• Sync smart albums from macOS to iOS
  • Ability to modify smart albums on iOS
• Hide hidden photos album behind FaceID/TouchID
• I want a single Photos Library with a subset synced to iCloud–when I export a photo from the Photos app, it should keep the live, burst, and other Apple-specific features–the fact that it doesn't forces me to keep paying for iCloud storage to preserve my memories. It is monopolistic of Apple to force me to pay for iCloud storage in order to to enjoy my photographs.

Misc.

• A true 1Password competitor
• Sublime Text's multiple selections feature system-wide
• Ask Siri to complete multiple commands at once
• Dark and light shading of alarms based on a.m. or p.m. in Clock app
• Improved PDF annotation in iBooks
• Contact photo in contact list of Contacts app

Completed

iOS 14

• Home screen widgets
• Privacy considerations around apps reading the clipboard
• Folders in the Shortcuts app
• Less-intrusive Siri and background requests
• Turn off lights/tv when I fall asleep
• Threaded conversations in iMessage
• Mentions in iMessage
• iMessage group photos
• Allow users to backup and restore Shortcuts from files–not just iCloud links (this worked in iOS 12, but not 13. They are adding it back in 14)

iOS 13 and Earlier

• iCloud Keychain password management on iOS
• Access macOS shared files from iOS
• Night Shift on macOS
• Native screen sharing support with Mac on iPad (SideCar)
• Dark mode on iOS
• Multiple windows of the same app open side by side
• Multiple timers on HomePod
• Amazon prime in TV app
• Now playing across all devices in a single interface
• Better ui for notification settings
• Color coded Reminders lists
• Don’t pause music while dictating or talking to Siri through headphones, bluetooth speaker or AirPlay
• Allow third-party provided Shortcuts take input/receive output
• Send an email to all members of a contact group
• True file downloads in Safari on iOS
• Maps for icloud.com
• Jump to album, artist, from song in Music app
• WiFi and Bluetooth settings in control center
• Quicker event entry in Calendar app
• Home automation integration, start playing when I get home
• Annotate PDFs from Files or iBooks
• Open whole folder from Files app in another App
• iMessage
  • TimeStamps
  • Quick Reply
  • Proper Color button when messaging from API
  • Avatars
  • Extract 2 factor auth codes from sms

• Black Lives Matter
• Announcements
  • Misc.
• Voice Memos
• Apple Music
• Notes & Reminders
  • Home Screen & App Library
  • Home Screen Widgets
  • Siri changes
  • Translation
  • Messages
  • Maps
  • CarPlay
  • CarKey
  • App Clips
  • iPadOS 14
  • Apple Pencil
    • Scribble
  • AirPods
  • watchOS 7
    • Sleep Tracking
  • Privacy
  • Home
  • AppleTV
  • Safari
  • MacOS Big Sur
  • Transition to ARM
    • How does this benefit users?
• Device Compatibility
• Updates
  • Control Center
  • Shortcuts

Black Lives Matter

Apple covered this topic at the forefront of the event, and for good reason. I gotta say it here as well. Black Lives Matter! 🗣

If you're white, you probably believe that you embody the idea of Black Lives Matter. Thats a start.

I'd put money that unconsciously, you still contribute to making a Black person have a shitty day somewhere in America. In part, The Black Lives Matter movement is about making those unconscious acts of racism conscious (to you). Only then (and after we abolish the police, and reform our justice system) can everyone walk around our society as comfortable as you always have. If you're white, shut the hell up, let go of your ego, listen to Black people (by reading what they have written, not by asking the nearest Black person to speak for all of Black America), challenge yourself and other whites around you to embrace Black perspectives, and have a nice day.

Announcements

Apple announced a lot on Monday, in their first ever streaming-only WWDC keynote, a brand new format brought to you by the coronavirus.

Below you'll find an outline of a lot of the stuff that Apple announced related to iOS 14, iPadOS 14, tvOS 14, watchOS 7, AirPods, macOS Big Sur, and the transition from Intel chips to Apple's own ARM-based silicon. Apple has their own version of this list. I guarantee you that I missed some things, more details will emerge, and features will be added and dropped before these updates are available in the Fall.

My thoughts are included below in itallics. I try to link out to relevant articles or discussions where applicable.

Curious to see what features I want to see Apple to introduce, but that didn't make the cut this year? Check out my Apple Wishlist.

Misc.

• Third-party apps can tap into the Find My app interface
  • Apple is smart to do this before announcing their own trackers. This will lull complaints of anti-trust behaviors coming from companies like Tile.
  • I wonder if this extends to the Find My offline finding ability update: it does
• Severe weather tracking and real-time precipitation in Weather app
  • Likely from their Dark Sky purchase
• Search is revamped
  • On iPad, it doesn't take over the full screen. Like spotlight on Mac
  • "Universal search" – intended to be the starting point for all searches
    • I thought this was always their goal with search on iOS but arite...
• Phone calls don't take over the full screen anymore
• Picture-in-picture on iPhone
  • If you leave the app while watching a video, you get a video window floating above everything else. Works like picture-in-picture on iPad today.
  • I really want to see a full-out split view feature on iPhone. Looks like we will have to wait another year.
• HomePod works with Spotify and other music services
• Set default email and browser apps
• Redesigned photo and video picker
• One for developers, they will be able to formally challenge their app store rejections
• If the developer enables it, family sharing groups can share app subscriptions
• FaceTime eye correction. When you look at the screen, it'll make it look like you are looking at the camera.
  • This was from the iOS 13 beta, but got dropped
• Emoji search in the keyboard
  • So you can type words while you avoid typing words to send an emoji
• Revamped Podcasts app with curated suggestions
• Back Tap accessibility setting–you can trigger an action (any shortcut!) by double tapping the back of your iPhone or iPad
• All iPhone models now feature quick toggles to change video resolution and frame rate in Video mode.
• A new option allows you to capture burst photos by pressing the Volume Up button, and QuickTake video can be captured on supported devices using the Volume Down button.
• A new option in Settings lets you capture mirrored selfies, which reflect the front camera preview.
• The Files app supports external drives using APFS encryption. Simply enter the password to access the content of the drive.
• Contacts autofill in third party apps
  • should reduce the number of times you have to give an app contact access just to pick a single contact
• Time Machine now supports APFS drives
• Long press back button to view navigation stack
• In app intent handling
  • Android has always had this feature. Recent additions to iOS have made it painfully necessary. What this means is that your apps won't have to jump around between different apps to get things done as much. This was extra painful for Shortcuts.

Voice Memos

• Mark some voice memos as favorites
• Enhanced recording setting
• Folders and smart folders

Apple Music

• Listen now tab
• Endless Autoplay when Apple Music reaches the end of a playlist
• Overhauled sidebar on iPad
• New search experience
• Multi-window support for Music on iPad

Notes & Reminders

Good overview.

• No more texture in Notes
• Better scan quality
• Collapse pinned notes
• Redesigned actions menu in Notes
• "Send a Copy" action in Notes that exports your notes to other apps, in other formats
• Touch and hold Aa button to quickly change section styling
• Assign Reminders to other people
• New date picker for Calendars and Reminders
  • 

Home Screen & App Library

• You can hide entire pages of the home screen... cuz Apple knows none of us ever touch page 2, 3, 4...
• The last page becomes "App Library"
  • Broken down by category automatically
  • Has "Suggestions" section with most relevant apps
  • Can launch top 3 apps from each category or tap to view all apps in the category
  • I would like the ability to organize what categories appear in App Library, and which app falls into which category. It seems like Apple could let us put our own folders into this section, rather than using Apple's pre-determined categories.
• Settings for if new app downloads show up on an app page, or in the App Library

Home Screen Widgets

• You can drag widgets out of today view onto the home screen
• Widgets live along-side app icons on your home screen.
  • We been waiting on this for a minuteeeee
• ‪Widgets come in different sizes. Some are 2x2 app icons big, some are 2x4, 4x4, etc.
• Special widget called "Smart stack"
  • You can swipe between widgets at will, the OS will sort them based on what it thinks you might care about at that moment
  • This seems like the siri watch face, but on the iPhone home screen
• In wiggle mode, you can also add widgets, and browse all available widgets for a given app by pressing a + button in the top-left corner of the screen.
• I would like to be able to put a watch face on my iPhone home screen as a widget

Siri changes

• No longer takes over the whole screen!
  • Great for if you wanna reference something on the screen while using Siri, to tell Siri to dial a non-clickable phone number or something like that.
• If you ask for stuff like Weather, it shows up at the top of the screen, like a notification.
• ‪You can ask Siri to send audio messages‬
• ‪Voice dictation is run on the device instead of in the cloud. No internet connection required‬.
• "Siri is getting smarter every day"
  • 20x more facts than 3 years ago
  • Can answer stuff like "how do hybrid cars work"
    • I'll believe it when I see it. Siri was better at complex queries when she dropped in 2010 or whenever it was.

Translation

• ‪New app called "Translate"
  • 9to5mac hands on
• Help facilitate conversation across languages
• Works offline
• Can translate text and voice conversations between 11 languages
• 9to5mac hands-on

Messages

• You can pin conversations to the top of the list so you don't miss messages from people you care about‬
• Memoji updates
  • Memoji have face masks now... very necessary...
    • People are gonna use this more than they use masks in real life
  • 20 new Memoji hair styles
• ‪You can mention people in messages... just type their name
  • Setting for group conversation to only be notified when mentioned
• You can reply to a specific message, and view replies in the conversation, or in their own thread.
  • I want to see this in action. Slack does a terrible job at this and I'm looking forward to seeing how Apple handles it.
• New display at top of group
  • Custom group photo
  • Latest person to send a message has biggest picture

Maps

• Will warn you about speed traps and traffic cameras.
• Apple has finished rolling out the new maps designs from last year to all of the U.S.
  • More countries coming this year
• "The worlds most trusted brands" can create guides of places to check out
  • They need to make this a feature that any user can create, share and monetize. This is another place Apple could have a direct impact on diversity. Are Black-owned and hole-in-the wall spots gonna be featured in these places from "trusted brands"? No need for Apple to be a gatekeeper of this feature when user reviews could do the job.
  • Update: it seems like it will be possible for users to make and share their own guides, but it will likely be difficult to get them the same level of exposure as guides from "trusted brands"
• Cycling directions, will tell you what your route will be like
  • Includes cycling paths (duh)
  • Elevation
  • Quiet or busy roads
  • If you will need to carry your bike up stairs
    • Can choose to avoid stairs
  • NY, LA, SF, cities in China
    • They won't have Detroit for years 🙄
• Directions to electric charging vehicle stations, with knowledge of what stations work for what brands of cars
• Congestion-based navigation. Tells you if it's too busy to go somewhere. Limited to very few cities.

CarPlay

• Wallpapers in CarPlay
• New app categories (parking, car charging, food ordering)

CarKey

• Lets you unlock and start your car with your phone.
  • This shit sweet but first car w it is BMW so it'll be FOREVER until its a regular degular feature. I still dont have CarPlay in my car... This is the worst part about CarPlay.‬
  • Apple has worked with an open industry-wide committee to support this in all cars, so support for this should be coming to new cars soon.
    • The question is, are asshole car manufacturers gonna up-charge for access to the feature?
• You can text a key to someone with rules about how fast they can drive, when they can use the car, etc.
  • If you spend thousands more for a car that supports this, you can save hundreds on physical copies of your car key.
  • I want to see this supported at the OS level for smart locks in the Home app too... why is it limited to cars?
• Coming to iOS 13.6 sooner than later

App Clips

• Sometimes you want to interact with a part of a service without downloading the full app.
• Apple gives lots of examples in the keynote, some:
  • Paying for parking - Hold your phone up to the meter and a ParkYourCityNameHere screen pops up for you to pay for parking. No more downloading app for a one-off trip to some random city.
  • Shared scooters - You hold your phone up and can Apple Pay to use the scooter. No account or app download required.
  • Paying at a coffee shop
  • Buying something from an Etsy link that a friend texted you
  • Ordering food from a nearby restaurant (directly from the Maps app)
  • That one friend who insists on using Venmo instead of Apple Pay
• Never need to use credit card numbers, because they work with Apple Pay
• Can use Sign in With Apple
• Won't clutter your home screen but you can still access recent App Clips
• ‪Businesses can stick these tags on the register, integrate Apple Pay, or people can quickly get info about an app.
• Yelp can make App Clips for businesses, so individual businesses will be able to take advantage of App Clips without being developers themselves.‬

iPadOS 14

• A lil history lesson: iPad apps started as iPhone apps on larger screens. People started making apps designed specifically for the iPad that were optimized for the larger screen.
• Now, people are making iPad apps more rich and powerful.
  • Basically, what Apple is saying here, without saying it is that iPad apps are catching up to Mac apps in power and quality.
• ‪Photos, Notes, Files, Music, and Calendar apps all getting a new sidebar
  • The 12.9" iPad Pro has had a 3rd sidebar panel for some-time, but it seems they are making it standard & improved for all iPads with iPad OS 14.
• Filter and sort photos
• Add caption to photos to add context
• Redesigned image picker
• A lot of apps are adding toolbars at the top of the window, letting you control sort order, etc.
  • The Mac been had a lot of these features, but this is all great to see on iPad. Trackpad support makes these features feel necessary, so I am glad to see Apple adding them. This is only gonna increase how much I use my iPad.‬

Apple Pencil

• You can edit handwriting like text, with cursor, easily add more space between sections, etc.
• Shapes will sharpen their lines if you pause at the end of drawing them so you can draw straight lines, round circles, etc.
• Double-tap to select a word or drawing... easily change color or move it around the document
• Handwritten phone numbers can be acted on–place a call or whatever
• Copy handwriting into another app and it will paste as typed text

Scribble

• Whenever a cursor is active, you can write text anywhere on the screen and it will convert to typed text. Fuck a keyboard!
• You can jump between languages
• Tap and hold to add space between handwritten text

AirPods

This article has a great overview.

• Auto-switch between devices.. if you are paired with your iPhone then start a zoom call on your Mac, your AirPods will switch over.
  • This is gonna save me so much frustration. It's shit like this that drives people to update all of their devices to the latest version ASAP.
• Spatial audio, 3D audio but for AirPods Pro... makes you feel like you're in a movie theater.
  • ‪They talking about how they solve that technically... they use motion data from your head combined with your device to keep the audio scene centered relative to your device's screen, even as you are moving around in physical space. Sounds crazy as shit.
  • Clearly this is gonna be super useful for their AR goggles...
  • I hope this works with the PS5's 3D audio feature
• Optimized battery charging
• Charge alerts if you should top off the battery before a meeting
• Developers can get motion data from AirPods Pro to know how you are moving your head in space
  • this is another precursor to the Goggles

watchOS 7

• You can now have multiple complications for a single app on the same watch face, so one app can expose multiple features on your watch face.
  • Clever developers were working around this by letting you customize how each type of complication slot behaved, but it is great to see Apple adding a standard, OS-level way to do this. I'm sure it will save lots of developer's time.
• All the new faces and complications
• ‪New faces, one with a tachyometer (a tool for measuring speed based on travel time, or distance based on speed)‬
• Share watch faces
  • overview
• ‪You can share a watch face with friends... this is lowkey a genius way to drive app downloads‬
  • ‪If I share a face with you and you don't have the apps, it'll prompt you to download them.
  • The Shortcuts app already does that but everyday users don't use Shortcuts. Watch faces is a feature with much more broad appeal.
• Redesigned interface for configuring watch faces
• A new dance workout type
  • ‪People will say "they shOulDa bEeN haD tHis" but they had to solve for different types of dance styles to ensure they all get tracked properly
  • ‪Apple prolly had people dancing in a lab for DAYS...
  • This is where Apple can put their money where their mouth is on the Black Lives Matter front. What all types of dance are supported? They make it sound like a wide range but I'd be curious to see a breakdown of what dancers they measured when building the feature‬. It would not be a good feeling to try out this new feature only to discover that Apple failed to incorporate the ability to track your favorite method of dance.
• Activity app improvements
  • Overview page, more intelligently curated
  • Renamed to "Fitness"
• Removed force touch on the watch
  • You have to go into settings to toggle between grid and list view for apps
• Faster animations
• Notification on your iPhone when your watch battery is low
• Announce messages with siri
  • I don't know if this is like out loud or if this means when the watch is paired with AirPods, it will announce messages

Sleep Tracking

• This another big one. I been waiting on this for forever.
• Phone has a "wind down" mode that dims the screen, sets alarm, and lets you specify shortcuts to quickly kick off. If you have hue lights, easy way to dim shortcuts, etc.
  • This ties in with the mood-based lighting feature.
  • I am curious how this relates to Bed Time mode (a feature I find to be confusing.)
• ‪Watch will remind you to charge when you get home and after you wake up so you will have charge for the day and for sleeping.
  • Or they could just improve the watch's battery life. The cynic in me knows this is a way for them to get people to own two watches‬.
• ‪Watch OS 7 detect hand watching and times how long you watch, it gives a countdown.
  • They should do this for teeth brushing.

Privacy

• ‪New location sharing option to share approximate instead of precise location with apps
  • Approximate location is within 10 miles of your actual location
  • This is a great idea
• Mic and Camera have a recording indicator in the status bar, so you always know if either are in use.
• App Store policy requires apps to ask you for a system-level permission before allowing them to track you with third parties.
  • I assume the OS will block third party tracking if the user says no to these prompts
• ‪Introducing a "nutrition labels"-like card in App Store listings for developers to disclose their privacy practices–before you download an app.
• New ability to convert existing accounts within apps to "Sign in With Apple" accounts
  • They said that when Kayak added "Sign in With Apple", it quickly became their most used login method.
    • This makes sense to me. Its a much better option than Login With Facebook, and I think most people understand this.
• Safari now blocks Google Analytics.
  • Good for Apple. I encourage and instruct people to do this on this website's privacy page.
• New Privacy settings for Photo Library access–you can give apps like Instagram access to only specific photos instead of the full library
• Sends a notification when apps read the clipboard
  • provides API for developers to figure out what is on the clipboard before accessing the full contents, this will cut down on how much you see the notification
  • this is great, apps have had unfettered access to the clipboard without user knowledge for too long
  • Thanks to this feature, people who installed the beta have already caught TikTok sniffing user's clipboard, even when running in the background
• Microphone and screen recording indicator in the status bar
• Apps have to ask permission to track you

Home

• New standard making it easier for device manufacturers to make new devices and device types for the Home app
• Automations will be suggested when you add new devices
• New widget at top of Home app with contextually relevant device controls available–a quick visual status indicator
• ‪Adaptive lighting: hue has had this forever, but you can make your lights switch from cool to warm based on time of day, simulate sunset and sunrise, among other things.
  • I am excited for the ability to integrate this with HomeKit Automations
• ‪Activity zones–lets you draw areas to be alerted about activity... so you can ignore cars on the street, but catch people on your walkway.
• Face recognition for HomeKit camera‬
• HomePod can announce whose at the door if it recognizes them
• This sounds creepy, but it all happens locally within your HomeKit system, unlike Amazon's Ring doorbell, which freely shares footage with Police. For the love of all that is holy, don't buy a Ring
• Pull up HomeKit camera video at any time with Siri on iOS or tvOS device
• AppleTV will automatically pop up a video window when someone rings the doorbell

AppleTV

• New Home app
• New Home controls on AppleTV sidebar
• ‪Picture in picture system wide. You can watch one thing on AppleTV and AirPlay another thing to another window... this is dope‬
• You can use a workout app while watching a TV show in the corner
• Multi-user support for Apple Arcade
  • This is okay, but I wanted a more rich user profile feature. Why can't we have different app layouts for different users? Why doesnt the iPad support multiple user accounts yet?
• I fasho be wanting to watch two things at once, or watch some shit while I'm playing some shit‬, so this is great.
• New AppleTV+ series: Foundation (based on the Isaac Asimov book series) (watch the trailer)
• Audio sharing so that multiple people can listen with AirPods

Safari

It seems a lot of these features are Mac specific. Its not clear yet.

• 50% faster than Chrome
• More rich Safari extensions
  • Support for web extensions api
    • Chrome supports this–so extensions should be able to be translated across browsers a lot easier.
  • Privacy controls for extensions–you control which sites each extension can see.
    • You can give an extension access to a site for the hour, the day, or forever.
• Redesigned tabs
  • Icons in tabs
    • I thought this already existed
  • Tabs will now scale themselves like Chrome tabs do–this is way better. You can see more tabs in the tab bar.
    • This was long overdue.
• Monitors saved passwords and notifies you if they were in a data breach
  • 1Password already does this, I wanted Apple to make a full-blown password manager
• Native web page translation‬
• ‪Safari will report the trackers that it blocks‬
• Customizable start page
  • Custom wallpaper–drag and drop an image onto the start page to set a new background
• Can now stream 4K HDR videos in Safari

MacOS Big Sur

We love the Mac, its the tool we use to make all of the products that we put out into the world.

• They didn't stress this on stage, but the X (10) in macOS X is no more. MacOS is moving on to version 11.0.
• Major visual refresh. Everything is refined
  • looks more iOS like
• Apps have their own "Key color" that is used on sidebar icons, list highlights, etc.
  • This seems to usurp the system-level highlight color they introduced with the last MacOS release.
• New suite of sounds
• ‪Menu bar drop downs like the Sound menu is a lot more helpful, new designs and better affordances
• Control Center on Mac.
  • You can drag stuff out of control center straight into the menu bar, and vice-versa
• Redesigned Notification Center, grouped with widgets, no more tabs
• iOS widgets supported on the Mac
  • I assume that this is thanks to Catalyst–developers can likely add widgets to macOS super easily if they have one in their iOS app today
• Messages on Mac works like iOS messages, complete with the new groups features, pinned conversations, better search, an app menu, etc.
• All new version of Maps
  • Favorites and lists from iOS will show up in Maps on Mac
  • Ability to see friend's ETA progress
  • All iOS maps features
• Catalyst
  • Lets developers bring their iPad apps over to the Mac with minimal effort
  • Lots of enhancements to Catalyst that developers can take advantage of
  • Maps and Messages are now Catalyst apps
• osxdaily post with lots of screenshots

Transition to ARM

• After the Mac demo, they revealed the whole thing was run on an ARM-based Mac.
• Theres a few components to this, and a lot to be said on this topic, in particular related to app compatibility
  • Here's a good overview by tidbits.com
• They rewrote their redesigned Mac apps for their custom chips, but they are backwards compatible with Intel chips
• You can still run windows within parallels and other virtualization
• Developers can make their iOS apps available for download on the Mac, running natively, if they choose to
• First ARM Mac shipping to consumers by the end of this year
• BootCamp is dead. Seems like virtualization is the wave
• New system recovery method

How does this benefit users?

In theory, new ARM-based Macs running Apple chips can take advantage of Apple's full-stack approach to designing their devices. My hope is that Apple can deliver two things to consumers with this transition:

1. Better battery life
2. Faster year-over-year speed improvements.

The iPhone has been outpacing the Mac in speed and efficiency gains for years, and the theory is that the transition to Apple's own chips can help the Mac play catch up.

Device Compatibility

Check out The Verge's article on this.

Updates

I will update this secton as details of new features emerge in the coming days.

• System wide color picker
• Home screen web apps
• FaceTime can detect when someone is using sign language and auto-focus them just like it does for speech
• Login to websites with FaceId and TouchID
• GameCanter app is coming back
• Hand and body pose detection to vision framework
  • Another one that will be useful for the AR goggles
  • I remember doing this with the Kinect back in college, its taken this long for this technology to jump to the phone. Kinda crazy to think about.
• Sound recognition–if you are hard of hearing you can have your phone notify you of common sounds such as doorbells, etc.
• Headphone accommodations
  • My interpretation of this is that Apple is strategically turning the AirPods into (relatively affordable) hearing aids
  • This is a big deal.
    • From Apple's website: "This new accessibility feature is designed to amplify soft sounds and adjust certain frequencies for an individual’s hearing, to help music, movies, phone calls, and podcasts sound more crisp and clear. Headphone Accommodations also supports Transparency mode on AirPods Pro, making quiet voices more audible and tuning the sounds of your environment to your hearing needs."
• New status alerts when headphones and other devices connect-looks like the apple pencil charge notifications
• You can enable/disable specific screensaver categories on AppleTV
• The Nearby Interaction Framework will help developers make apps that let your phone know where it is relative to other phones.
• ARKit lets developers anchor things at specific locations in the real world
• Apple News can auto-redirect web links into the News app
• Improved game controller support–including support for the DualShock 4 Light Bar
• Low Power Mode on iPad
• iPhone will notify you when your Watch is fully charged

Control Center

• Announce messages with Siri in control center
• Hearing toggle in control center
• HomeKit devices and scenes inline in Control Center

Shortcuts

I am a huge fan of the Shortcuts app. It got no mention on stage, which makes sense since it got a lot of love last year and the year before that. It turns out Shortcuts is getting some updates after all.

• Shortcuts folders
• More automatic automation options for personal automations
• Shortcuts can run locally on Watch–no iPhone required
• Can import .shortcut files again
• Copy and paste actions

The old lukezilioli.com was written in PHP, the new one is written in NodeJS (with a super light-weight front-end). There's lots of cool technical stuff going on behind the scenes. Some of it has been open sourced.

I've got the new site set up so that I can edit blog posts in markdown on my iPad, commit and push the changes to a git repository, and have them published to this site automatically.

Open Source

While architecting this blog, I kept open source in mind. It is not open-sourced yet, but I have defined a standard format for a blog repository (written in markdown, of course), and created @lzilioli/blog-parser, a module that I am using internally to turn my blog into structured data for rendering this website. Eventually I will open source this module.

I also created md-macros, which I use to parse my blog's markdown, and embed rich markup and data into my blog posts.

Shoutouts

I wanted to include a shoutouts section with this post, like I did with the launch of the last redesign.

Newcomers

RSS Feed

I love RSS. I was sad when Google Reader died. I have long since switched over to feedly, a more than sufficient replacement. Since I am such a fan of RSS, I created an RSS feed for the site. Subscribe here. Like most node-based web services that provide an RSS feed, I am using an npm package, rss.

navigator.share api

At the bottom of every post, if your browser supports it, you can find a "Share" button, which will pop up your browser's native share sheet. If you are on an iOS device or using Safari on your Mac, sharing posts from this site is extra easy.

ClipboardJS

I am no longer using ZeroClipboard. (Flash is sooo 2013.) This redesigned website uses ClipboardJS to provide the same functionality. ClipboardJS doesn't need flash and instead relies on browser standards.

Try it! Click on the copy icon on the right to
copy this block of text to your clipboard.

Now paste it here:

Dark Mode

If you are using MacOS or iOS latest versions, you will notice this site will match your system-level light or dark preference. Switch to light or dark mode and watch the page update!

:visited link styling

My old website displayed circular read/unread indicators beside the post titles. This is impossible using the :visited pseudo element styling, so the old website was tracking post read/unread status in the browser's localStorage. At the time, I wanted to learn how to work with localStorage, and that feature was the perfect place to do it. As part of simplifying the codebase for this redesign, I ripped out localStorage usage in favor of :visited pseudo-element styling.

Nodejs + heroku

Most would say this simple blog could be published as a static site. I didn't want to do that for a few reasons. First, as part of migrating from the old design to the new design, I implemented some better practices. (Working on an SEO optimization team at RetailMeNot rubbed off of me). On my old site, blog post urls were formed as follows: /blog?id=<post-id>. Here they live at /blog/post/<post-slug>, which makes the urls more human readable, follows RESTful principles, and is better practice all around. However, you can still visit the old urls, and get 301 redirected to their new URLs. That small bit of redirect logic mapping post ids to post slugs was much easier to put on a node server than in a static front-end app.

Also, I'm a front-end engineer, so this was the perfect excuse to play with supporting and building node app in a production environment.

bitbucket pipelines

I'm using bitbucket pipelines to build the site and push it out whenever I push code to the repo. Its mad easy, and it took me 10 minutes to integrate with heroku. Everything is so standardzed these days, I love it.

2023 Update

• Heroku raised prices, so I switched to render.com
• As part of this process, I replaced BitBucket & pipelines with GitHub & actions

TypeScript

JavaScript has come a long way, but it remains error prone and untyped. Thankfully, theres TypeScript. I don't write JavaScript anymore, everything I do is TypeScript. If you haven't made the switch, do so. I can't believe I could ever write functioning applications using vanilla JS.

Webpack

I don't even know how I would compile a front-end (or node back-end) without webpack. It has become my go to TypeScript bundler, is highly extensible, and gets better with every update.

Gulp

Out with the old and in with the new (less old?). Over the years, I have used Grunt as my task runner. I used it for a long time. Longer than most. I'd even created a shared-grunt-config package that encapsulated all of my favorite grunt plugins and standardized my JavaScript development workflow across multiple repos.

With this website overhaul, I jumped ship from Grunt over to gulp, since its better supported and been updated to play nicely with newer versions of node. I ditched shared-grunt-config in favor of Github's template repo feature. I created lz-ts-template which will be the basis for my future JavaScript projects.

I have used npm scripts, which is everybody's favorite way to manage their scripts these days, but I still prefer the power and abstractions provided by a JavaScript task runner.

Open Graph Tags

When you share a link to a post using iMessage or another modern messaging app, you will get rich inline previews of what is on the page. This improves everyone's life, and it means if you share a link to my blog with a friend, they are more likely to know what you sent them, even if they don't bother to click the link.

Handlebars

I have a few rules when it comes to selecting a template library:

1. Must be able to render client, or server-side in JavaScript
2. Must encourage minimal logic in templates (but support if/else/for)
3. Read like html insofar as possible

Handlebars checks these boxes, and I have used it in many projects both personal and professional, making it the obvious candidate for this site.

Updates

A lot changes in the web development community, and as such, some of the tools that I was excited about back when I first created this site in 2012 have fallen by the wayside.

Twitter Bootstrap

Twitter Bootstrap had its time, but I have stopped using it. These days, I write my own custom styles for stuff.

Old-Timers

Sass

I still love Sass. Lucky for me, so does the web community. There are some great people behind the project, and it now has a c++ implementation (Libsass) which is much faster and more reliable.

jquery

I'm still using jQuery. Its great in my opinion. This site is super lightweight on the front-end, so jQuery is the perfect candidate.

Even for more complex applications, I am a big fan of event delegation combined with stateless functions and centralized state management (shoutout to redux). But I work on an Angular app as my day job, and as an engineer I try and remain framework agnostic. Finding, fixing, and folding code patterns onto themselves is what I'm good at.

I have backfilled the contents of this site to capture some of the milestones I've hit over the last seven years, both personal and technical. Stay tuned for more posts.

Why Now?

Anyone who knows me knows I am an avid Apple user. I have been known to live-tweet their product and software announcements for my friends.

For years, I have kept my own personal "Apple Wishlist", a list of things I'd like to see them support in future versions of their whateverOS. This year, I want to start capturing those thoughts on my website. I also want to start writing tips and tricks to help people get the most out of their MacOS and iOS devices.

In April, I set the goal of relaunching my website by June 20th. I wanted to get it done by the time iOS 14 is announced so that I have a place to put my thoughts about the release. I've hit that goal, so stay tuned for Apple-related content in the coming weeks as I process what they announce at this year's WWDC.

Last time I launched this website, I wrote 2 posts in the following months, and didn't touch it again until today. Back then, I had to manually upload the posts to my website after I finished writing them. Today, that process is automated. Since its easy to write and publish posts, and I can do it all from my iPad, I should be posting regularly. We gon see...

Enter md-macros, an npm package that I created and use myself on this blog. It allows me to link from one post to another with \\[[macro:postLink slug="welcome-2"]](update 2023-12: I now support wiki-style backlinks popularized by second brain apps like Obsidian), or embed a youtube video with \\[[macro:youtubeEmbed url="<youtube video url>"]]. This enables me to keep my markdown documents clean and free of html.

Each macro maps to a simple JavaScript function, making this a highly extensible library. I use it in other projects to embed a table of contents inside of the README.

Check out the code on my github, or use it in one of your projects by installing the npm package.

For posterity, I kept the old site hanging around here. I'd made it with a drag and drop website making app on my first MacBook, way back before I even knew how to code a website.

What is Prism?

Prism is an Austin-based start-up that was co-founded by my homie Adrian. To steal a blurb from their website: "Prism is revolutionizing how live music events are managed."

In short, it's a software solution for venues and promoters to streamline their concert-planning workflow. As a software engineer who deeply loves music, Prism couldn't be a better fit for me.

On My Joining

I worked with Adrian at Zappos back in 2012. He and I built their internship website as a pet-project at the end of the summer. Working with him was great–an experience that stuck with me through 4+ years at RetailMeNot.

As Adrian's friend, I've watched Prism.fm evolve over the years. He and I have shared many late night working sessions with me hacking on a personal project or some task for RetailMeNot, and him working his ass off to build Prism. On occasion, I've given him random advice related to his responsibilities as a CTO at Prism. I'm hype to be able to play a direct role in its future evolution.

I got the Withings Sleep Mat as a gift. While the sleep tracking and health app integrations are cool, what I find exciting is that it can sense when I get in and out of bed. This gives me lots of new automation ideas to implement in my smart home. I was mad excited to start playing with this aspect of the sleep mat, but once I got everything set up, I was disappointed to learn that the Withings Sleep Mat doesn't integrate with HomeKit, only IFTTT, leaving Apple users out to dry.

I couldn't have this. My house needs to know when I get in or out of the bed, and a Shortcut should be able to determine if I am in bed or not–if the sleep mat doesn't enable that, its only realizing half of its purpose.

After brainstorming, I figured I can use the same contact sensor approach that I use to bridge plex to HomeKit, with the help of homebridge-http-webhooks. Except this time, the incoming webhook will be coming from IFTTT, which the sleep sensor does support.

I adapted the code I use to receive Plex webhooks and forward it to hemebridge-http-webhooks, and repurposed it for receiving webhooks from IFTTT and sending them along to HomeBridge. Find it here.

Note the code integrates with ngrok. The node server runs on your local network, while IFTTT is a hosted service, so ngrok is used to set up a persistent hostname for handling the incoming requests. This requires a paid ngrok account.

I learned a lot and wanna shout out to everyone I worked with over the years. I hope to work with some of y'all again.

So... whats the next move?

As I mentioned in my stand-up comedy post, I've started doing stand-up. My only plan right now is to focus on honing that craft. Catch me grindin' at open mics in the coming months...

Besides that... I don't have a solid plan. I hope to return to Detroit, where the majority of my family and friends live. At the end of the day, I hope to find a decent living situation, and enough work/life balance to focus on comedy or other passions on an ongoing basis.

Goal

I wanted to set it up so that when I play a movie or TV show, my lights dim, and when I pause, they brighten. I'd like to be able to set different scenes to activate depending on if I start watching in the bedroom vs the living room.

Alternatives

IFTTT is too dumb to support this, because there needs to be logic around what to do depending on which webhook event was fired.

Solution

I wrote a small node app for this. It receives incoming webhooks from Plex. For play/pause/start events, it forwards the webhook to homebridge-http-webhooks, which maps to a contact sensor in my HomeKit setup.

With a contact sensor whose state maps to the playing status of Plex, I can use Apple's Home app to set up automations for different HomeKit scenes based on changes to the contact sensor state.

Check out the package on my GitHub for details.

I adapted the code from an example app published by the Plex developers. I don't expect this to be universally useful, but the more tech savvy smart home user could use or adapt the code for their needs. For this reason, I figured there's no harm in open sourcing it.

Why?

It does't sit well with me when I watch a term that Black people originated enter the collective consciousness and get used by your every day run-of-the-mill white person. The term "on fleek" is the latest example of this. Many others have covered this topic.

I wanted to find a way to apply my software skills to this problem. The popularization of "on fleek" is a great opportunity for this. Peaches, the term's originator, has an active GoFundMe campaign to raise money for having originated the term.

You might ask, "why does Peaches deserve money? Memes get created every day". I think anyone would agree with the sentiment that for any meme, the creator deserves credit and proper compensation when profits are involved. In the absence of universal justice for meme originators, you might ask what makes Peaches' case unique enough that I am blogging about it–America's ongoing crimes against Black people is your answer.

What some fail to recognize is that there are white-owned brands using the term "on fleek" in their advertising. Thanks to Peaches, these brands are able to gain access to a demographic that is otherwise inaccessible to them–there is value in that. White-owned brands should not be furthering their economic advantages over Peaches without elevating her along with them–to not do so is classical white people bullshit if you ask me.

There are people profiting off "on fleek" today who would look down on someone like Peaches if they encountered her in their everyday lives. THAT doesn't sit well with me. This is what people refer to when they speak of cultural appropriation–how many people throwing around "on fleek" knowing good and god damn well it's a term they would never embrace on their own, if the rest of the hive mind weren't too?

Enter @fuckyoupaymemes, a twitter bot I created that subscribes to all tweets across twitter, and when it finds one that contains the term "on fleek", it responds with one of a few random messages asking the user to contribute to Peaches' GoFundMe.

The code is sitting on my desktop, and I've got the bot running locally on my MacBook. I'll keep it up and running for the next few weeks while "on fleek" is dominating the hive mind. If it gets a massive response, I might spend time open sourcing the code and getting the bot hosted long term–no promises on that. The search term (in this case, "on fleek") and the canned responses are both configurable, meaning that this code could easily be adapted for the next meme.

Consider this my part in trying to get Peaches paid and raise awareness on the fact that even the seemingly innocuous spreading of memes can harm marginalized groups and further reinforce a wealth disparity in this country which white people reap by capitalizing on the labor (both physical and intellectual) of Black people without proper compensation.

To that end, I've started doing stand-up. My first time was earlier this year at an open mic night here in Austin.

My second time doing stand-up was today. I'm home for Christmas, and my friends encouraged me to do an open mic, so I did. I got a lot of laughs, prolly cuz I had friends there. I don't care the reason, all I know is that it went way better than my first time.

After that, I went to a few different cities in Italy, piggybacking off of the trip that my aunt had planned. I got to spend two weeks with my aunt, uncle and cousins. It was hype as hell.

The whole purpose of this post is to show off the delicious food from the trip.

Mixin’ It Up With FlightJS

As RetailMeNot started to develop more rich interactions for our site, we found ourselves needing to include the same functionality and patterns in different components or objects without duplicating the code, lest we end up in the wild west of inheritance. Enter Twitter’s FlightJS framework.

FlightJS is something that we already make use of a great deal at RetailMeNot. One of the key features of FlightJS is the .mixin() pattern. Using mixin() enables us to associate a piece of functionality with any component, without having to worry about how said functionality fits into some class hierarchy.

Guidelines

At RetailMeNot, we’ve been using FlightJS since February 2014, and what we consider "best practices" has been continually evolving as the framework — and our understanding of it has matured. We currently use the following set of guidelines while working on FlightJS code:

• Separate your concerns into single-purposed functions. This helps with unit testing and AB testing, as it becomes easy to override small bits of functionality. Such concerns may include: dom updating, analytics, ajax requests, internal state management
• Keep functions small, if you find yourself writing a function that’s more than 9–10 lines of code, you’re probably doing too much.
• Look for opportunities to mix functionality into a component. Use component.mixin, and the advice API. This helps with not forking huge js files, and with identifying common functionality between components.
• Look for repeated code, I guarantee there is almost always a way to not repeat it.
• Avoid calling one function from another when possible, instead use event communication (internal or external), and the advice API.

Missteps

When we first moved from FlightJS, we blindly ported most of our JS code into flight components. In hindsight this was probably unnecessary, given that Flight plays well with non-Flight JS. This was a mistake that we are still paying for.

The beauty of FlightJS is that it encourages and enforces separation of concerns using a combination of functional mixins and aspect oriented programming paradigms. Unfortunately, the library doesn’t stop you from putting too much code in any single file/function.

Our older JS code tended towards putting too much functionality in our functions, which our FlightJS components inherited when we ported over to FlightJS. Because of this, we started out of the gate with FlightJS by breaking many of the above guidelines. This made it difficult to leverage other aspects of the library, such as the advice API or component.mixin. As a result, our initially ported code is no easier to maintain then if we had never started using FlightJS.

We are refactoring our older FlightJS components to make them better-aligned with our guidelines. This will ensure the maintainability and testability of our components moving forward.

Lack of component.mixin prior to FlightJS 1.2.0

Before upgrading to FlightJS version 1.2.0, which added component.mixin(), we had to include all of a component’s desired functionality when we returned the result of calling component(). But what if we needed a component that is in all ways identical to the original component, except that it fires different analytics upon the user taking some action? Well, prior to the flight 1.2 upgrade, we were forced to split the bulk of out component’s implementation into a mixin of it’s own, for later inclusion in a particular component. This limitation combined with the fact that our functions were not small and single-purposed, forced us into some strange paradigms. Let’s examine them:

Code for one of our components might typically look something like this:

component.js

define([
    'flight/lib/component'
], function(
    component
){
    return component( componentCode );
    function componentCode() {
        // Define default attributes for the component
        this.attributes({ /*...*/ });
        // Once the user has successfully completed an action, update the DOM accordingly
        this.updateDomOnSuccess = function () { /*...*/ };
        // Fire analytics indicating that the user has successfully completed an action
        this.doSuccessAnalytics = function () { /*...*/ };
        // Set up listeners to make the component do things
        this.after( 'initialize', function () { /*...*/ });
    }
});

But what if we want to start using this component in two different places on the site, and in one context we want to run a different doSuccessAnalytics() function?

Prior to the FlightJS 1.2 upgrade, we would do it this way:

The "Override Functions in the attachTo" Approach

component.js, with abstracted analytics

define([
    'flight/lib/component'
], function(
    component
){
    return component( componentCode );
    function componentCode() {
        // Define default attributes for the component
        this.attributes({
            // default analytics implementation for component
            successAnalyticsImplementation**:** function () { /*...*/ }
        });
        // Once the user has successfully completed an action, update the DOM accordingly
        this.updateDomOnSuccess = function () { /*...*/ };
        // Fire analytics indicating that the user has successfully completed an action
        this.doSuccessAnalytics = function () {
            if (this.attr.successAnalyticsImplementation){
                this.attr.successAnalyticsImplementation();
            }
        };
        // Set up listeners to make the component do things
        this.after( 'initialize', function () { /*...*/ });
    }
});

With the above set of changes, we now have the ability to override the analytics function by passing a different implementation in via the .attachTo call for our component’s different context. But is this much better? All we have done is push concern of analytics for a component up to the page level, where these components are being attached. This introduces the potential issue of failing to fire analytics when we add our components to new pages (by omitting an analytics implementation).

To rectify the aforementioned issue, we shifted to the following pattern:

The "Move the Bulk of your Component’s Implementation Into a Mixin" Approach

mixins/with-component-core.js

define([
    'flight/lib/component'
], function(
    component
){
    return componentCode;
    function componentCode() {
        // Define default attributes for the component
        this.attributes({ /*...*/ });
        // Once the user has successfully completed an action, update the DOM accordingly
        this.updateDomOnSuccess = function () { /*...*/ };
        // Fire analytics indicating that the user has successfully completed an action
        this.doSuccessAnalytics = function () {
            // default analytics implementation for component
        };
        // Set up listeners to make the component do things
        this.after( 'initialize', function () { /*...*/ });
    }
});

This pulls the bulk our components implementation into a mixin, to be shared between different implementations of the component as follows:

component.js

define([
    'mixins/with-component-core'
    'flight/lib/component'
], function(
    componentCore
    component
){
    return component( componentCore );
});

tests/component.js — with variation in analytics

define([
    'mixins/with-component-core'
    'flight/lib/component'
], function(
    componentCore
    component
){
    return component( componentCore, withVariationInAnalytics );
    function withVariationInAnalytics() {
        // Fire analytics indicating that the user has successfully completed an action
        this.doSuccessAnalytics = function () {
            // overriding analytics implementation for our test
        }
    };
});

Following this approach, we can now provide a default analytics implementation, override it at the component level, and not have to worry about remembering to include it when we add the component to a new context. However, we were forced to move the majority of our component’s implementation into a mixin, one that can essentially stand alone as a component, which totally defeats the purpose of the mixin pattern.

Enter FlightJS 1.2, which introduced component.mixin(). We can now solve this problem as follows:

The "Flight 1.2’s component.mixin Function is the Answer to All of Our Problems" Approach

component.js

define([
    'flight/lib/component'
], function(
    component
){
    return component( componentCode );
    function componentCode() {
        // Define default attributes for the component
        this.attributes({ /*...*/ });
        // Once the user has successfully completed an action, update the DOM accordingly
        this.updateDomOnSuccess = function () { /*...*/ };
        // Fire analytics indicating that the user has successfully completed an action
        this.doSuccessAnalytics = function () {
            // default analytics implementation for component
        };
        // Set up listeners to make the component do things
        this.after( 'initialize', function () { /*...*/ });
    }
});

tests/component.js — with variation in analytics

define([
    'component' // path to component.js
], function(
    originalComponent
){
    return originalComponent.mixin( analyticsOverride );
    function analyticsOverride() {
        // Fire analytics indicating that the user has successfully completed an action
        this.doSuccessAnalytics = function () {
        // overriding analytics implementation for our test
        }
    };
});

This new pattern solves the aforementioned issues, and comes with the following benefits:

• We can implement the component as it is intended to behave in the majority of cases.
• We can provide variations of the existing component without having to touch our original component.
• As a bonus, it is much more semantically clear as to what we are trying to achieve for the purpose of our test.

By following the guidelines above, and leveraging the power of FlightJS and its component.mixin() function, it becomes easy to write testable client-side JavaScript that encapsulates functionality in a clear, concise manner. As a result the reading, reasoning about, and extending the code becomes much more straight-forward because our component definitions are more expressive and easy to follow. We hope you find the mixin() pattern as valuable as we do.

Originally published at www.retailmenot.com on November 18, 2014. Now available at engineering.ziffmedia.com. Forever available on Luke's Blog

As stated in my Since Graduation post, I have been working on a TV show script. I've been playing with different software for writing scripts. I've tried Apple's Pages (with my own custom template), a trial of Final Draft (which I decided not to pay for), among other things. As a coder who is accustomed to working with plain text, none of these solutions are ideal for me.

One night, I thought: what if I could write my TV scripts in plain text just as I do my blog posts? So I created scriptdown. Inspired by Markdown. For me, this is the optimal way to write TV scripts. I can track them in a git repository and treat them like code. The coder in me loves it.

This project was also a quick way to play with Python. I won't update or enhance this script beyond my own needs, but it was a fun little project to throw together.

I have since paused my TV writing ambitions, packed up my apartment in Ann Arbor, moved to Austin, and began working at RetailMeNot.

I've learned A LOT. The UI team is led by Mike Cravey, he's a great leader and has helped me grow and begin to realize my potential as a software engineer.

I won't go into too much detail about what I've worked on in my short time here, but some highlights:

• Lots of front-end components and improvements.
• I've refactored numerous components for reuse across different contexts.
• I built an admin tool for our marketing team to generate the html for their weekly emails. This saved them hours each week by automating a previously manual process.
• I worked with two other engineers, a project manager, and a designer to redesign our mobile website
• RetailMeNot relies on being at the top of Google's search results. Thus our pages need to be fast and highly ranked. I have worked on performance improvements to the end of speeding up the webpage and boosting SEO.
• I've implemented lots of AB tests that we have run on the website to help us optimize our user's experience and reduce their bounce rate back to Google search.

Since the site went live, a lot has happened. We had the protest on October 25, and the CTE has remained hard at work on this issue.

I just wanted to give them a quick shout-out. Today, everyone involved in this effort is celebrating a big win. The University of Michigan Regents voted on the issue, approving a change to Michigan's residency guidelines.

The approval means affected students pay $27,250 less in tuition. In the fall Michigan residents will pay $13,142 a year, while non-residents will pay $40,392. Under current tuition levels, the difference amounts to $109,000 over the course of four years.

Many people fought long and hard for this, and FOKUS' My Dream Is Bigger Than campaign was just the beginning.

Audience

The intended audience for this post is web developers, as the information is only useful to them, but anyone who reads it might learn something.

Background

As most people know, I have been very interested in web development, which I have been learning and working on for quite some time. When I started learning, like most people, Google was my best friend. Anything I needed to know about web development, I would search on Google. Anyone who started learning web development this way should recognize the name w3schools, which is commonly ranked very high in Google's results. Fortunately, I also am a big fan of StackOverflow, and frequently ask questions and search for answers on there as well. Fortunately, one day early in my learning days, I stumbled across this comment on StackOverflow, which is in response to a question that referenced w3schools.

w3schools is a terrible reference. Please avoid it, and don't trust information they publish.

and the next comment:

check out: w3fools.com for evidence of w3schools poor quality

I suggest that you read w3fools, not only to see the argument against w3schools, but also because you will learn a lot of small nuances about web development in doing so.

Conclusion

Because it can sometimes provide incorrect information, and typically when I end up on the site, its for information I don't know, I wanted to avoid the site altogether. As suggested at the bottom of w3fools here, I blocked it from my Google results.

After educating myself on this matter, I turned to this StackOverflow question which helped shape my ultimate opinion. Read through the question and answers yourself, but my takeaway can be best summed up with the following excerpt from this answer:

In short, we should be thinking for ourselves when deciding what specific page is a good reference, not relying on a blanket statement made by a 3rd party.

Which is really just a good rule to follow in life.

Don't worry, Reeder won't die with Google Reader.

— Reeder (@reederapp) March 14, 2013

The real purpose of this post, however, is to inform people what Google Reader is was, because a surprising number of people I have talked to have told me they had no idea.

Google Reader is an RSS client, so in order to understand what Google Reader is, you must first understand what RSS is. RSS stands for "Rich Site Summary", or "Really Simple Syndication". Most news sites or blogs publish what is called an RSS feed. This feed is a file that can be accessed over the internet that represents a list of all of the content that has been published to the site. For example, Twitter publishes RSS feeds for each of its user's tweets. An RSS reader could subscribe to this feed, and use it to display a user's recent tweets to a subscriber of the feed.

Google Reader had the added bonus of living 'in the cloud', which means it could act as a central hub for my client, "Reeder". This enabled my read and starred status of articles to keep in sync across all three of my devices, so reading an article on my iPhone would mark it read on my Mac and my iPad when those clients synced with Google Reader.

On the technical side of things, this RSS feed is represented as an XML document, you can view the feed for The Verge by visiting the following URL: https://www.theverge.com/rss/frontpage. You should view the RSS feed so that the next paragraph makes sense to you.

An RSS reader maintains a list of all of the feeds that a user has subscribed to, and displays to them a list of posts for each feed. As you saw, the XML document is not pretty. To a human, it is almost unreadable, but it is in the exact format a computer needs in order to be able to understand it as a list of articles. You might have noticed a bunch of similar looking blocks in the RSS feed, such as this one:

<entry>
    <published>2013-03-141T17:59:20-05:00</published>
    <updated>2013-03-15T17:59:20-07:04</updated>
    <title> ... </title>
    <content type="html"> ... </content>
    <link rel="alternate" type="text/html" href="..."/>
    <id>...</id>
    <author>
        <name> ... </name>
    </author>
</entry>

Notice how this item is surrounded by an opening <entry> and a closing </entry> tag. Each article is represented as an entry, and within each item there is information such as the title, a link, and the date the article was published. This opening and closing tag convention comes in handy for the computer to make sense of the XML document. The opening and closing tags help the reader separate the document into a list of items, and learn important information about each item. The RSS reader does so through a process called parsing.

Once the RSS reader has parsed the document, it can use the parsed data to display articles in a way that is meaningful to you, the user.

The loss of Google Reader creates a big hole for many people that needs to be filled. I am eager to see who fills it in, hopefully breathing new life into RSS along the way.

On December 16, 2012, I graduated from the University of Michigan with a Bachelors of Science degree in Computer Science from the College of Literature, Science, and the Arts.

What've you been up to?

A lot of people have asked me what I've been up to since graduation, and why I, like most graduates, didn't start a job straight out the gate. I've been doing a few things:

Writing a TV show

I have always loved film, and have taken a few courses through the film department here at Michigan. Last semester, I took SAC 311, an introductory TV writing class in which I wrote an episode of an existing TV show. I wrote an episode of Modern Family.

Last semester, while in this class, I also began working on an original idea for a TV pilot with a friend of mine who recently graduated from Michigan's Screen Arts and Culture department (read: film). The show is a Louie-esque comedy about recent college graduates in the city of Detroit. We have been working diligently to complete the pilot, and our goal is to have it completed within a couple of months. Since graduating, we have ramped up our efforts on the show, and I have been unofficially auditing SAC 411, the second level TV writing course at Michigan, in order to learn further about writing TV pilots.

Working on web development

Since my internship at Zappos this summer, I have taken a big interest in web development (in particular, front end development), and have been doing as much as I can to learn more about it.

Tech advisor for BitBox

A good friend of mine is working on starting a company, BitBox. He wants to provide an effortless exchange between Bitcoin, an emerging online currency, and the US dollar; in hopes of helping Bitcoin become more mainstream and accessible to the masses.

I have been helping BitBox flesh out their technical direction, help with their website, spread the word about Bitcoin, and screen potential candidates for employment. Additionally, I will be working with them to perfect their pitch, and joining them on the 2013 Bay Area Entrepreneurial Experience (now called the Weather Underground Startup Trek), a University of Michigan sponsored event for entrepreneurs.

Visiting my grandma

Toward the end of last year, my grandmother has not been doing as well as she'd been doing in months prior, so I've been taking out a little extra time to visit her more regularly.

Job hunting

This should go without saying.

Introduction

Mike and I, both being Computer Science students, have grown very passionate about Computer Science as a field of study. Unfortunately for us neither of us had any exposure to CS prior to EECS 183/ENGIN 101 here at the University. Such is the case for every student within the Detroit Public School district where there is no curriculum in place to teach students any amount of Computer Science, which is the fastest growing industry in the world today. If we are serious about preparing our children for the future past High School, we are doing them a disservice by not offering them any Computer Science related courses.

Our greater goal is to design an after school program curriculum to expose High School students to Computer Science. A part of that goal, is enabling them to teach themselves, and ultimately prepare for the AP EECS exam.

To help us achieve this goal, we developed an iPad application, with an accompanying study guide that aims to give the student a broad understanding of the content that will be on the AP EECS exam. This app, in conjunction with other resources, helps prepare the student for the AP EECS exam. This app can be used as part of achieving our wider goal of offering an after-school Computer Science course in High Schools that don’t otherwise offer any computer science related content.

EECS 101 at UofM

Last semester marked the first offering of EECS 101, a course taught by Jeff Ringenberg which is designed to be equivalent to the new, more theoretical AP EECS exam. Having this class offered at UofM enables the University to accept AP EECS credit from incoming students who did well on the AP EECS test. We worked with Dr. Ringenberg and used his course slides and information in designing the study guide and accompanying questions for this app.

The Study Guide

Half of the goal of this independent study was to have a study guide that clearly, and concisely presents the student with AP EECS course content. This study guide is embedded within the application behind the “Study” button in the upper-right hand corner.

The App

The app itself is primarily a question asking application that enables the user to study the content in the study guide. A button in the top right of the app, labeled “Topics” will present the user with a list of topics that they can study in-app. Selecting a topic causes the app to begin asking the user questions for the selected topic. As the user cycles through the questions, their progress is tracked and saved, so they can track their progress as they learn the material.

The content of the questions that the app asks are defined using xml, and adding new topics or questions is as easy as modifying the xml file. The app supports various question types, and developers can easily add new ones by inheriting from a base class that we created. Additionally, images can be added to the questions within the XML file by just adding an attribute to that question.

The Outcome

When we first set out to create this app, we had the vision of using it as just a study guide for EECS 101. Along the way, however, we realized that this app can be used as a study platform for literally any subject one wants. After this was decided, we abstracted the app enough to be able to handle questions from any subject, as long as they follow the construct we created for questions. Making the app in this manner opens up the opportunity for growth in any area of study, anyone can create a 'course', upload it to the internet, tell the app where to look for it, and study the materials provided.

I am in talks with a professor at the university about turning the source code over to Michigan for continued development. Unfortunately, neither Mike nor I have had any time to do much with the app since we've handed it in, but a few screenshots are below to illustrate the way it works.

We created the animations in Adobe Flash CS6, and all of the code in C# using Microsoft's XNA.

Embedded above, you'll find a video of the game in action. The battle you see takes place at Michigan's Burton Memorial Tower between Rudy of Notre Dame, Brutus of Ohio State, and Denard Robinson of Michigan.

Luckily, my summer experience got me heavily into web development, so I decided to rectify this issue. The new lukezilioli.com is a project I built from the ground up. It fits my needs very well, and I suspect the simplicity would be enticing to some would-be bloggers, but currently I only intend on using it for my own personal use.

Right now, much more energy has been put into the site itself, and little has been put into the content. Now that the new version of the site is up and running, I intend to change that, and will be posting more content.

Jeff Atwood has tried to make the argument that Software Engineering is dead. I see a lot of merit behind the software engineering process itself, so I don't agree with Atwood's conclusion, however I wholeheartedly agree with one of his arguments: there is a certain aspect of craftsmanship involved in making software products that doesn't exist with other forms of engineering. Nothing makes me feel like a craftsman more than web development, which at its core is a combination of many existing and emerging technologies. In the Shoutouts section below, I discuss many utilities that I have used and integrated while working on my site.

Shoutouts

Markdown

In the past year, I have fallen in love with markdown and its syntax. Because of this, I knew I wanted to write my blog posts in markdown, so I took the simplest approach I could think of. Every post you see on this site is a simple .md file. There is a file called meta.json which contains information for each blog post on the site. Each entry in this file corresponds to one markdown file. As an example, the post you are currently viewing is represented as:

"id":"13",
"title":"Welcome to the New lukezilioli.com",
"filename":"lzcom.md",
"format":"md",
"date":"2012-11-05",

Currently, I have to enter this information manually, but I plan to implement a page that enables me to create new posts directly on the site.

Sass

One thing I love about web development is CSS and the ability to directly command the layout of a page. While CSS is great, it definitely has its shortcomings. Designed to rectify many of CSS's shortcomings, is Sass. There are many great features of Sass which you can check out on their website, but by far my favorite is the ability to add @media queries to your CSS with a few lines of code using mixins.

The following, which declares that the header should have a left margin of 10px, unless the page is being viewed on a mobile device, in which case, it should have a left margin of 0px, would look like this in CSS:

#header {
    // Other styling for header
    margin-left: 10px;
}

@media only screen and (min-device-width: 320px) and (max-device-width: 800px) {
    #header {
        margin-left: 0px;
    }
}

and like this in Sass:

    #header {
        // Other styling for header
        margin-left: 10px;
        @include respond-to(mobile) { margin-left: 0px; }
    }

This is much cleaner and easier to read. By looking at the styling under #header, we can easily see what was less obvious in the CSS example.

Such functionality is thanks to mixins, and a tutorial of how to do what I just discussed can be found here. Under the heading: "The Future of Media Queries in Sass"

Prettify.js

Prettify.js is a neat little javascript utility that allows me to have syntax highlighting on my site. Once a post has loaded, prettify jumps in and separates the code blocks into a bunch of <span>s, whose classes I can target in my CSS for syntax coloring. Neat, huh?

ZeroClipboard

If you are viewing this page on a computer with flash installed and enabled, you should see a little white file icon within code blocks. Hovering on this icon reveals its purpose: to copy the code to the clipboard. To achieve this, I used the plugin ZeroClipboard, which 'glues' a small flash video on top of the file icon. This video captures the click and uses flash to place text on your clipboard.

Twitter Bootstrap

Twitter Bootstrap is just fantastic. I relied on it much more this summer, however it was a great reference in styling things such as pre and code blocks.

FontAwesome

FontAwesome is really great. It offers tons of scalable icons that designers can add to their site. These icons look great no matter the size you make them, and no matter the device on which they are being displayed, no more retina woes with bootstrap's glyphicons.

When FOKUS, a student org I'm in decided to join the CTE last year, I was very excited at the prospect of helping them out in any way possible. This year, when we stepped up to the plate to help them promote their protest on October 25, I jumped at the opportunity to be on the committee. It was a good opportunity to support a good cause, and learn some more web development.

Check out the website I created here. The site was designed by the incredibly talented Mallika Roy.

Update - 2012/10/25

The protest was today, and it was a success. The Michigan Daily wrote an article about it. Check that out here.

Update - 2013/07/18

The Regents voted on the issue today. Read more here.

ToDo (now called Finishit), an Android application I developed as part of an independent study at UofM, and subsequently started selling under my LLC, Starbelly Software is featured on the University of Michigan CSE Website.

Check it out here.

Because of my OCD, I insist on saving these files with their filenames as yyyy-mm-dd.jpg. This way, Finder sorts them and I can easily revisit them in order.

To save myself some of the effort of renaming these files every day, I went ahead and wrote a ruby script that does it for me. I can get my daily dose of garfield simply by running this script and opening the file it drops on to my desktop.

Instructions below.

Save the following script to a file such as ~/Desktop/garfield.rb and run it with ruby ~/Desktop/garfield.rb 2012-09-27 or just ruby ~/Desktop/garfield.rb.

require 'net/http'
require 'uri'
require "open-uri"

# This regular expression matches a date that
# is in the form ####-##-##
regex = /\d\d\d\d-\d\d-\d\d/

# Get the date for the comic we are retreiving,
# what's passed to the command line or the current
# date if nothing
if(ARGV[0])
    date = ARGV[0].gsub(/-/, "\/")
else
    # Match the date in time.now.to_s using the regex,
    # and then replace the dashes with slashes for the url
    date = regex.match(Time.now.to_s).to_s.gsub(/-/, "\/")
end

url = "http://www.gocomics.com/garfield/#{date}"

# Perform the HTTP get request
url = URI.parse(url)
req = Net::HTTP::Get.new(url.path)
res = Net::HTTP.start(url.host, url.port) { |http|
    http.request(req)
}

# Pull the src url for the comic image itself from
# the html for the page
url = /img alt="Garfield" .*src="([a-z:\/.0-9]*).*/.match(res.body)[1]

# Reformat the date to contain '-'es instead of '/'
# es to save it to the desktop
date = date.gsub(/\//, "-")

# Save the file to the Desktop in the format yyyy-mm-dd.gif
open(url) {|f|
    File.open(File.expand_path("~/Desktop/#{date}.gif"),"wb") do |file|
        file.puts f.read
    end
}

My first day at work here at Zappos, I had a meeting with my superhero (read: mentor) and a few members of the API team. I was given my own project to work on, left in charge of everything from determining what technologies to use, to designing the user interface. Basically the meeting went like this: "We have this API here for you, and we want a front end for these 4 controllers. Now GO!". The 4 controllers are all controllers pertaining to managing which third party developers have access to the Zappos public API.

I decided to do my project as a Rails app, using Twitter's bootstrap for the front end. Having not done any web development in the past, I had to spend my first couple of weeks at work teaching myself Ruby, Rails, Javascript, CSS, and HTML. I worked through a few tutorials, and did a lot of research as to the best approach for the project.

I was quite happy with the way the project came out, and based on feedback from the people using it, I think they are too. For the rest of the summer, it looks like I will be working with my actual team: Zeta, on bug fixes, etc. It will be a different experience compared to my first project because I will actually be functioning as a member of a team working on code for the actual Zappos website. I'm very excited to get going with this. Check back for updates.

USA Today has written an article about video games used as ASD therapy, and it mentions my class by name. I thought it was pretty cool and something worth sharing. Find the USA Today article here.

Update - 2012/06/06

To corroborate the story, the kind folks over at the University of Michigan made a video about the class. I'm even in it for a brief moment!

Anyway, the other day a friend and I got to talking about adding new music to out libraries, and the headache involved in assimilating the new songs' metadata to our preferred formats. I mentioned an AppleScript I had written that uses sed to do a lot of the heavy lifting. He expressed interest in seeing what I had done and I realized there was no good way for me to show him. Enter github. With encouragement from Tony, I have finally registered and set up my first public git repo.

Update 2012-08-01: I was wrong about git, and have seen the light.

fs setacl path/to/repo/ rlidwk

rlidwk - explained

However, once the repo has been created, its not quite as easy. From what I can tell, this is because this command sets the access control list (ACL) on the directory, and when you later svnadmin create path/to/repo/, all of the new files (or files added any other way, for that matter) inherit the ACL from the parent directory (I am unclear as to whether this happens upon file creation, or upon access of the file, as it seems the only thing that matters in the solution is the ACL on the directories). Thus, if you need to change the ACL for an already existing repo, you will have to set the ACL on every directory within the repo as well. After much searching, and trial and error, I found that this can be done with the following command:

find path/to/repo/ -type d -exec fs setacl {} rlidwk;

Basically, what this command does is searches for all of the directories within the repository, and for each one, executes the fs setacl command.

Note: At the very least this will apply to those on an OpenAFS network file server. At most, it will apply to more than that. Either way, it is the hope that somewhere, somewhat this post ends up helping somebody and saves them the time I put in trying to figure it out.

Our assignment for the semester was to make a Microsoft Kinect game designed to be therapeutically beneficial to people with Autism Spectrum Disorder (ASD). Given that we were a class full of computer scientists, none of us knew anything about ASD; considering that we were making games designed to help people with ASD, we had to figure out what developmental deficiencies we could help improve through our medium of video games.

And theres also a USA today article about us here.

Dancezilla

Because of the size of the class, we split into 9 or 10 teams of 3-5 people each. There were a total of five people on my team. We created a 70's themed dancing game by the name of Dancezilla. The game maps the player's movements to an in-game 3D character, so that anything the player does is mirrored on-screen. The object of the game is to dance while reaching for 3D spheres that are flying around you. When you successfully come into contact with one of the spheres, it explodes adding points to your funk-o-meter. Once the funk-o-meter is full, you have beaten the level.

Our goals in making this game were to aid in the development of the following skills:

1. Process multiple stimuli - Certain patients of ASD often get overwhelmed when presented with what most of us would consider to be a reasonable amount of stimuli. Because of this, some ASD patients find it difficult to attend large events, movies, theme parks, etc. due to their very stimulating nature. We addressed this within our game by increasing the amount of stimuli that the user experiences as they advance through the levels–on level 1, they would only be presented with one or two spheres at a time, ensuring that they wouldn't become overwhelmed. As levels advance, the number of spheres increases, in addition to their speed increasing and the complexity of their paths increasing as well.
2. Improve hand-eye coordination - Many ASD patients also struggle with simple tasks that require hand-eye coordination. By making it the player's goal to destroy spheres, and rewarding them when they do so (by adding funk to the funk-o-meter, and animating an explosion, something kids in our testing couldn't get enough of), Dancezilla encourages players to work on their hand-eye coordination, a skill required to make your body actually come into contact with the spheres.
3. Remain in control under exertion - Some ASD patients, particularly younger ones often have a hard time remaining in control when physically or mentally exerted, often getting frustrated beyond being able to complete a task. We all know that dancing is physically tiring, however, Dancezilla-ing is both physically and mentally tiring, because it requires you to focus on destroying spheres while dancing. As I discussed before, Dancezilla is a game of increasing difficulty, so it helps the user grow more accustomed to increasing levels of exertion as the game advances. Similar to how this increasing difficulty helps ASD patients process multiple stimuli, it also helps them grow more comfortable with higher levels of physical exertion.

In addition to the features of the game I described above, I implemented what we ended up calling "Caregiver Mode", a game mode in which a caregiver of the ASD patient can use an Xbox 360 controller to spawn balls on command, or spawn a special ball that they can then control with the joysticks. This enables caregivers to use Dancezilla in any way they see fit. For example, if their patient has particular difficulty doing reaching over their body, I.e. using their right hand to pick something up that is to their left, the caregiver can position the special ball on the side of the player, and instruct them to destroy it using the arm on the opposite side of their body.

Pictured above: Screenshot of Dancezilla. I can't take a screenshot and play at the same time, so the 3D on-screen model is in his default position. Hopefully I can get a video uploaded at some point.

Thankfully, there is a way to have svn ignore certain files or folders. These preferences are on a per-directory basis. To tell SVN to ignore a particular file or folder, first navigate to the directory in which the file or folder lies, and type:

svn propedit svn:ignore .

A text editor will open with a file containing everything within that directory that SVN will ignore. Place whatever you like in this file, separating different file or folder names on individual lines. You can use wildcards as well, for example, if you don't want any .txt files to appear in your SVN repo, enter *.txt.

Happy version-controlling!

I looked into a few programs offered through the University, but ultimately felt like they all cost way more than they were worth–so I set out to get the same benefits of those programs without wasting my money.

Fortunately, my Dad has some friends in Málaga, Spain that were willing to put me up when I first arrived while I figured out what I was going to do. The first week I was there, I just spent time with my dad's friends enjoying Málaga and practicing my Spanish while I found a local school at which I could take a class to formally learn more of the language.

For the latter two weeks that I was there, I took a Spanish class with people from all over Europe who were also there to learn Spanish; we had people from Morocco, Italy, Russia, Germany, Iceland, and Scotland, among other countries. While I was taking this class, I also paid to live with a local woman. She fed me home-made Spanish food everyday, and spoke nothing but Spanish, so basically, if I wanted to eat, I had to be able to communicate.

Immersing myself in the language was definitely the way to go; when I got back to Michigan for Fall semester, when I took my last required Spanish course (Spanish 232) I was the only person who could understand what our professor was saying to us. Everyone else in the class looked to me to translate.

At the end of my time in Spain, I flew to Hamburg, Germany and spent 5 days with my good friend Rasmus, who I met my Junior year of high school when he was there for a year as a foreign exchange student. To cap it all off, I stopped off in New York for a few days en route back to Detroit to visit my friend Steve, who had a summer internship out there.

I use Subversion (SVN) as my version control software for all of my Android development. Although a powerful tool, it is not always obvious how to achieve the goal I want. Here are some Tasks I have needed complete using SVN, and how I went about doing so.

NOTE: For all of the following instructions, assume we are working in the user's home directory.

Moving repo A to a server

1. Dump the repo A

    svnadmin dump A a.dmp

2. Copy the dump to the server.

    scp a.dmp username@ssh.server:path:to:file

In my example, I use scp, however you can use FTP, or any other means of getting the a.dmp file to the server.

3. Connect to the server

   ssh username@ssh.server

   You will likely be prompted for your password.

4. Create the new repository on the server.

   svnadmin create NewRepo

5. Load a.dmp into the new repo.

   svnadmin load NewRepo < a

What if you want to create a new repo, that acts as a parent for your already existing repos?

Moving repo A, and repo B into a new parent repo C

1. Create the new repository

   svnadmin create C

2. Create A and B directories within the newly created repository

   svn mkdir file:///path/to/home/dir/A -m "Adding A directory"
   svn mkdir file:///path/to/home/dir/B -m "Adding B directory"

3. Create dumps of repo A, and repo B

   svnadmin dump A     a.dmp"
   svnadmin dump B     b.dmp

4. Load these dumps into the subdirectories of repo C

   svnadmin load C/ -parent-dir A < a.dmp
   svnadmin load C/ -parent-dir B < b.dmp

As I developed ToDo, I was using a lot of onClickListeners, especially on the Task Details screen. In onCreate, I was setting up onClickListeners for all 4 priority radio buttons, as well as for the Pick Date, and Pick List buttons. While this was an acceptable implementation, I have always thought onClickListeners were an ugly API requirement.

That's why when I learned about being able to specify android:onClick for Buttons in the layout.xml files, I immediately jumped on board. I retroactively removed all of my onClickListeners, and changed them to functions specified by the android:onClick xml attribute.

GREAT! Clean code, happy coder. But, of course, it was almost too good to be true.

I do extensive testing of all of my apps before releasing them, however most of this testing is done on the emulator, with the APK as signed by eclipse for debugging. This is a mistake–one I will not make again.

The Problem

As I got closer to the release of my application, and learned that the Android Market's copy protection was going to soon be deprecated, I began researching the Android Application Licensing scheme, and implementing this in ToDo. All went well. I thought I had licensing implemented and working flawlessly.

Part of implementing licensing (and a good practice in general) is using ProGuard, as recommended here, when exporting your unsigned application or obfuscate your application's code and make it more difficult to hack.

Having tested my application extensively on the emulator, and under the impression I had the licensing working perfectly, I uploaded my app to the Android Market, and published. My friends were the first to download the app, and then immediately reported that anytime they clicked on a button in the TaskDetails screen, the app would crash. I installed it on my Android handset, and sure enough was able to re-create the issue right away. Plugging it into my computer, and looking at the LogCat's output in the DDMS prospective, I was able to deduce that the app was unable to find any of the functions that were being called by my buttons' onClick xml attribute.

WHAT THE F? I double checked the function names, and they were defined correctly, as specified in my xml files. After much experimentation, I narrowed down the possibilities as to what could be causing this issue, and determined that since it wasn't happening in the emulator (before I was exporting and signing my application), and it wasn't happening prior to implementing my application's licensing, that it had to be something occurring in between exporting my application, and signing, and zipalign-ing it. What is in between these steps that wasn't before? ProGuard. Of course, ProGuard was, unbeknownst to me, making optimizations in my code. Because my onClick functions were never being called from my code (as they were only referenced from my xml), ProGuard decided they were "dead code" and removed from my exported APK.

The Solution

Once I identified the problem, conceiving the solution was simple. Implementing it was a whole 'nother story. I knew right away I would have to add some kind of additional -keep option in the proguard.cfg file, but was very against adding a line for every function I specified to be called by a button's onClick attribute. My solution is this:

Step 1: For every function called by a button's onClick, pick a naming convention: i.e. onclick_functionName

Step 2: In the proguard.cfg file, add the following

-keepclassmembers class * {
    public void onclick_*(android.view.View);
}

This tells ProGuard to keep any function that is in any (*) class, whose signature is public, returns void, name starts with "onclick_" and who takes a single parameter of type android.view.View.

Don't forget to update the android:onClick xml attribute in your layouts, or the app will crash for a different reason.

I asked this on StackOverflow but got a response I was not entirely happy with. The primary advantages to my approach are that the functions can exist in any class, not just a single class specified as in the StackOverflow response.

I hope this was helpful, and that I saved you the time I spent.

Update 2013-01-01: This post was updated to remove links to the app on the amazon and google marketplace. As The app is no being longer sold or maintained.

Winter term 2011, I did an independent study through the Computer Science department at Michigan in order to better learn Android development. During the course of the semester, I developed ToDo, a simple task management Android app featuring multiple lists, notification reminders, and tons of user-customizable settings. ToDo has since been renamed to FinishIt, but what its about hasn't changed.

It was also featured by the University of Michigan. here

FinishIt Features

• Alarms - Get reminded of the stuff you have to do.
• Password Protection - Set a numeric passcode to keep your friend's and relative's prying eyes away from your tasks. Set an amount of time you can be gone from the app, and not be prompted for your password on return. If you are gone for longer then this amount of time, you will be re-prompted for your passcode. This is great for switching between applications.
• Simple Display - Displays your tasks in an elegant list. See the information you need, when you need it.
• Smart bar - At the top of every list, you will see the smart bar, a quick at-a-glance view of your progress for the currently displayed list.
• Multiple List Support - Create, rename, and delete lists 'till you heart's content. Features 3 smart lists, All Tasks, Done Tasks, and Today so you can view what you want, when you want.
• Multi-Edit Mode - Edit multiple items at a time to mark as done, move to a different list, modify the due date, or delete them in one fell swoop.
• Clean Up - Delete completed tasks, or all tasks quickly, and easily for whatever list you are currently viewing.
• Innovative Date Slider - Slide left and right to intuitively select the month and date in which your task is due. No more clunky + or - buttons to deal with.
• Simple Task Creation - Clean and intuitive task creation screen, featuring task title, done status, list, due date, priority and a note.

Plus Many More!

• Rapid Fire Mode - quickly create more then 1 task
• Sorting Options - sort your tasks by Name, Due Date, or Priority
• Highly Customizable - offers a plethora of settings so the app behaves the way you want it to
• Quick Task Deletion - turn off the task deletion prompt for even faster task organization.

Starbelly Software, LLC.

Once the semester ended, I decided that I wanted to continue development on FinishIt and release it on the Android Market. To do so, I formed a Michigan LLC. I spent the first few weeks of the summer readying ToDo/FinishIt for release and trying to come up with a name for the company. Once that was done, and Starbelly Software, LLC was legit, I released ToDo for both the Google Market and the Amazon app store.

As of 2013/01/01, it has sold over 480 copies.

Expected FS format '2'; found format '4'

I found many suggestions on the internet, however what ultimately worked for me was this

svnadmin create -pre-1.5-compatible repoName

You need to add the -pre-1.5-compatible flag to get it to work correctly. I am not sure what caused the issue, but I assume it was something relating to SVN being upgraded either on my local machine, or the university computers. Just thought I would post this here in case anyone else is having the same issues.

This summer, while taking Calc III and Physics II at Wayne State, I was also working for SHAPE Detroit, a part of Adult Well-Being Services.

SHAPE works with women within the city of Detroit to educate them about various health issues. One thing that SHAPE does for the community is put on weekly workshops to educate women about HIV/AIDS. Their problem was that after these workshops, they had no way of remaining in contact with these women and keeping them up to date with the latest news or health risks.

In order to rectify this problem, they hired me as their Social Media Manager under a grant that they received to kickstart a social media campaign. At the beginning of the summer, a consultant and I worked with the director of the SHAPE office in order to determine their social media plan. Once the plan was formulated, it was left up to me to put everything into place, and train the necessary people on how to use/maintain it once I left.

In addition to the obvious social media platforms (facebook, twitter, and blog), SHAPE wanted a sacred place that they could interact with past workshop participants (and past participants could interact with each-other) in order to further discuss HIV/AIDS in a private, anonymous forum.

The first month and a half, I set these things up, ensuring that they had a consistent theme and branding across sites. Additionally, I configured it so that whenever they post to their blog, posts automatically go out to their twitter and facebook pages, eliminating the need for them to post the same content in three different locations.

Check them out here: Twitter • facebook

Multilingual

Because SHAPE serves English, Spanish, and Arabic speaking women, they wanted the blog to be able to reach people of all three languages. This is something that they did not realize until half-way through the summer, but I was able to accommodate their needs. The SHAPE Detroit blog supports multiple languages in two ways:

1. Authors at SHAPE can post to the blog in any of the three languages. There are separate RSS feeds for each language, and links to view only posts in a particular language.
2. There is a translate button on each post. Clicking this button allows the user to select any of the three languages, and using Google's translate API, translates them into the desired language. This way all of the site's content is accessible to everybody.*

*This was the case up until May of 2011, when Google discontinued their free Google translate API, in favor of a paid service. This broke this feature, and a few months later, SHAPE temporarily hired me to make some enhancements to the site, and they opted not to move to a paid translate service, so this feature has been discontinued.

Training

Once these sites were created, it was my job to ensure that all of SHAPE's authors knew how to post to the blog, and moderate the forum. Additionally, since SHAPE's employees were new to the platform, we decided that I would train the first couple groups of women on using the forum and accessing the blog in order to help things get off the ground. To that end, I created workshops, videos, and documents for both parties.

Assessing success

Since this grant was an experimental venture for organizations like AWBS or SHAPE, it was important to be able to assess the overall success of the efforts in order to determine if it is worth continuing to invest the necessary time and effort. For this, I recommended Google analytics, which I configured for the blog, and they are still using to monitor their success.

Putting it all together

I was responsible for presenting the social media plan. At the end of the summer, I presented the social media plan we developed and implemented to a group of AWBS partners in order to share insights from what we learned/were learning.

TxtArchive is an Android app I created in the Summer of 2009 for Zill Computer and Engineering, Inc. (ZillCE). It allows the user to archive and export the messages stored in their phone's SMS database, so that they can be safely removed from the device. It currently has 6700+ active users with an average rating of 4 1/2 stars on the Google Play store (as of 2012/11/15, its two year anniversary).

This was my first time developing a piece of software from its conception to its release. It was also my first experience with Android development.

In the summer of 2009, my friend Steve and I worked at Zill Computer and Engineering. Our primary job was to develop some C++ modules for a waste inventory system that ZillCE created and maintains for Dow Chemical. Fortunately, Steve and I finished this task sooner than expected, and needed to keep busy for the rest of the summer.

Since Android was just starting to take off, and Google was offering prizes to developers who submitted their applications to the Android Developer Challenge 2, our supervisor decided that we should get into Android development.

For the first few weeks, while Steve and I learned the basics of Java and the Android SDK, we also brainstormed ideas for the application. Eventually, we came up with the idea for TxtArchive, and began the design and coding process. After 2-3 weeks of development, our supervisors realized that we had a viable product on our hands, and decided to accelerate its release schedule.

TxtArchive was officially released onto the Android Market on November 15, 2009, and placed in the top 50% of applications submitted to Google's Android Developer Challenge 2.

In 2011, after forming Starbelly Software, I did some additional work on TxtArchive for ZillCE. There was a bug involving one of the most popular Android phones at the time–the Motorola Droid. User's messages were not showing up within TxtArchive, which was resulting in poor reviews on the Android app store, and in turn, poor sales. ZillCE hired me to track down the issue and implement a fix, which I was able to do by creating a separate Android utility application that we sent to some affected customers. When this application was run on customer's phones, it would (with the user's permission) email a diagnostic report to a ZillCE email account. With this diagnostic data, I was able to target and fix the bug, resulting in a four-fold sales increase.