/sci/ - Science & Math

[Anonymous No.14777637]

What do you guys think of Julia? I've been using it recently and it's been really great. It's also inspired me to learn more about how the JIT works and LLVM in general to improve performance. Julia seems like a no-brainer compared to C/C++/Fortran/python for 21st century scientific computing but it seems like there isn't much traction. Is this because there is just so much already written in these other languages? Do you think there's hope for major adoption someday?

[Anonymous No.14777650]

>>14777637
The computing ecosystem is infested by clinical subhumans. You can't have good things. You WILL use obsolete, horribly designed programming languages. You WILL deal with 50 layers of unnecessary complexity. You WILL use an IDE that takes 2 minutes to start up on a modern machine. You WILL run all this on a bloatware system that barely holds together.

[Anonymous No.14777654]

Julia looks good, but there's no real reason for me to use it when I can use python. I already know python, it's just as fast (inb4 "it isn't"), it can be used for any purpose, there are one million python examples on the web etc

[Anonymous No.14777680]

>>14777654
Python may be "just as fast" in your use case, but that doesn't mean it is in everyone's use case. In particular, stuff like numpy and scipy are written predominantly in C. The goal of Julia is to solve the two language problem i.e. remove the interface between the "easy-to-prototype" language and the fast language (e.g python and C). I do hear your point about millions of examples though, and I really am wondering if there will ever be enough traction for Julia. I have had to dig into source code many times due to bad library documentation.

[Anonymous No.14777683]

>>14777650
Ugh, tell me about it. Even in academia I am floored by the amount of Matlab shills. I pray that Julia can at least replace Matlab one day.. these people are literally paying thousands of dollars to get fucked in the ass.

[Anonymous No.14777706]

>>14777683
>I pray that Julia can at least replace Matlab one day..
I don't think praying will help in this godforsaken field, anon. What's needed is hard-headed dedication to do pioneering work with new tools that you see potential in, even if it puts you at a disadvantage relative to people who just slap shit together using more mainstream tools.

[Anonymous No.14777707]

>>14777683
My uni pays for my MATLAB license. Not my problem. Plus Python/Julia/etc. suffer from the usual FOSS problem of getting what you pay for. There's better quality control in MATLAB and even mainstream libraries like scipy have issues that the MATLAB equivalents don't have.

[Anonymous No.14777708]

This is something you’ll always see in programming languages
Even if your language of choice that seems perfect to you SHOULD be used everywhere, tough shit everyone else is using the most common language at the time with the widest adoption

The only time this changes is when someone with dominant market share over an ecosystem makes a decree upon high. Think swift vs obj c. Obj-c was the bees knees, and was a bit difficult for the average retard. Early on if you learned it you made bank with iOS. Swift is like javascript, for morons, aimed at morons. Who cares about projects getting delivered faster, what a programmer should be concerned with is getting paid first. But we see how that turned out. Nope lets all decide to work for free like commies in our off hours. No tradesman does this, they always get paid for work somehow. Lamers work these jobs. All the OGs are managers or dipped on this nonsense.

You’re at the behest of a group of shitlords, so you get to use python. That’s what you should focus on. Learning python and be a scientist and not fall into the programmer loser bracket.

Never be a software developer, be a scientist first and foremost

[Anonymous No.14777717]

>>14777708
>programmer loser bracket
what is that

t r&d eng that mostly translates concepts on paper defined by others into code plus some of my own

[Anonymous No.14777720]

[Anonymous No.14777735]

>>14777708
>am scientist
>75k/year
>younger brother is programmer
>110k/year with no degree
Y-yeah programmer losers

[Anonymous No.14777738]

>>14777735
>b-b-but muh money
Money means nothing, greedy kike. Nothing can buy you the pleasure of pandering to the establishment for grants, doctoring data to get published and brown-nosing a corrupt """experts""".

[Anonymous No.14777773]

>>14777706
Thanks anon this is what I needed to hear :'-)

At the very least I'm learning a lot from having to dig a little deeper every time I get stuck rather than just copypasta StackOverflow

[Anonymous No.14778129]

>>14777777

[Anonymous No.14778265]

>>14777637
fun to programm in especially for scientific tasks. still niche though, so not really general purpose as it's advertised. also once you try to do anything on a larger scale it becomes cumbersome. No binary compilation, many outdated 'academia' packages programmed only once for some project and HUGE memory footprint. The amount of memory julia uses for trivial programms like 'Hello World' is almost not justifiable.

