News for hackers. Stuff that matters.
Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Monday July 09, 2012 @09:48AM (#4218132)
Clojure is one of the cooler languages out there. There has been one major blocker for me, though: the JVM. I don't want to have anything to do with the JVM. Not because it's bad. It's just that native code is better, especially for the stuff I'm doing.

I hope these developments eventually turn into a proper Lisp that you can interface with native C code efficiently.

Racket is pretty cool too.

Re:Direct Clojure to C Compiler - Based on ClojureScript by alberich on Monday July 09, 2012 @09:55AM (#4218170)
I wonder what would be the advantages of using Clojure without the JVM over, say, Common Lisp. To me, it seems the great advantage of Clojure is its ease of using the large number of java libraries out there. However, if you take those libraries out, wouldn't a mature Lisp implementation like SBCL be much better?
Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @10:02AM (#4218195)
There a few differences that might be worth still.

Clojure is a Lisp-1, and provides better data structures as Common Lisp as far as I am aware.

But the JVM benefit is a big one indeed.

Re:Direct Clojure to C Compiler - Based on ClojureScript by alberich on Monday July 09, 2012 @10:10AM (#4218226)
I thought that, besides the JVM itself, the advantages of Clojure would be its concurrency model - as CL standard doesn't define anything related to this - and its stronger functional approach.

I don't fully grasp the advantages of being a Lisp-1 or Lisp-2 :)

Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @10:21AM (#4218293)
> I don't fully grasp the advantages of being a Lisp-1 or Lisp-2 :)

It has to do with variable scoping. Lisp-1 only accepts lexical scoping, while Lisp-2 also allows for dynamic scoping.

http://www.nhplace.com/kent/Papers/Technical-Issues.html

Re:Direct Clojure to C Compiler - Based on ClojureScript by mahmud on Monday July 09, 2012 @10:48AM (#4218424)
Good grief.

No.

Lisp-N has to do with the number of name spaces in the language. Lisp-1s only have ONE environment; the variables range over all values of the language, integers, functions, vectors, symbols, strings. In Lisp-N, there are N namespaces for each "kind" of value.

Common Lisp is called a "Lisp-2" because it separates functions from other values. (it's closer to Lisp-5 or even Lisp-7, forgot which, because it allows that many kinds of "names" without collission.

Also above you said Clojure "probably" has better data structures than Common Lisp. That is unsubstantiated.

Re:Direct Clojure to C Compiler - Based on ClojureScript by yoklov on Monday July 09, 2012 @11:17AM (#4218560)
For what it's worth, Clojure has implementations of Phil Bagwell's HAMT-based hash-maps, vectors, and sets. These are absolutely amazing data structures, and offer functional updates, a list-like API (O(log_32(n)) for most operations, which ends up being less than seven operations in practice, which is similar enough to O(1) for most programmers).

I'm not much of a common lisp programmer (mostly sticking with scheme/racket and Clojure), but I don't think they've been ported to Common Lisp (yet), so the claim that Clojure has better data structures than Common Lisp, while somewhat a matter of preference, isn't entirely unsubstantiated.

Re:Direct Clojure to C Compiler - Based on ClojureScript by mahmud on Monday July 09, 2012 @11:26AM (#4218610)
Common Lisp has hash-tables, vectors, and sets .. had it, in an ANSI-specified document since 1984. The implementation details of these is, well, implementation dependent, be they HAMT or whatever.

The language provides a wealth of tools out of the box, but it's the job of the programmer to choose more appropriate tools for the problems at hand.

The following is the Common Lisp specification. 12+ implementations, half of them industrial strength, more than half commercial vendors, and everyone of them has to adhere to this spec:

http://www.franz.com/support/documentation/8.2/ansicl/ansicl...

Re:Direct Clojure to C Compiler - Based on ClojureScript by swannodette on Monday July 09, 2012 @12:03PM (#4218773)
But does Common Lisp allow multiple implementations of those data structures to exist in the same program actually allowing programmers to utilize the best tool for the job?
Re:Direct Clojure to C Compiler - Based on ClojureScript by mahmud on Monday July 09, 2012 @12:24PM (#4218905)
Are you seriously asking me if a programming language allows for the implementation of data-structures?

If you mean can users extend the core CL data-types, no, but you have a wealth of tools to do that yourself; use generic functions to implement whatever interface you wish, then provide for specific implementations.

Re:Direct Clojure to C Compiler - Based on ClojureScript by swannodette on Monday July 09, 2012 @01:03PM (#4219084)
but you have a wealth of tools to do that yourself

That's the problem. With Clojure you don't have to invent interfaces and then convince other libraries to use them. All the data structures are built upon well considered language level protocols that anyone can implement preventing pointless API proliferation.

Re:Direct Clojure to C Compiler - Based on ClojureScript by mahmud on Monday July 09, 2012 @08:30PM (#4221346)
Clojure has the benefit of hindsight; it is one of the newest programming languages and it is not constrained by a published standard, nor does it need to cater to tens of vendors or any existant code-bases (Nearly every user of Clojure is on github ;-)
Re:Direct Clojure to C Compiler - Based on ClojureScript by honr on Saturday July 14, 2012 @12:10AM (#4243102)
I think wise people prefer programming in good languages that enjoy the benefit of hindsight. Common Lisp does not have the luxury of hindsight, and can hardly change its specification to reflect modern theoretical and practical PL results.

Personally, I slightly prefer Clojure over SBCL.

Re:Direct Clojure to C Compiler - Based on ClojureScript by jules on Monday July 09, 2012 @11:49AM (#4218706)
Note that CL's data structures are mutable, whereas Clojure's are persistent.
Re:Direct Clojure to C Compiler - Based on ClojureScript by swah on Monday July 09, 2012 @03:40PM (#4219999)
Google search saver: immutable = persistent
Re:Direct Clojure to C Compiler - Based on ClojureScript by postfuturist on Monday July 09, 2012 @11:28AM (#4218619)
yoklov, for some reason I can't reply directly. There are a few common lisp libraries of persistent, immutable data structures that perform well. This one is implemented most closely to Clojure's: https://github.com/ks/X.FDATATYPES . This one has been around for a long time and is quite stable: http://common-lisp.net/project/fset/Site/index.html .
Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @12:00PM (#4218755)
> Also above you said Clojure "probably" has better data structures than Common Lisp. That is unsubstantiated.

It is my understanding that Common Lisp lacks the vector and hash maps that Clojure has.

Sorry if I got it wrong. I am more a ML guy than Lisp.

Re:Direct Clojure to C Compiler - Based on ClojureScript by aidenn0 on Monday July 09, 2012 @03:08PM (#4219834)
Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @04:35PM (#4220253)
I was wrong it seems.

From the documentation I have not seen the simplified syntax Clojure uses for vectors, hashes and sets.

I imagine that the syntax is Clojure specific.

Re:Direct Clojure to C Compiler - Based on ClojureScript by mahmud on Monday July 09, 2012 @12:28PM (#4218924)
Your understanding continues to be wrong.
Re:Direct Clojure to C Compiler - Based on ClojureScript by spacemanaki on Monday July 09, 2012 @10:50AM (#4218432)
edited bc mahmud said it better, but

Also, Clojure supports (optional) dynamically scoped variables.

Re:Direct Clojure to C Compiler - Based on ClojureScript by amouat on Monday July 09, 2012 @10:01AM (#4218191)
There are still some nice things such as destructuring and vectors & maps as base types. The syntax of Clojure is generally a bit cleaner and more concise, though I'm sure some lispers will disagree.
Re:Direct Clojure to C Compiler - Based on ClojureScript by FrojoS on Monday July 09, 2012 @10:03AM (#4218197)
Prototype on the JVM but compile to C for production or performance critical tests? Ideally, no refactoring required at all.

I guess it also helps to work with a dialect with more momentum. E.g. its easier to find support, on- and offline.

Since I haven't really used Closure or any other Lisp for more than a tutorial, I might be very wrong, though.

Re:Direct Clojure to C Compiler - Based on ClojureScript by Raphael_Amiard on Monday July 09, 2012 @10:15AM (#4218259)
Clojure -> C will very probably be slower than Clojure -> JVM, at least if the compiler is naive.
Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @10:23AM (#4218303)
There are JVMs with native code generation like you would expect from a normal C compiler, they are just a bit too expensive.

Here is one example, http://www.atego.com/products/aonix-perc/

Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Monday July 09, 2012 @10:40AM (#4218395)
Yes. Java is getting closer and closer to native code performance. In some rare cases it can even beat C. But this is after billions of dollars have been thrown at trying to make Java fast.

If you intend to distribute your software (as opposed to running on your own servers), it would require all the customers to have a fancy JVM. Or buying an expensive license to be able to distribute the runtime with your software.

Re:Direct Clojure to C Compiler - Based on ClojureScript by markokocic on Monday July 09, 2012 @10:52AM (#4218440)
> Yes. Java is getting closer and closer to native code performance. In some rare cases it can even beat C. But this is after billions of dollars have been thrown at trying to make Java fast.

Why is it a bad thing that someone was willing to pay money to make Java fast. Do you want to say that there haven't been billions of dollars in both money and man-hours thrown at trying to make C/C++ fast? There's no free performance.

Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Monday July 09, 2012 @11:09AM (#4218518)
> Why is it a bad thing that someone was willing to pay money to make Java fast.

I guess there's someone who wants to pay for that.

But I don't think it's money well spent. The Java bytecode is not designed for or suited to fast execution and it's a bad intermediate representation for computer programs to be compiled into native code. The Java byte code was designed to be easy to interpret and was designed at a time when a memory access was faster to execute than an ALU instruction (on cheap h/w where Java was originally intended to be run on). Those days have passed and we should move on to better intermediate representations for computer programs. Like LLVM IR.

Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @11:29AM (#4218626)
You mean VM Kit then, with AOT compilation for Java, just like Clang but for Java.

http://vmkit.llvm.org/

Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Monday July 09, 2012 @12:38PM (#4218973)
Except that I don't want the Java part of it. I'd much rather just use Clang and C.

VMkit is a nice effort, though. I hope it will some day power fancy new languages that have dynamic features which are not well suited for AOT compilation.

Re:Direct Clojure to C Compiler - Based on ClojureScript by pjmlp on Monday July 09, 2012 @11:26AM (#4218611)
What part did you not understand from my post?

These are native code compilers without any need of extra runtime exactly like C.

Just because most people only know Oracle(Sun)'s JVM, it does not mean it is the only way to execute Java code.

Re:Direct Clojure to C Compiler - Based on ClojureScript by Raphael_Amiard on Monday July 09, 2012 @10:00AM (#4218185)
Why do you prefer native code ? What do you even mean by native code ? The JVM does produce native code, it just does it at runtime (JIT compilation).

So maybe you mean static compilation, but then, why is it better for the stuff you're doing ?

Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Monday July 09, 2012 @10:37AM (#4218379)
> Why do you prefer native code ? What do you even mean by native code ? The JVM does produce native code, it just does it at runtime (JIT compilation).

By native code I mean binaries emitted by my compiler in a format that my operating system can link and load. I usually write the code in C with some CPU-specific assembly intrinsics for the critical stuff.

I tend to write computer graphics and physics simulation stuff which has to be quite fast. A lot of stuff I deal with is moving blobs of binary data from buffer to another (disk, memory, dma, gpu). Or computing a SIMD fused multiply-and-add for a few hundred megabytes of floating point data. Or invert and transpose a hundred thousand 4x4 matrices. Everything the JVM does is acting against me, so better just write native.

Sure there are games and physics and whatnot written with Java and other systems, but they are more commonly "low perf" stuff. 2d games and that kind of stuff. And even then they suffer from JIT & GC pauses and other undesirable effects. It always ruins my day when in the middle of a Minecraft session the GC kicks in while running away from a Creeper.

Re:Direct Clojure to C Compiler - Based on ClojureScript by rayiner on Monday July 09, 2012 @01:53PM (#4219389)
> I tend to write computer graphics and physics simulation stuff which has to be quite fast. A lot of stuff I deal with is moving blobs of binary data from buffer to another (disk, memory, dma, gpu). Or computing a SIMD fused multiply-and-add for a few hundred megabytes of floating point data. Or invert and transpose a hundred thousand 4x4 matrices. Everything the JVM does is acting against me, so better just write native.

The JVM is very fast for these things. There remaining delta is the result of more investment into optimizations in GCC/LLVM than any limitation of the JVM model itself.

Re:Direct Clojure to C Compiler - Based on ClojureScript by jwr on Monday July 09, 2012 @03:45PM (#4220023)
What makes you think that code compiled through C suddenly loses the need for GC?

GC, allocation, thread management, OS interfacing and compilation (JIT or AOT) together make up a VM. Removing the compilation part doesn't make the rest of your VM requirements disappear.

Having used a number of various VMs in the Common Lisp world (yes, including one implementation that went through C) I value the JVM greatly. It is an impressive engineering effort.

Also, I wrote code like yours (hand-written x86-64 SIMD assembly). I then used it from Clojure through JNA and was quite happy with the results.

Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Monday July 09, 2012 @05:50PM (#4220738)
> What makes you think that code compiled through C suddenly loses the need for GC?

Yes, you might need to free some heap memory with C and having malloc/free cause GC-like performance. That's why I have zero mallocs in the fast path. The bad part in GC is the unpredictability, which makes it unsuitable for games, simulation and multimedia stuff. But for most allocs I can get away with using the stack, which is essentially free (a possibility of a page fault exists).

> Also, I wrote code like yours (hand-written x86-64 SIMD assembly). I then used it from Clojure through JNA and was quite happy with the results.

Yes that works quite well as long as the foreign function is big enough.

What I have is a bunch of code written with C intrinsics, mostly small functions which I use a handful of for a big bunch of data. What I want is that inner loop to be efficient yet readable.

With C and intrinsics I get interprocedural optimization between the small functions. Everything gets inlined and all the values are stored in registers. There are a few hundred SSE math instructions without a single memory operation in between. I get the compiler to do register allocation for instruction scheduling for me, which it is great at (and I suck in) and leaves me with the instruction selection which it is not so great at.

Now had this been written with any higher level language, or even C across translation units (without link time optimization), my resulting code would be a lot worse. In particular, live values get spilled out of registers to memory when theres a foreign function call (as per abi requirements).

The non-fast path of my project could very well be written in any language as long as the beef would be written in C or similar. I would have to avoid allocating new heap objects to avoid GC unpredicatbility.

Re:Direct Clojure to C Compiler - Based on ClojureScript by exDM69 on Tuesday July 10, 2012 @03:35AM (#4222562)
Misread the part about the GC. Sure you do need a GC when using C as an intermediate language. If done well, you can get long pieces of code with no need to touch the heap, and hopefully your backend (the C compiler in this case) will be able to optimize it, at least a little. I'm sure LLVM would do a lot better job there.
Re:Direct Clojure to C Compiler - Based on ClojureScript by jbooth on Monday July 09, 2012 @02:28PM (#4219601)
That's all well and good, but wouldn't any LISP be way insufficient for your needs then? I mean, Java's going to be closer to C's performance than any LISP dialect until we have a "sufficiently smart compiler", right?
Re:Direct Clojure to C Compiler - Based on ClojureScript by heretohelp on Monday July 09, 2012 @01:56PM (#4219409)
This is the sort of thing I'm talking about, when I talk about the insufficiency of Java and other VM languages for high performance programming.

It'd be nice if somebody made a new systems language to succeed C or C++. Rust is looking less likely these days. Maybe Clay or Deca?

Re:Direct Clojure to C Compiler - Based on ClojureScript by raphinou on Monday July 09, 2012 @02:52PM (#4219748)
Why is Rust less likely these days?
Re:Direct Clojure to C Compiler - Based on ClojureScript by heretohelp on Monday July 09, 2012 @02:56PM (#4219774)
A thousand papercuts and a preoccupation with things that don't make it nicer to use. Supremely practical in a sense though.

It's like the inverse of golang. golang is unimpressive, and totally impractical for systems programming, but is nice to use for general purpose programming.

Rust is impressive and could'ish be used for systems programming (I'm not sure how much uphill fighting is involved with the current memory management model, it seems ARC is the default which makes me intensely uncomfortable about its prospects for 'hard' systems programming) but it's not very pleasant at all. The syntax and semantics make me nauseous.

Rust can be fixed, golang cannot. Unlikely though.

I'm not sure it's more realistic to make a practical implementation of region-based memory management than it is to ameliorate the pains of day-to-day systems programming in C.

There is a lot of low-hanging fruit when it comes to systems programming if you're allowed to make a language from scratch and they've not really capitalized on much of that due to ambition.

Re:Direct Clojure to C Compiler - Based on ClojureScript by regularfry on Monday July 09, 2012 @10:12AM (#4218242)
I can't answer for the GP, but native code is generally better for me because of the startup time.
Re:Direct Clojure to C Compiler - Based on ClojureScript by batista on Monday July 09, 2012 @10:14AM (#4218250)
>Why do you prefer native code ?

For me, because I don't want to install the JVM, or force users of my stuff to install the JVM. I also don't care about JVM libs.

>What do you even mean by native code ? The JVM does produce native code, it just does it at runtime (JIT compilation).

I, for one, mean non-JIT, no virtual machine needed, native code.

>So maybe you mean static compilation, but then, why is it better for the stuff you're doing ?

Less startup overhead. Small binaries. Easily redistributable. No stuff I don't need.

Re:Direct Clojure to C Compiler - Based on ClojureScript by sanxiyn on Monday July 09, 2012 @10:20AM (#4218289)
Does GCJ qualify? No JIT, no VM, native code, less startup overhead, easily redistributable.