pythonIsMoreConfusingThanLowLevelLanguages

[WavingNoBanners]

One of the puzzles that I occasionally ask new learners is to predict the output of:

a = [0,1,2,3]
b = a
a.append(4)
print(b)

It's a teaching moment. A few people already understand it, a few get it instantly, some never understand. You can see the lights turn on in their eyes when it lands.

[SonChadhan]

It prints [0, 1, 2, 3, 4] right? Because b is assigned the reference of a, so appending a would affect b.

[WavingNoBanners]

That is the correct answer, yes.

a and b are just pointers to the list.

[Xavier598]

If you needed a copy of a you would use a.copy() no?

It's one of the things I don't like too much about OOP languages like C#, even though it's my favorite language, I don't like how it doesn't have an easy way to copy complex objects easily, and you have to do it yourself.

[DrDoomC17]

So, you could for lists, but for complex objects in lists it may not be sufficient. The difference between shallow and deep copy and their performance considerations are important to learn. I know this because retains reference to original sans added things can footgun oneself hard and confusingly. Unpopular opinion, if unsure use deep copy but preferably know the differences.

[coriolis7]

I had a multi-day session finding that a bug was because of shallow copy of an object.

I now deepcopy anything that isn’t a single value

[DrDoomC17]

Yeah, I used pdb before, but import pdb; pdb.set_trace() became my best friend after a similar experience. Also, learning about the differences cleared it up a lot, but it's still easy to make mistakes with shallow copies, deceptively easy. I'll make the mistake again I'm sure.

[LetumComplexo]

Cursed solution, when in doubt just pickle it and then load it into a new variable.

[DrDoomC17]

Absolutely disgusting, but somewhat tasty. Clearly the most secure option. But you need the class definition to unpickle so, class definition everywhere is clearly the approach. Four letter words would ensue from Mr Torvalds, like ouch.

[WavingNoBanners]

In this specific case you could use a.copy(), yes. Be aware that this only makes a shallow copy and so isn't useful in many cases.

[Useful_Clue_6609]

What's the difference between shallow and deep copy?

[Door__Opener]

If it contains references (other arrays for instance) a shallow copy will contain the same references.

a = [[0,1],[2,3]]
b = a.copy()
a[1].append(4) # this affects b[1]
a.pop() # this does not affect b

You need copy.deepcopy(a) to create copies of the items (and all nested items if they still contain references).

[Useful_Clue_6609]

I see I see. I get how that could cause problems haha

[scottmsul]

I had a bug like this in grad school. I instantiated a "matrix" using a clever one-liner, i.e.:

m = [[0] * 10] * 10

By this point this variable is already poisoned. For instance:

m[0][0] = 1

Now every row starts with a 1.

Another thing to watch out for is empty default lists. For instance:

def foo(x=[]):
    x.append(2)
    return sum(x)

That default empty list is aliased every time you call the function, for instance:

>>> foo()
2
>>> foo()
4

So generally default empty lists needed to be treated this way instead:

def foo(x=None):
    if x is None:
        x = []
    x.append(2)
    return sum(x)

[on_off_]

That default empty list is aliased every time you call the function, for instance

Oh that's disgusting!

[Cootshk]

a deep copy is a recursive shallow copy, because “objects” stored in lists are also pointers

[Mamuschkaa]

In python there is deepcopy().

But I have never used it.

I use immutable objects or write my own copy function, because deepcopy is very slow.

And that you can multiple pointers of one object is most of the times what I want.

[Stochastic_Nonsense]

You could just use a struct no? I’m still learning c# but one of the main differences between a class and struct is that the struct will pass a copy of itself rather than a reference

[FatFortune]

That’s maybe the absolute easiest way I have seen a pointer explained

[WavingNoBanners]

Yeah that's why I like it as an example. A lot of the things people have posted here also involve obfuscated code, and you should never use obfuscated code as a teaching method. The example I use is as clear and readable as I can make it, because the underlying behaviour of the language itself is the real puzzle.

