Jasonette – Native App over HTTP | Hacker News Reader

Jasonette – Native App over HTTP

jasonette.com

65 pointsjalvz028 comments

Previous discussion: https://news.ycombinator.com/item?id=12879179

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

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

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?

| The only downside I've noticed so far is a lack of theming support.

you can probably write a simple pre-processing script using node (or python, ruby, go, etc) to do this, it wouldn't be that hard. But I agree that it should just be part of the library.

Sort of like Interface Builder and nibs?

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?

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

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

> 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

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.

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.

> 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.

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?

You do realize that the radios in a phone eat more battery than the CPU under regular compute workloads?

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/

Very cool, I think.

SHHHHHH! (whispered) We don't want our users knowing that. We don't want them finding out they have a choice of managing their own pony-related data, rather than letting us at Bronygram do that for them. So we're going to stay on message and talk up "cloud computing" and convince them their very powerful computing devices are just dumb terminals, so they remain on our service.

this flies in the face of all the mobile trends... smartphones are getting MUCH faster/more powerful every year.

That may be the case, but mobile OSes and apps are designed around the cloud-centric service-centric consumer model that much more closely resembles the mainframe/VT paradigm. iOS is more extreme than Android in this area, but both platforms are locked down pretty hard against user control of their own device.

Most of that power is being used for UI.

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.

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.

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

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

Is it better though? Honest question.

I thought the same as you first. So much so, that i thought it was a joke at first (not being negative, fwiw). I figured it was a cheeky poke at webapps. So yea, i'll have to look into this to see what the fuss is, at the moment i don't understand.

With that said, if it can create mobile apps with Native components, i'm interested. Mobile development sucks atm, and at work we're in need of native component mobile apps (or at least, i think we do). So i'm always looking for new options :)

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

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

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.

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

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

Reply on news.ycombinator.com