Michael Melanson

SenchaCon 2011: Day 3

2011-10-25T00:00:00-07:00

Designing Sencha Touch interfaces with Designer 2

Not much to say about this session. It was a walkthrough of developing a simple application in Designer 2.

Q&A

If you edit the UI file outside of Designer, will it work? You can edit them, but the changes will be overwritten the next time you export.
(Something about Intellisense) No, but Intellisense is something they want to add in the future.
Does Designer support the MVC architecture? It does generate views, but not controllers or models yet. These will be supported in the final version of 2.0.
Is it safe to develop applications now? Will the file format change? It should be safe, but no guarantees. The file format is fairly stable now.
Can you re-use generated code in Designer between Ext.JS and Sencha Touch? No, you can’t share code between an Ext.JS project and a Sencha Touch project in Designer.
Does Designer support Sencha.io services? Yes, though it’s limited now. It will support it better before the final version.

Migrating Sencha Touch 1.x to 2.0

Layout

Rendering in Touch 2 as split into separate Creation and Placement processes, because creating a DOM element is very expensive. This also allows components to be removed from the DOM and re-used elsewhere. This is done automatically in some places, such as in the new Component View control, which caches components.

The render and afterRender methods are no longer supported. The render event is deprecated, but will still work.

All layout is now done with CSS selectors. There is no Javascript-based measurement. This means that the doLayout, doComponentLayout, and afterLayout no longer exist. As soon as a component is added to a container, it will be laid out by CSS.

Because these methods mean that components are no longer notified when they need to adjust to size changes, they’ve introduced the Ext.util.SizeMonitor class which is bound to a control and fires events when the size of the control changes. Internally it adds two absolutely-positioned elements to the DOM to detect resizing, so this monitoring has a cost and shouldn’t be over-used.

Docking can now be done on any Container. The DataPanel class is gone, and the dockedItems property is deprecated.

The Panel class is very barebones at this point. It’s essentially the same as Container. Sencha is debating whether to get rid of it.

The floating configuration is deprecated. Setting the top, left, bottom and right properties will now float components.

Properties

Getters and setters should now be used everywhere to access properties. This allows Sencha to do lazy instantiation, where the getter instantiates on first call, filtering and validation. Also it supports automatic property dependencies when you use getters.

The initComponent methods still exist but should rarely be used. Most of their code should go elsewhere.

Events

Observable is now a mixin, not a base class, and the Observable/Observer classes are being replaced by Publisher/Subscriber. This is related to the new ‘event bus’ architecture.

They’ve also introduced the fireAction convenience method and the eventedConfig property. The eventedConfig method is similar to the config property, but fires change events.

Q&A

Will Sencha Touch support ordering multiple modals popups? Yes, they will be adding a modal manager.

Sencha Touch 2 Performance

Primary concern in 2.0 development is performance. The rendering process has been very much simplified. Templates are no longer rendered from HTML strings; they’re created as DOM nodes directly. These template DOM nodes are duplicated and loaded with the instance’s data.

The layout engine is entirely CSS-based instead of using Javascript-based measurement. Viewport handling, for hiding the address bar and determining the fullscreen view size (which is apparently a tricky and varies with different browsers, even between Android 2.2 and Android 2.3) has been re-architected to be much faster.

They’ve also added a clever system for patch updates of the application code, so only deltas (in a custom format) are transferred when the app code changes. The application code and build number are stored in local storage. When the application is reloaded, it requests a delta file from the server, and applies it to the code in local storage.

Q&A

What are some things people do with Sencha that leads to bad performance? Especially on Android devices, don’t overuse CSS transforms.

Accessing Native APIs from Sencha Touch

There are currently three independent sets of native APIs: the W3C, WAC, and Mozilla’s Web API. These all overlap each other, and are incompatible.

Tip: Weinre (pronounced “winery”) is a tool for remote debugging of PhoneGap applications.

When standard Javascript APIs are not provided for something, you must use PhoneGap plugins to call native code.

Community Code: VGF

VGF is Frankfurt’s public transportation company. Nils Dehl’s company developed a mobile app for VGF.

The app allows searching for nearby stations, especially barrier-free stations, and information about delays.

SenchaCon 2011: Day 2

2011-10-24T00:00:00-07:00

Today’s the first day of actual talks at SenchaCon. This post, and tomorrow’s post, will mostly be notes I take during the talks. I’ll post an analysis at the end of the conference.