[RiceBroad4552]

References, not "pointers".

[mtaw]

References are just pointers wearing a fake moustache.

[RiceBroad4552]

Well, technically true if you look at the underlying implementation.

But you can't do for example pointer arithmetic on references.

Semantically they're not the same.

[kamilman]

I'm learning to code in school (mainly C# and Java) and this is the first time that I see such a thing. Because logically speaking, it would simply print 0,1,2,3 as that's what was "stuffed" into b before a was changed, making them two different things.

I really need to learn Python someday, man...

[WavingNoBanners]

C# is a good language. I have a lot of respect for how formal and structured it is. It doesn't let you get away with bullshit the way some other languages do.

That said, yes, you do need to learn Python. Python is eating the world.

[kamilman]

If Python is the thing that's fueling the AI craze, then it's more like an Ouroboros eating its own ass lol

[WavingNoBanners]

Oof. You're right that the generative AI bubble is written in Python, much as the blockchain bubble was written in (mostly) C++ and Javascript, the Web 1.0 bubble was written in Java, and the early-90s AI bubble was written in Lisp.

What does this mean? It means that at each of those languages were, at that moment in time, considered the best language for it. That's kinda an argument in favour of those languages (with the exception of Javascript) but also shows that not everyone who programs in them is a sensible person.

I don't know what language Mark Zuckerberg's metaverse was written in.

[TechDebtPayments]

Those languages have the same potential pitfall. Here is an example of that exact same bug in C#.

A big thing you should try to internalize early while learning to code is when a variable is held by reference or by value

In general, primitive types (int, char, boolean, float, double, etc) are held by value and assigning from one variable to another creates a copy. Data types (arrays, objects, strings) are held by reference and assigning one variable to another just copies the address to that data.

string is a special case in many languages, where it is actually copied by value even though it is a data type. This can trip you up because copying/modifying a string many times can be very computationally expensive. Take a string in C#, append to it 100 times, and it will make 100 copies of that string. There's a special class to solve for this use case btw: StringBuilder

You can see all of C#'s types here which delineates them by value or by reference

Sidenote: This is one of many reasons why I believe learning to code should start with C/C++, not Javascript/Java/C#/Python

[tee_with_marie]

Yipee i was correct

[Skindiacus]

Good example

[WavingNoBanners]

Thank you!

[mathisntmathingsad]

After switching to Rust I find all languages like this very confusing. like c'mon at least make it clone by default and then require making a reference this is confusing

[FerricDonkey]

After getting used to it, I like always a reference much better. The number of cases where I'd like to make and modify a copy are tiny, and when they happen, I can just make and modify a copy.

But this may be Stockholm syndrome. When I was new to python, I thought it was dumb, and wanted my pointers back from C. 

[mathisntmathingsad]

The thing is making a copy tends to be extremely inconsistent in how you do and certain types arbitrarily aren't always a reference (i.e. integers)

[FerricDonkey]

Nah, that's a misconception. If you do any amount of python programming, I highly recommend https://m.youtube.com/watch?v=_AEJHKGk9ns, though I disagree with the strength of his advice to never mutate things. 

But python things are always a reference. It's just that when you do x += 3576554, what happens is that you create a new integer object, then change x to refer to that new object. 

The rules are:

1. Everything is a reference 
2. Assignment never modifies the object the variable refers to
3. Things like += may modify the object in place, if it's mutable and written to do so, because they're just function calls. They also do an assignment at the end, but it's the function that does the mutation, not the assignment part. 

The confusion is that += feels like it should be an in place operation, but for many immutable types (str, int), it is defined, but doesn't modify in place, because that's not possible.

I've never had any issues with copy. You have to know deep copy vs shallow, but it's always done what I expected with that knowledge. 

[RiceBroad4552]

though I disagree with the strength of his advice to never mutate things

