ejones

Ah nice! Well, hats off this is really impressive. As other commenters mentioned the extent to which it's documented and the restricted scope probably helped.

Amazing work. I'm interested in the choice of WASM - presumably any target that can run DOOM could've been used? Of which there are innumerable choices I assume. Was it for symbolic reasons or genuinely the most useful target?

You might be right that they're similarly powerful. In some cases, an arbitrary output format might in and of itself be desirable. Like it might result in token savings or be more natural for the LLM. For instance, generating code snippets to an API or plain text with constraints.

And this is more esoteric, but technically in the case of JSON I suppose you could embed a grammar inside a JSON string, which I'm not sure JSON schema can express.

FWIW, llama.cpp has always had a JSON schema -> GBNF converter, although it launched as a companion script. Now I think it's more integrated in the CLI and server.

But yeah I mean, GBNF or other structured output solutions would of course allow you to supply formats other than JSON schema. It sounds conceivable though that OpenAI could expose the grammars directly in the future, though.

Similar approach to llama.cpp under the hood - they convert the schema to a grammar. Llama.cpp's implementation was specific to the ggml stack, but what they've built sounds similar to Outlines, which they acknowledged.

Awesome to see work in the DB wire compatible space. On the MySQL side, there was MySQL Proxy (https://github.com/mysql/mysql-proxy), which was scriptable with Lua, with which you could create your own MySQL wire compatible connections. Unfortunately it appears to have been abandoned by Oracle and IIRC doesn't work with 5.7 and beyond. I used it in the past to hack together a MySQL wire adapter for Interana (https://scuba.io/).

I guess these days the best approach for connecting arbitrary data sources to existing drivers, at least for OLAP, is Apache Calcite (https://calcite.apache.org/). Unfortunately that feels a little more involved.

In fact it looks like there are already browser extensions that do this for Markdown:

https://chrome.google.com/webstore/detail/markdown-viewer/ck... https://chrome.google.com/webstore/detail/markdown-preview-p...

There's a proposal for this: https://github.com/tc39/proposal-partial-application

It just navigated the page itself by assigning window.location.href, which isn't subject to the same restrictions as popups.

Yeah, the inclusion criteria are pretty broad:

  The snapshot will include every repo with any commits
  between the announcement at GitHub Universe on November 13th
  and 02/02/2020, every repo with at least 1 star and any
  commits from the year before the snapshot (02/03/2019 -
  02/02/2020), and every repo with at least 250 stars.

Apparently the Saguache Crescent in Colorado is (as of this video in 2016) still using the linotype, the last known newspaper in the US to do so: https://www.youtube.com/watch?v=DNa9XRoNRUM

That, or use a split-frame browser extension (https://addons.mozilla.org/en-US/firefox/addon/fox-splitter-...) (http://www.chromeplugins.org/plugins/google-chrome-dual-view...)

Code sharing really only becomes a compelling argument if you're building browser games or something similarly interactive (i.e., really bloody interactive). In this case, you need to run the same logic on the client (to reduce latency) and on the server (to validate and actually update game state).

Otherwise, you really have no excuse for putting logic on the client. Even with something like validation, I think its much more sensible to have your renderers pump out generic validation event handlers than to reconstruct the whole model class on the client.

Indeed. Linear Lisp promises the same thing (http://www.deepdyve.com/lp/association-for-computing-machine...) and perhaps Linear Joy (http://osdir.com/ml/lang.concatenative/2005-10/msg00009.html)...

It seems that when you do that, though, and especially from looking at the tutorial, you end up with semantics that are a) fundamentally different from GC-ed semantics, and b) explicit about memory management. But perhaps it amounts to a kind of type-safe memory management?

Yeah, it doesn't seem to be a complete solution. My client actually ended up deploying a virtualized IE8 to sit alongside IE6 on all workstations.

That exists, it's called 'Compatibility Mode'. And by default (at least in IE8, at my current client's deployment) it uses it for all Intranet Sites. You can also use meta-tag 'X-UA-Compatible' to force a certain compatibility (http://msdn.microsoft.com/en-us/library/cc288325(v=vs.85).as...)

EDIT: Apparently the best you can do for IE6 is to 'emulate IE5,' which actually means 'emulate IE7 quirks mode'. Oh well...

You could just write a mixed-mode assembly to bridge V8 to the .NET thread pool and libraries...