
Julia Language Co-Creators Win James H. Wilkinson Prize for Numerical Software - yarapavan
https://sinews.siam.org/Details-Page/january-prize-spotlight-jeff-bezanson-steven-l-brunton-jack-dongarra-stefan-karpinski-and-viral-b-shah
======
azhenley
From the interview with the award recipients:

“A programming language cannot be derived from first principles alone.
Language design is applied psychology—the computer program is the ultimate
human-computer interface. Sometimes you have to try a design out and see how
people interact with it and iterate based on that real-world feedback.”

I wish more people viewed PL like this.

~~~
sephoric
That's why C is the way it is, for all the hate it gets. I've been teaching my
son the beginnings of C now that he's proficient in JavaScript and Lua, but
making sure that every step of the way, we jump from a concept he already
understands, to a new but related concept, and how they're connected.

For example, when I explained signed and unsigned to him, since we already
covered the concepts of groups of bits having 2^n possible values, he quickly
understood that signed has just as many values as unsigned, but the upper half
just become negative inverse of the lower half.

C evolved from actual needs, and the fact that it's still widely used today
shows how incredibly well designed it was for practical but relatively general
problem solving. The C committee's job is mostly just a matter of saying "no"
to every new feature request, because C has proven to be versatile enough to
work in an extremely diverse array of situations.

We've been using Lua's C API and the Win32 API[1] to make cool things, such as
a primitive Love2d clone, and just last night he said "Wait, you're telling me
this is the _old_ way of programming Windows? It just makes so much sense and
seems so well designed!" C isn't perfect, but if you start from where C
started, and trace it until now, you'll learn all the reasons behind its
decisions, and they make sense in practical situations.

Kind of like the difference between metric and imperial measurement systems.
Metric makes sense in an isolated mathematical world (i.e. science), bu
imperial units make sense when you're working with real physical objects (e.g.
construction).