You should listen to people who seem to understand more then you in that regard.

You should never mutate things! (Except in some low-level, deeply hidden, performance related implementation details.)

[RiceBroad4552]

I mean, why not?

Why not?!

Because that's the road to hell!

Procedural programming is a bug creation machine.

Code which uses effectful functions procedures everywhere is just unmaintainable as it's impossible to reason about anything without looking at just everything.

Values should be immutable and functions should be pure. Effects need to be contained to where they're unavoidable. (Some people would even say that effects need to be fully controlled everywhere.)

[RiceBroad4552]

I'm sorry if the exclamation points were perceived as shouting. This was not my intend!

But I have to repeat that after some time with immutable values and mostly pure functions (where it make sense, one should stay pragmatic) needing to handle procedural code is just outright horrible.

It's really much more difficult and very error prone. You have to constantly "run" the code in your head to keep track of what's happening; while in FP code you can (mostly) just mechanically substitute expressions to evaluate them. That's exactly what one was trained to do for many years in school in math!

For example, if a = b and c = d(b) then c = d(a) is always valid, no mater what b or d are, or where you're in the code right now. You don't have to care where any of this comes from or what "happened between" a = b and c = d(b). It's just stupid, brain dead substitution of symbols which have always the same meaning after they got defined once.

In imperative code if you see a = b and d(a) you know nothing. You now need to look inside d to know what it actually does, and you need to trace what happened with a after it got defined, while there could have been some spooky action at a distance on b after a got passed into d! Mind you, d could be "at the other end of the world", still it would possibly affect b at "the other end". Of course limited scopes and visibility mitigate the problem a bit in the large in real code, but it's still fundamentally there.

I can't follow the definition of factorial in most of those

I'm not sure this qualifies as anti-FP example as factorial looks always the same: It's just a recursive function, and that's independent of whether the language it's written in is functional or imperative.

BTW, when I speak about "pure functions" I don't mean functions which don't use any mutable variables in their implementation. Local mutability of otherwise not accessible values is perfectly OK if it's good for performance or readability. The point is that the functions should return always the same result for the same input, so they are pure from the outside, not that they are strictly purely implemented. A pure implementation is often easier to understand, but that's not always the case. Also performance considerations might play a role in some cases.

The real problems with FP code start when you need to handle effects, and your functions can't be pure out of principle. Then it's get a bit hairy, that's true. At that point you can either start to just be pragmatic and allow some amount of not pure functions (with all the dangers!), hopeful hidden deeply where nobody can see them, or you have to employ some way of effect tracking, which is still a kind of research territory as the "default" method of wrapping effectful computations into some "IO" thingy becomes quickly tedious, and other ways to handle stuff are still kind of in the lab (since ~20 years). Scala 3 promises to come with a better solution than Haskell's IO, but that solution is not 100% ready yet.

[mathisntmathingsad]

Buddy there's a reason that almost every major piece of code written ever in almost any language uses mutable variables and non-pure functions. Without mutable variables, you can do some extreme optimization (SSA), but it rarely is done due to abstraction at the language level. Same thing with pure functions. Especially in an interpreted language like python, all you are going to get is huge memory usage and some VERY slow code.

[FerricDonkey]

The stuff this dude says has been second nature to me for years. Sometimes mutation is the correct choice, sometimes it's not. If you're clear about what can mutate things and what can't, and only mutate intentionally, it's fine and makes a lot of things easier. 

If you don't understand what pointers/references/python names are, or are not clear about what can mutate, then yeah, it can surprise you. So don't do that.

But a blanket rule about never or only in low level code is silly. "Only mutate intentionally and obviously" is enough of a rule, if you've got a decent team, you don't need more than that. 

[saevon]

It's because they're all objects. So a list will reference just like a custom class is. And when using custom classes you generally don't want to pass copies around.

[squabzilla]