[Anonymous No.14778277]

>>14777637
>What do you guys think of Julia?
meme language. just use python

[Anonymous No.14778284]

>>14777683
>Even in academia I am floored by the amount of Matlab shills. I pray that Julia can at least replace Matlab one day.
An open source language isn't a good substitute for a proprietary language because the point of a proprietary language is paid engineering support. Matlab even has a button in the gui that will send a full report to an engineering team about what you were doing so they can help you diagnose any issue you are having and fix it asap.

[Anonymous No.14778299]

>>14778284
>An open source language isn't a good substitute for a proprietary language because the point of a proprietary language is paid engineering support
What the fuck did I just read? Maybe you should implement a proprietary knock-off [insert mainstream programming language] so that people could pay for you to fix the bugs you introduce into your own dogshit-tier software. I'm sure it'll be super popular.

[Anonymous No.14778309]

>>14778299
>Maybe you should implement a proprietary knock-off [insert mainstream programming language] so that people could pay for you to fix the bugs you introduce into your own dogshit-tier software. I'm sure it'll be super popular.
You say this like it's stupid, but what you're describing is almost every software company.

[Anonymous No.14778316]

>>14777637
Here at my uni in Germany its being used in many lectures. In fact I took a lecture which explicitly made you use it and learn it.
The prof that taught the lecture works in an institute that's spending a lot of resources and man hours writting scientific computing libraries in Julia.
Moreover most people in the area know about it.
So im my experience whilst mostly academic, there's a sizable amount of interest in the language and I think it will only grow

[Anonymous No.14778317]

>>14778309
>he pays for shit-tier buggy software
They live solely off of suckers like you.

[Anonymous No.14778329]

>>14778317
Unless you're using loonix, libre office, and all FOSS then they're living off of you too.

[Anonymous No.14778330]

>>14778316
what german uni uses julia? for all I know they used matlab/python but times might have changed

[Anonymous No.14778337]

>>14778330
Its by no means a monolitic thing, it depends on the lecture/professor.
If you need to know im in tub.

[Anonymous No.14778340]

>>14778329
>she doesn't know about torrents
>she doesn't use cracked software
>she actually pays programming-sock-wearing troons and their kike managers

[Anonymous No.14778354]

>>14777637
Julia ils not mature enough to have a large traction. They often break compatibility between version on major packages. For example CUDA.jl got completely changed I had the rewrite the entire cuda part of a medium size application to update to a more recent version of Julia.

A lot of basic packages are also not really ready. For example for optimisation you have three packages which are competing for supremacy and they are all fairly limited if you want to do complex stuff.

Also debugging is a nightmare in Julia at the moment. Personally I find it easier to just use print statement.

All those factors can scare of new users who are not willing to put the effort to got around Julia current clunkiness. But I am optimistic if the Julia team do not do a major fuckup in the next five years it will have a real shot at becoming a widely adopted language for scientific tasks.

[Anonymous No.14778359]

>>14778340
>torrents
>cracked software
This stuff is bad at keeping your systems maintained and up-to-date. If you want to update your software then you need to install a whole new crack just for that update, assuming there is one which there usually isn't, and if you do find one, it doesn't maintain your files and configurations from the last crack, and also forget about using any plugged in cloud computing services. Just about the only files I still have from 10+ years ago are those that are hosted by a mega globo homo corp.
>she actually pays programming-sock-wearing troons and their kike managers
That's right, the trannies and the kikes work for me now

[Anonymous No.14778390]

>>14778359
>but what about muh updaterinos!! i can't live unless i have the latest and greats version of Schlomosoft Bloatware Manger
I'm fucking dying here. Please stop.

[Anonymous No.14778394]

>>14778265
Binary compilation is coming along. In a few years you might be able to ship a Julia binary without needing a few week to do a full precompilation coverage of you code. Julia 1.8 is really going in the right directing on that

[Anonymous No.14778415]

>>14778390
>no updates
Don't you work on anything cutting edge?

[Anonymous No.14778422]

>>14778415
People working on cutting-edge projects are the last people to update their software, you filthy LARPer. They prefer to have a stable production environment.

[Anonymous No.14778430]

>>14778422
But how do you integrate the recent contributions of other people if you never update your environment?

[Anonymous No.14778456]

