Live data from Hacker News

Static, Ahead of Time Compiled Julia

juliacomputing.com

71–80 of 87 posts

Re: Static, Ahead of Time Compiled Julia

#71

> Julia Computing carried out this work under contract from the Johns Hopkins Applied Physics Laboratory (JHU APL) for the Federal Aviation Administration (FAA) to support its TCAS (Traffic Collision Avoidance System) program. It's great! Looks like a very interesting contract.

In case you are interested, here are slides (http://juliacon.org/2015/images/juliacon2015_moss_v3.pdf) and a presentation (https://www.youtube.com/watch?v=19zm1Fn0S9M) about TCAS (and its successor, ACAS X)

Re: Static, Ahead of Time Compiled Julia

#72

Earlier quoted context omitted.

"Strong typing" and "weak typing" don't really mean anything: http://blogs.perl.org/users/ovid/2010/08/what-to-know-before... You probably mean "static typing" versus "dynamic typing" which I wrote a bit about in the context of Julia here: http://stackoverflow.com/questions/28078089/is-julia-dynamic... Basically, I think "type stability" hasn't really been a thing in the past because in dynamic languages, people have…

I disagree: strong and weak typing are fairly well defined terms. I'm going off the definition given in "Programming Language Pragmatics," which states "a language is strongly typed if it never allows an operation to be applied to an object that does not support it; a language is said to be statically typed if it enforces strong typing at compile time."

Even if you are correct that they are well defined, by that definition Lisp, Ruby, Python, JavaScript and Julia are strongly typed. C, Forth and assembly language are not. So the distinction isn't useful in this discussion.

Re: Static, Ahead of Time Compiled Julia

#73
post #8

I think this [0] is worth reading before starting a project in julia (it's quite shocking). Does anyone know if anything has changed in julia's development process over the last year? [0] http://danluu.com/julialang/

I, for one, much prefer tons of bugs if that's what's necessary to keep the language evolving. I like the fact that powerful features are rapidly being added to the language, even if it breaks backward compatibility. Most of my programming is scientific in nature, so I write lots of one-off scripts. "Fixing" these scripts for the newest version of Julia rarely takes more than a few minutes.

Considering that Matlab, which is supposed to be a stable platform, seems about as buggy as Julia with a lot of regressions, API changes, and new bugs every release, I, too, prefer Julia, as it's not only a nicer language with better programmer and execution efficiency, but it's also open source.

I'd rather try to fix a bug in some undocumented codebase than wait 6 months for a new black box.

Re: Static, Ahead of Time Compiled Julia

#74

Earlier quoted context omitted.

> I've no idea about the "private and semi-private communications" and I can only hope things were patched up there. I'm the co-creator that Dan was talking about. He wrote a bunch of less-than-charitable comments on the aforementioned semi-private forum – not specifically to me, but where he surely knew I would read them – to which I responded with: https://gist.github.com/StefanKarpinski/c72219ff8ce261172b11 You ca…

Luu's claims made me hold off on pushing people to contribute to Julia as I waited for corroboration (or refutation) of them. I appreciate you linking to that very fair post that replies to it. The contrast between how the two of your present your claims adds credibility to yours. I also got a great laugh out of part about one guy that barely speaks English using the project as a personal Stackoverflow. A problem I'd…

The parser and some lowering passes are still written in femtolisp. There has been some discussion of switching to the native JuliaParser package [1]. However, JuliaParser doesn't implement the fairly tricky lowering passes that the femtolisp parser does. I personally would prefer to have the parser in Julia, but at this point the most pressing issue with parsing and lowering is speed – so it's possible that the parsing and lowering will be converted to C instead.

[1] https://github.com/JuliaLang/JuliaParser.jl

Re: Static, Ahead of Time Compiled Julia

#75

Earlier quoted context omitted.

Luu's claims made me hold off on pushing people to contribute to Julia as I waited for corroboration (or refutation) of them. I appreciate you linking to that very fair post that replies to it. The contrast between how the two of your present your claims adds credibility to yours. I also got a great laugh out of part about one guy that barely speaks English using the project as a personal Stackoverflow. A problem I'd…

The parser and some lowering passes are still written in femtolisp. There has been some discussion of switching to the native JuliaParser package [1]. However, JuliaParser doesn't implement the fairly tricky lowering passes that the femtolisp parser does. I personally would prefer to have the parser in Julia, but at this point the most pressing issue with parsing and lowering is speed – so it's possible that the pars…

Thanks for the update. Decent plan. An alternative would be to code it in SPARK Ada for speed and correctness. Has side benefit that each component done that way won't be touched by halfassed developers because they lack the will to learn it. Not quick n dirty enough for them. ;)

Re: Static, Ahead of Time Compiled Julia

#76
post #3

I personally find the syntax of the language and quality of the current implementation (speed!) excellent. However, it doesn't experience the marketing languages like Rust or Golang receive. What I personally also find worrisome is the perception (at least for me) that Julia is confined to scientific computing whereas I find it should really be a general purpose language.

There is no technical reason that Julia can't be used for general purpose computing. (Well personally, I'd like nested namespaces, but) it is an amazing language. Just a matter of someone putting in the time to build the required libraries and glue code. Which will happen in time.

The lack of AOT has been the main thing holding me back from adopting it for more general purpose computing. Now with AOT I can "compile" the code and get some reasonable expectation of performance and ease of deployment. I'm probably going to start using Julia and (hopefully) extending the web server packages. Basically it feels similar enough to JavaScript for web development but with more expressiveness, so I'm pretty excited by the prospect.

Now this turns up a terrible delima, do I try to use Julia or Rust for writing embedded controllers? Rust has macros and direct memory control, but the article mentions. :)

