Cljs2go – A ClojureScript to Go compiler | Hacker News Reader

Cljs2go – A ClojureScript to Go compiler

github.com

98 pointsnetworked13 comments

Very neat project, will be keeping an eye on it to see how it grows and progresses.

I love the idea behind this project. The clean and intuitive project structure and layout is exemplary.

At present the emitted go code is quite nasty looking [for human-readable purposes :D]. Not meant as a complaint, just an observation.

For an example of what the outputted go code looks like check out https://github.com/hraberg/cljs2go/blob/master/cljs/core/cor...

And clojure's reach grows larger!

It's pretty exciting to watch the community grow. The community feels much larger than it is.

Interesting project! May I ask why you chose ClojureScript over straight Clojure?

My understanding of ClojureScript is that it's Clojure syntax for a simple single threaded environment (probably an oversimplification), but with Golang you have a lot more reach in terms of concurrency.

Please forgive me if I haven't phrased this very well. I certainly don't mean to put a negative spin on this or anything; I'm just curious.

A contributing reason is because Clojurescript compiles down to javascript, which can compile down to anything JS touches. It's harder in the Java version because it compiles down to the Java bytecode.

I would guess, because the cljs compiler infrastructure is written in clojure/clojurescript, thus easier to port and extend, compared to the clojure compiler which is written in java.

Technically speaking it is a transpiler, not a compiler.

This one statement could easily trigger an avalanche larger than all the other comments combined. I’ll start:

What is the difference between a transpiler and a compiler?

A transpiler is a compiler that will transform a high level language into another high level language. Examples: Coffeescript, Sass, this thing.

Compiling is a more generic term that includes transpiling, but is usually used to mean the kind that transforms into assembly/bytecode/executables.

Edit: Since I have no interest in furthering a thread on a legitimate question, let me just answer to the replies here: There is no reason to make the difference other than pickiness, and there is no legitimate claim as to what is or isn't high level. Use your common sense, computers don't care whether it's a transpiler or compiler.

What makes a high level language?

Is Assembly high level? In that case GCC would be a transpiler, not a compiler.

What about C? If C is considered high level, the original C++ compiler would have to be considered a transpiler rather than a compiler. Same goes for Chicken Scheme, or any of the other compilers that target C.

If we take the example even further, what about Fog Creek's Wasabi, which compiles to either PHP or VBScript? Or Ruby's compiler, which takes Ruby source and outputs very high level bytecode.

I don't think there's much value in distinguishing 'transpilers' from compilers. It's still the exact same principles at play, no matter what your source or target languages are.

If compiling includes transpiling, then isn't it both? Why make the distinction?

Many argue that there's no difference. However, if I were to attempt a definition (not that I use the word), I'd say that transpiling is compilation from a language to another language with same or similar level of abstraction, whereas compiling might be to a language with lower level of abstraction.

fascinating project!

Reply on news.ycombinator.com