>>14778337
I am curious what lecture of yours uses julia? It would be really odd to use julia for machine learning, since python is still the standard. I'd guess numerical computations like optimization or differential equations.

[Anonymous No.14778466]

>>14778394
I just don't want to compile my whole environment into a package. That's not what compilation is about. It's like shipping your whole OS as a virtual machine. Also you can't make closed source binaries for other platforms like mobile or embedded, the latter being rather important for applications, so there's that.

[Anonymous No.14778512]

>>14778430
You update it once in a blue moon unless what you currently have is afflicted with some show-stopper issue. Even large organizations that pay for their shitty software and priority support work this way. No one likes having their shit constantly update because in a complex production environment, it inevitably breaks things.

[Anonymous No.14778513]

>>14778316
Oh cool! I am glad to hear that. Here in France there is a small group of academics really into Julia.. but outside that nothing

[Anonymous No.14778521]

>>14778456
>It would be really odd to use julia for machine learning, since python is still the standard. I'd guess numerical computations like optimization or differential equations.
You COULD for sure use julia for ml/dl but obviously that would be quite ... Clunky.
Anyways I did use it for numerics, specifically pde numerics and linear solvers

[Anonymous No.14778559]

>>14778512
I didn't say to frequently update, but using cracked software almost guarantees you won't have continuity from one environment to the other.

[Anonymous No.14778566]

>>14778559
Never had that problem, but then again, I'm not the kinda guy to use MATLAB.

[Anonymous No.14778573]

>>14778566
Free software is only free if you don't value your time

[Anonymous No.14778579]

>>14778573
I don't know why you're spitting out this anal-crust-licking corporate slave rheotoric at me again; we've already established that only mouth-breathing imbeciles like you haven't figured out how to use torrents.

[Anonymous No.14778587]

>>14778521
>pde numerics
Did you use Gridap?

[Anonymous No.14778589]

>>14778579
Where's the torrent for Maple 2021 or 2022?

[Anonymous No.14778596]

>>14778589
>>>/t/
It's like you're making my point for me.

[Anonymous No.14778607]

>>14778596

[Anonymous No.14778608]

>>14778466
You can compile without the entire environment. It is just really hard to do. It is likely to happen in the future.

For embedded and mobile I don't Julia will ever be a good choice. If you are not trying to do high performance scientific modelling/ computation s or data processing/analysis Julia is unlikely to be the right choice.

[Anonymous No.14778645]

>>14778607
>this is the level of the average corporate consoomer
Maybe call 4chan tech support and notify them about this issue. I'm fucking dying.

[Anonymous No.14778657]

>>14778645
I already tried downloading the Maple torrents from the pirate bay and they turned out to be trojans and cryptominers. So the onus is really on the 1337 warez script kiddie community to show they can pirate anything besides muh vidya games and move consooomtion

[Anonymous No.14778665]

I'll preface by saying I love julia and hope it continues to improve. Now though, I find it too immature and buggy. It looks like they are pushing for more meta packages to unify interfacing in some domains (like stat regression), which will greatly help usability and hopefully smooth out composition issue between packages, but even in the main language there are errors that make me cringe. For instance: -Int8(-128) silently fails (or overflows) and returns -128 rather than throwing an inexact error or something. I absolutely do not like this as edge cases can now lead to incorrect results rather than no results and an error. In fact, this is the reason the quantile function returns an incorrect value:
>quantile(Int8[-128,127],1)
>-129
Not good. Now I have faith these correctness issues will get addressed but until then I do not think it's ready for widespread industry use.

[Anonymous No.14778667]

>>14778657
>I already tried downloading the Maple torrents from the pirate bay and they turned out to be trojans and cryptominers.
>So the onus is on you to find it for me!
Get a load of this goddamn nigger monkey.

[Anonymous No.14778682]

>>14778665
>For instance: -Int8(-128) silently fails (or overflows) and returns -128 rather than throwing an inexact error or something.
I don't use Julia but this smells like a textbook case of you failing to RTFM rather than an error in Julia.

[Anonymous No.14778684]

i don't use anything named after women.

[Anonymous No.14778687]

>>14778682
Well maybe you should use it a bit and read the documentation then get back to me on how this is appropriate behaviour when this is handled perfectly in python. Further maybe you should then go to the core devs and tell them they don't know enough about their own language since this behaviour is leading to errors IN THE CORE STATS LIBRARY. Retard.