I also think the more of us that recommend Julia for general compute, the more likely it'll get used that way.

Re: Static, Ahead of Time Compiled Julia

#77

Earlier quoted context omitted.

I disagree: strong and weak typing are fairly well defined terms. I'm going off the definition given in "Programming Language Pragmatics," which states "a language is strongly typed if it never allows an operation to be applied to an object that does not support it; a language is said to be statically typed if it enforces strong typing at compile time."

Even if you are correct that they are well defined, by that definition Lisp, Ruby, Python, JavaScript and Julia are strongly typed. C, Forth and assembly language are not. So the distinction isn't useful in this discussion.

Javascript is probably one of the weakest typed languages out there. {}+{}, []+[], {}+[] are all completely valid operations in javascript that cause all kinds of implicit coercions. And assembly language is very strongly typed: it just has a very simple type system.

As for Julia, I'm not sure how strongly or weakly typed it is, but I would probably put it at around the same level as Java.

Re: Static, Ahead of Time Compiled Julia

#79
post #78
post #12

Earlier quoted context omitted.

Me too, maybe this will pressure more adoption of PyPy.

Can you elaborate on this?

For the majority of people without CS background Language == Implementation.

So if the reference implementation is a bare bones interpreter, even though there are JIT and AOT compilers tp choose from, they will say language X is interpreted.

Which in Python's case means many ignore the existence of PyPy, given that the language designers don't want to change the nature of CPython.

Re: Static, Ahead of Time Compiled Julia

#80
post #79
post #78

Earlier quoted context omitted.

Can you elaborate on this?

For the majority of people without CS background Language == Implementation. So if the reference implementation is a bare bones interpreter, even though there are JIT and AOT compilers tp choose from, they will say language X is interpreted. Which in Python's case means many ignore the existence of PyPy, given that the language designers don't want to change the nature of CPython.

PyPy's adoption problem is not that it isn't the reference implementation. It's that it is incompatible with a huge body of Python modules that rely on C extensions. If you're going to lose access to libraries, may as well not make the same exact semantic decisions for a JIT-oriented language implementation that you made for an interpreted implementation.
Post reply on HN