Lambda the Ultimate

Yet another "Common Lisp" with infix notation. And ponies. And not quite working...

Why not include some practicable Burke-Fischer error repair (http://www.ccs.neu.edu/home/turon/icfp-2011-slides.pdf), and then extend it to semantic errors as well :-) Then we'd have DWIM, the successor to ISWIM.

I remember 1-2 decades ago Java(*) was promoted for
scientific computation. JDK 1.2 could easily beat
some C or FORTRAN linpacks. Meanwhile Java has mostly
evolved in the type system but also in the backend,
particularly GC.

If I look at your language it looks more that it aims
at being a script language and not a compiled language.
For example you issue a warning when ambiguious overloading
happens already during the declaration (**), which more or
less forces the programmer to order declarations, if he
doesn't want to get warnings.

In Java I can order declarations as I wish, here some
JDK 1.7 code:

    public static String f(String x, Object y) {
        return "f2 "+x+", "+y;
    }

    public static String f(Object x, String y) {
        return "f3 "+x+", "+y;
    }

    public static String f(String x, String y) {
        return "f1 "+x+", "+y;
    }

    public static void main(String[] args) {
        System.out.println("f(1,2)="+f("a","b"));
        System.out.println("f(1,2.0)="+f("a",Integer.valueOf(1)));
        System.out.println("f(1.0,2)="+f(Integer.valueOf(1),"b"));
    }

The specific method is declared last. The output is:

f(1,2)=f1 a, b
f(1,2.0)=f2 a, 1
f(1.0,2)=f3 1, b

Any particular scientific method underlying the development of the "warnings" of Julia, or are they just ad-hoc? Are there more "warnings" around? Is there a summary list?

Bye

(*)
http://www.javagrande.org/

(**)
http://julialang.org/manual/methods/

I use Matlab every single day in my capacity as a data oriented neuroscientist. I am also a deep lover of Lisp, and as such I can make the following observation.

The precise language semantics are nice things to get right, but Matlab's real powers are twofold: 1) it lets me write relatively sloppy matrix code and its jit makes it fast enough to do interactive data exploration, and 2) it has a rich system for displaying that data and interacting with it visually (eg, zooming in on data, associating mouse clicks with other transformations, making different kinds of plots, etc), whipping up quick and dirty applications for specific data analysis pipelines that require human interaction.

Julia might compete with the former, but as of now it doesn't have a plotting system, as I understand it. This is an absolutely critical feature, especially if you want to get matlab users to convert.

Secondly, as a Lisp programmer, I can only ask "who cares about non-s-expression syntax?" I am always astounded that s-expressions are an issue for any programmer anywhere. Syntax seems like such a silly thing to worry over.

I know I'm probably in the minority on this one, but would you consider an s-expression syntax? I'd be much, much, much more likely to convert if I could program in s-expressions.

But:
1) The manual's section about integers don't talk about overflow so I guess that it has either C/C++ or Java behaviour: each language which implement such poor semantic tend to avoid discussing about overflow, too bad.

2) minor criticism: "elseif" is a bad keyword: "elseif" and "else if" sound the same even if they are different. "elif" doesn't have such problem.

3) for exception processing, if you don't have the equivalent of D's "scope", please make sure that you do: IMHO this makes it much simpler to write readable programs even when they use functions which can throw exceptions.

As a longtime Java/C#/C++/VB programmer I have never been comfortable with LISPy languages like Clojure - the syntax (or lack thereof) frys my teeny brain.
But I have read the Julia manual and I think I have finally found a LISPy language that I could really use. The section on Metaprogramming explained Expr's in a clear and concise way that I was able to wrap my head around.
Plus, I have always wanted a language that supported multiple dispatch.

I like the Matlab syntax and Lispy function. Just a nitpick but looking at the raw data types in the manual

1) you might really want to consider longer base types. IEEE 754-2008 (128 bit floats) are now standard in the very spec you are using. x86-64 supports in in hardware and gcc compiles to it. You obviously are aiming for math applications so you need to at least support current hardware.

2) When you define your char type as unicode, and specify 32 bits I'm assuming you are using the UTF-32 encoding and not a UTF-8. I'd say that explicitly since most people reading a manual in English are going to expect UTF-8 encodings when they import data.