[Anonymous No.14778697]

>>14778687
There's no reason to get mad and chimp out, anon.

[Anonymous No.14778699]

>>14778697
There's no reason for you to speak on technical subjects you don't know about either, but here we are.

[Anonymous No.14778701]

>>14778667
>You can pirate anything!
>NO NOT THAT!
schizos 0 paychads 1

[Anonymous No.14778702]

>>14778699
>https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/
>In Julia, exceeding the maximum representable value of a given type results in a wraparound behavior
Did you RTFM?

[Anonymous No.14778709]

>>14778521
PDE chad, I kneel

[Anonymous No.14778711]

>>14778702
Did you listen? I'm aware of WHY this occurs, my problem is with HOW it is handled. Not throwing so much as a warning means implementations buried in the core language spit out incorrect results. This is not excusable when it's meant for serious academic or industry work.

[Anonymous No.14778712]

>>14778701
>if i can't do it then it's impossible

[Anonymous No.14778716]

>>14778711
>I'm aware of WHY this occurs, my problem is with HOW it is handled.
It is handled exactly as the manual specifies: it causes a wraparound without any errors or warnings.

[Anonymous No.14778724]

>>14778716
And my point is their handling is poor and not sufficient for serious work. Once again, as it leads to incorrect results from core functions. Now a statistician needs to audit the implementation of basic functions to ensure correctness.

[Anonymous No.14778737]

>>14778724
>And my point is their handling is poor
Or maybe you just need to RTFM so that you don't use Int8 and have it wrap around when that's not what you want. The language is clearly doing what it's supposed to do in this case.

[Anonymous No.14778752]

>>14778737
>Or maybe you just need to RTFM so that you don't use Int8 and have it wrap around when that's not what you want.
You are unimaginably obtuse. It doesn't matter if it's doing what it "should", when this behaviour silently breaks core functionality. Look at quantile(Int8[-128,127],1). This range is entirely within an Int8. Outwardly, there is no reason to suspect this will fail, but it does, not due to any fault of the caller, but due to the implementation of quantile, which a user does not control. Now, is it a good thing for this language to expect users to read the source code before doing anything? Or do you think this will drive people away? A reminder, this is handled perfectly by numpy.

[Anonymous No.14778810]

>>14778752
The most you could say here is that the quantile function is implemented poorly because it (apparently) uses the same type as the argument internally, which gives counter-intuitive results. That's not a bug or flaw with the language semantics (contrary to your claims). There are two ways to handle this issue: one is to hand-hold people like you and convert everything to the highest-precision type available internally, in pretty much every library function, incurring a performance cost on everybody even when it's unnecessary; the other is to just let newbies get bitten by this once or twice so that they remember to use an appropriate argument type.

[Anonymous No.14778831]

>>14778752
>>14778810
By the way, you could have avoided this problem altogether by not specifying a type at all. From what I understand, Julia uses types for optimizations and doesn't actually require you to ever specify them.

[Anonymous No.14778863]

>>14778810
>The most you could say here is that the quantile function is implemented poorly because it (apparently) uses the same type as the argument internally, which gives counter-intuitive results.
It gives incorrect results. Not counter intuitive ones. numpy uses int8 internally and returns the correct result. Further, it doesn't even return an Int8, it returns -129 as an Int64.
> That's not a bug or flaw with the language semantics (contrary to your claims).
It absolutely is a bug unless you are seriously arguing the true value is -129. -128:127 is exactly representable by an Int8. A user would have no foreknowledge of this call failing.
> There are two ways to handle this issue
No, there a third, and that's ensure correct handling of edge cases while using the given type. Which numpy does.
>the other is to just let newbies get bitten by this once or twice so that they remember to use an appropriate argument type.
This is the appropriate argument type, and it happens on the end range of every Int type, including the default Int64. Further, it isn't always evident that one is given an incorrect result immediately when this is part of a larger script. This is a huge correctness concern for practitioners running analysis.

>>14778831
>By the way, you could have avoided this problem altogether by not specifying a type at all. From what I understand
No you can't, it happens with -9,223,372,036,854,775,808 for the default Int64. To avoid this you would need to wrap everything in big() to give arbitrary precision.

[Anonymous No.14778888]

>>14778863
>It gives incorrect results
Your notion of "correct results" kinda flies out of the window once you start doing statistical calculations using 8 bits of precision.

