Comment by ACow_Adonis | Hacker News Reader

Comment by ACow_Adonis | Hacker News Reader

Keeping in mind that Julia appears to be very very close to common lisp, some minor differences that you appear to lose going over:

- 1) lisp 1 vs lisp 2

- 2) Matlab syntax (y tho?), infix, and sygils everywhere

- 3) Clos and metaobject protocol and ability to adjust these as easily at run-time

You do appear to gain some things though in all honesty. I'm trying to program up an dataframe/analytics type program/library in Common Lisp as we speak, and I'll admit, getting that stuff right and efficient is hard work. Gives you immediate respect for anyone who has done the same in other languages.

Additionally:

- 1) Parametric types and dispatch on them

- 2) Potentially inlining and compiler optimisations and integration around their generic functions. My gut says SBCL would need some compiler magic and metaobject protocol type stuff to do the same, and it would no longer be standard Common Lisp. That's not necessarily a bad thing, there are some warts around in-builts/objects/generic functions in Common Lisp, but it would be a fracturing of the community to update/change them.

You’d only be able to inline if you know that your call-site is monomorphic. Also, there’s a Lisp library [0] for inlining generic functions that give you huge efficiency gains for certain use-cases (especially monomorphic ones). I couldn’t imagine this being a _library_ in any other language.

[0] https://github.com/guicho271828/inlined-generic-function

Julia does this automatically, it you force it with @inline

1) lisp 1 vs lisp 2

Eh. Emacs vs Vim.

2) Matlab syntax (y tho?), infix, and sigils everywhere

The target audience is scientific and mathematical users, not necessarily "programmers", and certainly not "software engineers". Matlab syntax, infix, and sygils read like math notation. The target use-case is mathematical and scientific programming. This is a benefit in my opinion.

Also, with respect to sigils, I can think of at least one popular sigil in Common Lisp: the #' reader macro for accessing functions! So much for Lisp-1 vs Lisp-2.

3) Clos and metaobject protocol and ability to adjust these as easily at run-time

Fair, but do you really need CLOS with a delightful type system and multiple dispatch?

And to be totally fair to point 3, I doubt that 99% of common lisp code either uses our needs these qualities.

Structures, types, generics, etc, do cover a lot of what people actually want in practice...

> Structures, types, generics, etc, do cover a lot of what people actually want in practice...

For scientific computing, no. However it is very useful in other areas such as web, agents, gui, where you have many methods to combine in many ways and OOP really suits in.

MATLAB syntax is pretty convenient for linear algebra. It makes things very readable.

Maybe Julia should be seen as an infix typed Lisp DSL for math. It'd make a good stack (see my other comment) with Clasp or any other Common Lisp that offers good bindings to LLVM.

CL-INFIX [0] gives you infix syntax in Lisp a la carte.

[0] https://github.com/rigetticomputing/cmu-infix/blob/master/RE...

There is already a lisp-based infix DSL for math: it is called maxima CAS.

Hi there,

I am also working on a data frame like library, using Tamas's experimental cl-dataframes as a starting point.

I'd be interested in learning a bit more about your effort - whats the motivation, why something like clml was not appropriate and so on. There might be an opportunity to collaborate?

Cheers

Reply on news.ycombinator.com