Recently I sat down and looked into some features and previous design decisions that made Jasonette needlessly more confusing that it needed to be, and fixed them. Here are the three:

1. No more “String only” policy
2. No mandatory requirement for “head”
3. No more confusing tab bar

1. No more “String ONLY” policy

Anyone who’s had to deal with Jasonette templates will appreciate this a lot. Previously, a lot of confusion and annoyance came from the fact that you had to turn everything into string before rendering.

For example, something like this would crash the app because the 12345 is a number:

{
  "type": "label", "text": 12345…

Jasonette takes security very seriously. The entire architecture was built on a sandbox model that took inspiration from web browsers and applied to mobile context.

Each view is completely sandboxed but they can communicate with other views through predefined protocols, resembling how microservices work.

In this post I will explain:

1. How the sandbox model works in Jasonette
2. How two views can communicate back and forth using $href and $ok action protocols.

How Sandbox Model Works in Jasonette

If a language encourages certain design patterns that are insecure, regardless of how secure the low level architecture is, we should consider the language insecure.

For example, the language…

What if I told you the 7 lines of JSON above, colored in orange is all you need to turn a website into a mobile app? No need to rewrite your website using some framework API just to make it behave like a mobile app. Just bring your existing website as is, and blend it into a native app with a simple URL reference.

And what if, just by tweaking the JSON markup a bit, you can access all the native APIs, native UI components, as well as native view transitions out of the box?

Here’s what a minimal example…

Nowadays we see QR code everywhere. We see it on a billboard, we see it embedded in product packaging, we use it to share Bitcoin public key.

QR code is like a 2D version of barcode.

As a publisher, you can pack all kinds of data in it as an image, and as a consumer you can simply scan the QR code to extract whatever is stored in the code.

Jasonette lets you build cross platform native mobile apps simply by writing a JSON markup.

When you load your JSON markup URL from it, Jasonette “remote controls” all the built-in native Objective-C (iOS) and Java (Android) components/APIs, in realtime.

What if you could do the same, but in a web browser?

This is Jasonette-Web.

How it works

Here’s a simple comparison

• Jasonette-iOS: JSON => Native iOS Components + Objective-C function calls
• Jasonette-Android: JSON => Native Android Components + Java function calls
• Jasonette-Web: JSON => HTML DOM

One notable difference:

• Jasonette-iOS and Jasonette-Android let you express an entire app in JSON — that is…

The latest version of Jasonette supports a “Headerless view”, in other words a view without the header navigation bar at the top.

See below images for an example. Depending on whether you define $jason.body.header or not, the header part shows up or goes away completely.

Jasonette has a powerful client-side template engine built in, which uses the commonly used {{ }} notation. It looks like this:

{
  "items": [{
    "type": "image",
    "url": "{{$jason.image}}"
  }, {
    "type": "label",
    "text": "{{$jason.username}}"
  }]
}

Aside from obvious templating features like #if, #each, etc., the template lets you even use full-fledged JavaScript expressions:

{
  "items": [{
    "type": "label",
    "url": "Reversed Fullname"
  }, {
    "type": "label",
    "text": "{{var sorted_posts = $jason.posts.sort(function(a,b){ return new Date(b.created_at) - new Date(a.created_at); }); return sorted_posts[0];}}"
  }]
}

This has been very useful, but we can do better. Here are some of the problems:

1. This can…

Jasonette is an open source framework that makes it super easy to build iOS and Android native apps using just a single JSON markup.

It’s like building a website by writing HTML, but you’re building a native app instead, by writing JSON.

Whenever you open an app built with Jasonette, its JSON markup would load over HTTP and self-construct into a native app, in realtime. Basically the entire app logic exists on a remote server and gets streamed to your “app”.

What if we could load the app not just from a remote server, but directly from the device?

Introducing Jasonette Offline.

Not…