>It absolutely is a bug
Like I said, the most you could claim is that it's a bug with that function. You were claiming it's a bug in the language semantics when it clearly isn't.

>ensure correct handling of edge cases while using the given type
There is no way to handle this edge case except to use the highest precision type available, and even then it would fail when you reach the limits of that type.

>This is the appropriate argument type
You're clearly a retarded Python monkey running into a type system for the first time. Int8 is not the appropriate type for anything except binary data manipulation. It sure as fuck isn't the appropriate type for statistical calculations.

>it happens with -9,223,372,036,854,775,808 for the default Int64
Yes, you retard. The perils of using a computer.

[Anonymous No.14778928]

>>14778888
>Your notion of "correct results" kinda flies out of the window once you start doing statistical calculations using 8 bits of precision.
Use of Int8 is for ease of demonstration. You're intentionally missing the point, which is edge case handling.
>You were claiming it's a bug in the language semantics when it clearly isn't.
I was claiming the quantile result is a bug. I said the overflow does not raise an error or warning and that I did not like that behaviour, since it leads to errors in the core language. I'm sorry of that wasn't clear.
>There is no way to handle this edge case except to use the highest precision type available, and even then it would fail when you reach the limits of that type.
Absolutely 100 percent incorrect. For quantile, an swap of the subtraction terms, then correcting with another negation would work. Hell it would work in all cases and would be a better implementation.
>You're clearly a retarded Python monkey running into a type system for the first time.
My guy, most of programming is in C.
> Int8 is not the appropriate type for anything except binary data manipulation. It sure as fuck isn't the appropriate type for statistical calculations.
Missing the point, again. Expecting layman to audit source code and then avoid using the total range of their variables is enormously stupid.
>Yes, you retard. The perils of using a computer.
The perils of shitty devs and their lickspittles. This has been handled by like everyone else.

[Anonymous No.14778935]

>>14778928
>My guy
Stopped reading.

[Anonymous No.14778946]

>>14778935
Stop breathing too you oxygen thief.
Also look:
>julia Int8(-128)-(Int8(-128)-Int8(127))
127
>julia typeof(ans)
Int8
Wow, fixed the implementation without type promotion.

[Anonymous No.14778948]

>>14778946
You sure are a retard.

[Anonymous No.14778978]

>>14778948
Avoid talking about numerical programming when you don't know anything about it. The fix is trivial. All other major libraries I've used handle this without issue. julia devs had several ways of dealing with this stupidity without compromising correctness, and they chose not to do any of them.

[Anonymous No.14779004]

>>14777637
Don't care, still using C++

[Anonymous No.14779017]

>>14778978
I went and looked up what their code actually does:
https://github.com/JuliaStats/Statistics.jl/blob/master/src/Statistics.jl
Look at the '_quantile' function. It does linear interpolation using some parameters you didn't specify which causes the weird behavior with Int8. There is no trivial fix for this. Maybe you could cast 'a' and 'b' into high precision floats but you can still get weird results out of it.

[Anonymous No.14779040]

>>14778587
Nope. Guess thats a triangulation tool? Cant be bothered to look it up right now.
If it is, for triangulations I used interoperability with python and used some triangulation library from it, iirc theres some other ways to do that stuff but I havent touched this stuff in a bit

[Anonymous No.14779082]

Parameters are for specifying the quantiles(s). Dropped for demonstration, fix is essentially the same (i.e. inverting it). Chase it down in the debugger if you don't believe me.

[Anonymous No.14779088]

>>14779082
for
>>14779017

[Anonymous No.14779111]

>>14779088
I think it's this line causing the problem:
>return a + γ*(b-a)
What do you want to do with it?

[Anonymous No.14779134]

>>14779111
You are correct. It becomes
>a - γ*(a-b)
Due to quirks w/ floats distribute gamma:
>a - (γ*a-γ*b)
Which I'm getting correct results with.

[Anonymous No.14779160]

>>14779134
I suspect that now you're spitting out a float which, like I said earlier, can still give you unexpected results when what you arguably want is one of the numbers in your original vector. Probably better than -129, though, so good job. Submit a PR or something. I don't use Julia and I don't even have it installed.

[Anonymous No.14779173]

>>14778946
the issue is open for some time now, but it was found and mentioned by someone
https://github.com/JuliaStats/Statistics.jl/issues/119

[Anonymous No.14779185]

