chrisoakman

For the 30th anniversary I worked with some friends on an implementation using ClojureScript: https://github.com/imalooney/t3tr0s

You can play online here: http://t3tr0s.com/

Battle Mode is especially fun with a group :) You can see everyone's board in real-time on this page: http://t3tr0s.com/#/spectate

Build tooling stability is one of the great undersold benefits of the ClojureScript ecosystem IMO.

The build process is defined by the compiler (using Google Closure tooling under the hood) and has not significantly changed since the introduction of ClojureScript in 2011.

Since all CLJS projects use the same compiler, the build process works the same everywhere, regardless of which actual build program is being used (Leiningen, shadow-cljs, etc).

I gave a talk about Record Linking at Clojure/conj 2019: https://www.youtube.com/watch?v=rGKEOMUtJfE

I opened a PR to add it to your list

I maintain an updated fork: https://github.com/oakmac/parinfer

ClojureScript is self-hosted and thus can be compiled in a browser (see https://clojurescript.io/ for an example).

For most serious usage and projects you will want to use the JVM though.

The Parinfer core algorithm is mostly "complete", with the remaining work being various editor integrations (which can be quite tricky).

I maintain an up-to-date fork of Parinfer JS here: https://github.com/oakmac/parinfer

The Rust implementation is also popular and actively maintained: https://github.com/eraserhd/parinfer-rust

This is very similar to https://CheckForCorona.com

The team at Luminare (https://luminaremed.com) has been working with epidemiologists and doctors from Harris County and the City of Houston to build out a screening tool to help prioritize public testing. We are doing about ~10k screenings per day and ready to ramp up as more testing becomes available: https://checkforcorona.com/harris-county

We are providing this tool free for any hospital or public health organization that needs it. Please reach out if you have any connections!

Nice work! :)

A few years ago some friends and I wrote a tetris clone to celebrate the 30th anniversary of tetris and learn ClojureScript in the process. Really fun group project.

Playable here: http://t3tr0s.com/

Repo: https://github.com/imalooney/t3tr0s

I did a quick project around this idea a while ago:

http://oakmac.com/lisp-3d-1.gif

http://oakmac.com/lisp-3d-2.gif

I'm glad you like Parinfer!

The only problem is working on a shared code base where people don't bother to indent code properly.

Parlinter was designed for this purpose. Maybe you could suggest it to your team? https://github.com/shaunlebron/parlinter

I was casually reading this article when I noticed a familiar bug when quickly moving the pieces. A quick "Inspect" reveals they are using one of my JavaScript components :)

https://chessboardjs.com/

I'm sorry your original question has been downvoted. I think it's a perfectly reasonable experience report and question. I replied here: https://news.ycombinator.com/item?id=15527041

Hi :)

I feel your pain here and just wanted to let you know how common this is for programmers who initially try out Lisp for the first time. As others have alluded to, I promise this initial "parenthesis shock" goes away rather quickly as you read and write Lisp code. In my direct experience, I have hired junior developers straight out of a coding bootcamp who were able to pick up ClojureScript in their first week using Sublime Text with no editor extensions. In other words: you can definitely do this; it's not magic.

I would strongly encourage you to check out Parinfer [1]. Parinfer makes indentation "significant" so you never have to worry about "closing the parens". Basically, if you can handle Python or CoffeeScript indentation, you can handle Lisp. There are no hotkeys to learn and it is available in most common editors today.

For a first project I would recommend rewriting something you have already written and are familiar with. That way you can focus on just the language and not worry about the problem domain or "how to solve it". Just do a 1-to-1 port of something you've already done and compare how the two solutions are the same or different.

I'm sorry you are being downvoted and being told to "just use emacs" or "use the REPL more". IMO, these are not helpful suggestions for someone new to the language.

Good luck. You won't regret learning Clojure. One of the best things I have ever done for my career.

[1] https://shaunlebron.github.io/parinfer/

Hi - I'm the author of the Parinfer Vimscript port.

If you've found a bug with the port, please report it here: https://github.com/oakmac/parinfer-viml/issues/new

Thanks :)

I totally agree the overhead of learning Emacs is orthogonal from learning Lisp. IMO, it's a shame that there is such a strong association between that tooling ecosystem and Lisp languages. I think it pushes a lot of newcomers away from the learning process.

One of the design goals of Parinfer[1] is to help reduce the cognitive load of Lisp syntax for newcomers. Hopefully more introductory texts adopt it as part of their environment setup.

[1] https://shaunlebron.github.io/parinfer/

I'm not sure when your last exposure to the ClojureScript ecosystem was, but almost nothing you mention is a problem as of 2016: debugging, hot reloading, large JS deps, etc.

I'm biased, but I think ClojureScript is the best way to use the JavaScript platform today. Awesome core library, consistent build process, best of breed tooling, persistent data structures, flexible syntax (JSX is madness compared to hiccups); I could go on.

JavaScript the platform may have it's warts, but ClojureScript is all beauty :)

Check out Rum: https://github.com/tonsky/rum

FYI - the JavaScript output of the ClojureScript compiler is designed to be compatible with the Google Closure Compiler in Advanced mode.

In other words, CLJS users don't have to do anything special to benefit from the power of Google Closure. It just works :)

Give Parinfer a try!

https://shaunlebron.github.io/parinfer/

https://atom.io/packages/parinfer

Thank you for the kind comment :) I'm glad you like atom-parinfer!

You could also just put a "[" in front of "4" and "7".

Parinfer will infer the closing brackets.

Not really due to the fundamental difference between Lisp and JavaScript syntax.

You could borrow the idea of indentation inferring function scope structure and make a plugin that would modify JavaScript syntax accordingly, but I'm not sure that would even be desirable when writing JavaScript.

Parinfer is made possible by Lisp's unique syntax.

  they have to make the indentation part of the syntax

  shifts cognitive load from managing parenthesis to managing indentation

This comment makes me so happy; thank you :)

I'm glad it "just works"!

I can speak to this as I've been using Parinfer on existing code for the last week or so.

There can potentially be a "big diff" when you run Paren Mode on a file for the first time, but that's typically a one-time event. The beauty of Parinfer is that most Lisp code already uses these conventions.

Once you start using Parinfer's Indent Mode regularly it feels crazy to write or edit lisp without it.

One of my plans for atom-parinfer[0] is to have a comment flag in a file that will automatically signal "use Parinfer on this file". Similar to JSHint inline configurations [1].

[0] https://github.com/oakmac/atom-parinfer [1] http://jshint.com/docs/#inline-configuration

I can assure you the author of Parinfer is aware of this distinction ;)

That sentence is an oversimplification to give context to the rest of the content in that section. Should probably have an asterisk to clarify.

Hi folks -- I've been working with Shaun on the tail end of this project.

Have an early prototype of Parinfer working with the Atom editor here: https://github.com/oakmac/atom-parinfer

It's pretty early software, but feedback appreciated :)

FYI - I'm fairly certain that CLJS does not use Google Closure because it is "already in java", but rather because of it's maturity and awesome features like DCE.

https://github.com/clojure/clojurescript/wiki/Rationale#goog...

Never thought this comment would end up on HN when I wrote it ;)

I remember writing this example and being mesmerized watching the games progress. I think I made an alternate version that speed up the time and opened a handful of browser tabs to watch the games. Most of them do end up in insufficient piece draws or the 50-move rule.

Glad to see others are enjoying it :)

Not a huge fan of the class keyword in ES6 either...

I do not use statically typed languages and I have nothing against MSFT; I was solely commenting on TypeScript as a language.