Almost as fast as C++

>almost as fast as C++
>more convenient than Python

has anybody tried this? it starts indexing at 1 and looks like fucking visual basic and matlab so i assume it's shit, but i might be surprised

Attached: Julia_prog_language.svg.png (1200x811, 43K)

Other urls found in this thread:

docs.julialang.org/en/latest/devdocs/offset-arrays/#man-custom-indices-1
github.com/user/youreanidiot.git
twitter.com/SFWRedditVideos

I used it a bit. It's fast but the community is small and its package library is no where near as good as R or Python. Basically, you can get the same performance out of R or Python if you wrote your own C or C++ functions in either one of those frameworks.

>almost as fast as C++
so it's not as fast as a few languages then.

>more convenient than python
i'll just cite their own package databases here:

Julia:
Listing all 1853 registered packages for the Julia programming language.

Python
142,527 projects 1,001,197 releases 1,346,240 files 282,070 users

hmmmmmmmm.

Attached: 1528935252028.jpg (225x225, 8K)

>Used to do a lot of Pascal back in the day.
>Pascal starts indexing at 1
>Company wants to port all sources to C
>20 million lines of code
>Nearly everything is broken because of index compatibility
>Not just the code, but the data stored in files

It's promising, I've dabbled a little but I'm waiting until they stop deprecating things and changing the syntax to learn it properly.

>it starts indexing at 1
Dropped.

>more convenient than Python
in what way? more special snowflake points?

It's essentially what MATLAB should have been, and it's promising for DSP/Control stuff.

all data science languages start indexing at 1 including R, Matlab, Mathematica

when you stop and think about it there is no sane reason to start indexing from zero other than it allows you to use the size of the container as the finish value in a loop without having to add 1 to it or use an equal sign instead of less-than sign

More convenient than Python? Seriously doubt that.

>>more convenient than Python
>in what way? more special snowflake points?
>More convenient than Python? Seriously doubt that.


>python
>use shitty autism os package-manger, dependency not there
>accidentally forget to use --user when pip installing, break system
>still have to manually tweak environment to use virtualenv correctly or use tools like pipenv.
>setup.py tier bullshit for packaging and distribution.
>dependency is recorded in something that isn't a fucking setup.py and not something as completely useless as requirements.txt

For math it is, at least.

And because it's not as retardedly dynamic as Python, so it's amenable to compilation. The JIT compilation thing is a bit annoying, but also amazing. I hope it will improve in the future. It has generic functions in the Common Lisp fashion (dispatch on every parameter, not just the first), but with a gradual, parametric type system. The kind of things you can do with it are pretty crazy but phenomenal for efficient math. For example, it has apparently the best differential equation solver package available in any language, already.

However good Julia is otherwise, 1-based indices is like finding out that the woman you like has a penis.

>python
>infinite libraries to pick and choose from

There, it's already more convenient.

>jose

>when you stop and think about it there is no sane reason to start indexing from zero other than it allows you to use the size of the container as the finish value in a loop without having to add 1 to it or use an equal sign instead of less-than sign
Not always true.
#include

int main() {
int array[3] = {1, 2, 3};
printf("array = {1, 2, 3}\n\n");
printf("array[0] : %d\n", array[0]);
printf("*(array+0) : %d\n\n", *(array + 0));
printf("array[1] : %d\n", array[1]);
printf("*(array+1) : %d\n", *(array + 1));
return 0;
}

starting at 0 makes sense in C.

>I blindly use libraries/packages that anyone including untouchables living on the streets of Calcutta can upload
keep working on that fizzbuzz, you'll get hired someday

I don't use Python at work at all. I use it for personal projects. And it feels good to make a fuckton of progress every day. But you keep being butthurt for... whatever reason.

The fact there's no agreement about what's best means it depends on the application. Math is almost always 1-based, but sometimes not. The best probably would be user definable indexes, as in Ada, and there's some experimental support for it, not too polished yet.

docs.julialang.org/en/latest/devdocs/offset-arrays/#man-custom-indices-1

>I don't do actual work, I only fap on new languages without any support and community.
start learning theoretical computer science and you'll get hired someday

>almost as fast as C++
ha

>support and community
>hey boss, I cant use this language because there is no hand-holding support and community of people to babby duck with
ok, sure

I envy you. Where can I find a job as a developer where my boss will pay me to fuck around in slow to write/unknown languages without getting any actual shit done at all?

>end

please
no

>it starts indexing at 1
straight to the trash it goes

so it's a dream come true?

It does, actually. It's the whole point of the language:

The first time you call a function the compiler emits fully specialized (monomorphized) code corresponding to the actual, concrete types of the arguments passed. For the price of an annoying pause you get a dynamic type system with C-tier speed execution.

This is pretty unique. I don't know of any other language which does this.


Although, there's a need for more documentation for the type systems because it's actually pretty complex, much more than Python's or Lisp's ones.

yes. A surprise but a pleasant one.

This is one of those meme langs that no matter how good it is it will be ruined by not having enough packages to cover general computing needs. Darn shame.

being able to refer to an array index as being +1 away from the first element is still sort of a weak argument for using zero indexing

>> Actually needing to index your arrays in Julia in a way where zero or one based indexing makes a difference.

I very rarely do this. Use broadcast, array slicing, multidimensional arrays, matrix multiplication, foreach loops, map/filter/reduce,iterators like columns/rows/indices etc etc.

Half of the arrays I use are sparse arrays or triangular matrices instead of vanilla arrays, so indexing from zero/one to size would be horribly wrong in generic code.

Also, offsetarrays allows you to start indexing from any number instead of 1 if it makes more sense for a particular algorithm.

