gtoolkit VS reagent

You might find Glamorous Toolkit[1] and Folk computer[2] in that category too! Full disclaimer, I currently contribute to Folk (it's still pre-alpha but it has some really exciting ideas).

[1] https://gtoolkit.com/

[2] https://folk.computer/

> we should be able to do better than text files

https://gtoolkit.com/

?

Are you using Pharo already? If not, give it a go: https://pharo.org/

For taking notes and stuff you'd otherwise do in Jupyter or Livebook, try GT: https://gtoolkit.com/

It's not an OS, but you can just abstract over OS actions within either and keep them as your main interface, similar to how some people rarely leave Emacs.

Having GUI tooling to inspect, debug and develop integrated in the execution environment is kind of Smalltalk's thing. It's like a Common Lisp with more clicking in that regard.

It's rather neat, and means you can extend your development environment in the same way you develop your applications. If you want to extend the inspector for a particular type of object you can do that. Compared to writing plugins for Eclipse or IntelliJ it's a trivial exercise.

GT does it too, though explicitly aimed at tool development rather than application development: https://gtoolkit.com/

In a sense it's the original vibe coding environment.

Nice set of features you have here, very similar to Smalltalk (particularly Pharo) ideals. Actually I'm also actively working on a Pharo VM simulator so I can ultimately get GToolkit[0], which I really like and is based on it, running in Python. Nothing published yet though, but can definitely get in touch via your project.

[0] https://gtoolkit.com/

Cool, reminds me somewhat of Glamorous Toolkit [1], another project I just found out about. Excited to give it a try, I love these sort of "explain a program as it's running" type tools.

1. https://gtoolkit.com/

https://book.gtoolkit.com/understanding-lepiter-in-7--6n7q1o...

> I know to really use it, I have to learn to program it, but I am also of the mind basic functionality should be self explanatory. And pharo itself as the basis of this seems so convoluted and complex...

We use Pharo as a programming language for building the system, and most extensions are expected to be written in it. It's possible to connect to other runtimes, like Python or JS, and extend the object inspector that works with remote objects using those languages. But overall, learning Pharo is a bit of a prerequisite. I certainly understand that it can appear foreign, but convoluted and complex are not an attributes I would associate with it :).

Now, in GT, the environment is built from the ground up anew and it's different from classic interfaces found in Pharo or Cuis. And of course, it's different from typical development environment, too, because we wanted to build a different kind of interface in which visualization is a first class entity.

Our community is indeed on Discord a lot, but we also host discussions on our GitHub repository: https://github.com/feenkcom/gtoolkit/discussions

In any case, I am happy you find the need for "a great knowledge base and data visualization" relevant and useful.

This might be what you're looking for... https://gtoolkit.com/

> with very little way to find and eliminate them.

The best Smalltalk these days is GlamorousToolkit: https://gtoolkit.com/

It has a sort of git in it, so you can easily "rollback" your image to previous states. So going back and forth in history is trivial.

Generating `HTML` from lisps has poisoned any other approach for me, see for example https://www.neilvandyke.org/racket/html-writing/, https://reagent-project.github.io/, and https://edicl.github.io/cl-who/

Hiccup syntax for Clojure uses hash maps (curly braces) for attrs, e.g. `{:style {:background "red" :margin "1em"}`

See Reagent which uses Hiccup synta: https://reagent-project.github.io/

 (defn simple-component []

* Single-Page App: shadow-cljs for the build concerns (https://github.com/thheller/shadow-cljs), Reagent with Re-frame for complex/large app (https://reagent-project.github.io and https://github.com/day8/re-frame). Even if we now prefer using HTMX (https://htmx.org) and server-side rendering (Hiccup way of manipulating HTML is just amazing, https://github.com/weavejester/hiccup).

The API documentation lists the most commonly and rarely used parts before going into detail and there are many usage examples.

Reagent has a nice intro tutorial (classic todo-app): http://reagent-project.github.io and many other helpful tutorials and resources for beginners: https://cljdoc.org/d/reagent/reagent/1.2.0/doc/documentation...

However, since Reagent is still stuck with class-components for more complex behavior and relies on Hiccup, which is nice but has a performance cost compared to pure React, I am unsure about its future. Like some others in the Clojure community, I have moved to thin React wrappers like Helix and use Refx to integrate those with re-frame. It may be a bit confusing right now for beginners since there is no “golden path”.

Also, unfortunately, many smaller libraries are poorly documented and it seems like it is expected from the developer to dig into the source code to find out what’s going on.

What I found the most difficult as a beginner was how to setup a project in ClojureScript in the first place, like all the configuration in shadow-cljs, how it interacts with deps.edn, how it integrates with npm, the REPL, etc. But dev/build config has always been a weak spot for me, so it might be just that.

Overall, I still very much enjoy working with Clojure(Script), more than in any other language. Anyone who likes Lisps and functional programming should give it a try (and be sure to watch Rich Hickeys amazing talks!).

have you tried cljs and reagent? it’s a different vibe.

my bootstrap: https://github.com/nathants/aws-gocljs

the project: https://reagent-project.github.io/

Clojure people have been doing this for a decade or so. It’s really so much better to work with. All started with Hiccup and when React came along you got Reagent and many more developments building on the idea.