
McCLIM 0.9.7 "Imbolc" release - jackdaniel
https://common-lisp.net/project/mcclim/posts/McCLIM-097-Imbolc-release.html
======
jf
It took me a while to find, examples of user interfaces made with CLIM can be
found by scrolling down on this page: [https://common-
lisp.net/project/mcclim/excite.html](https://common-
lisp.net/project/mcclim/excite.html)

------
lf-non
For the uninitiated, McCLIM demo [1] by Jack Daniel is a very good
introduction to REPL driven GUI programming using Common Lisp and McCLIM.

[1]
[https://www.youtube.com/watch?v=kfBmRsPRdGg](https://www.youtube.com/watch?v=kfBmRsPRdGg)

~~~
IronBacon
There's also a video by Jeremiah Stoddard that shows a live programming
session based on McCLIM where he codes a "snake" game
[https://www.youtube.com/watch?v=Rdb17YDRTVc](https://www.youtube.com/watch?v=Rdb17YDRTVc)

------
carry_bit
Is there anything like CLIM available for JavaScript? My time playing with
McCLIM years ago made an impact. I've made things inspired by it over the
years, but nothing close to the framework itself.

~~~
lf-non
Can you elaborate what you would expect from such a system ?

As someone not having much familiarity with CLIM or common lisp, I seem to be
lacking the perspective to appreciate the relevance of this technology in
2018.

Things like support for truetype rendering, bezier curves, tab layout etc. are
not exactly cutting edge advancements.

~~~
jackdaniel
These things are just improvements to catch up with rendering and things
people require from toolkits currently. Where CLIM really shines is its model
of presenting things (and this is something developed long time ago).

UI is not just a rectangular area where you slap things (which may be
eventually clicked). It is rather a representation of the application state
and possible interactions with it.

In McCLIM presented objects have types and inner state. When you activate
command you may select arguments (which are typed) on the screen or by doing a
particular gesture. Same object may be presented differently based on a view.

Relevance is not about sexy new things from the last month. I don't know JS
well, but my impression is that rotation of technologies in its ecosystem is
pretty big, what may be a clue, that abstractions may be just so-so. CLIM is a
specification which covers many concepts required to build efficient and
extensible user interfaces.

~~~
lf-non
The rotation of technologies that depend on (and attempt to simply) the
abstractions exposed by the browser's host APIs may be quite frequent, however
the underlying DOM model seems very similar to what you are describing here.
The web standards have a stellar track record of backward compatibility.

> UI is not just a rectangular area where you slap things (which may be
> eventually clicked)

Web developers (or application developers) in present day world don't write
routines to draw things on canvas (although you can if you really have a use
case [1]). We program against the dynamic DOM tree, which presents our
application state. We have sophisticated data binding libraries [2] to bind
javascript models with the DOM tree.

The emergent web component standard appears very similar to what you describe
as "presented objects having types and inner state".

> Relevance is not about sexy new things from last month

When asking the question my objective was not to deride the effort that has
gone behind this project. It is just that the current application homepage
does not do a very good job of convincing a present day developer the appeal
of developing GUI systems using common lisp.

Also an X server is required to run the applications, which, excluding linux
users, is not something most people have installed now a days.

[1] For example paper.js implements a scene graph model on top of canvas.

[2] Mobx is a popular library for transparent functional reactive programming
in javascript.

~~~
aidenn0
I'm probably more familiar with JS than Dan is, so let me address some things:

You could, eventually, implement something similar to CLIM presentations with
web components. You could also implement something a lot like webcomponents
with CLIM presentations. They are quite different though.

I have not used MobX, but I just browsed the intro page (yes it's way better
at explaining what it is than CLIM is). CLIM doesn't really compare apples-to-
apples with React/MobX, since the abstractions used are different, but they
are both approaches to providing simple ways of presenting and manipulating
domain state with a gui.

In particular MobX _actions_ and CLIM _commands_ have some similarities, but
also significant differences.

Also, (assuming MobX doesn't change this) React is typically used to provide
declarative rendering of the full application state. CLIM allows you to do
this, but it is more common to have each bit of state declaratively rendered,
while treating the UI state imperatively. This was absolutely necessary 20
years ago, and is still often a good idea today (look at some of the
gymnastics Netflix has had to do to make long-lists render efficiently in
React; with imperative state you can just keep appending and CLIM doesn't care
because non-visible state won't get re-rendered until it is needed; granted
some of that is also because the DOM is a different level of abstraction than
a local GUI window...). On the other hand, after doing some javascript GUIs, I
think I'll be more intentional about when I make this divide in CLIM
applications; declarative GUIs are almost always easier to reason about.

