Humans should never have to write strange punctuation to make their computers obey them. The computer should interact with humans in ways they understand: visual diagrams and standard English sentences.

The goal of this project is to provide a visual & plain English 1 programming environment.

!Important: This probably isn’t for you 2.

It is highly doubtful than any experienced software developers will find this useful in day-to-day development.

The goal here is not to:

  • make the latest whiz-bang programming language to churn out yet another lead submission tool for your sales team
  • replace javascript/ruby/java/c++/haskell/lisp/whatever
  • build an app, a website, a script, or a bot

The goal is to:

  • change how normal people work “on” their computer, instead getting them to work “with” their computer.
  • enable normal people to build tools to automate their digital lives
  • give the power of truly general purpose computing to the masses

This programming environment likely won’t be the fastest, most efficient, or most scalable way to get things done.

Vision: A day in the life of a Personal Computer

You open up the app. You see whatever you were working on yesterday. It appears to be a small spreadsheet-like grid showing a list of contacts.

  • You click the arrow in the headers to sort the list.
  • You click again to reverse the sort. So far, nothing that you couldn’t get from Excel.

Then you click the ellipsis at the start of one of the rows.

  • You get a custom view of that person’s data.
  • You see a profile picture, pulled from linked social accounts.
  • You see their address, with a map.
  • You see a preview of recent tweets and facebook posts.
  • You see emails this person has sent you.

You have heard they started a blog.

  • You click the plus icon
  • You paste the link to their latest post in the popup that appears
< [fancycats.blog/2018/11/04/mr-scruffles-goes-to-the-pub]
> Processing...
> This appears to be a blog article. One moment...
> I see this contact's name in the footer of the blog.
> Is this their blog? [Yes]
> Great! Any further details? [No]
  • The popup disappears
  • You now see previews of all the recent blog posts.

You want to stay current with the blog…

  • You click the ellipsis next to the list of blog articles
  • You select Add Action, then On New Post from the list of default options.
  • You select Display on Dashboard
  • You see several default rules generated from this action.
  • You click the default rule “Display until read”
  • You edit it to read “Display until read, or 7 days have passed”, because you are a realist.
  • You click the default rule “Display default tile”
  • You edit it to read “Display default tile with first paragraph as text.
    • This shows more of the article in the preview, instead of the default first couple sentences.

You decide to set aside some time to read it, so you don’t fall behind.

  • You add another action to the On New Post section.
  • You select Create an event
  • You click in the highlighted title placeholder.
  • You type Read the blog post title and hit enter.
  • It is annotated: “Read the blog post title”.
  • On the next line, in faded text, you see an example title using the latest article: Read "Mr Scruffles Goes to the Pub"
  • You click in the highlighted date placeholder.
  • You type if after 5 PM then tomorrow and hit enter.
  • The text is annotated if (posted) after 5 PM,
  • The phrase then tomorrow drops to the next line and is annotated: tomorrow (the following day after the new post)
  • An or ... prompt appears on the line below, and you click it
  • You fill in today
  • It is likewise annotated: today (the same day as the blog post)
  • You consider in the highlighted time placeholder.
  • You drag the if (posted) after 5 PM, phrase into the time spot.
  • A then ... prompt appears below, and you click it.
  • You fill in then after coffee and hit enter
  • A tooltip pops up: “You don’t have time for an average blog article (15 minutes) before your next appointment.”
  • There is an option to view your calendar.
  • You see that you have to leave only 10 minutes after your coffee to get to work.
  • You push the blog reading to then during lunch.
  • You fill in or after dinner on the next line.

You review the actions, which are summarized in plain English:

When a new blog is posted:
  - Display it on the dashboard.
    - Display the default tile, with the blog's first paragraph as the tile text.
    - Display until read, or until 7 days have passed.
  - Create an event.
    - The event title will be: Read `the blog post title`
    - If the blog is posted after 5PM, create an event during lunch the following day.
    - If the blog is posted before 5PM, create an event after dinner the same day.

Finished, you back out of the action screen, the profile page, and even the contact list. You are back on your dashboard, and you click the latest article to go read it.

Summary

Spreadsheets are currently the best we developers have come up with for making personal computing approachable.

This is a sad fact, but it is true. Might as well leverage the paradigm whenever we have lists of data to display/edit.

But we can do better, right?

  • We can give a WYSIWYG UI editor, and let people plug in data to various controls.
  • We can make it easy to connect to common web services, caching copies of data locally for better indexing and faster display.
  • We can add actions on common events, customized by data source, with reasonable defaults and easy to specify required inputs.
  • We can do very basic natural language parsing to extract if/then/else keywords, dates, times, etc.
  • We can make reasonable guesses at meaning
    • Like: tomorrow in the context of an action on a new blog post, and
  • We can provide detailed documentation of where we have made these inferences
    • Like: tomorrow (the following day after the new blog post).
  • We can do basic collision detection to prevent error states (double booking), and provide a way for the user to fix their own problems if we can’t suggest a reasonable alternative.

In short: we can make it not just possible, but easy to have the computer work for a normal person instead of the person having to work around the computer (which is frankly what most apps do today).

Call to Arms

This tool (probably) isn’t for you.

I mean, it would be kind of nice to use an app like what we just described, right?

It’s not like we have that today…

You will (eventually) be able to pitch in by:

  • Testing, finding, and fixing bugs
  • Writing plugins, like painlessly connecting to twitter…
  • Writing logic, like detecting overbooking on a calendar…
  • Writing story based tutorials like the one you just read.
    • These are interactive, and must be flexible enough to work around user input
    • These have a main “quest” (import a blog) with many sub-quests (add actions)
    • We need to teach first principles in a way that isn’t overwhelming.

Note about our users

Remember these are regular people. They aren’t professional programmers. They don’t understand:

  • algorithmic complexity
  • code reuse
  • code organization
  • safety!!!

And honestly, they shouldn’t.

We should make a system that is

  • fast enough
  • reusable enough
  • organized enough
  • completely safe

If we want to optimize common user generated algorithms, that is great.

If we want to recommend users keep a shared “recipe book” for common strategies, that is fantastic.

If you want to offer APIs (“integrations”) that do some voodoo with user data… that is not gonna happen.

We have too many APIs with too many points of failure and silos already on the internet. This project is about users working on their own systems with their own data (or their own local caches of web data).

We fight for the Users. Don’t ever forget that.

I fight for the Users

1 At some point, we will tackle localization and/or translation. But it is too big of scope for now. ↩

2 You are, after all, likely reading this blog on github pages, and are therefore likely already a software developer ↩