[...]
Fastcomp is the name of EmScripten's new LLVM C++ back-end. Fastcomp lives outside of the LLVM tree (along with some other EmScripten-designed LLVM patches) but aims to provide noticeable benefits over its original compiler back-end.
The new Fastcomp compiler core/back-end is more streamlined, tuned around producing ASM.js code, is much faster (around four times faster), uses less system memory, and has other improvements too. The JavaScript generated by Fastcomp is also slated to be better than its original compiler core. The downside to this work though is that this LLVM code is out-of-tree and doesn't work with a stock build of LLVM for right now.
[...]
Duetto is fully compatible with almost all C and C++ 11 code. You just need to add some tags to tell duetto if you want your methods compiled for the server or for the client. Everything else (including client to server and server to client remote procedure call, serialization and deserialization, etc.) will work automagically! The duetto compiler is based on the proven and robust LLVM stack.
So the current version is 0.9.3., so they are near the magic first stable release.
If you take a look into the example section, you get the picture pretty fast. A wiki page is also available. What its left to need, is some spare time :-).
can be addressed and rendered separately (by pure html response or json/xml data that is rendered by javascript on the client)
javascript is part of the component (easy up refactoring)
initial page request is returning a simple html page as response that is triggering a lot of ajax calls
if ajax request returns a ok, the return contains the updated data or handles the error (hint, on the backend, a "read from master" flag is added to retrieve the most accurate data without running into master/slave replication problems)
share code between server and client
templates, validation, entities
create "a widget"
php controller (providing data)
...
do not fetch data directly (because it is painfully slow)
require stuff (search for "evolution of code design at facebook" at infoq)
fetch requirements in a preparing step
batch requirements by calling resolvers
resolvers talks with services (multi-GET)
services calls connector interface (databases for example)
fetching data from connector
distribute back all the fetched data
entity requirement
service requirement
request cache
Multi-Get (get multiple data via one request for fetching a lot of data)
requirement vs. optional
optional, template will be rendered without that data
data dependencies within a widget by using callbacks (to create a dependencies and dataload workflow)
data dependecies between widgets by using data requirements (fetched from the require stuff above)
looks like this is complicated to debug by using symfony debugging tools (for example ;-))
rendering (by using mustache)
[x]html
json
v8js for rendering templates on the server (rendering mustache templates is faster in javascript then in php) and to provide a single place to render templates (cool!)
use models in javascript to stop messings things up
enables developers to only focus on their components
single place for refactoring
moving ugly code to one point
easies up testing (also with faked data)
error handling is simplified
remove component from the view
try to rerender it later
display a generic component
a/b testing is easied up (removing "long hanging fruites" - that just made my date :-D))
create multiple components and simple render then via a/b testing on the frontend
Arm-js is an ARM emulator written in Javascript. It emulates ARMv7-A and some peripherals of Versatile Express. It can boot Linux 3.6.1 and run busybox processes.
Get Started
1. Download the source code
1. git clone git://github.com/ozaki-r/arm-js.git
2. cd arm-js/
3. git submodule init
4. git submodule update
2. Execute ruby misc/simple-http-server.rb on terminal
3. Access http://localhost:8080/arm-js.html
4. Push Boot button at the top-left corner to start the emulator