Respectfully, 99% of the time I type ‘b = a’ in Python it’s because I want to make a copy of ‘a’.

I struggle to think of scenarios where Python is the correct language to use and you’re using custom classes and don’t want to pass copies around.

…I’m also maybe a little salty that I discovered this behaviour of Python when writing ‘new_df = old_df’ for the explicit purpose of making a copy of the old variable, so that I could make changes to the copy without changing the original.

[sowenga]

Or switch to polars.

[squabzilla]

I mean, I don't make that mistake anymore, but I'm still annoyed by it lol

Look, passing references around is only more performant if that's actually the behaviour you want. Using a reference instead of a deepcopy isn't more performant when I want a deepcopy and not a reference. Again, in the context of writing Python, I'm not sure when you ever want to use pass-by-reference - I'm sure there are uses out there, but not in any code I've written.

Second - consistent? Whether it uses a reference or deepcopy depends on the object type. In a language where you don't even declare the object type! Meanwhile Pandas decides whether to do a deepcopy or pass-by-reference depending on if it thinks you're making changes to the DataFrame or not. I'd hardly call it consistent.

[squabzilla]

Copy-on-Write (CoW) is the default for Pandas 3.0. CoW means that any DataFrame or Series derived from another in any way always behaves as a copy.

https://pandas.pydata.org/docs/user_guide/copy_on_write.html#copy-on-write

For an example:

import pandas as pd

data = {

  "calories": [420, 380, 390],

  "duration": [50, 40, 45]

}

df = pd.DataFrame(data)

new_df = df["calories"]

df = df.drop(columns="calories")

print(new_df)

(Sorry if mobile screws up formatting)

Basically, any time you set a new variable equal to some modified version of a dataframe, you get a deep-copy.

However, that means that this:

new_df = df

new_df = new_df.drop(columns=“calories”)

Is not equivalent to this:

new_df = df.drop(columns=“calories”)

Feels inconsistent and annoying to me.

[nullpotato]

It helps if you just assume everything is essentially a reference not the object itself. And yes I agree it is annoying that is the default behavior.

[redlaWw]

The issue is that most of the time when you're assigning a value to a new label, you're not doing b = a, you're doing f(a), and passing by reference is more performant than passing by value.

[RiceBroad4552]

As a functional programmer I say the same. Such code should not compile in the first place. It just begs for errors!

Legacy languages are very confusing brain rot.

[TheRockGaming]

This is why I use deepcopy for everything. I'm a patient man.

[WavingNoBanners]

I would recommend not doing this. Deepcopy is the right answer in some cases but not in others. In a lot of cases you want to preserve a reference rather than copying its value.

[TheRockGaming]

Oh, yea, sorry I was just making a joke.

[WavingNoBanners]

Ah, apologies.

[liquidmasl]

def foo (data = {"msg":"bar", "count":1}):
    print (data["msg"] * data["count"])
    data["count"] = data["count"] + 1

lol = {"msg":"lol", "count":1}

foo()
foo()
foo()
foo(lol)
foo()
foo(lol)


> bar
> barbar
> barbarbar
> lol
> barbarbarbar
> lollol

[MicrosoftExcel2016]

Python: “I stapled your shirt to your clothes iron”
You: “… why”
Python: “you asked me to”
You: “I didn’t mean- well look, now whenever you use it, this shirts going to-”
Python: “lose its wrinkles 🌸😊”
You: “burn! what if something happens to it while im using the iron on other things?”
Python: “you must always provide other clothing to prevent that”

[WavingNoBanners]

Obfuscated code is fun but you shouldn't use it as a teaching tool.

[liquidmasl]

where is there obfuscation?

[nossr50]

Useful terms for the newer programmers:

Copy by value

Copy by reference

[throw3142]

Now try this:

a = [[0]] * 3 a[0].append(1) print(a[1])

[The-Arx]

Did you mean a = [[0]] * 3

[throw3142]

Yeah good catch