Keynote

Sencha’s CEO was up first, talking about their vision for where Sencha is going. He highlighted three big trends they’re riding: mobile, sharing, and HTML5. He pointed out that desktop sales have been flat now for some time but the mobile platforms (smartphones, tablets and even laptops) have been growing exponentially over the same time period. He says that sharing has become a core feature of apps these days; people expect it, and it’s strange for an app to not have sharing.

Google talked about Chrome’s role in revitalizing the development of web technologies, and especially about the Chromebook. One very interesting thing they pointed out was that there’s a huge interest in Chromebooks from businesses and government. These organizations are very interested in them because they’re stateless, which reduces administrative costs, and because many employees basically spend all their time in web browsers anyways.

Jarvus Innovations demoed their custom t-shirt printing site which uses Ext.JS.

Juniper also talked about their “Junos Space” platform, which uses Ext.JS. It also lets application developers create custom, hosted, applications using Ext.JS.

Sencha’s big vision for the future is that web technologies are going to take over app development, and expand into other devices. A big device they talked about is in-car dashboard apps that integrate with apps on other devices and use platform-specific sensors like gas levels. Maybe they’ve got something in the works here that they’re not talking about?

Introducing Sencha Touch 2

Performance

The big focus in Sencha Touch 2 is performance. They claim improvements of 10-30% in startup time vs 1.1. It also has a new layout engine which uses the browser’s CSS engine to lay out the components rather than laying them out via Javascript. This new engine improves layout performance; they showed a video where it does a re-layout of the kitchen sink app in 0.35s vs 0.98s. At that point, they say, the phone’s layout animation is the limiting factor.

They also improved interaction performance by using ‘selective use of CSS3 transforms’ to eliminate flicker, etc.

Sencha Touch 2 uses CSS-based layouts so Javascript doesn’t get invoked to layout the components. This means that the layout process is asynchronous and not dependant on the Javascript runtime. It’s also smarter about re-using DOM elements especially for lists, since creating DOM objects is very expensive. Doing this manually is a large part of how you improve the performance of a Sencha application, and now this is (hopefully) all done by Sencha Touch automatically.

Other improvements

They also say they’ve improved their internal processes a lot, adding a QA team and code review process. They’ve also made much-needed improvements to their documentation and learning materials.

Q&A

Here’s a few of the questions that were asked. There were a couple others that I either missed or didn’t find interesting. I found in this talk that the speakers tended to talk around the question and never answer it unfortunately.

How does Sencha support multiple devices? Speaker mostly dodged the question.
Has Sencha fixed problems where, during keyboard input, the viewport turns into a sliver? Yes, the new layout engine in 2.0 should be more correct because it uses CSS for layout.
What’s the difference between PhoneGap and Project “Ion”? Ion will have good continuous integration support, etc.

Introducing Designer 2

Designer is turning from a visual layout designer, kind of like Interface Builder for Cocoa / Cocoa Touch pre-XCode 4, into an integrated development environment with a layout designer. I’m seeing it turning into something more like Expression Studio. It includes a code editor for inserting code into event handlers, generators for MVC components, source control integration, and native deployment (to the Apple App Store, or the Android market). Designer 2 also includes support for Sencha Touch; the current stable release only supports Ext.JS.

Q&A

This session had a longer Q&A session that had some interesting questions.

Will Designer support generating MVC stubs? Designer will fully support MVC, but it isn’t quite there yet.
What unit testing frameworks does Sencha support? Sencha uses Jasmine internally, but doesn’t really recommend any in particular.
Why is Sencha creating an IDE instead of integrating with Visual Studio or Eclipse? They did not want to rely on the release schedule of a third party, and like to develop their platform all internally. They said they do plan on integrating with Eclipse, but didn’t give details.
Will Designer support custom theming and custom templates? Yes, it’s in the roadmap but they’re “focusing on the basics” right now.
If I have an existing application not developed in Designer, will Designer be able to open it? No, Designer has a specific filesystem layout it uses. Because every project has its code structured differently. They recommend developing it again, from scratch, in Designer. (Aside: This was a common thread in a few talks. Sencha doesn’t really allow forward-porting of applications from previous versions of their frameworks. They assume that all projects are either greenfield or will stick with an earlier version of the framework.)
Does Designer support Ext.JS 3.x? No, you should be moving to Ext.JS 4.

