
Ceramic – Turn Lisp web applications into desktop apps - blue1
http://ceramic.github.io/
======
mark_l_watson
This certainly looks interesting, but it might help generate interest if the
landing page addressed two questions: what is the application size overhead
(how large is a hello world app) and what is the app startup overhead.

I used to make standalone apps from SBCL Common Lisp, and they were not too
large (even though SBCL has no tree shaker unused code remover).

~~~
eggy
I agree final app size would be a further selling point for me too. I am glad
to see Lisp, CL, in the headlines other than clojure. I guess the ubiquity of
JS has lead to the possibility Ceramic offers due to Electron. Slightly, OT,
but I am reading 'The Handbook of Neuroevolution Through Erlang', and I am
waiting to learn enough Erlang to jump over to using LFE (Lisp flavored
Erlang) mid-book. @mark_l_watson, I started with your 'Common Lisp Modules:..'
book, and now I am hooked on AI, NN and Lisp. Thanks!

Rob

~~~
mark_l_watson
Thanks! Richard Stallman asked me several years ago about releasing my old
Lisp book under a FSF documentation license, but I can't find my old
manuscript files. Maybe I will ask my wife to re-type it all.

~~~
jakub_h
What about crowdsourcing the job? I'm sure people would be willing to help.

------
gaze
Can we PLEASE just work on writing a decent native GUI library for lisp?
Making QT work better? Something?

~~~
oskarth
You are more than welcome to work on it and submit it to HN. However, please
refrain from being gratuitously negative in this forum; someone just spent a
lot of time and effort into making something, and your comment - which took
less than a minute to write - is purely negative and adds nothing to the
discussion.

~~~
tomjen3
It is entirely legitimate to point out that somebody the submission is going
in the wrong direction, yes they spend a bunch of time on it, but that is sunk
cost and better they not waste any more.

GP was to the point, but not mean and added something to the discussion (even
if you disagree with it). You, however, were rude.

------
StudyAnimal
Heh weird. 15 years ago my job was porting apps the other way. Turning lisp
desktop apps into lisp web apps with cl-http. Of course that was hard. Turning
a web app into a desktop app is just a matter of embedding a browser. The
other way around requires work.

------
orthecreedence
This is a really cool/interesting way of packaging an entire app. I never even
thought to have a CL backend in a separate process that you could communicate
with via HTTP. I've done the same thing (browser, embedded lisp) using
nanomsg, but this seems a lot more straightforward.

Good work =]! I also really need to look more into Electron. I've only used
node-webkit (before it was NW.js).

------
giancarlostoro
If a given language you enjoy can run a web server, you could potentially take
advantage of Electron. This of course includes Go, D, C#, Java, Clojure and
plenty of other languages everyone loves. Not telling everyone to do this for
every type of application though, but it is definitely not impossible to
approach making a desktop application with web technologies.

------
nahiluhmot
Is there any reason that this wouldn't be able to work with another language?
If the interface is an HTTP port, it seems like this isn't necessarily tied to
Common Lisp.

~~~
orthecreedence
Yes, you could rebuild the project in any language if you wanted.

Ceramic opens an HTTP server (in lisp), starts electron (using a shell
command), communicates to the electron process via streaming, then electron
sends back HTTP requests to the lisp process.

However this is tied to Common Lisp because the containing project itself is
built in Common Lisp and can't be switched out without completely rebuilding
in another language.

------
jahnu
The links to Electron and Atom point to this page. Can someone provide correct
links please?

~~~
aidenn0
[http://electron.atom.io/](http://electron.atom.io/)

------
ragna_rock_rock
Why don't use haxe and openfl/nme and transpiling lisp code in haxe?

~~~
fnordsensei
What do you reckon the benefits would be over this solution?

------
sfilipov
How much work it is to extend Electron to create the same thing but for a
different language i.e. "Turn Haskell/Python web applications into native
desktop apps"?

~~~
WorldWideWayne
Along the same lines - how hard would it be to let Electron create more native
widgets instead of just Window, Menu and BrowserWindow.

~~~
fnordsensei
I'd be stoked if something like React Native (or indeed, React Native itself)
landed for desktop development.

I guess I'm not alone in thinking so: [https://github.com/facebook/react-
native/issues/247](https://github.com/facebook/react-native/issues/247)

------
mariusmg
A "app" running in a webview on a desktop is NOT "native". A Swing app is not
native nevermind these web apps running in chrome.

~~~
tomjen3
A native app is one you download and execute on your computer. In reality it
doesn't matter much what gui toolkit you write it in, there is nearly always
going to be some xml and styling involved - GTK is native on Ubuntu (I hope
you will grant me that), but programs written in it typically uses glade files
to design the gui and load and bind event handlers at runtime. Glade is XML.

.net uses the native win32 gui toolkit - but you typically build it WPF, which
is XML, styled with XML.

On mac? plists - which is you guess it XML (I have no idea what, if anything,
you style a mac app with).

So basically the three biggest platforms use XML to bind their guis with - and
there isn't much difference between XML and HTML. Granted when you design XML
for guis it tends to be nicer than if you wrangle HTML into that role but this
is a programmer, not a user, issue.

~~~
PuercoPop
as JayVanguard already pointed out native means another thing. but putting
that aside.

You are confusing what HTML and XML are if you think they are similar. XML is
a way to encode data, validate it conforms to a schema, query it, etc. HTML is
more than the surface syntax. It includes an schema and semantics (the DOM,
the CSS OM, the boxing model, etc). Using XML as a declarative layer on top of
their UI, as android does _, does not make it similar to writing HTML because
of the completely different semantics associated with it.

_ Android takes all the xml layouts and compile them and expose them through
the R(esource) class.

~~~
aidenn0
I see more than one person on this thread who thinks native means "runs native
machine code" and more than one person who thinks it means "looks like it was
built with the native GUI library" so the term is ambiguous. Before iOS app
store, I think it was more common to mean the former, so it may be related to
that.