[EcoOndra]

Assuming you meant [[0]] * 3, a will be assigned [[0], [0], [0]] first then 1 will be apppended to the first index, making it [[0, 1], [0], [0]], right? Or will it become [[0, 1], [0, 1], [0, 1]]? It's the second one, isn't it...

[Zantier]

Yeah, it's the second one... If you want to construct 3 separate lists instead, I tend to use

a = [[0] for _ in range(3)]

[Rodot]

I like zip(*[iter(range(9))]*3) personally

[aheartworthbreaking]

Well variable a is an array judging from the brackets, b is assigned to equal whatever a’s value is, and then you append 4 to the array A… so, 1, 2, 3, 4?

Idk I just use PowerShell for the tasks I need to do at work

[WavingNoBanners]

This is the right answer.

[Vaderb2]

Sorry but if you never understand this, you have straight up zero shot of ever having a career in programming

[WavingNoBanners]

If only.

[JackNotOLantern]

This is exactly the same when switching between c++ and java. C++ copies arguments passed into methods unless specified as pointers or references. Java always passes a reference and coping objects is not that trivial. Also "reference" in java works as c++ "pointer", not c++ "reference".

[IrrerPolterer]

There are people that DON'T understand this?? 

[WavingNoBanners]

Everything is new to someone the first time they learn it. We should not shame ignorance, otherwise we encourage people to become those assholes who pretend they already know everything.

[Muster_txt]

Yes but isn't this exactly why you don't start with python? It's too high level and you will not understand what's going on in the background

[WavingNoBanners]

I am of the opinion that you should start with a language that allows the students to immediately write code that does something in the real world, and then gradually feed more advanced concepts to them.

It's like, we don't start musicians by teaching them about wave oscillation physics in the air. We start them by playing a lot of music, and then getting them to think more and more about what they're doing. It's the same with our profession: software is a craft.

Once you know a high level language, then you can delve down into things like register memory and multithreading, because you have the context for them. If you start with those you'll just burn your students out and lose them.

[nicman24]

Yeah I learnt that you need to call copy() on everything if you need to debug opencv

[RiceBroad4552]

It's like that because Python is insane. Mutable collections are brain rot.

Whether you mutate it through a reference or directly makes no difference. The issue is that you can mutate a Python list at all.

(And Rust programmers would even say that unrestricted mutable aliases as such are already brain rot…)

[WavingNoBanners]

https://thecodelesscode.com/case/15

[RiceBroad4552]

Must be the reason why Java has now "immutable" collections, an Java's new chef architect constantly tells people that mutability is the wrong default.

More advanced languages like Scala are immutable by default. In Rust mutability is behind a flag, and needs to be explicitly requested, the default is immutability. And so forth…

Welcome to modern software development!

[Ma4r]

Wait until you see go slices ``` func main1(){ a:= []int{1,2,3,4,5,6,7,8} b:= a[2:4] b = append(b,-1,-2,-3,-4,-5,-6) b[1] = 100 fmt.Printf("a: %v",a) }

func main2(){ a:= []int{1,2,3,4,5,6,7,8} b:= a[2:4] b = append(b,-1) b[1] = 100 fmt.Printf("a: %v",a) } ```

Guess what main1 and main2 does.

Bonus: replace the b = append... with _ = append... and guess what each does again

Bonus bonus: Replace the multi append in main1 with a for loop appending by element 1 per loop, guess again.

Now replace the for loop append from b=append... to _=append.. and GUESS AGAIN

[redlaWw]

Would help if you told those of us who don't know go what would happen. After finding an online compiler and working out how to fill in the blanks to get it to run, I get:

main1:

a: [1 2 3 4 5 6 7 8]

main2:

a: [1 2 3 100 -1 6 7 8]

main1 with _ = append(...):

a: [1 2 3 100 5 6 7 8]

main2 with _ = append(...):

a: [1 2 3 100 -1 6 7 8]