MVC in depth

These talks were a rapid-fire tour through MVC in Sencha Touch and Ext.JS. Honestly, I missed a few parts, but I think I captured the most important bits.

Part 1

Why use MVC in Sencha? By applying a standard application structure you can keep things organized, prevent spaghetti code, and allow collaboration between developers.

Sencha’s implementation of MVC also includes a standard directory layout that’s similar to Rails with controllers in MyApp/app/controllers, models in MyApp/app/models, etc.

Overall, Sencha’s implementation of MVC is fairly standard. The most interesting part is the controller which is bound to the view using “component queries” to get references to objects on the view using CSS selectors, then lazy binding to bind to their events (more on this below).

Part 2

Biggest difference between most MVC implementations on the web (e.g. Rails, Django, etc.) is that in server-side MVC the actions are based on pages, whereas Sencha’s client-side MVC actions are based on user actions.

It’s an event-based model where controllers bind to view events like so:

this.control ({
  'contact-listpanel': {
      activate: this.onListActivate
  },

  'contact-listpanel > list': {
      select: this.onListSelect
  },

  'button[action=addcontact]': {
    tap: this.onAddButtonTap
  }
});

This snippet of code, from a controller’s init method, binds to the activate, select, and tap events of their respective components. Bindings are lazy, similar to the jQuery’s ‘.live()’ method, where event bindings apply to DOM elements created now and in the future. You declare that you’re interested in an event, and if a control appears at some point that matches a query, you will be bound to it.

Sencha uses an “Event Bus” model for dispatching events. When an event is fired, its controller dispatches an event to the application object:

this.application.fireEvent(‘stationstart’, context);

Then someone else can bind to the ‘stationstart’ event and do an action when it occurs.

In Sencha Touch 2.0, the initialization process is a two-phase process:

- Application: init - All controllers: init - Application: launch - All controllers: launch

The init methods should do all the event binding, whereas the launch methods should do the rest of the initialization (creating views, loading data from stores, etc).

Using Node.js with Sencha Technologies

Rationale for server-side Javascript: using Javascript everywhere means fewer context switches for developers. It also allows code portability between the client and the server.

Node.js is Google’s v8 Javascript engine (same as Chrome uses) with I/O libraries on top. All I/O is non-blocking (aka. “evented”).

Craig implemented a Node.js module called node-extjs which lets you use Ext.js or Sencha Touch’s MVC architecture on the server-side. This allows code to be shared between the client and the server, such as models with validations that exist on both the client and the server.

There’s also three projects to blur the difference between clients and servers: now, dnode, hook.io. now is the most interesting. It lets the client invoke methods on the server via a function call, or vice versa, via WebSockets.

Q&A

What about debugging node programs? There’s a package called “node-inspector” that’s like Web Inspector for introspecting node applications.
Does node-extjs use Ext.JS’s loader mechanism? Yes, it does.
How does CouchDB compare to other NoSQL databases? CouchDB is very simple and all Javascript-based (Aside: not quite — it’s implemented in Erlang, but he’s right that all the extension points are Javascript). MongoDB is very good, but there’s no Ext.JS integration for it.

Sencha.io

Sencha.io has three core services: Login, Data, Messages.

Provides authentication, registration (both via a standard form, and via an API), etc. Allows user groups, and searching by properties (including custom properties).

Data

Data is replicated locally on devices and synchronized to the cloud. Data can be shared between users to allow collaboration. Data can be updated while offline, and will be synced automatically when connectivity is restored. Only the user’s individual data is stored on the device.

This of course opens the door for inconsistencies. Sencha.io allows collisions, then uses a conflict resolution. When a property is set to two values independently, then it uses a timestamp to determine the winner.

He called this a ‘timestamp’ first then later clarified that it’s not an actual time. But, he didn’t go into details. I suspect he means that it uses a vector clock or MVCC, but that’s speculation and doesn’t answer how they resolve conflicts. He didn’t mention any manual mechanism for pushing conflict resolution up to the application like Riak does.

Messages

Allows device-to-device communication, either one-to-one or one-to-many. Offline messaging is a core feature, so messages are queued up while offline and delivered later.

Has a couple different protocols for client-server communication, including the default polling one and an asynchronous push one. He seemed to say that it uses different ones in different situations.

