Kickstarter

Hi team,

Over the course of this project, we have designed, engineered and tested a lot of hardware and software.  We have purchased components for AGENT Smartwatch rewards.  We have built out an assembly and service center for AGENT Smartwatches, as promised, in the USA. Unfortunately we have also really struggled on the watch case design front, and our watch case design team has experienced significant setbacks.  

We have also been able to evolve AGENT technology beyond the original software we demoed and which was analyzed in-person by backers during the fundraising campaign and at several public events.  In today's update, I will show you some of the ongoing work that our team has done to make the developer experience for AGENT Smartwatches even better—and provide you with a download link if you would like to use some of the work in your own maker and wearable IoT projects.

I want to be very clear regarding expectations on technology work beyond that which was originally promised: Secret Labs has taken on a significant amount of debt to cover burn rate and cost overruns on this project related to the watch case design troubles, to cover lease and debt payments on the service center, etc.  With that, our technology team has been able to build some cool new technology for AGENT Smartwatch rewards—but the budget for ongoing (non-core) technology development is very limited (i.e. we are only be able to build part of the new technology prior to/without funding from retail sales).

ECMAScript 6 compiler

One of the projects we have put some significant effort behind is expanding the AGENT Smartwatch development platform.  From day one, we have had really great support for C# developers.  We really love C# and we really love C# developers.  But a lot of the world's developers write code in JavaScript—and we have been working on a from-the-ground-up implementation of ECMAScript 6 (commonly referred to as JavaScript) targeting the AGENT Smartwatch's runtime.

To be clear, this is not a small project.  It's an enormous project.  This is something that I would have loved to announce as an official feature for AGENT OS 2.0—but again, on the expectations front: late last year when the severe defects in House of Horology's work became more clear, I had to pull funding from this compiler project for the time being to focus available resources on final integration and solving the watch case design issues.  We can evaluate returning to this work later.

Secret Labs has published source code for the first component of the ECMAScript 6 compiler over on GitHub.

https://github.com/agentwatches/EcmaScriptCompiler

Compilers are specialized, complicated beasts.  I could write pages of technical details about how a company builds a compiler, but let me summarize it here to (over-)simplify things a bit.

For a device like the AGENT Smartwatch, an ECMAScript compiler goes through the following steps to turn ECMAScript ("JavaScript") code into binary code which the device can execute as a (compiled or interpreted) app:

• Lexical scanning/parsing
• (Abstract) syntax tree building
• Stack analysis and type checking
• Intermediate code generation (and optimization)

Lexical parsing is the process of breaking source code down into tokens which, as an analogy, can be thought of like words.  The line of source code "a = b + c;" would be broken down into "a", "=", "b", "+", "c", and ";".  If we were parsing the equivalent English sentence, we would similarly break down "A equals B plus C" into "A", "equals", "B", "plus", and "C".

At first glance, lexical parsing seems pretty straight-forward: just chop apart the source code anywhere there is a space.  But the reality is a bit more nuanced: programming languages have concepts of white space (spaces, blank lines, and in the case of ECMAScript some extra Unicode white space characters).  Literal strings and regular expressions and template substitution tails can contain characters which would otherwise be ignored white space; and sometimes software engineers like adding extra white space or leaving out the white space entirely, so the lexical parser needs to understand that "a=b +     c;" means the same thing as "a = b + c ;" and "a=b+c;".

Compilers understand the type of each token (identifier, white space, reserved words, literals, operators, etc.)—similar to how we understand the type of each words in a sentence (nouns, verbs, punctuation, etc.).

Ideally a lexical scanner (parser) should also be able to produce a token list which can be converted back into the original source code (to enable a rich debugging experience).  So the lexer (lexical parser) needs to store white space as trivia tokens.  And it needs to store the original code sequences used for unicode values (character substitution).

Finally, ECMAScript lexers also need to be able to understand the difference between reserved keywords (programming tokens which cannot be used as placeholders for data), Null and Boolean literals, identifiers (placeholders for data), etc.

There is a specification for the language grammar of ECMAScript 6 (formally known as ECMAScript 2015) available which our lexical parser implementation is based on:
http://www.ecma-international.org/ecma-262/6.0

Here is a screenshot of our lexical scanner at work, breaking down one of our source code samples into tokens:

As the next step in the compilation process, the abstract syntax tree builder uses the token list built by the lexical analyzer to make sense of what each component of the source code "sentence" does—which should sound pretty familiar to those who spent time in English classes breaking sentences down into subjects, verbs, predicates, etc.

After the compiler has built an abstract syntax tree (representing both the type of each token and how those tokens build the logic of an app, the compiler can then analyze how all those sentences of source code interrelate with stack analysis and can make sure that the tokens are being used consistently with type checking.

Finally, the compiler takes all the tokens and syntax and structure as input and generates binary code which the runtime can understand and execute.

For today, we have a nice lexical scanner for ECMAScript apps on AGENT Smartwatches.  We have released the source code as public domain so those of you who are makers or tinkerers and would like to use this component in your own projects or in ECMAScript compiler/interpreter implementations are free to do so without restriction.  This work could be expanded in the far future to running natively-compiled JavaScript apps on tiny button-cell-powered wearable widgets that run for years on a battery—but that would require further optimization and an appropriate native .NET compiler in addition to the remaining compiler work.

Visual Studio Code support

One of the really exciting new projects over at Microsoft is Visual Studio Code, a cross-platform code editor that runs on Mac and Linux.  This brings both C# and JavaScript programming to legions of new software developers on all three major platforms.

I really wanted to provide both JavaScript and C# developers with tools enabling them to develop AGENT Smartwatch watch apps on Mac and Linux.  One of the projects I worked on personally reverse engineered the Mono (C#) and NodeJS (JavaScript) debug protocols which Visual Studio Code uses on the Mac.  The theory here is that I want to enable Mac developers to seamlessly edit, deploy and debug apps right from their Macs.

Here are a few screenshots of the Mono debug analyzer, both the source code and an action shot running on my old Macbook.  This work is not funded—but hopefully and conceivably could provide our project with really awesome developer support for JavaScript developers on Windows/Mac/Linux and for C# developers on Mac/Linux.

Summary

We are still struggling with some serious watch case design problems—but our team has not given up on backers.  Secret Labs has taken on some serious debt and is pushing this project to completion (unfortunately without House of Horology).  Part of this work has included building out some new (not previously seen or promised) technology which benefits the AGENT Smartwatch's OS, developers and users.

To be clear: I had to pull funding for some of the new technology that Secret Labs has been building.  As a company, Secret Labs has been making some very serious cutbacks in an effort to see this project to completion.  I really wish that House of Horology was pulling their weight—but in any case, our team has been making some progress.

Thank you very much for your patience, for your notes of kindness, and for your support.

- Chris, Project Manager
AGENT Smartwatch Team