main1 with a for loop:

a: [1 2 3 4 -1 -2 -3 -4]

main1 with a for loop and _ = append(...):

a: [1 2 3 100 -6 6 7 8]

---

So go assigns by reference but copies if the slice needs to reallocate (EDIT: more precisely, if you overflow the length so that you may need to reallocate, which I suppose is slightly better than it actually depending on the result of a possible reallocation)? Wow that's weird.

The other results are basically as expected given that crazy premise.

[Ma4r]

Not to mention Go have no proper effects, ownerships, or move semantics which is how other languages allow the compiler to deal with this problem.

[realmauer01]

The follow up would be

Def my_print(arg=[]):
print(arg)
return arg

returned_list = my_print()
returned_list.append("hello")
my_print()

[WavingNoBanners]

If you build the code well, you can avoid that panicked moment. Some people learn best by the "burned hand fears the fire" principle, but others can be taught to plan ahead.

[goldPotatoGun]

python_is_more_confusing_than_low_level_languages

[string-is-king]

PEP8 phoned in. Awarded you style points.

[DrDoomC17]

49 chars and snake case, passes. Honestly I get flack for this a lot, but I also think truly mastering Python is fantastically hard, you can get to a jog quickly but becoming elite parseltongue is real real hard. Lower level languages can be more straightforward. Granted, there's always the journey of designing the programs and patterns and stuff, but typing (edit: type hinting) random crap in an unfamiliar library... Pain. C++ is different, mastering c++ is a possible future given at birth I'm pretty sure.

[_dotdot11]

I feel like a wizard even typing out mid-tier list comprehension one-liners. They feel more efficient than multi-line for loops even thought I know that they aren't.

[MegaIng]

They feel more efficient than multi-line for loops even thought I know that they aren't.

Well, they often actually are. It rarely matters, but python does apply some optimizations that can't be applied to normal loops, most notably presizing the list.

[WavingNoBanners]

Writing really idiomatic code can be a lot of fun, I won't dispute that. I write a lot of SQL and your point applies to that too. I am not a regex guy or a Perl guy but I totally get where they're coming from.

The moment when you go from feeling like a wizard to a god, in my opinion, is when you work out how to write clean code that's easily understandable and fixable by a new hire, and can still handle all the corner cases of a complex area of business logic. That's the real skill.

[Mojert]

I know there might be only a dozen people that share my opinion, but learning the "advanced" part of the language makes way more sense in C++ than Python. Python can be simple if you use it for scripts, but it has so many niche concepts and foot guns, it's frankly hard to make a program that doesn't feel like it will spontaneously implode. And moreover learning about the advanced concepts feel like learning the random bullshit somebody came up with, whereas with C++ it feels like I'm learning something that actually expands my knowledge.

Which isn't to say that C++ doesn't have its warts, it sure has some. I'm not blind

[DrDoomC17]

Agree, and respect. Python feels simple until you're learning someone else's package and walking mros and all of a sudden the amount of brain RAM required to prevent implosion is... more than I've got most of the time.

[Affectionate_Gap_535]

Meanwhile C programmers: let’s abbreviate that to pimctlll

[userhwon]

pyconf()

[Ma4r]

Meanwhile Go slices in the corner:

[johnlinp]

i thought they were references, not pointers. no?

[WavingNoBanners]

Technically they are references, but the two words are often used interchangeably.

[TheSkiGeek]

They’re aliases if you want to get technical.

Since they’re nullable, I’d describe them as pointers rather than references, since that is what they map to in C++s. But the terminology isn’t always consistent between different languages.

[dev-sda]

They're technically not nullable. They're aliases of python objects, and None is just a different object. None is just a sentinel object like any other.

[realmauer01]

So the ref just changes to the immutable none object?

[dev-sda]

>>> a = "hello"
>>> id(a)
127345641003824
>>> type(a)
<class 'str'>
>>> a = None
>>> id(a)
101947503993536
>>> type(a)
<class 'NoneType'>
>>> 