Messaging models supported:

Service requests (request-response, or RPC)
Broadcasting data (one sender, many recipients)
Collecting data (many senders, one recipient)

Messages are just JSON blobs. The one-to-many messaging reminds me of AMQP with message queues and brokers.

Q&A

Is data encrypted? No, except authentication.
Can we access data using SQL, etc.? No.
Can you use social network logins for the Login service? Yes. It also supports third-party authentication providers.
Asked by me: Can you replicate shared data on the devices? Yes.
What’s the business model? Free for now. There will be some sort of ‘enterprise tier’ later that will be paid.
Will Sencha.io support Ext.JS? Yes, eventually. It actually works right now, by accident. Official support will come soon.
How are devices uniquely identified since UDIDs change? They put a random number into local storage. Of course this can be deleted, in which case it’ll appear as a new device. Devices are bound to users, so if data is stored in the user object, then it’ll appear on whatever device they use. This only would be a problem for anonymous users.
(Did not hear question) Sencha will re-write HTML files to point references to sencha-touch.js to a CDN so it loads faster. It also ships device-specific code, or do other tricks (e.g. progressive loading).
Can you inspect the device’s queues to figure out when messages aren’t being delivered? Yes, there will be a console / other debugging tools.
How fast is message delivery? Does it support real-time? In the asynchronous push delivery, latency will be about the same as the network latency. For the polling delivery it will depend on the polling policy.

SenchaCon 2011: Day 1

2011-10-23T00:00:00-07:00

I’m here in sunny Austin, Texas at SenchaCon 2011 where I’ll be posting highlights each day this week.

Today they kicked things off with the welcome reception, where I got a chance to talk with a bunch of other developers from all over the world. England, the Czech Republic, and a half dozen US states were represented &emdash; just in the people I managed to see before the beer stopped flowing! I overheard that some people travelled for 25 hours to get here, which I find incredible.

Everyone was very positive about their experiences with Sencha. Many, like myself, have only used it once or twice and are here to find out more. So, this should be a learning experience for everyone.

I’ll be sticking mostly to the Javascript track because I think that’s the most relevant to Macadamian. Tomorrow, I plan on attending:

Keynote
Introducing Sencha Touch 2
Introducing Designer 2 (though I’m split between that and Hacking WebKit)
The Sencha Class System
MVC In Depth (both parts)
Using Node.js with Sencha Technologies
Introducing Sencha.io

Should be fun!

Weekend project: Knitting charter

2010-10-03T00:00:00-07:00

I wrote this small knitting tool for my fiancée to convert written knitting instructions to a chart.

In the future, I plan on extending the chart UI to allow you to edit the chart and have those changes be carried back to the instructions.

Knitting charter

Git tip: Using interactive rebase

2010-09-30T00:00:00-07:00

Interactive rebase is a one-stop shop for revising history: combining, removing and reordering commits. It’s one of those things where you learn it, and afterward wonder how you got by without knowing it. I use it almost every day when preparing a topic branch for review. If I have to make changes during review, I commit them as incremental patches, then squash them with an interactive rebase before I commit.

In this post, I’ll explain a bit about how it works. Let’s forget about topic branches right now, and just assume you’re working directly on the master.

Say you’ve been working a bit, and you have a recent history that looks like this (most recent to oldest):

Fix a bug when you foo the bar
Fix typo
Implement the remainder of feature XYZ
Oops, forgot to add this file
Implement part of feature XYZ
(Ancient history that’s in the upstream repo)

If your history doesn’t look like this you either don’t commit often enough or you’re super-human. But we all want to appear super-human, so let’s clean that up a bit before we show it to anyone.

We’ve added five commits here, so we want to run the following command:

git rebase -i HEAD~5

(If we were using a topic branch, we could do git rebase -i master — this also has the effect of rebasing the topic branch if the master has been updated)

This will open up your editor, with something that looks like this:

pick 39a2bef Implement part of feature XYZ
pick 4bc987e Oops, forgot to add this file
pick f9282bc Implement the remainder of feature XYZ
pick 2c5dd33 Fix typo
pick a524b5c Fix a bug when you foo the bar

On each line, you have the command (“pick” here), the commit ID, and the description. At the bottom of the file, you’ll see a list of commands you can use:

