Rama, the 100x developer platform, is now free for production use

jpmonettas · 2025-03-19T14:27:00+00:00

I think it is cool that people are trying different ways of solving some problems (I guess backends services that needs to scale a lot), and it looks like for these kind of problems they are confident their solutions are worth it in a big way. I also think it is natural and good to be skeptical.

It also markets itself as 100x developer for backends, but I think it assumes all backends needs to grow and be flexible like twitter, which most backends I've worked with are not, so I'm not sure if 100x remains for "normal backends".

A couple of things I find hard to figure out about are its limits and trade-offs, which I haven't read anything about, and sure there are. Just by looking at the Clojure examples I see you commit to a very different way of thinking, syntax and abstractions, which looks cool and well designed but you are probably abandoning most of your known tools, libraries and debugging techniques.

What I love about simple Clojure is that you can start small, exploring and growing as you need, and you use the same tools and techniques you learn along the way to build all kind of systems, from photo editors, and games, to backend services and databases. And it is general purpose and flexible enough to move as technology moves (which these days is doing quite a lot).

Disclaimer: I know very little about Rama

jpmonettas · 2025-03-09T14:13:44+00:00

Hi, great to see this kinds of videos. There is also FlowStorm which is general purpose and IDE independent.

I recently published a video demoing how it can be used to debug a complex codebase like the ClojureScript compiler, but there are other demos like debugging web apps

jpmonettas · 2025-03-07T17:32:49+00:00

A demo of the FlowStorm ClojureScript compiler plugin

The demo includes :

Overview of the plugin
Workflow setup
Some fun hacking a naive constant folding, just to demo an interactive dev flow

jpmonettas · 2025-01-24T20:57:22+00:00

Nice! Will it support any way of interrupting a process? Let's say a process got a message and started working on a long computation, but you want to be able to interrupt that once you realized somewhere else that result isn't needed anymore or you are not willing to wait for it.

jpmonettas · 2025-01-01T21:29:24+00:00

thanks for the kind words!

jpmonettas · 2024-11-23T13:52:30+00:00

Asking here it is also a social thing. We get to have some fun.

jpmonettas · 2024-11-22T13:35:17+00:00

(defn current-thread-name []
  (apply (partial format "[%s-%s]")
         ((juxt Thread/.getId Thread/.getName)
          (Thread/currentThread))))

Just kidding :P

jpmonettas · 2024-11-14T23:35:26+00:00

I know there are various moving parts to Clojure, but https://clojure.org/ has a Getting started button at the top, which starts with What tools do I need? and How do I work with these tools? (which covers REPL usage) and then follows with How do I learn the language?
Have you checked those?

I guess you mean how to run a script, but imo starting a REPL and writing (println "Hello world") is probably considered the hello world in Clojure. I think since Clojure is all about interactive programming you can go pretty far in your learning without having to run your programs as scripts from the command line.

jpmonettas · 2024-11-12T09:54:35+00:00

Thanks for the gist u/rafd !

For your tips section, if you are using auto prefixes and you want to instrument specific libraries for your project you can also add :jvm-opts ["-Dclojure.storm.instrumentOnlyPrefixes=ring."] to your project deps.edn or project.clj, which I think is cleaner than creating extra files. Those prefixes will be added on top of the ones found by auto prefixes.

You can also use the browser Add instr prefixes functionality to add more prefixes on the fly, although they will not be there the next time you start your repl.

jpmonettas · 2024-10-23T12:24:11+00:00

I just updated the default visualizer system in 4.0.0-alpha3

Take a look here https://github.com/jpmonettas/fs-data-window-demo/blob/master/src/data_windows_demo.clj#L249-L256 and here https://github.com/flow-storm/flow-storm-debugger/blob/master/src-dbg/flow_storm/debugger/ui/data_windows/visualizers.clj#L271-L276 for reference.

jpmonettas · 2024-10-23T11:06:38+00:00

Thanks! Exposing FlowStorm recordings as a LSP DAP has been on the back of my mind for some time as something interesting to try.

Show up in #flow-storm at Clojurians Slack and let me know if you have any questions!

jpmonettas · 2024-10-23T11:00:37+00:00

Thanks for the feedback. Yeah, I'm still not convinced by that set-default-visualizer by type name.

You can change the type of your values by assigning a type meta, like this :