>>14779160
It will certainly spit out a float for any gamma not 0 or 1, this is ok though and necessary as we are defining a continuous uniform distribution in this case (instead of discrete).
>julia> quantile([-128,127], 0.99)
>124.44999999999999

>julia> (Int8(-128)-(0.99*Int8(-128)-0.99*Int8(127)))
>124.44999999999999
From testing, accuracy seems to be eps or close to it. Debugger shows no unnecessary type promotions.

https://github.com/JuliaStats/Statistics.jl/issues/119
Looks like it yeah. They haven't touched the repo in months which doesn't inspire confidence.

[Anonymous No.14779198]

>>14779185
Oh. Now that I look at it more closely, I don't really get why it doesn't get promoted into a float in either case since 'gamma' depends on 'aleph' and 'aleph' depends on 'p' which is declared Real. What type is your -129...?

[Anonymous No.14779204]

>>14779198
>What type is your -129
Fucking Int64 of all things.

[Anonymous No.14779210]

>>14779204
Cool. Alright. Maybe Jualia is broken.

[Anonymous No.14779259]

>>14777683
There might be hope. When I was in grad school not that long ago we still used Stata for all sorts of stats and now R has surged in marketshare.

I think one of the key advantages open source has is that it can then be interfaced with by other proprietary packages.

So for example, I've been developing this
new concept for the social sciences where papers are published as interactive dashboards. People can run all sorts of robustness tests, hit your data with different tests, see it visualized, all with a button click. The use case is big public datasets, because that allows me to have the data automatically refreshing, and then each refresh is a Bayseian update. Also standardized a nomenclature across multiple states so that it's a very large n set.

This is possible because Microsoft's Power BI has plugins for R and Python and is free if you make the report public.

Open source gets you the ability to have your work interface easier.

You also get people doing hobby horse projects they sometimes produce novel new things that company's won't take as a loss leader because it isn't going to generate enough cash. The flip side is flawed add ons though.

[Anonymous No.14779314]

>>14777717
pls gib library
>jk

[Anonymous No.14779317]

>>14778645
ROFLMAO

[Anonymous No.14780156]

>>14777738
kek, I work in industry I don't need to brown nose. I just have to pretend I don't see all the things the engineers do wrong/skip to get products out.

[Anonymous No.14780164]

>>14777637
>>14777680
>>14777707

Why not solidity?

[Anonymous No.14780202]

>>14780164
filtered

[Anonymous No.14780212]

>>14779259
why are you here posting your low tier post? isn't reddit enough?

[Anonymous No.14780549]

>>14780156
>I just have to pretend I don't see all the things the engineers do wrong/skip to get products out.
heh, yep

[Anonymous No.14780625]

V I R A L
M A R K E T I N G
T H R E A D

[Anonymous No.14780714]

>indices starting at 1
Dropped.

[Anonymous No.14780737]

>>14777650
JUST USE VIM. It is literally faster at doing everything, is preloaded on almost anything, and is as lightweight as you can get besides just using notepad. It takes like a week to get somewhat proficient and your efficiency only increases the more you use it. You can even use it in vscode if you really can't get used to navigating directories in the terminal.

[Anonymous No.14780742]

>>14777738
kek

[Anonymous No.14780749]

>>14778359
Nearly every new software update on any piece of software written by coding monkies at FANMG breaks everything/isn't backwards compatible/includes free security vulnerabilities. You are wasting likely thousands of dollars a year and are coping by saying you actually 'own' these companies because you shill them 20% of your paycheck. I guess those poor rednecks that smoke 10 packs a day control the tobacco industry too?

[Anonymous No.14780753]

>>14778415
Linux, the backbone of essentially every backend is still written in C89.

[Anonymous No.14780760]

>>14778701
>paychad
Yep, that is definitely what you are anon.

[Anonymous No.14781061]

>>14780714
> filtered by small offset of one
more like dropped out, you're clearly not a scientist let alone mathematician.

[Anonymous No.14781071]

>>14781061
He's not wrong. 1-based indexing is disgusting.

[Anonymous No.14781114]

>>14781071
a scientist writes down his formulas on paper before implementing them. there is nothing disgusting there and it really doesn't make a difference, just a change if variables. most arguments rely on C styled programming with pointer arithmetic, where you will most likely make overflow mistakes because of the indexing. not in julia.

[Anonymous No.14781153]

>>14781114
>there is nothing disgusting there
Why do you lie?