pick — leave the commit as-is
reword — change the commit summary only (this is a recent addition)
edit — change the commit contents, much like doing a git reset --mixed
squash — keep the changes in this commit, but merge it with the commit on the previous line, and append the commit messages and allow the message to be edited.
fixup — keep the changes, as with squash but throw away the log message.

You can also delete a line to discard a commit entirely, or reorder them. The idea is that you edit this file so it shows the history you wish you created, then write the file and close your editor. Let’s change it so it looks like this:

pick 39a2bef Implement part of feature XYZ
fixup 4bc987e Oops, forgot to add this file
pick f9282bc Implement the remainder of feature XYZ
fixup 2c5dd33 Fix typo
fixup a524b5c Fix a bug when you foo the bar

I’ve just changed “pick” to “fixup” for all the mistake commits I made. This will roll them in with the commits above them so that, when we close the editor, git will re-write your history so it looks like this:

Implement the remainder of feature XYZ
Implement part of feature XYZ
(Ancient history)

Mistakes? What mistakes? :)

As I said, I use this almost daily to prepare a patch set for review. After I rebase, I’d prepare patch emails with git format-patch -2 --attach, then send them with git send-email 000[12]* --to=mailinglist@somewhere.com.

Hope that helps you out. Rewriting history like this is a key feature of git that I haven’t seen in other source control systems, and it goes a long way towards making your project history look professional.

Apologies for the lack of updates

2009-08-10T00:00:00-07:00

Apologies for the lack of updates. In the meantime, here’s what I’ve been doing lately.

Introduction to neuroscience package

2009-07-27T00:00:00-07:00

These are my notes from a casual lecture I gave earlier today. It talks about the general layout of the central nervous system, some stuff about the amygdala and the hippocampus, and the visual system. It’s quite incomplete, because it was meant to accompany my lecture.

I have also included articles from Wikipedia that I referenced to produce the notes and which may be interesting, and the slides from two other talks I gave in school last Fall.

Link to package

CMake packages

2009-05-14T00:00:00-07:00

At work, I’ve started transitioning the company’s build system to CMake. Makefiles are a huge pain in the ass, though not as big as some other tools (but I digress).

The biggest problem with CMake so far is that you have to write “FindXXX.cmake” packages for any external dependencies so CMake knows how to find their headers and link against its libraries.

Here are the package files for LibEvent, MySQL client, Net-SNMP, Libnet, PCRE and GLIB2. Some of these I found on the Internet and others I wrote myself. You can find the files on GitHub at:

Link to GitHub Gist

In-place editing in Rails

2009-03-11T00:00:00-07:00

Just now, I wanted to add in-place editing to a Rails application. At first, I used jQuery’s Ajax.InPlaceEditor, and that worked (with a bit of authentication_token hackery), but I figured someone had done this before and had a Rails helper to do it.

Well, I found editable_content_tag, which mostly did the trick except that it wasn’t updating the page correctly. It turns out the controller was returning a nested JSON hash that looked something like this:

{'obj' => {'property_one': 'value', 'property_two', 'value two'}}

Their implementation of editable_content_tag wasn’t digging into the nested hash (i.e, it was using json.property_one instead of json.obj.property_one), and so it would display “undefined” when after being edited. Not cool.

Their implementation also didn’t work when a value was blank. It would generate a zero-width div, which wasn’t clickable. So I made it display “(not set)” when the value is blank.

Just in case anyone has encountered similar problems, here’s the modified code. To use it, put this into your app/helpers/application_helper.rb file.

Productivity tip: Using the Bash history

2009-03-10T00:00:00-07:00

The next time you’re using the terminal a lot and want to run a previous command again, try using Bash’s “reverse-i-search” feature. Type “Ctrl-r” and enter part of the command. For example, if you’ve recently run “make” and want to run it again, typing “<Ctrl-r>ma” might bring up:

(reverse-i-search)`ma': make

Hitting enter now will run “make”. If this isn’t the line you wanted, either type more characters or hit Ctrl-r again to show an earlier line matching your search.

I use this all the time in combination with git-svn, because its rebase command needs a clean index (if you’re not familiar with git, this means that there are no uncommitted changes in your tree). To rebase despite a dirty index, you can use the stash like this:

git stash && git svn rebase && git stash apply

But that’s a pain to type over and over, so once I’ve done it once I can type something like “<Ctrl-r>re”, and Bash responds with:

(reverse-i-search)`re': git stash && git svn rebase && git stash apply

