turbolent

... in browsers. Which at best JIT compile. There are several WASM runtimes that AOT compile and have significantly better performance (e.g. ~5-10% slower).

The title is highly misleading.

GCC just got musttail too: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83324#c27

Very few languages have "Some Language -> C" or "Some Language -> non-common OS / arch combo". The "just" part is a whole new backend, which is a massive amount of work for common languages.

But it turns out many languages do have "Some Language -> WASM" now. WebAssembly brings portability to the table.

Exactly!

You do not have to deal with the generated C, simply consider it the IR.

The main benefit of generating C over LLVM IR is portability: C is supported by far more systems than LLVM can target.

For example, it enables porting Rust applications to Mac OS 9 (https://twitter.com/turbolent/status/1617231570573873152), or porting Python to all sorts of operating systems and CPUs (https://twitter.com/turbolent/status/1621992945745547264).

The main "goal" of w2c2 so far has been allowing to port applications and libraries to as many systems as possible. For more information, see the README of w2c2.

Just to clarify: Compared to wasm2c, w2c2 does not (yet) have sandboxing capabilities, so assumes the translated WebAssembly module is trustworthy. The main "goal" of w2c2 so far has been allowing to port applications and libraries to as many systems as possible.

If you are looking for a more flexible solution with support for any layout and support for animations, something like iOS' UICollectionView or Android's RecyclerView, have a look at https://github.com/turbolent/collection-view.

Impressive. What are the differences for decoding/load time? Especially on mobile devices this is a big deciding factor.

The paper (http://www.cs.cmu.edu/~nlao/publication/2014.kdd.pdf) mentions the extracted knowledge base is about 38 times larger than DeepDive's, the largest previous comparable system.

Paper: http://www.cs.cmu.edu/~nlao/publication/2014.kdd.pdf

There's a really nice explanation at http://galaxy.agh.edu.pl/~vlsi/AI/backp_t_en/backprop.html

It's object-oriented and especially designed to be extensible. The slides on the pages contain many examples. It's fairly stand-alone and isn't integrated into an IDE. However, it's small, which allows for easy implementation (see original OMeta in Smalltalk, Ometa/JS, Ometa#, etc.) and could be used as a base for implementing these IDE features.

I'd love to see a cleanup of OMeta/JS and combining it with CodeMirror.

Looks very similar to OMeta (http://tinlizzie.org/ometa/)

http://www.limbikfreq.com/ http://somafm.com/

Really liked http://dribbble.com/shots/282948-Raspberry-Pi

At the beginning I tried implementing various object systems. The first one was indeed multiple inheritance with multimethods, based on C3 linearization (http://en.wikipedia.org/wiki/C3_linearization) and didn't use the prototype chain, but wasn't finished. The second one was similar to Clojure's protocols (define-protocol, extend-protocol, ...), but wasn't very handy.

The current one is single-inheritance, because it uses the prototype chain. It's a compromise between speed and usefulness. I'd prefer having multimethods (and maybe also multiple inheritance), but speed is a bit more important, as JavaScript is already quite slow.

So far I'm quite pleased with the single-inheritance and single dispatch solution, which basically works like that: https://gist.github.com/866506

I like Dylan (http://www.opendylan.org/) and CL - and I wanted to write both server side and client side web applications in it, so I wrote a compiler for a Lisp that resembles the original prefix/sexp-style Dylan as much as possible, described in (http://lispm.dyndns.org/documentation/prefix-dylan/book.anno...).

As I needed a name, I just chose "Ralph" as that was the original code-name of Dylan (see http://en.wikipedia.org/wiki/History_of_the_Dylan_programmin...). I'm currently implementing a web-based IDE for the OpenDylan compiler (http://www.opendylan.org/), called "Hula" (original code-name of Apple's IDE, see http://wiki.opendylan.org/wiki/view.dsp?title=AppleDylanScre...). The work-in-progress is at https://github.com/turbolent/hula.

If you're interested in a demo, let me know.

I've been working on Ralph for a while now: https://github.com/turbolent/ralph

It compiles a major subset of Apple's Dylan (http://lispm.dyndns.org/documentation/prefix-dylan/book.anno...) to JavaScript, both for use on a CommonJS implementation and in the browser. A bootstrapping compiler is implemented in JS, but the same compiler is also available in Ralph itself and features define-macro (Cl-like). The whole runtime is defined in Ralph as well and provides a single-inheritance object system (including next-method): https://github.com/turbolent/ralph/blob/master/src/runtime/c...

Almost all of the features are shown in https://github.com/turbolent/ralph/blob/master/src/tests/run... and I'm using it a project now. To build HTML5 apps, there's a small toolbox: https://github.com/turbolent/toolbox

Maybe it's useful to someone else. Cheers

Clickable links: http://turbolent.com/ http://itunes.apple.com/us/app/objects/id410949899 http://news.ycombinator.com/item?id=2096730