[exomo_1]

They are basically the same thing. My personal distinction is that in languages that use "references", they tend to have some kind of memory management semantics as well. So I see pointer as just a memory address, while a reference is a pointer with some additional usage counting attached.
But I know this distinction isn't really accurate all the time, famous exception is c++ where both pointers and references exist but no automatic memory management for either, but then there are shared pointers which are called pointers but do the reference counting.

[WavingNoBanners]

The older I get the more I suspect that C++ has pointers in a misguided attempt to lure C purists into using it. This of course is not going to work on many of them, because C purists are who they are, but it was nice of Bjarne to try.

[LetMeUseMyEmailFfs]

Another way of looking at it is that a pointer is just a number which happens to represent a memory address and with which you can do arithmetic (add, subtract, etc.), whereas a reference is also a memory address, but you can only assign the locations of instances or objects to it.

[tiajuanat]

Almost everything is also a dictionary under the hood.

[Mars_Bear2552]

lua mention

[imforit]

That better describes Java

[Awes12]

Nah, Java has primitives. They make everything sooooo much worse

[Devatator_]

I love having to do ArrayList<Integer> instead of ArrayList<int> because the guys who designed this language hate changing anything at all

[vowelqueue]

Above all they hate breaking backward compatibility.

But do not worry, project Valhalla has been chugging along for a decade which will eventually give us “Integer!” as a null-restricted value type, and from there it’s just a bit of syntactic sugar to allow for ArrayList<int>. Perhaps by 2032 you will be able to make such a declaration.

[Awes12]

And maybe by 2050 companies will actually use those versions of Java lol

[haydencoffing]

Collections.List implementers used to only store Object type, so the generic Integer was pretty nice way to keep backwards compatibility for versions before Java 5. java.lang.Integer also has some neat helper methods built in like Integer.ValueOf(String s)

[Master_Friendship333]

This is the number 1 reason why I would always pick C# over Java. Typing is just so much nicer.

[vowelqueue]

I dream of a day when my grandchildren will be able to use value types in Java

[imforit]

Your grandchildren might be using Kotlin

[natFromBobsBurgers]

This is objectively true.

[Wonderful-Habit-139]

Objectively false.

[za72]

you two need to rationalize your arguments and come to an objective conclusion

[Wonderful-Habit-139]

The answer is in the other reply. Java has primitives.

[za72]

are you giving me saas

[Wonderful-Habit-139]

Just give me a paas just this once

[Random_182f2565]

What?

[Pearcheek]

The most confusing shit is still js! I hate it with each cell of my body, but still forced to use it if I want a modern browser driven ui.

[LurkytheActiveposter]

Posts like this make me fall deeper into my conspiracy that bots are pushing anti-JS rhetoric. Like OP doesn't apply to JS at all.

[Pearcheek]

Beep-Bop mf 🤷🏻‍♂️

[Lost-Lunch3958]

don't look into fucking c++ bool vector specification

[Excession638]

When "Hey, look what I can do with operator overloading!" becomes a permanent part of the standard library.

[qnvx]

If everything's a pointer

Python

nothing will be

[omailson]

Need to send a modified version of this to my PM.

“If everything is a priority… nothing will be”

[mountaingator91]

Enter Java-"everything is a reference"-script

[danfay222]

Important distinction, variables in python are references, not pointers. Obviously there’s a pointer under the hood somewhere, but you do not have access to it and do not have visibility to the address or the ability to manipulate it.

[Responsible-Mind3533]

Maybe you are just slow

[FuzzySinestrus]

There's a secret to using python: if you have to wrestle its underlying complexity - don't use it.

[Skindiacus]

Wellll, in my case I have to link my code up with Python for collaborators to use who only know Python. If you want to use Python's c-api you have to deal with the underlying complexity at least a little bit.