Although I’ve been talking about Bash here, this is actually a GNU Readline feature, and works the same way in other programs that use Readline or a similar library.

Language, religion, origins, etc.

2009-02-24T00:00:00-08:00

This is a reply to a post by dailymeh where he said:

While we’re on the topic of divine revelations, I wouldn’t mind a revelation, though a scientific one would do, about the origin of language. It is, with only a bit of hyperbole, as mysterious as the origin of the universe or of life. We know a lot about how the universe evolved after the Big Bang and about how animals evolved from the primordial life and about how languages evolve from their ancestors, but how the universe, the first life, or the first language came into existence is very, very unclear. The relationship between sounds and concepts is essentially arbitrary. It makes no difference whether I call water afdaxhamasr or water, so long as my friends and my family and you and everyone else calls it the same. So how did the first association come about? We can explain why water is called water by studying the history of the word, but how did there come to be a word for water in the first place, and how was that word chosen? Did language develop once or many times? Does every language that exists today have a common ancestor, and if so, can we reconstruct it? (No, we probably can’t even if we could show that there was a common ancestor. But the rest of those are open.)

A few years ago, I took a course on psycholinguistics. Some courses have had a profound impact on my world view, and this was one of them. The required reading for the course was Pinker’s The language instinct. I can’t recommend that book enough for anyone interested in the topic.

In that book, Pinker argues that we humans are driven to learn language and that it takes very strange circumstances indeed (essentially total isolation until adolescence) for this to not happen. He discusses some interesting cases, such as the development of Nicaraguan Sign Language. I’ll only summarize it here; that Wikipedia article gives a more detailed description.

In Nicaragua, until the 1970s-1980s, deaf children were scattered across the country and were not taught a sign language. Although I assume many learned to lip-read, this is a very difficult (and even at its best, inaccurate) skill. Because of this, they had a hard time fitting into society. To address this problem, the government established a school to bring these children together and teach them a sign language. A group of educators sat down and developed their own sign language and began to teach it at this school. The children hated it and were incapable learn it. It simply wasn’t a human language.

Instead, the teachers noticed that on the playground, completely spontaneously, the children were developing their own sign language completely unlike the one the teachers had tried to teach them. It began with simple gestures (the signing equivalent of a pidgin language), but over time it developed its own syntax much like you would find in a mature language like American Sign Language. It had transitioned from a pidgin to a creole language. Similar phenomena have been observed in other situations where people without a common language are forced together. The “pidgin language” article linked above lists some examples.

In fact, this should not be surprising since all human languages share a common structure, which linguists call X-bar theory. I don’t know enough about X-bar theory to comment on it, except that the theory states that the syntax of all human languages differ only in the order of elements within X-bar rules.

To specifically answer dailymeh’s questions, the actual words of a language are not important and have more to do with history and anthropology than anything else. Obviously, the pronunciation is limited by the phonemes (sounds) that a human can produce, but other than that they are arbitrary.

I suspect that what we consider language developed from simpler roots that we can see in our living primate relatives. At some point, our hominid ancestors needed more sophisticated ways of communicating. Perhaps it was an advantage for groups of hunters to be able to plan elaborate strategies while on a hunt. For this reason, I suspect that language developed only once, but over millions of years of refinement.

Since our language faculties have not changed substantially for as long as we have been homo sapiens, if you were to clone an early modern human they would be able to learn a modern language like any other child born today. Similarly, if you found yourself with a group of neolithic humans you would have no more difficulty than learning another (unrelated) modern language.

I think that human language is one of our most fascinating abilities. It’s humbling to think that all human languages are so similar — far more similar, in fact, than they are different.

Introducing Foodster

2008-11-20T00:00:00-08:00

For one of the courses I’m taking this semester, we had to develop some sort of project to do with sustainability or use of local resources. My group decided to make an online “Farmer’s Market” with recipe sharing.

The result is Foodster, and it’s up in “beta”. I did the programming and web design; the rest of the group did usability testing and research. It’s not complete, but I think the core features are well represented. I’m not sure what I’m going to do about continuing development once this course is over. I think it’s an interesting idea, and I’ve put a lot of time into developing this prototype.

At any rate, I’m going to keep it up at that URL for the foreseeable future. I welcome feedback, and may return to it soon.