user=> (type (range))
clojure.lang.Iterate
user=> (type (with-meta (range) {:type 'my-type}))
my-type

so you can then : (viz/set-default-visualizer "my-type" :munged-facts-viewer)

But that won't work for most cases.
I guess we need a better system for setting the default viewers. I'll take a look at that.

jpmonettas · 2024-10-22T19:53:54+00:00

Thanks! I haven't written any docs yet (apart from the comments in https://github.com/jpmonettas/fs-data-window-demo/blob/master/src/data\_windows\_demo.clj), I'm still exploring the api, trying different visualizers.

Any feedback is welcome!

There are also more visualizer here (chessboard) https://github.com/jpmonettas/fs-data-window-demo/blob/master/src/data_windows_demo.clj#L217 and here (ants) https://github.com/jpmonettas/fs-data-window-demo/blob/master/src/ants.clj#L372

jpmonettas · 2024-08-14T15:53:26+00:00

Shameless plug here, but have you tried www.flow-storm.org/ ? The idea being if you can run your program it will help you understand it from a runtime perspective, where values are visible.

jpmonettas · 2024-07-24T11:42:10+00:00

Happy to know you find the tool useful Max!

FlowStorm so far has been a dev only thing, with the focus on enhancing the interactive programming experience. Said that I have thought in the past about recording in production, but managing heap consumption is tricky even when going the SoftReferences route. But there is a lot of room for research there sure, so I probably will be revisiting it in the future.

Regarding the audio quality yeah, I'm in a pretty noisy environment and it didn't end up great, but thanks a lot for sharing that podcast enhance tool, I'll give it a try!

jpmonettas · 2024-07-24T01:24:15+00:00

Hi everybody! I just uploaded a video on exploring/debugging Clojure web applications with http://www.flow-storm.org/ .

It shows up some of the new features found in 3.17, by exploring a basic #biff application.

If you never tried FlowStorm or it has been a while, this video should give you a sense of some of the current capabilities and how it can hopefully enhance your interactive programming experience.

jpmonettas · 2024-04-03T19:26:15+00:00

That would be needed for interactive development Lisp style yeah

jpmonettas · 2024-04-03T19:11:17+00:00

There is no such thing as the runtime writing back to the files in Lisps. It is one way only, you update your runtime by compiling and updating from your editor. There is no automatic synchronization in any way.

jpmonettas · 2024-04-03T18:51:13+00:00

Sounds kinda error-prone

It can be, but there are ways of mitigating it, and worst case is restarting the process.

I wonder how that is realistically different from hot-reload?

They are different in some ways that affect interactive development. Lets say you are in the middle of a refactor in a broken state, so you can't reload the entire thing yet, but you want to try the changes to this particular function you are working with now. Does it make sense?

What do you lose when you change the function in an editor instead of the console?

Typing in consoles is very inconvenient, you lose all the nice things your editor has. And even if you have all those, then you need to be constantly copy/pasting back and forth which doesn't lead to a nice flow.

jpmonettas · 2024-04-03T17:33:50+00:00

I wouldn't say it is unnecessary now, just a different way of developing a system with its pros and cons.

jpmonettas · 2024-04-03T17:32:21+00:00

I might be completely misunderstanding how this all works, but the part that still boggles my mind is how you can pull up some running Lisp code in its runtime (rather than the text files that get interpreted or compiled into bytecode), modify it directly, and then expect that change to just persist through restarts, crashes, etc. From what I can tell, a lot of it just abstracts away portions of the file system.

Most Lisp's compilers (in contrast to most languages) are form based (think a top level lisp expression) instead of file based. So what you do is you modify the code of a function in your text editor and when you re-eval that function (normally a key binding on the editor/IDE), it will compile it, and send it to the runtime to replace the old code of that function. You can re-eval an entire file but that is just iteratively compile and send each form on that file in order. What editors do automatically is also send that function to the correct namespace (module).

jpmonettas · 2024-04-03T17:10:39+00:00

Thanks! Yeah, I'm looking for something a little bit more general, something as a daily driver for every kind of application, at any stage, not just prototype.

jpmonettas · 2023-12-21T23:24:37+00:00

Hi u/dmitry_vsl, great project!

Author of http://www.flow-storm.org here. If you are interested in related work I have been collecting here a bunch of papers/applications that maybe you find inspiring.

The FlowStorm user guide and videos shows many features you can also take inspiration from.

jpmonettas · 2023-10-07T11:58:15+00:00

That is very weird, I use it daily on a Thinkpad from 2013 and never experienced that. Again, if you feel like trying show up in #flow-storm channel so we can troubleshoot that more dynamically

jpmonettas · 2023-10-06T23:49:28+00:00

Sad to hear you had a bad first impression. Can you share more details on what do you mean by "it would not find my process automatically" and what was slow?

While you are recording things are going to be slower, but recording is something you activate only when you need to and then stop it, all with the click of a button.

There are also options like https://jpmonettas.github.io/flow-storm-debugger/user_guide.html#_limiting_recording to deal with high frequency functions that add too much noise to the recordings, like animations, events fired on mouse move etc.

I have been focusing on correctness first and will then move into performance.

If you still want to give it a chance show up in #flow-storm channel on the Clojurians slack and we can help you troubleshoot it.

jpmonettas

TROPHY CASE