4 ms·

It's dead easy to get started. If you want to spend an hour playing with a "lisp" you're only a small download away. Clojure could learn a thing of two from thi

It's dead easy to get started. If you want to spend an hour playing with a "lisp" you're only a small download away. Clojure could learn a thing of two from this.. It's also not dogmatic. You can use mutable and immutable versions of the same data structure. Docs are concise: https://janet-lang.org/docs/index.html https://janet-lang.org/docs/index.html Full API is here: https://janet-lang.org/api/index.html https://janet-lang.org/api/index.html [edit] I fully agree that "getting started" on Clojure is easier than used to be. Anyway I still think there is room for improvement.

monsieurbanana 5y ago
You're 2 clicks away from having a fully-featured clojure environment + an interactive clojure tutorial, thanks to Calva (vscode clojure plugin) running in the browser: - click here[0] - click on SSO provider More information here[1]. Of course, it'd be better to just use the Calva plugin with VSCode. That's a bit more than 2 clicks, maybe about 5. On another hand, I don't mean to say that it's easy to start programming on Clojure, merely that it's now easy to try it out. There's a steeper learning curve than python or JavaScript, specially on the tooling side. [0] https://gitpod.io/#https://github.com/PEZ/get-started-with-clojure https://gitpod.io/#https://github.com/PEZ/get-started-with-c... [1] https://calva.io/get-started-with-clojure/ https://calva.io/get-started-with-clojure/
masklinn 5y ago
> It's also not dogmatic. You can use mutable and immutable versions of the same data structure. However from their description and the complexity promises it looks like the immutable collections are literally just the mutable ones without mutation ability (similar to Java's immutable* wrappers) which greatly limits their effective usefulness. > Full API is here: https://janet-lang.org/api/index.html https://janet-lang.org/api/index.html Sadly even worse than clojure's which is already not great.
- nuclearnice1 5y ago
  > which greatly limits their effective usefulness. Interesting Why? And what’s the alternative implementation?
  - masklinn 5y ago
    Persistent collections with structural sharing (b-trees, HAMT, RRB-vectors, …). I can absolutely understand not using them if the implementation is intended to be simple or the systems it's running on is resource limited, but simply removing the mutation bits of mutable collections is quite limiting as it incurs large overhead when actually working with them (you have to copy the entire thing every time you want to update anything). Unless the collections are always kept quite small: modern architectures are very good at dense arrays, so modern immutable data structures are trees of small-ish arrays (usually a small number of dozens, IIRC Clojure uses 32-wide nodes).
    - nuclearnice1 5y ago
      I learned a lot. Thank you
- creata 5y ago
  > Sadly even worse than clojure's which is already not great. I thought Clojure's immutable collections were generally considered good. What else would you consider "great"? Edit: or was that a complaint about the quality of the documentation, not the quality of the immutable collections?
  - masklinn 5y ago
    > Edit: or was that a complaint about the quality of the documentation, not the quality of the immutable collections? Yes, sorry if that wasn't clear.
  - bjoli 5y ago
    I think the HAMTs are pretty darn solid. I think, however, that scala raised the bar with RRB trees over the trie-based immutable vectors. And using java strings is pretty sad...
okkdev 5y ago
Racket is also just 1 download away and even comes with an IDE.
- deleted 5y ago
  [deleted]

monsieurbanana 5y ago

You're 2 clicks away from having a fully-featured clojure environment + an interactive clojure tutorial, thanks to Calva (vscode clojure plugin) running in the browser: - click here[0] - click on SSO provider More information here[1]. Of course, it'd be better to just use the Calva plugin with VSCode. That's a bit more than 2 clicks, maybe about 5. On another hand, I don't mean to say that it's easy to start programming on Clojure, merely that it's now easy to try it out. There's a steeper learning curve than python or JavaScript, specially on the tooling side. [0] https://gitpod.io/#https://github.com/PEZ/get-started-with-clojure https://gitpod.io/#https://github.com/PEZ/get-started-with-c... [1] https://calva.io/get-started-with-clojure/ https://calva.io/get-started-with-clojure/

masklinn 5y ago

> It's also not dogmatic. You can use mutable and immutable versions of the same data structure. However from their description and the complexity promises it looks like the immutable collections are literally just the mutable ones without mutation ability (similar to Java's immutable* wrappers) which greatly limits their effective usefulness. > Full API is here: https://janet-lang.org/api/index.html https://janet-lang.org/api/index.html Sadly even worse than clojure's which is already not great.

nuclearnice1 5y ago
> which greatly limits their effective usefulness. Interesting Why? And what’s the alternative implementation?
- masklinn 5y ago
  Persistent collections with structural sharing (b-trees, HAMT, RRB-vectors, …). I can absolutely understand not using them if the implementation is intended to be simple or the systems it's running on is resource limited, but simply removing the mutation bits of mutable collections is quite limiting as it incurs large overhead when actually working with them (you have to copy the entire thing every time you want to update anything). Unless the collections are always kept quite small: modern architectures are very good at dense arrays, so modern immutable data structures are trees of small-ish arrays (usually a small number of dozens, IIRC Clojure uses 32-wide nodes).
  - nuclearnice1 5y ago
    I learned a lot. Thank you
creata 5y ago
> Sadly even worse than clojure's which is already not great. I thought Clojure's immutable collections were generally considered good. What else would you consider "great"? Edit: or was that a complaint about the quality of the documentation, not the quality of the immutable collections?
- masklinn 5y ago
  > Edit: or was that a complaint about the quality of the documentation, not the quality of the immutable collections? Yes, sorry if that wasn't clear.
- bjoli 5y ago
  I think the HAMTs are pretty darn solid. I think, however, that scala raised the bar with RRB trees over the trie-based immutable vectors. And using java strings is pretty sad...

okkdev 5y ago

Racket is also just 1 download away and even comes with an IDE.

deleted 5y ago
[deleted]