[1] [http://laurencejackson.com/win32/](http://laurencejackson.com/win32/)

~~~
renox
Well designed.. I'm not so sure, once you're used to something you're 'blind'
to its defaults.. Big: signed/unsigned automatic conversion? Minor: conflating
unsigned and modulo arithmetic (why not allowing signed modulo int?)? Huge: no
way to pass an array but just a pointer? ...

------
marviel
If anyone is interested, I was snooping around and found one of the co-
creator's PHD thesis that explains in detailed terms some of the ideology
behind Julia: [https://dspace.mit.edu/handle/1721.1/99811#files-
area](https://dspace.mit.edu/handle/1721.1/99811#files-area)

~~~
StefanKarpinski
Can be downloaded here (PDF):
[https://github.com/JeffBezanson/phdthesis/raw/master/main.pd...](https://github.com/JeffBezanson/phdthesis/raw/master/main.pdf)

For a shorter read with many of the same highlights, this is a paper about the
design and implementation of Julia (PDF):

[https://julialang.org/publications/julia-fresh-approach-
BEKS...](https://julialang.org/publications/julia-fresh-approach-BEKS.pdf)

~~~
marviel
Thanks! Awesome work on Julia!

------
linkingday
Can't wait for the language to be as widely used as Python or R. Been playing
around with it at home since the 1.0 release and it really is a joy to use.

~~~
pjmlp
I wish that Python feels a bit of Julia's heat, as that might be the only way
for more PyPy love.

~~~
h8hawk
Pypy is basically abandoned project. Main version is Python2 and It has poor
support for python 3. The latest version They are supporting is python3.5.
Beside that even with Pypy they wouldn't be even close to nodejs. Julia is on
par with Fortran or C. Reason behind Julia amazing performance is its type
system. e.g multiple dispatch and value types. Python lakes both. Python also
has parallelism problem with GIL. Mypy team currently works on compiler based
on static type annotation:
[https://github.com/mypyc/mypyc](https://github.com/mypyc/mypyc) I think they
could gain much more performance than Pypy.

~~~
j88439h84
This is not correct. Pypy is actively developed.

Numerical code is always written in numpy which can drop the GIL.

------
tombert
I built a very simple neural-network app a few years ago with Julia, and while
the project was fun and I didn't think the language was _bad_ by any means, as
someone who does software for a living I had trouble seeing why compsci people
really got into it.

I could totally see someone like my dad using it (he's an aerospace engineer,
not software), but I have friends who work in compsci in academia trying to
evangelize the language.

Not trying to start a war here, but I'm curious what more-seasoned Julia vet
might have seen that someone with only ~12 hours with the language wouldn't.

~~~
lenticular
It's extremely expressive. Notably, Julia is homoiconic, with full lisp-style
macros. It also has multiple dispatch, which is a far more general technique
that OO single-dispatch. This makes it very easy to define modular interfaces
that work much like statically-typed type classes in Haskell. This allows you,
for example, to define a custom matrix type for your bespoke sparse matrix
layout and have it work seamlessly with existing linear algebra types.

I've done a lot of work in both Python with Scipy/Numpy, and Julia. Python is
painfully inexpressive in comparison. Not only this, but Julia has excellent
type inference. Combined with the JIT, this makes it very fast. Inner
numerical loops can be nearly as fast as C/Fortran.

Expanding on the macro system, this has allowed things like libraries that
give easy support for GPU programming, fast automatic differentiation,
seamless Python interop, etc.

~~~
you_owe_me
Please don't vilify Python or R thinking that will help with Julia's adoption
or popularity. If Julia is as awesome as its evangelists say, it will
gracefully displace its competitors without the need of a smear campaign

~~~
eigenspace
Criticisms of languages should not be taken as criticisms of their creators or
users. I don't see anything wrong with saying "Language X does Y better than
language Z in my use cases."

Languages are toolsets and programmers are always looking for appropriate
tools for a given task. It seems crazy to demand that people not be able to
talk honestly about their experiences using a given tool. Python doesn't have
feelings, it won't be sad if you don't like it.

~~~
xiaodai
Even if it does, what's wrong with stating an opinion? Why does an honest
opinion have to be branded "smear"?

------
ArtWomb
Congrats! JuliaCon 2019 registration also just opened (22 July, Baltimore)

[https://juliacon.org/2019/](https://juliacon.org/2019/)

------
ForHackernews
Julia deserves way more attention than it's currently getting. I'm hoping now
that it's past 1.0, a few big-name companies will start using it and raise its
profile.

~~~
agumonkey
Attention is better in small doses, I think it's clear to many that Julia is a
strong project, let it grow peacefully.

------
make3
The fact that you have numpy like matrix manipulation directly out of the box
is really cool, and it's even better than numpy because if the dot operator
for element wise operation, which is just awesome

------
you_owe_me
The authors claim Julia is a general programming language, but after a few
tries I am not totally sure about that. Yes, it's a nice programming language
for scientific computing but I am afraid its usefulness stops there.

Matlab is (was?) the default tool for computational science, and Julia borrows
lots from it. I'd say it's safe to put Julia in the same category with Matlab
and Mathematica

~~~
krull10
What about the Julia 1.0 language design do you find prevents general purpose
programming?

~~~
xiaodai
I think he's just trolling...

------
emmanueloga_
I'm always looking for good computer tools to assist with learning Math with
computers. I found this: [1].

Are there any other resources like this to learn fundamentals of Math with
Julia? ([Linear] Algebra, Calculus, Geometry, Basic Physics, Discrete Math).

1:
[https://calculuswithjulia.github.io/](https://calculuswithjulia.github.io/)

~~~
byt143
[https://discourse.julialang.org/t/new-linear-algebra-
textboo...](https://discourse.julialang.org/t/new-linear-algebra-textbook-
downloadable-has-julia-companion/18665)

~~~
emmanueloga_
This course looks fantastic! Thanks for sharing :-)

~~~
byt143
Sure!

------
francasso
I'll say only one thing: 1 based indexing.

Jokes asides, congratulations to Jeff Bezanson, Stefan Karpinski, and Viral B.
Shah, well deserved!

~~~
coldtea
> _I 'll say only one thing: 1 based indexing._

You mean you'll say only zero thing?

------
uptownfunk
Want to drive adoption? Introduce it in schools.

~~~
giornogiovanna
Evil but true. I think the easiest way in would be to rally up some university
students into starting a "Julia Club" or maybe even a "Julia Evangelism Strike
Force".

~~~
uptownfunk
Even further than that, you need faculty to teach with it. I know I use R a
lot primarily because that's what I learnt at Cal, it was easy, and it worked.
Things are probably shifting towards Python in schools now, but I think that's
the best way you're going to get a lot of users using it persistently in their
careers.

------
WhompingWindows
As a current R user, and former SAS user, can someone give me an elevator
pitch as to why Julia is worth my time? I use a lot of the tidyverse and some
more niche epidemiology/stats packages in R, I'm also pulling in datasets on
the order of 1-10 million rows from MS SQL.

~~~
currymj
the elevator pitch is, it's an easy to use language, you can vectorize things
if you want, but also if you hand-write loops it will be very fast. Whereas in
R, hand-writing loops brings you to the 3rd circle of hell [1].

the more general version of the elevator pitch is that being in an environment
where all the code is written in one high-level language that is still fast is
qualitatively different. you can combine things in all kinds of strange ways
with surprisingly little work. I.e. the DiffEqFlux package takes about a
hundred lines of code to glue together a GPU neural network library and some
very advanced differential equation solvers.

realistically, it sounds like you are hitting all of R's strongest points
currently, though. I suspect right now you would be pretty dissatisfied with
Julia.

1: [https://www.burns-stat.com/pages/Tutor/R_inferno.pdf](https://www.burns-
stat.com/pages/Tutor/R_inferno.pdf)

------
asimpletune
Wow, congratulations to the Julia team!

------
kkylin
The prize lecture will be given at the SIAM Computational Science &
Engineering conference in a little over a month
([https://www.siam.org/conferences/CM/Main/cse19](https://www.siam.org/conferences/CM/Main/cse19)).
SIAM hasn't been doing live streams, but does sometimes put up video or
audio+synchronized slides a little (a couple months?) after the conference, in
case anyone is interested.

------
Iwan-Zotow
Problem with Julia is not (only) 1-based array indexing, but their uses of
ranges. Closed ranges are not composable. For Python-style ranges for a lot of
operations (mean, sum, ...) I could define monoid, provide composition rules
and be done with it. WTF I supposed to do with Julia ranges?!

~~~
maxmouchet
What do you mean by closed ranges composition ?

~~~
Iwan-Zotow
Suppose I have to compute sum for array of length N. In python it is something
like

s = 0 for k in range(0, N): s += a[k]

Ok, I have more cores/CPUs, could I do it in parallel? Sure

v1 = Sum(0, N/2) v2 = Sum(N/2, N) s = v1 + v2

I even could do it on asymmetric cores (like most phone CPUs today)

v1 = Sum(0, K) v2 = Sum(K, N) s = v1 + v2

I could do a bit more complicated things, like calculating means. For that, I
have to make a monoid

def mean(from, to, a): m = 0 for k in range(from, to): m += a[k] N = to - from
return (m/N, N)

Here I'm returning tuple, and for that to be a monoid I have to state
composition law:

def compose(M1, M2): A1, N1 = M1 A2, N2 = M2 N = N1+N2 return ((A1 _N1 + A2_
N2)/N, N)

If my identity is (0,0) tuple, it is quite easy to verify that indeed I have a
monoid. Nice, simple, composable ranges.

For closed [1...N] ranges this is NOT nice, NOT simple, just plain fugly
exercise. Sorry, looks like code samples are screwed up a bit, don't know how
to fix it

~~~
mcabbott
But why should you have to care, why not just sum(range)? Or

    
    
        @threads for i in eachindex(object) 
    

and let the details about how many cores be written once, correctly,
elsewhere?

~~~
Iwan-Zotow
> But why should you have to care, why not just sum(range)?

Sure, if you have single infinitely fast CPU. In real life, we have to
decompose problem, run it in parallel and compose it back.

> Or @threads for i in eachindex(object) & let the details about how many
> cores be written once, correctly, elsewhere?

Here I'm explicitly talking about details, how it should be done, importance
of composition, monoids etc. I understand, that if someone did it for you, you
might not care - well, more power to you then. But some basics rules about
Pyton ranges are pretty good:

1\. [0...K) + [K...N) = [0...N)

2\. Given range [K...N), number of elements in the range is N-K, in case of
[0...N) number of elements is N-0=N.

Simple, elegant, composable. I can't say the same about Julia

~~~
hhmc
1-indexed ranges can still be composable if we define them as open on the
right at N+1 (which is how I imagine one would want to define things in their
implementation).

[1...N] = [1...N+1) = [1...K+1) + [K+1..N+1)

So the real loss is your point (2) - which, I agree, makes the implementation
much less elegant and simple.

~~~
Iwan-Zotow
> 1-indexed ranges can still be composable

you could make them work, but improper abstraction leaks out in so many fugly
ways. F.e. in Python you could compose functions, not only ranges. What do you
pass in? Simple, [0, len(a)). What you get out? Simple, len(a). So you could
operate on ranges composing function calls like in FP. Even works for unknown
beforehand sequences/streams, just count along the sequence how many events
you processed, and return it as length, and it could go into composition
function. With Julia you have to think what is passed and what is returned.
Shall I always return len(a)? Or maybe len(a)+1? What to return in case of
streaming events? Sometimes len(a) and sometimes len(a)+1 with tons of
comments and warnings? It is not a good way to deal with all that and not a
good way to build API. Could be done and probably was already done, sure. BUt
simplicity, elegance and composability is missing in the base design.

~~~
newen
I don't buy it. Inclusive ranges are much more intuitive than left side
inclusive and right side exclusive ranges. And they compose just fine; you
just have to add a plus one at the right places. E.g.

    
    
        function mean(a, l, r)
            s = 0
            N = r-l+1
            for k in l:r
                s += a[k]
            end
            s/N, N
        end
        
        function mean2(a)
            N = length(a)
            lr1 = (1,div(N,2))
            lr2 = (div(N,2)+1,N)
            v1, N1 = mean(a, lr1...)
            v2, N2 = mean(a, lr2...)
            N = N1+N2
            (v1 * N1 + v2 * N2) / N, N
        end
    
        function compose(M1, M2)
            v1, N1 = M1
            v2, N2 = M2
            N = N1+N2
            (v1 * N1 + v2 * N2) / N
        end
        
        function mean3(a)
            N = length(a)
            lr1 = (1,div(N,2))
            lr2 = (div(N,2)+1,N)
            compose(mean(a, lr1...), mean(a, lr2...))
        end
    

You have to think about what is passed in and out anyway. Arguments of
elegance etc. are most of the time personal preferences and very biased.

~~~
Iwan-Zotow
> Arguments of elegance etc. are most of the time personal preferences and
> very biased.

No, they are not. I'm talking about ability to build (and build upon)
underlying algebraic structure.

ok, could you make a monoid out of your/Julia closed ranges? What would be a
unit in this monoid? How would you make a null/empty range?

~~~
newen
Empty range is 1:0 or a+1:a or a:a-1 for any integer a. Closed ranges (for
integers) are equivalent to open ranges since [a,b] is the same as [a,b+1).
You just put the plus ones in the right places.

------
xiphias2
Multi-methods really are a lot of fun, but I'm missing the Trait system
(instead of the object hierarchy) that makes Rust so modular. I know that
there are some tries to put it into Julia, but none of them is well supported.

~~~
vanderZwan
I thought Tim Holy's Trait Tick was considered the de facto way to use traits
in Julia?

[https://github.com/mauro3/SimpleTraits.jl](https://github.com/mauro3/SimpleTraits.jl)

~~~
xiphias2
Maybe it works great, but the syntax doesn't feel native to me, and I don't
see it used in the standard library, which means that it's not embraced by the
language developers.

~~~
3JPLW
Not many folks use the macros that those macro-trait packages define, but the
technique itself is in widespread use throughout the core language and
standard library. That's where it was first posited and implemented, in fact:
[https://github.com/JuliaLang/julia/pull/8432](https://github.com/JuliaLang/julia/pull/8432)
(and see the link to the "trait trick")

~~~
xiphias2
Great, thanks!

------
amrrs
With computational power becoming cheaper and cheaper - will we have two-
language problem anymore?

~~~
coldtea
Computational power doesn't become cheaper and cheaper.

If anything it's the inverse:

Not only Moore's law has stopped working for several years now ([1]), but we
have also greatly increased what we do with computers (e.g. the whole dataset
of an 80s company could fit on a 1GB disk -- today we routinely need to
process terabytes of data both streaming and offline -- see also 4K video,
webasm vs simple websites of 1999, VR, AR, and so on).

But even if computational power increased continuously and became cheaper and
cheaper it would only help if our data and processing needs remained static or
increased at a significantly slower pace.

[1] [https://steveblank.com/2018/09/12/the-end-of-more-the-
death-...](https://steveblank.com/2018/09/12/the-end-of-more-the-death-of-
moores-law/)

[https://www.extremetech.com/computing/256558-nvidias-ceo-
dec...](https://www.extremetech.com/computing/256558-nvidias-ceo-declares-
moores-law-dead)

[https://interestingengineering.com/no-more-transistors-
the-e...](https://interestingengineering.com/no-more-transistors-the-end-of-
moores-law)

[https://en.wikipedia.org/wiki/Moore%27s_law](https://en.wikipedia.org/wiki/Moore%27s_law)

~~~
yellowapple
I don't know if I'd call processing terabytes of data "routine" even in this
day and age. Same deal with 4k video, VR/AR, etc. Yeah, some particularly
large or cutting-edge companies might be doing that, but the average business
will likely not have nearly as extreme of needs.

Re: the "webasm vs simple websites of 1999" factor, I think that's a case of
designers (and the programmers enabling them) self-inducing such problems.
Most business sites don't actually need all those newfangled features and
tools; plain old HTML5+CSS3 (plus maybe a little bit of JS here and there) is
more than good enough.

------
make3
I personally don't like the fact that you have structs but no classes and no
instance methods, but I know this is personal and don't want to start a
religious war this morning

~~~
pjmlp
Multi-methods are much more powerfull than instance methods, but yeah lets
agree to disagree. :)

~~~
yellowapple
I feel like they're a significant departure from the OO concept of sending a
message to an object (for example, "Foo ! bar()" in Erlang or "Foo.bar()" in a
more typical OO language would be interpreted as "send message bar() to
object/actor/whatever Foo"). Julia's approach is more "call this function on
this object", which is indeed perfectly useful, but is semantically different.

~~~
pjmlp
That OO concept is pretty much Simula specific, Lisp languages got influenced
by the work done in LOOP and Flavours which lead to the design of CLOS, the
origin of multi-methods idea.

Building on top of your remark, Julia's approach is more "call the visible
implementation of this function that better matches the types of all given
parameters".

And these are only two possible ways of doing OOP, there are a few other ways
of approaching the ideas of writing extensible modular code with polyphormism.

~~~
yellowapple
That OO concept is also what Alan Kay et. al. were envisioning when they
coined the term "object-oriented". It's all about message passing between
blackboxed instances with isolated/private states. Multi-methods and such are
cool and useful, but they're kinda secondary to that core concept (which Julia
doesn't really have, to my knowledge at least).

In other words: object orientation != strong typing (even if they do tend to
go hand-in-hand).

~~~
pjmlp
I never said that object orientation == strong typing, rather that
Smalltalk/Simula OOP isn't the only way of doing OOP.

CLOS, Beta, SELF, Oberon (the first version), Component Pascal all have
explored different ways of doing OOP.

------
xvilka
Julia needs something like IPython/Jupyter but without Python.

~~~
SiempreViernes
the "Ju" in Jupyter is for julia, do you mean you want Jupyter without the
python support?

~~~
xvilka
Yes, this is why I said "without Python".

~~~
yellowapple
Wouldn't it be easier to just use Jupyter and not use the Python-supporting
stuff?

Just because Visual Studio supports Visual Basic doesn't mean I can't use it
when I'm only interested in writing things in C#.

------
guessmyname
HackerNews’ traffic broke this website’s database:

\---

500 - Internal server error.

SQL Exception

Error Details

File

Error Index #: 0

Source: .Net SqlClient Data Provider

Class: 17

Number: 1105

Procedure: AddEventLog

Message: System.Data.SqlClient.SqlException (0x80131904): Could not allocate
space for object 'dbo.EventLog'.'PK_EventLogMaster' in database 'DNN-PROD'
because the 'PRIMARY' filegroup is full. Create disk space by deleting
unneeded files, dropping objects in the filegroup, adding additional files to
the filegroup, or setting autogrowth on for existing files in the filegroup.
at System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean
breakConnection, Action`1 wrapCloseInAction) at
System.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception,
Boolean breakConnection, Action`1 wrapCloseInAction) at
System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject
stateObj, Boolean callerHasConnectionLock, Boolean asyncClose) at
System.Data.SqlClient.TdsParser.TryRun(RunBehavior runBehavior, SqlCommand
cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler,
TdsParserStateObject stateObj, Boolean& dataReady) at
System.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds,
RunBehavior runBehavior, String resetOptionsString, Boolean isInternal,
Boolean forDescribeParameterEncryption, Boolean shouldCacheForAlwaysEncrypted)
at System.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior
cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean async,
Int32 timeout, Task& task, Boolean asyncWrite, Boolean inRetry, SqlDataReader
ds, Boolean describeParameterEncryptionRequest) at
System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior,
RunBehavior runBehavior, Boolean returnStream, String method,
TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean&
usedCache, Boolean asyncWrite, Boolean inRetry) at
System.Data.SqlClient.SqlCommand.InternalExecuteNonQuery(TaskCompletionSource`1
completion, String methodName, Boolean sendToPipe, Int32 timeout, Boolean&
usedCache, Boolean asyncWrite, Boolean inRetry) at
System.Data.SqlClient.SqlCommand.ExecuteNonQuery() at
PetaPoco.Database.Execute(String sql, Object[] args) at
DotNetNuke.Data.PetaPoco.PetaPocoHelper.ExecuteNonQuery(String
connectionString, CommandType type, Int32 timeout, String sql, Object[] args)
at DotNetNuke.Data.SqlDataProvider.ExecuteNonQuery(String procedureName,
Object[] commandParameters) at DotNetNuke.Data.DataProvider.AddLog(String
logGUID, String logTypeKey, Int32 logUserID, String logUserName, Int32
logPortalID, String logPortalName, DateTime logCreateDate, String
logServerName, String logProperties, Int32 logConfigID) at
DotNetNuke.Services.Log.EventLog.DBLoggingProvider.WriteLog(LogQueueItem
logQueueItem) ClientConnectionId:84098483-739c-4cd8-bf62-38ff4b256361 Error
Number:1105,State:2,Class:17

------
mruts
Julia is interesting, but the block syntax is a little off-putting. I'm not
sure why someone would design a language that uses 'end' to delineate a block.
Curly brackets make sense. Tabs make sense. But 'end'? All it does is make
code harder to read and harder to write.

~~~
yellowapple
Ruby and Elixir both made the same decision, and I don't feel like it's had an
actual negative impact, for me at least; I've found both languages to be
delightfully readable. I haven't dabbled very much in Julia since the pre-1.0
days, but I don't recall it being any more or less jarring.

I suppose it could indeed be jarring if you're not already used to languages
which use 'end' to terminate blocks, but after awhile your brain will just
start to treat 'end' synonymously with '}' and all will be right with the
world.

~~~
mruts
I mean, maybe it's not a big deal. But what value does it add? What if we had
a 50 character string of random digits be the terminating identifier for a
block? What about 100 characters? What about 200? Syntax shouldn't create
visual noise, it should be as lightweight as possible.

Maybe someone can justify why a 3 character word (end) doesn't really matter.
But can someone give an argument on how it adds value versus one character (a
bracket), or zero characters (visible at least), a tab?

~~~
xiaodai
it's easier to read.

~~~
mruts
If every sentence ended in an "end" instead of a period, would you posit that
that would be easier to read as well?

The crux of the issue is the signal to noise ratio. The more noise there is
(syntax), the more difficult it is to pick up the signal (the semantics).

~~~
xiaodai
Sentence is not code! According to your logic, when do you see {} in prose?

begin some code some more code end

It's easier to read.

------
spot
what good is philosophy if you choose arrays based on 1?
[https://groups.google.com/forum/?hl=en#!topic/julia-
dev/tNN7...](https://groups.google.com/forum/?hl=en#!topic/julia-
dev/tNN72FnYbYQ)

~~~
baldfat
So does:

APL, AWK, COBOL, Fortran, Lua, Mathematica, MATLAB, R, Smalltalk, Wolfram

Because it is Mathmatics and have 1 be based on 0 makes no sense, you then
have to switch between the two and it is easy to make a mistake. This is why I
don't use Python and Pandas. I got burnt once and that was enough and switched
to R. Sadly we are stuck with 0 based array in programming and due to a
historical issue.

~~~
nadam
0 based arrays is objectively the preferred way for me and not for historical
reasons. I write a lot of low level graphics algorithm stuff, and 1-based
arrays would complicate index arithmetic.

like now with everything 0 based having something like:

arr[offset1 * 32 + offset2]

would be the following if all my offsets would be 1-based and arrays would be
1-based:

arr[(offset1 -1) * 32 + offset2]

which is pretty arbitrary...

~~~
b_tterc_p
“Objectively preferred for me” sounds an awful lot like it’s subjective

------
antpls
I'm ready to burn a part of my karma to say the following :

\- Naming a PL "Julia" is sexist and creepy

\- The language doesn't add any substantial value to PL theory or programming
methodology compared to say, Python

\- The future of computer-human interaction is not in programming. Python will
be good enough until we reach that point where we can use neural networks/AI
to do most of the business tasks.

~~~
dragonwriter
> Naming a PL "Julia" is sexist and creepy

How? (I kind of assume that a big reason computer scientists would pull out
that name without a specific referent in mind is the influence of the Julia
set, named for Gaston Julia.)

> The language doesn't add any substantial value to PL theory or programming
> methodology compared to say, Python

Maybe; not all practical benefits in programming come from advances in
methodology or PL theory.

> The future of computer-human interaction is not in programming.

I've been hearing that since the early 80s. When someone makes that future
reality, we can discuss what it requires, until then programming is what we
have and I'm glad it wasn't neglected for the last four decades, and I hope it
won't be for the next however many it takes, either.

~~~
mattkrause
I also thought it was related to Gaston Julia or his sets, but apparently not:
it was just chosen since it sounds nice
([https://www.infoworld.com/article/2616709/application-
develo...](https://www.infoworld.com/article/2616709/application-
development/new-julia-language-seeks-to-be-the-c-for-scientists.html))

