
Jasonette – Native App over HTTP - jalvz0
http://jasonette.com/
======
rahimnathwani
Previous discussion:
[https://news.ycombinator.com/item?id=12879179](https://news.ycombinator.com/item?id=12879179)

------
connor4312
Why would someone choose this over something like Ionic or React Native? Yes,
it's advertised as a tool for writing 'native' apps, but you the developer are
just trading HTML/CSS/JavaScript for some custom-baked JSON-based system.
(This reminds me a bit of some of the things people have done with XML to
build a scripting languages on top of it...) It advertises direct access to
various APIs as a primary selling point, but is this any more direct than what
frameworks like Ionic provide? You still have to access it through an
intermediate scripting language, just one less pervasive than JavaScript.

That being said, it is impressive how little code it takes to build a simple
functional app! [https://github.com/Jasonette/Twitter-UI-
example](https://github.com/Jasonette/Twitter-UI-example)

~~~
lawik
Well, Ionic doesn't use native UI which this seems to. Not convinced about
JSON as dev environment though. Interesting regardless.

------
lj3
This is pretty close to what video game companies do for their UIs and it
works very well. You can even create a graphical tool for creating the UI that
saves to json, circumventing the issues you always get when non-programmers
try to directly edit data files.

The only downside I've noticed so far is a lack of theming support. Say you
want consistent headers throughout your app and you only want to change the
header style in one place. Is there a way to define a style and apply it to
multiple components?

~~~
mpweiher
Sort of like Interface Builder and nibs?

~~~
lj3
It certainly sounds similar, but I've never used Interface Builder or .nib
files. Is that sort of thing still used in OS X and iOS development?

------
mendelk
Can this be considered an extension of Atwood's Law? :)

    
    
      Any application that can be written in JSON, will eventually be written in JSON.

~~~
yuchi
> Any application that can be written as a simple composition of smaller
> components, will eventually be written as a composition of smaller
> components, and then custom complex logic will sneak in mutating it into a
> big ball of mud

------
NickBusey
This looks incredibly cool and I'm going to try it out this week. The
structure of how this is setup makes it seem like it could potentially be
expanded to include Android support without too much fuss, which would be even
better.

------
api
This looks like an extreme version of a thesis I've had for a while: mobile
devices are portable dumb terminals for the cloud.

This basically drives the entire mobile UI remotely. It's like 21st century
touch based VT macros.

~~~
reitoei
> mobile devices are portable dumb terminals for the cloud

Catchy headline, but you and I both know that modern phones are _extremely_
powerful computing devices.

~~~
cjmcqueen
But do phones have to be so powerful? If they are dumb terminals, could we get
smaller form factors, longer battery life and make them more disposable for
the billions of people that cant pay $$$ for a device?

~~~
reitoei
A dumb terminal would still need some kind of network stack (munchy munchy
battery life).

Maybe something like a kindle but with apps like WhatsApp, Twitter etc.
optimized for e-ink displays.

I saw a kind of interesting device recently with a regular screen on the front
and e-ink screen on the back, the Yotaphone 2: [https://yotaphone.com/gb-
en/](https://yotaphone.com/gb-en/)

Very cool, I think.

------
treve
I'm not a big fan of manually producing JSON. It seems like the wrong format
to develop what is effectively a markup language/minimal programming language
in.

XML actually seems like a better fit in this case.

~~~
zeveb
Rather than XML or JSON, I think S-expressions would be better. Consider the
example:

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

In S-expressions, it would be:

    
    
        ($json (head …)
               (body
                (sections
                 (items
                  (image …)
                  (label …)))))
    

I think that's preferable.

------
sleepybrett
annoyed that it's using (essentially) the same name as
[http://jsonnet.org/](http://jsonnet.org/)

------
amelius
As I posted before, this is basically HTML reinvented :)

~~~
zamalek
We are destined to re-invent everything SGML in JSON. In a decade everyone
will be pointing fingers at JSON, "overly complex and cluttered."

------
nilved
This makes me cry. This is what's wrong with computer science in 2016.

~~~
lj3
Why? Somebody created a fast way of creating native apps. I don't quite get
the cries of heresy from the HN crowd on this one. Native apps have needed an
easier, faster way of developing UIs for years. This is a first attempt.

~~~
nilved
This is not a native app any more than a web app is a native app (because this
is a reinvention of the web.)

------
alvil
For now it looks like all you need is iOS not Json.

