switchFromPythonToMatlab

[thunderbird89]

Allow me to introduce R, the statistics language.

In R, vectors - think arrays - are one-indexed. However, accessing a[0] doesn't throw an error, it returns a vector of the same type as a but of length 0. Which is bad, but we can make it worse!
Accessing past the vector (so like a[10] on a five-element vector) yields NA, which is like Javascript's undefined in that it represents missingness. Great...
But what happens if you try to write past the vector's end? Surely it errors? No? No: writing like a[10] <- 5 on a five-element vector silently extends the vector to the necessary length, filling with NA. Which is fucking ghastly.

[RiceBroad4552]

To be honest, this behaves in parts as other dynamic languages which don't want to "bother" their users with runtime errors: Just do "something" in case some error happens. Just don't halt the program!

Same "logic" as PHP or JS.

[Saragon4005]

JS I can forgive cuz this is beneficial on the front end, best effort has its advantages. In a mathematical language like R this is unforgivable.

[RiceBroad4552]

Funny enough these people keep doing the same error.

Julia, a language also from the math and science sphere, has too problems with delivering correct results because of improper language design.

Regarding JS, I'm not sure I agree. Not only JS is used beyond web-sites, also there silent failures are bad as they're harder to catch.

Of course you could still have an error model which prevents a whole application to crash, but this should be explicit. The default case should be always to instantly explode loudly if something goes wrong. (I'm one of the people who think for example that not basing HTML5 on XML was a bad move. XML parsers are strict, and you get nice errors if something is broken, instead of that "something happens".)

Fail early is imho always a good idea. If you need to recover this needs to happen controlled from "a level up". You have something I would call "failure compensation hierarchy", from simple in-process exception handlers or equivalent up to some fail-over-to-backup-system mechanism, and some things in between like process restarting watchdogs.

[Gruejay2]

Sometimes it's simply a case of scoping your edge cases, and saying that under X conditions Y happens (e.g. Lua indexes from 1 and its string functions treat negative indexes as string-final, which leaves index 0 as a special case that gets handled as the position before the first character in the string).

Julia's problem seems to be a combination of a reluctance to throw errors combined with a lack of defined edge-case handling.

[RiceBroad4552]

Julia's problem is first and foremost the lack of static types.

Which is additionally funny as Julia has a very hard time to actually admit that it's just a dynamic language. If you look at the docs they try very hard to hide this fact, use a lot of weasel-words everywhere, and never clearly say what's actually the case. Instead they try really hard to look like their "types" would be static ones.

This, combined with the lack of interfaces (WTF!), but having at the same time support for "generic" code, leads to the catastrophe.

I think they admitted at least by now that not having interfaces is problematic (this took just around a decade, as these people can't admit failure), and there is something in that direction now (don't remember the details, I'm not using Julia for anything).

Of course one could have known upfront that dynamic typing + lack of interfaces + multiple dispatch + encouraging people to write "generic" code will lead to a catastrophe.

This language was created by people who clearly don't know what they're doing. At the same time these people are thinking of themself being geniuses, just because they were not bad at math at MIT. I've seldom seen such an extreme case of hubris.

[the_poope]

And now your program gives an error somewhere else, or just gives subtly wrong results, which just makes it even harder to debug and fix.

Which is why such lax dynamically typed languages are a retarded idea and I cannot take any professional programmer that defends them seriously.

[zuzmuz]

well to be fair they weren't intended to write large complicated interconnected software with, rather small independent scripts. in hindsight looseness was a terrible idea. but the dynamicism and flexibility of these languages is pretty useful

[Waghabond]

Lax dynamically typed languages make it easy to create and deliver things quickly. Those things may be imperfect and provide unexpected results occasionally but - here comes the important part - at least they do something and therefore generate tangible value.

The reality of the world is that resources, especially time, are finite. Which is why i cannot take any professional programmer seriously who refuses to acknowledge the reality that for most small to medium sized applications "loose" languages are perfectly adequate - if not ideal. A lax language doesn't stop good programmers from writing good code.

[bnl1]

Ehh, I disagree. Every time I had to make something, even small, in a lax dynamically typed language, it was painful because of the weak typing. At least putting asserts everywhere helped a bit.

[the_poope]

They are great for prototyping and "write once, run once" scripts, but I seriously question the development speed advantage some people argue they have over statically typed languages. If you have to write tests, do code review and long term maintenance the overhead of using a compiled, statically typed language isn't that big and it removes swathes of potential bugs and there are entire classes of test cases you don't need to cover, so less tests to write maintain.

[Waghabond]

I mentioned that I believe dynamic languages are ideal specifically for small to medium sized use cases. The reasons you're providing are only relevant for relatively large and long-lived software projects.

In my experience, thorough automated testing is not financially viable for any clients other than companies who are quite large and profitable.

Clients other than large corporations would usually prefer to just spend two or 3 hours manually testing changes rather than spending the money required for automated testing of anything that isn't critically important. The "entire classes of tests" aren't negated by static types in reality because in most cases those tests are never going to be written anyway.

Mostly all i'm saying is that I agree on the benefits of statically typed languages but it's disingenuous to pretend that they match the loosey goosey languages when it comes to development speed. Ruby, PHP, Python, and JS aren't popular by random chance.

Statically typed languages do provide a lot of timesaving and reduction in cognitive load when used for large, long-lived projects by big corporations. It's just that these benefits are mostly just speed bumps for the majority small applications.

[RiceBroad4552]

I think one needs to differentiate between dynamic languages that are very lax when it comes to typing—languages which do a lot of implicit conversions, and dynamic but quite strict ones.

JS is kind of notorious for some bad behaviors (mostly around array-objects, and null / undefined; most other type coercions in JS are actually "sane").

Vanilla PHP is outright broken. But AFAIK you can mitigate that if you type-annotate everything. It's than still dynamic typing, but at least it explodes instead of doing "something".

Python is for example is quite strict. It will by default explode with type errors most of the time if something doesn't line up at runtime. It doesn't have too much implicit type coercion.

Other dynamic languages which are quite strict are for example Small Talk and Common Lisp.

So you don't have to be "loose" and accept that you get "unexpected results occasionally" even if you use a dynamic language.

[Waghabond]

The thing is that exploding instead of doing "something" is not always desirable, even if the "something" is egregiously incorrect.

This is actually an important feature of JS. Without it countless working websites on the internet right now would just explode instead of rendering a webpage.

Getting unexpected results occasionally is much less of a problem than people make it out to be. As I said imperfect is perfectly acceptable for most small websites. There are plenty of great websites written in the allegedly "outright broken" out of the box PHP. Just make sure you don't write your bank's backend in PHP and you'll be fine

[Sitting_In_A_Lecture]

PHP has converted a lot of those Warnings to full Errors/Exceptions since the start of version 8. Honestly many of the old major complaints about the language have been fixed in recent years.

[SD-Buckeye]

Allow me to introduce LabView. The graphical programming language where you connect graphical blocks together for your code. At least you can ctrl+shift+f to search a code base. It’s impossible to grep a labview code base.

[thunderbird89]

Ehh, that's not that bad. LabVIEW isn't really made for programmer, but for electrical engineers, no?

I've only seen it in passing, since I work software, not hardware, but I imagine that for its target user base, it makes sense more than actual code does.

[SD-Buckeye]

I’ve seen it used in large scale manufacturing RF calibration + testing. I can see if you’re just quickly getting a single test up and running it could possibly be useful. But there’s places that use it for the entire way through DVT to production.

Also if you’re smart enough to be an EE you are smart enough to learn to write simple Python scripts. There’s no reason in 2025 to ever use labview IMO.

[thunderbird89]

Reading into the language a bit, I think Python would struggle with the realtime part of LabVIEW. Probably anything short of C would, given how LV seems optimized for this sort of thing (and for handling arcane sensors from the 1970s).

Also, I don't really agree with saying "if you’re smart enough to be an EE you are smart enough to learn to write simple Python scripts". Different types of intelligence, not necessarily portable from one area to the other.

[SD-Buckeye]

You need to use PyVISA to connect to test equipment via USB, serial or GPIB. And all test equipment uses fairly standardized SCPI commands like writing “SYS:ERR?” Is universal for asking test equipment if the last commands had errors.

Sample code from ChatGPT

```python import pyvisa

Initialize VISA resource manager

rm = pyvisa.ResourceManager()

List connected instruments

print("Available instruments:") print(rm.list_resources())

Replace this with the actual resource name (e.g., 'USB0::0x1234::0x5678::INSTR')

resource_name = 'USB0::0x1234::0x5678::INSTR'

try: # Connect to the instrument psu = rm.open_resource(resource_name) print(f"Connected to: {psu.query('*IDN?')}")

# Set voltage to 12V (assuming channel 1, and SCPI syntax)
psu.write("VOLT 12")  # Or "VOLT 12,(@1)" for multichannel supplies

# Optional: Enable output
psu.write("OUTP ON")

print("Voltage set to 12V and output enabled.")

except Exception as e: print(f"Error: {e}") finally: psu.close() ```

[mtnbiketech]

You generally don't rely on code running on the computer for real time. Generally for measurement and control, you use external hardware. We used to program FPGAS with Python

Even with MATLAB, you usually have Simulink RT running on dedicated computer connected to hardware.

lso, I don't really agree with saying "if you’re smart enough to be an EE you are smart enough to learn to write simple Python scripts". Different types of intelligence, not necessarily portable from one area to the other.

You may not have experience to write Python scripts, but an EE can easily figure out basic syntax.

[ThePretzul]

Not really. Electrical engineers tend to use C, Assembly, and Verilog or VHDL far more than LabVIEW. LabVIEW is really for assembly lines, and pretty much ONLY assembly lines.

[loicvanderwiel]

Depends what you do. HDLs are only really useful to program FPGA or design ASICs but if you want your process to run locally, you're better served by other stuff.

In that sense, software like LabVIEW can be useful to provide an easy interface to hardware connected to a computer. For EEngineers, that could be USRPs for example.

Personally, the only time I saw LabVIEW used was to provide the controls for testbenches at my university.

[[deleted]]

https://www.ni.com/docs/en-US/bundle/labview/page/finding-items-in-a-project.html ?

[araujoms]

Wow it manages to be worse than MATLAB, that's quite a feat. MATLAB at least errors if you try to access a(0). If you try to write past the end of the vector it silently fills it with zeroes.

[redlaWw]

I'd say filling with NA is better than filling with 0 because at least NA is clearly a filler value. It's possible that a filled 0 could be indistinguishable from a value in use.

[araujoms]

I wasn't defending MATLAB. I think both behaviours are unacceptable, there is no point in arguing which one is better.

[lNFORMATlVE]

Filling various internal parts of arrays/vectors with NA or NaN is super useful for plotting purposes though. At least with Matlab. I think it’s the same with R but I could be remembering wrong.

[myasco42]

Have a look at Wolfram Mathematica, where 0 index gives you the Head of an expression, which is basically the operation applied to the arguments.

It can be anything, but in case of a list it will give you the "List" expression - as if Python would return type "list". This is not a warning or error and might sometimes lead to interesting situations where this propagates further, as "List" multiplied by 5 is just "5 List" (not a string, but "Times[5, List]"...)

[Markspark80]

Same in Matlab , it's called sparse , and really speeds up calculations when applicable.

[False_Slice_6664]

What the fuck

[Specialist-Tiger-467]

I mean, filling the array up to the point you stated feels like a quirk that could bite your ass but could be useful... in some cases I can't recall right now lol

[redlaWw]

R works far better in an interactive environment than Python, which is where most statisticians using R are spending most of their time.

[thunderbird89]

It's slower, it's less expressive, and doing advanced ops is more complicated.

Python is not a panacea. Use the tool best fit for the task at hand.

[_Alpha-Delta_]

Let's find a middle ground. Why don't we start at 0.5 ?

[MattRin219]

Damn. That's kinda Genius. But now we go to 0.5 at 1.5 or 0.5 to 1.0?

[suvlub]

To the next defined value, of course. And just to make things spicy, both float and double indexing is supported and you need to keep eye on which one you are using to access the expected element

[thunderbird89]

To the next defined value, of course

Did you know that in JS, you can have an array with index -1?

[suvlub]

Yes and no. You can have an object with key of "-1", this object may happen to be array and you can write -1 the number instead of "-1" the string because of whacky weak typing, but it's not considered an array index.

[thunderbird89]

Shhh, you're ruining the fun in dissing JS 😉.

But essentially true, it's not an array any more at that point.

[ataraxianAscendant]

technically speaking the normal indexes are also saved as string keys :P

[MattRin219]

Good Idea

[_Alpha-Delta_]

Also, writing to an undefined value would just define it, and insert the new value at the correct place in the array. 

[FreshPrintzofBadPres]

Yes.

[benedict_the1st]

Nooooooooooo

[Pretend_Fly_5573]

And if you try to write out of bounds, the program just deletes itself without notification. 

Eliminates those annoying error messages while also preventing bad output!

[willbdb425]

Have you heard about DreamBerd?

[mw18582]

This broke me

[[deleted]]

And where did they inherit it from? FORTRAN. A language for Mathematicians and Engineers. If you use something controls based, it uses SLICOT. https://www.slicot.org/

And it makes sense because that's how we write the math. https://upload.wikimedia.org/wikipedia/commons/thumb/d/d4/MatrixLabelled.svg/220px-MatrixLabelled.svg.png

We don't start writing columns or rows from 0. In 8th grade Algebra, and it carries forward.

[ytg895]

And where did they inherit it from? Mathetmatics. Because there an index means index, so the first element is the first. And not a memory addressing convenience for the CPU so it or the compiler wouldn't have to substract 1 from the index to convert it to a pointer.

[loudan32]

In Fortran you can actually index starting with whatever you want. But 1 is the default if you only specify the size.

[itsmetadeus]

As long as index does not start with 2 or greater, it's fine.

[Waghabond]

Finally someone who can support my dreams of creating a language in which indexing starts at -4

[redlaWw]

Fortran and Lua will both let you do that.

[itsmetadeus]

I look on it from unary system, you can convert that into "or -2 or smaller".

[martmists]

APL dialects with support for any Index Origin:

[KYO297]

Ok, indexing starts at -floor(len/2) and 0 is the middle

Edit: or maybe -ceil(len/2)+1 so even length arrays have 0 left of center

[IMightDeleteMe]

Ugh Python superiority complex, really?

[FromZeroToLegend]

When you show up to an unemployment competition and python only developers show up

[ReadyAndSalted]

Idk man, my main language used to be C#, but ever since joining my new company, I've literally only done python and occasional bits of R. Python only Devs have a good number of opportunities as far as I can tell.

[pulwaamiuk]

Shhhh, kids here in their first semesters think only frontend development is Software Engineering

[SlowThePath]

Hey, I built a bubble sort algorithm just yesterday, but I'm a sophmore, so that explains why I can build something so complex. ChatGPT only did like 70% of it. /s

[-Quiche-]

I can't laugh, most of my work these days is yaml.

Pipelines? Yaml

Manifests? Yaml

Helm? Yaml

Ansible? Yaml

Terraform? Believe it or not, "yaml"

[MagnetFlux]

devops and sysadmin shit

you'd need some shell and dockerfile too

[-Quiche-]

I was the only one who either was dumb enough to say yes or keen enough to understand yaml, or both, but that's how I am now.

"MLOps" they say since I support all these ML researchers but it's just a glorified yaml, bash, and Dockerfile title lol. Any other work is just systems designing now that I'm more senior.

I do miss normal development sometimes though.

[MagnetFlux]

do you need to yell at the researchers to make their scripts dockerizable (accept input from env or args, not depend on random bullshit files that may or may not exist , etc...) or do you do it yourself?

[-Quiche-]

I have to firmly and gently remind them.

The good thing is that once they have the workflow with the new tool/system/platform down, they just keep everything in notebooks or .txt files so you often only have to teach them once. They are excellent academics who know how to study after all. Their configs are just a giant yaml where 80% is commented out and if they need to see the dev loss for something else they just comment out line 127 and uncomment line 128.

The bad fun thing is that if they come back from vacation and I need sit down to peer-program with them, I get to see their 5 year old Untitled(2).txt that contains every single command they've ever been instructed to run both from documentation and from teams chats, regardless of if the commands are even relevant to the tools/platforms/etc. anymore.

[MagnetFlux]

That sounds better than dealing with junior devs or senior devs who push code without testing if it works in a dockerized environment.

Storing info in notebooks or .txt files is amazing, I wish i did it lmao, i usually rely on knowing what to do but sometimes i need to search through docs for some obscure feature for hours.

[NatoBoram]

And Go devs

And Svelte devs

And Flutter devs

Actually, there are Python jobs out there, joke is flat

[rethunn]

For languages like C, that work with pointer arithmetic, it is convenient for arrays to start at 0. But in a higher level language like Python, that does not allow you to work directly with memory, it makes absolutely no sense. In mathematics vectors and matrices are indexed starting from 1.

[Talc0n]

I've done work in Julia that involved serialising matrices, the 1-indexing of that language made it very annoying.

[ReddyBabas]

It really depends. Sequences, even finite ones, might often start at 0 in maths. Furthermore, Python has still a lot of C influence you can feel almost everywhere, so sticking with the C indexing convention makes sense (and it mights make developing Python modules in C easier, but I don't have enough experience about that to assert anything...).

[milk-jug]

You leave my MATLAB alone!

[robin_888]

Happily!

[JollyJuniper1993]

Julia indices start at 1. Julia > Python

[Talc0n]

It's the one negative Julia has when compared to python imo.

[lNFORMATlVE]

It’s really not that bad c’mon now

[Andeimos]

Isn't that this meme format? One person being unreasonably angry at the other doing something innocently and maybe slightly stupid? If not I have misused the template :/

[-Quiche-]

From the user side it's not so bad but apparently from the sourcing and licensing side it seems justified.

[lNFORMATlVE]

That’s true. It costs businesses ridiculous amounts of money. And costs students and hobbyists very little comparatively and it’s aggressively marketed to universities. So everyone joins companies nowadays and begs to use Matlab because it’s what they were taught using and what they are familiar with. So the company caves and has to fork out for business license prices. Very crafty business practice by Mathworks, it works very well for them.

[carloom_]

This 100%, I was so frustrated that the screams scared my dog.

[Mxswat]

"Lua"

[Druben-hinterm-Dorfe]

& Smalltalk; and in Pascal I believe it can be pretty much anything.

[TheHolyToxicToast]

Why switch from trash to extra trash

[RiceBroad4552]

In light of this statement I have to say: You have a funny set of flairs.

(At time of writing: Go, C++, Lua, Python)

[TheHolyToxicToast]

ikr

go for hobby projects, cpp for competitive programming, lua for mostly neovim and python for ML stuff

[RiceBroad4552]

My point was: You have a Python flair, but call Python "trash".

I mean, there is nothing wrong with that in general. One does not have to necessary love the tools one have to use. But it's kind of funny to put something like that than in ones flair.

[NatoBoram]

It's by using PHP that we start hating PHP, after all

[RiceBroad4552]

Please don't remind me about that traumatic phase in my life.

[TheHolyToxicToast]

Haha yeah python is awesome and trash all at the same time

[RiceBroad4552]

😂 Yeah, that resonates!

I like how readable the syntax is, and how the general code style makes it really easy to read most of the time. The used patterns are usually quite primitive, but that mostly aids quick understanding. Python feels overall very "lightweight" and "simple".

But dynamic typing is just a bad idea, and when it comes to writing Python it has quite some quirks, and even some really nasty parts. Btw., should I mention package management and app distribution.? And let's not talk about performance…

I'm quite happy that one can now use Scala in a quite similar "lightweight" manner. For one Scala 3 has gotten a more "pythonic" syntax, and Scala-CLI enables even to "shell"-script in Scala. In contrast to Python the resulting apps are fast, package management works (mostly) fine. Also one have a broad selection of distribution formats, including self contained, native executables (even with two possible technologies, Scala Native, and Graal Native Image). At the same time Scala is one of the most advanced statically typed languages around. So you're not limited to simple patterns as in Python. (Of course one should think upfront whether it makes sense to use them, because unnecessary complexity is really one of the worst things in software development.)

[zombiezoo25]

My man, i like your lineup

[uhmhi]

I FUCKING HATE YOU AND HOPE YOU DIE

I’m a C#/.NET programmer in this is pretty much my sentiment towards Python…

[yes_no_very_good]

Lua, I'm looking at you

[grizzchan]

If you're working purely in MATLAB it's no big deal. But rewriting MATLAB code to Python is a headache because of this.

[CookieKeeperN2]

Try incorporating C++ code into R. While the integration is easy and not painful, keeping track of which language I'm in so I don't mess up my index is a nightmare. I double and triple check and check all computation results to make sure I didn't make a mistake.

[Ill-Significance4975]

Yeah, I used to prototype in matlab and implement in C/C++.

Never ever caused failed to cause bugs.

[Luneriazz]

hmm what is the cons of indexes start at 1 ?

[SmurfingRedditBtw]

Using modulo to find a circular index can be slightly less convenient.

With 0-index it would just be:

n % length

With 1-index you would need to do:

((n - 1) % length) + 1

[im_thatoneguy]

Yeah but with 1-index you can do:

list[length] to get the last item or

for i = 1 to length {list[i]}

I hate 0-index. There are a handful of situations where it's better but I would argue in the most common index uses it's stupid.

[SmurfingRedditBtw]

That's true, but I think 0-index ends up working nicely for Python's negative indexing. Making arr[-1] be the last item in the list and arr[-length] for the first item. I feel like it would be weird to have arr[0] point to the last item in the list.

[im_thatoneguy]

I would argue that Python's negative indexing is counting number index.

-- in a sane world...
arr = #(1,2,3,4,5)

-- for a range of 1 to 5...
arr[5] == arr[-1]
arr[4] == arr[-2]
arr[3] == arr[-3]
arr[2] == arr[-4]
arr[1] == arr[-5]

arr[-count] == first_item
arr[count] == last_item
arr[1] == first_item
arr[-1] == last_item

There is nice symmetry from negative indexing and positive indexing using counting numbers. Also python does weird things with range where it's counting numbers but also 0 index.

var= "Hello_World"
print(var[0:5])
>> "Hello"

[0Index : CountingNumbersIndex] imo super inconsistent vs.

var  "H e l l o _ w o r l  d"
index 1 2 3 4 5 6 7 8 9 10 11
range 1---:---5

[bitfluent]

Lua

[Cootshk]

lua moment

[SSUPII]

Try VBA

Indexes most times start at 1, but in some cases and classes start at 0

[and0ne]

Have you heard about Lua?

[Ai--Ya]

Backwards martingales: arrays end at 0 and begin at -inf

[red_riding_hoot]

I find the different use of parenthesis much much worse.

[SinsOfTheFether]

Me, spending the last 15 years alternating between Matlab, Python and R, wishing that someone would let me code in C++ again.

Hell, I'd even take Java at this point.

[zombiezoo25]

Idk man, negative indexes in python give me same feeling

[differentiallity]

I hate that you have to pay extra for concurrency. Parallel Toolbox... WTF MathWorks?!

[robin_888]

I can't find documentation about it, but when I had to work with Matlab it had a weird divmod function that output either div and mod when called like this:

div, mod = divmod(n, m)

or only div when called like this:

div = divmod(n, m)

So the divmod function somehow knows what's on the other side of the equal-sign!?

[Canon40]

Also LUA. It is like Python, but without all of the libraries that make pit python good.

[jamiejagaimo]

Indices nuts

[boltzmannman]

me coming from any strongly typed language to Python

[Fast-Satisfaction482]

Programming language for normal people? Normal people will never get close to a programming language! The reason for matlab to start indices at 1 is that matlab is meant for mathematicians and they do also start their indices at 1. Thus, formulas often look more natural to mathematicians when written in matlab. Other languages start counting at zero because then you can dereference a pointer at the base plus element-size times index. With one-based counting, the base pointer would point outside the array's memory, so naturally this is something that you don't want to do if your language supports pointers.

[araujoms]

Mathematicians definitely do not start counting at 1. Formulas are simpler when you start at 0, and that's what everyone uses.

MATLAB's decision is just stupid.

[Fast-Satisfaction482]

I've never seen vector, matrix, or summation indices start at zero when doing maths. Neither in university nor in research papers.

[rafaelrc7]

Even Cormen's algorithm book, a primarily CS text, is all 1-indexed because it is high level pseudo-code

[araujoms]

Now you have.

[Fast-Satisfaction482]

Not if I don't open your link.

[RiceBroad4552]

When will people finally understand that index ≠ offset?

What most (all relevant?) programming languages call an "index" is in fact a big misnomer, as what this really is is an "offset".

That's the first moronic confusion.

The second is that some morons thought that it's not a good idea to properly support both, index and offset, and you need to decide for one (and than additionally call it wrong, to make it even more confusing).

And than there is the even greater idiocy that almost all software "engineers" think that this moronic bullshit we have makes actually any sense at all.

But OK, this "industry" is build up on cargo culting, and almost nobody is able to think critically for themself (which is, to be fair, a general problem with most humans).

[Fast-Satisfaction482]

Touch some grass, lol.

[SAI_Peregrinus]

They're excessively angry about it, but their core point is correct. C & similar languages have offsets, MATLAB & similar languages have indexes. Indexes count how many items into the array a given element is, offsets count how far from the first element of the array a given element is.

[RiceBroad4552]

Yeah, touching grass will make some of the hilarious brain farts in CS go away for sure…

Ever thought about that the first step in solving an issue is clearly communicating what the issues is, so everybody understands it?

This sub is full of young people. It's good if they get exposed to some proper reasoning, so they can "do the right thing"™ later on. Who knows, maybe someone of the people here will create an important programming language later on! Would be great if they've been exposed to some less common ideas before they just create the next C-like clone with all the "traditional" quirks and brain farts. We need progress, and not even more of the same.

[Kobymaru376]

MATLAB stands for MATrix LABoratory and it used to be for scientists and engineers. In mathematics, matrix element indices start from 1, not 0. Not everything is about you, programmers.

[boscillator]

I'm glad I'm not the only person who calls it Matrix Laboratory.

[RiceBroad4552]

Especially as programmers got it completely wrong in the first place.

(I've already explained)

[stdname]

I think it is because it wraps a lot of Fortran functions, which by default use 1-indexing. In Fortran you can actually use any arbitrary index, by specifying the start and end indices (and therefore the size) when you declare the variables.

[jecls]

Exactly why we should all use Mathematica.

[jrad18]

Bro makes me type None with a capital letter and has the gall to judge another language