Indexing from zero makes sense if you know that accessing elements in containers is done by multiplying the index with bytesize of the type within the container and adding it to the address of the first element of the container. I suppose you didn't know this since you made this wild claim that there is no reason that containers are zero indexed :)

see

Pascal is underrated

>
>I envy you. Where can I find a job as a developer where my boss will pay me to fuck around in slow to write/unknown languages.
My boss actually ecoureges this. Get a new job, or get more experience.

But almost all of those Python packages are useless shit, because Python is the designated beginner language, while Julia has several best-in-class packages for particular areas of scientific computing.

For example, automatic differentiation on arbitrary Julia functions is absolutely amazing, and something that you will never see in Python, or any other mainstream language. At best you see it for a fixed number of functions in closed ecosystems like PyTorch.

>>adding it to the address of the first element of the container.
But the pointer that represents the array can be offset by the same amount, so you save nothing.

so is Modula2 and Oberon

>WAH WAH LOOK AT ME I'M SO SPECIAL I DON'T USE PYTHON

Attached: images.png (205x246, 6K)

But python has packages for fucking everything. Want to turn your data project into a web service wow there is something that straps directly on that gives you and instant REST api. Want drivers for any database that exists? python has that. Want crypto libraries, XML libraries, any shit that is actually used to make real software, wow python has that too.

>
>Indexing from zero makes sense...
Just add one dickhead, same as R. Werks fine.

Zero based: Arr[i] = Arr.start_zero + size*i
One based: Arr[i] = Arr.start_one + size*i

where Arr.start_one is equal to Arr.start_zero - size

So? If Julia has a better package for solving differential equations (which it does), I'm still going to use Julia. I don't care if Python has shitty libraries for any usecase, if I need a language for a particular usecase where Julia has the better implementation.

Absolutely true, you save nothing (in either 1-index or 0-index case!). I still think my remark motivates why zero-indexing exists. It could be that early languages only provided pointer arithmetics without array constructs.. then zero-indexing seems like a natural way to introduce arrays.. Im just speculating

>it starts indexing at 1
no thx

> more convenient than python
yes, if you're writing the Fibonacci function, and that's about it.

No one uses it in real life

python packaging is super fucking simple.

>use shitty autism os package-manger, dependency not there
If you plan to *use* python for stuff, use a specific distribution tailored for your usecase, like anaconda or enthought's canopy. Also, it's fucking source-based, so just pip install git+github.com/user/youreanidiot.git
>accidentally forget to use --user when pip installing, break system
not a problem for most packages and most distros. I used arch + pip in system mode for 3 out of the 5 years of my grad school using scientific python all day, every day.
>still have to manually tweak environment to use virtualenv correctly or use tools like pipenv.
this is how I know you're learning deprecated/bad shit. Use anaconda.
>setup.py tier bullshit for packaging and distribution.
setup.py is excellent and simple enough to use. I've published julia packages in .4,.5, and .6, and I find julia's METADATA.jl stuff only marginally easier to use.
>dependency is recorded in something that isn't a fucking setup.py and not something as completely useless as requirements.txt
all of that is convention. You can put dependencies directly into setup.py and have no problems whatsoever. Next time, try actually using the things, rather than parroting your irc-tier gripes.

I use Django, Im fully aware of the virtualenv bullshit that is required to make Python projects, so everything you say is just a smokescreen

And using babby-Python-dont-touch-anything system like Anaconda or Canopy fully illustrates how bad Python is and how bad most data science (((programmers))) are

Does the speed of a programming language matter for smaller or medium sized programs on a 2700x with 16 GB of 3200 Cl14 RAM?

>I'm too dumb to learn anything but babbys first language.

Great onions wojack. You showed them who's boss around here

what moron thought 1-indexing was ever a good idea?

Because of education.
Theoretical Computer Sciences think 1-index
Practical languages think 0-index

every fucking language loves to claim "(almost) as fast as c++*"
*in this micro-benchmark were we hamstring the c++ compiler
didn't java laughably make this claim when the JRE included its JIT compiler? and yet what happens is the fatass heavy java objects mean your cache lines are effectively halved, at best

>it starts indexing at 1
Into the trash it goes. Only retarded millenial cucks would want this. The "index" is literally an offset. An offset of 0 gets you the first element. Why the fuck would anyone need to change that? Fucking retards...

> be you
> not a single clue what you're talking about
> being this much of a try hard

> almost
> more convenient
> yet another shitty programming system in a world full of shitty programming systems
toppest of all keks.

how the fuck is a venv+packaging system done right like conda a "babby-Python-dont-touch-anything"? Are all venvs "babby-Python" to your nega-brain?

They fucking correctly package and distribute mkl,gfortran,netlib,and the llvm .

You're clearly an idiot.

Fortran was the first to have high level arrays, and it allowed arbitrary offsets. One-based arrays became the universal convention in Fortran, used by all Fortran libraries (which Julia heavily taps into).

Zero-based indexing only became the norm at least a decade later, because Djkstra said so (and most of his reasons are made completely redundant by proper ranges/slices and multidimensional arrays). Knuth and CLRS both use one-based for half of their algorithms, whenever it is convenient.

The fact that you have to create a virtual environment on your system to isolate a Python project is so beyond retarded that I honesty dont know where to start, only a complete idiot could take such an approach to package management seriously

Fun fact: the real reason why Guido hasn't been able to implement the changes needed for coexisting versioned packages, is because of backwards compatibility with pickle.

I'm seriously not kidding. Python's developers picked the ability to compress half-interpreted class files so that you can pass them around as objects instead of source code, instead of proper versioned packages.

>faster than C++
>as convenient as Python

Attached: dlang2.png (2000x1516, 567K)