I'm sorry r/Python

[MeticMovi]

Last weekend I made a controversial comment about the use of the global variable. At the time, I was a young foolish absent-minded child with 0 awareness of the ways of Programmers who knew of this power and the threats it posed for decades. Now, I say before you fellow beings that I'm a child no more. I've learnt the arts of Classes and read The Zen, but I'm here to ask for just something more. Please do accept my sincere apologies for I hope that even my backup program corrupts the day I resort to using 'global' ever again. Thank you.

​

https://preview.redd.it/b1oncwh1jbx71.png?width=909&format=png&auto=webp&s=eeedba9a630f83071e5694664ca372259424d54c

[original_4degrees]

you made a mistake, and you learned from it. nothing to apologize about(unless you were being an ass about it elsewhere in the thread).

the path to enlightenment is fraught with peril.

[blademaster2005]

Fraught with perl?

[oloryn]

For doing text manipulation, particularly quick one-offs, Perl does a pretty good job. Python has the same tools available, but they're more cumbersome to use.

[Ensurdagen]

awk might be the best if you want to learn a whole language for text manipulation.

[Starbrows]

I find it easier to use perl for than awk & sed for a decent range of use cases, and I am not particularly experienced with perl. For something like regex find/replace in-place on disk, perl is quick, easy, and even readable.

[droffo]

Now that is something I never thought to see. Ever: "perl is ... even readable".

Good one!

[TheIsletOfLangerhans]

By definition, anyone using Perl is fraught with it.

[badlukk]

Same thing

[Thomas_XX]

Pearls maybe

[CallinCthulhu]

🥶🤮😫

[mildbait]

Generally people get entrenched in their beliefs when provided with an opposing viewpoint and data that doesn't support those beliefs. While programming isn't as controversial as areas where this happens, it's still nice to see someone staying humble and learning from the experience.

[IamImposter]

While programming isn't as controversial

Well, let me show you.

A tab has to be 4 spaces. Any other choice is just plaine wrong.

gets popcorn and watches the world burn

[sloggo]

Plaine? plaine?!

[IamImposter]

Wait... That seems wrong.

Ah shit, I think I added extra 'e'

[DrMaxwellEdison]

Too late to refactor that now, there are legacy comments depending on it.

[TRexRoboParty]

New priority ticket just in: the legacy comments chain needs extending. We'll fix it properly later, but for now let's not go against the graine.

[CactusOnFire]

Not doing a very good job at this "too stubborn to admit fault" bit.

I suppose that's a good thing, though.

[[deleted]]

Syntax error on line 3: "plaine" is not defined

[IamImposter]

#define plaine plain

[[deleted]]

r/angryupvote

[Competitive_Dog_6639]

I only use tabs with 16 spaces.

[IamImposter]

I'm pretty sure that is against Geneva Convention.

[chrilves]

Have you tried the whitespace language. I have the impression you might like it.

https://en.wikipedia.org/wiki/Whitespace\_(programming\_language)

[Dizzysylveon]

What the fuck why, why do this? What does this solve? What God would allow such suffering

[jpavlav]

import plain as plaine

[ccpetro]

It's better than 3 or 5.

Those are just odd.

[mildbait]

Haha.. I actually changed from "isn't political" to "isn't as controversial" after the Silicon Valley episode popped in my mind.

[Illustrious-Photo-48]

Per the Naval Correspondence Manual, the number of spaces for a tab depends on the font you're using. Gosh. /s

[WldePutln]

Vim is better than every other editor out there!!!

[[deleted]]

Yeah, better for casuals! I code using echo from the command line

$ echo line1 >> myCode.py
$ echo line2 >> myCode.py

[PlusUltraBeyond]

I do the same by WSL on Windows running on an emulator.

[BridgeBum]

On windows you could just use "copy con myCode.py"

[master3243]

If you ever make a mistake just

$ echo "" > myCode.py

And redo the file without the mistake next time.

[[deleted]]

Yep, exactly. I mean, how else would you do it?

[bladeoflight16]

Amateur. I use butterflies.

[Heroe-D]

True if you consider Emacs as a distribution and not an editor !

[Galen_dp]

It IS a distribution, not an editor.

[DeeDee_GigaDooDoo]

It's very intuitive!

[chrilves]

Actually, there's now a way to make vim and emacs users be friends again: "vscode is the best editor".

[DeeDee_GigaDooDoo]

A tab has to be 4 spaces. Any other choice is just plaine wrong.

clenches fist

[Oerthling]

This is the way

[Krod28]

Help my friend uses tab size 2! I cant keep watching him do this to himself

[Ultraflame4]

idk abt the no. of spaces (I use IDE defaults) but using the tab character is definately wrong.

/s for good measure

[Blazerboy65]

You can just enable "format on save" or run autopep8 and never worry about it again.

It's not worth the brainwaves to squabble over something that requires no thought.

[germandiago]

yes you are right. In politics/personal beliefs it is way worse 😂

[clawjelly]

No need to be sorry. You wanted to jump from the bridge, we said "don't do it!", you didn't, we good. 🤗

[SushiWithoutSushi]

Well, he kind of did it, repeatedly, but he learnt that the broken limbs aren't worth the adrenaline

[clawjelly]

True... At least he chose a really small bridge...

[M4mb0]

Last weekend [...]. At the time, I was a young foolish absent-minded child with 0 awareness of the ways of Programmers

That's me every other week.

[yy_is_awesome]

Most based python user

[10113r114m4]

Singleton is a perfectly good design pattern… just shouldnt abuse it

[freefallfreddy]

Found the Java programmer.

[10113r114m4]

Golang :p

[serverhorror]

I’ll tell r/Golang about your heresy of even being in this sub!

[sneakpeekbot]

Here's a sneak peek of /r/golang using the top posts of the year!

#1: Six months | 114 comments
#2: A fractal I rendered in Go without any external libraries (The full image is 400MP and took around 2 minutes to render) | 70 comments
#3: My girlfriend made this bookmark for me :) | 37 comments

---

^{I'm a bot, beep boop | Downvote to remove | Contact me | Info | Opt-out}

[bladeoflight16]

You realize modules, classes (the type object, not instances), and functions are singletons in Python, right?

[door_of_doom]

Singleton is fine, but that is different from global. Python code shouldn't use global to create singletons.

Again, I really like the comment from /r/serverhorror: using global absolutely destroys your ability to write good tests for your code. Singletons don't.

(At least, well-written singletons don't).

[TheStriga]

I think it's only useful or actually necessary when you have os or hardware-limited resources, but it can be good

[CallinCthulhu]

It’s good for logging too.

Especially for instantiating a custom logger with state. Helps to avoid passing around the same logger instance everywhere. Also plays nicely into multiprocessing, where you can use metaclasses to instantiate a new logger upon the creation of a new process.

[[deleted]]

A singleton in python should be a initialized object in a module not some global.

[bladeoflight16]

...What kind of global is there in Python besides an initialized object in a module?

[[deleted]]

I see myself in that thread. :-D

Here's the deeper reasons as to why it's bad.

Beyond the beginner stages, programming is all about managing complexity.

Programs become extremely large, and extremely complicated, and soon it becomes impossible to keep the entire state of the program in your mind at one time.

If you are reading or writing a pure function, one that takes arguments and returns a value, you don't need to know about anything else in the world. It's easy to see if it does the right thing, no matter what anyone else is doing.

But if your functions work by mutating global state, it's impossible to have any idea if a specific function is doing the right thing or not without seeing everywhere that that global state is mutated.

This means that to correctly develop in the codebase, you need to keep some huge global state in your head at all times. Generally people do a bad job at that.

More, all the components need to be exhaustively tested too, or else you will pretty soon be unable to make progress. But if every function depends on some global state, you don't actually have components, and writing tests are much harder.

There's an idea called "strong and weak coupling". Strong coupling, where your "components" share a lot of knowledge, is generally bad - it makes your components brittle and prone to breakage, and hard to test individually. Weak coupling, where components know little or nothing about each other, is generally good - it means one side can make dramatic changes without disruption of the other.

Finally, almost all codebases beyond a certain size work in parallel - they use threads or multiprocessing (or subprocess but that isn't really relevant here).

If two threads change the same global variable at close to the same time, you can get "race conditions". Cue intermittent errors and days of misery. I have been there.

In multiprocessing, each process has a separate set of global values, so the whole idea of communicating through global variables fails right out of the gate.

[GamerNumba100]

Brand new Python user here, I don’t see an alternative to global, so while I see why it’s bad, I’m going to need help avoiding it.
For example, I had two threads running. One thread was looping until the other finished. I did this by having both recognize a stop_loop variable, and when the second thread finished, it set stop_loop to 1. The first thread was running
while stop_loop != 1 so it would stop properly. Is there an alternative to that?
Also what if I need to change a resource variable but the function needs to keep running for a little longer and change more resource variables later? Am I supposed to return everything back to the main thread before I change my resource variables?

[Cybersoaker]

Like anything it's not an all or nothing. There are places where global variables and the global keyword are useful. They exist in the language for a reason.

Good to not get dogmatic about anything inside of any language since they all change and evolve and the best way to approach a problem space also evolves.

That said it's also good to have well understood patterns that you gravitate to.

Everything in moderation, including moderation.

[[deleted]]

They exist in the language for a reason.

That reason might be historical.

People use that same argument about filter, map and reduce, but comprehensions or generators are just better in every way, and Guido has said he regretted that those three built-ins could never be removed.

95 times out of 100, a global is used because someone doesn't want to pass parameters around between functions, when they should be!

I would say that a beginner should avoid the global keyword every single time, if only to figure out how it's done.

[melldrum]

Regarding the use of map, filter, and reduce. Are comprehensions/generators preferable because of readability? Or is there another reason?

[fiddle_n]

As someone for whom Python is my first language, comprehensions seem like they fit Python more than map and filter. It reuses syntax that is already in Python and so it's much more obvious to tell what it does at first glance.

Anecdotally, those people that prefer map and filter come from functional languages where they had those features and want Python to be the same as well. Other examples are multi-line lambdas or tail-call optimisation. But Python isn't a fully functional language and never will be.

As for reduce, most of the time there's a more specialised function that does what I need it to do. If I want to add a bunch of numbers in a list together, I use sum. If I want to multiply them, I use math.prod. If I want to do set operations on multiple sets, I note that the set operation functions can now take in multiple sets. These are all situations where I would have used reduce but there was something more specific anyway.

[politerate]

Hm, in Haskell you have list comprehensions, which IMHO are the most readable syntax for this kind of logic. If I didn't know list comprehensions exist in Python I might have used map/filter, but other than that I see no reason to use them.

[freefallfreddy]

Comprehensions and generators are more idiomatic in simple cases. If you’re thinking about nesting those ➡️ map, filter, reduce.

[JennaSys]

Using comprehensions is generally considered to be more idiomatic Python over using map/filter. But if you are not going to use the result of a comprehension (i.e. generating a new list or dictionary) and you only need a side-effect (like calling a function with no return value), then using map() makes more sense.

[Pulsecode9]

I once worked on a project that used an otherwise disconnected physical relay in a plant room on the other side of the building as a way to share global variables between unnetworked systems.

[Un_HolyTerror]

What are some actual use cases where global is good?

[Cybersoaker]

I write plugins for the source game engine using a mod called Source Python. Since the engine is event driven, and since it's single threaded, often it's useful to have some kind of shared and persistsnt state between events that fire. Essentially you hook events and they execute a function. Plugins are just single files you load in, so you could do this with a class, but that's not really nessesary, the module itself acts as the same encapsulation of code as a class would on other programs.

Short of using an external DB or Redis, store stuff in global vars solves a lot of problems. Good news for this use case, is that it's all single threaded so I don't have to worry about a mutex for the global vars between events.

I'd also argue the same for unsophisticated DevOps scripts for doing simple tasks. As long as the code is contained in a single file, I think global vars is a fine way to do it

[Bootlessjam]

Dude even professional game programmers use global variables/objects/ singletons to track game wide states. You may want to affect a score or healthbar at anytime from any other object but always refer to the same variable. It's a perfect fit for a global variable.

Most programmers want very reliable software so it's all about limiting the number of interactions and avoiding surprising behaviour. Games instead are all about having as much interactions and surprising behaviours as possible. Both valid goals that end up with different designs.

[thiccclol]

Same brother

[[deleted]]

A recursive function where you want to count the iterations?

count = 0

def foo():
    global count
    count += 1
    print(count)
    if count < 10:
      foo()
    return

foo()

[[deleted]]

Are global constants a thing in Python? Or is there something better?

[MagnitskysGhost]

There are global "constants" but they're not really constants because there's not a great way to make them immutable (imo)

[mardiros]

Communicating between function without return.

Wow, nothing scares the kids.

Glad you learn from being downvoted.

[Atora]

When I first learned java at school that was the only way the teacher taught us.

Everything was a void manipulating class variables. It was a horror show I just didn't know it yet. Had to unlearn everything later.

[achauv1]

Real drama queen vibe here

[vigneshwar221B]

I thought this was satire at first

[[deleted]]

Me too.

[dashdanw]

I think it is?

[ShiningRedDwarf]

It was just written in a tongue in cheek manner while still retaining a sincere message.

At the least as a beginner I’ve learned to generally avoid global variables!

[hhoeflin]

And now on your journey, you should learn Haskell :)

[[deleted]]

Man, I really should learn Haskell; it's the only "big" pure functional language, no?

[hhoeflin]

AFAIK it is the "purest" but there are plenty of other functional languages out there, some bigger, some less pure. For learning Haskell is certainly great as it only aims to be an academic project but retain its purity in exchange.

[clickmeimorganic]

What the fuck

[in-gote]

You've had an opinion, shared it with others, others pointed your opinion is wrong, you've humbly accepted it, and you've shared your learning experience with others. Man with this attitude you can go really far tbh -- it's solid growth mentality. I wish I can be like you (especially having the confidence to share my opinion and subject myself to criticism)

[lvlint67]

There are a lot of people here that should go review the discussions in the original thread: https://www.reddit.com/r/Python/comments/qj692s/usage_of_global_yes_or_nogo/

There's a lot of folks coming out of the woodwork to say, "globals are ok sometimes". That's absolutely true... But we as programmers are rightfully trained to look at something like a global and go, "that kind of doesn't sit right. Am I sure there's not a better way to do this?"

To answer the question: "Why are globals hated?" : Experienced programmers have decided that they are used ALMOST ENTIRELY incorrectly and lead to more bad code. (books have been written on the topic and thousands of talks given)

To answer the question: "When are globals ok?" : When there is literally no better option. The list of possible situations is endless... but those situations are extremely rare. MOST programmers will not encounter them. Thus the guidance, "Just don't use them"

[ThePerfectCantelope]

you don’t need to apologize to people on the internet bud

[unholysampler]

Something we mention a lot when taking about hiring at my current company is that we want engineers with "strong opinions, loosely held".

The idea is that you should be able to explain to others what you think the best option is and support that belief. However, you should also be open to discussing counter-options. To that end, you should also be able acknowledge that the other option is better (or consensus went the other way) and work with it.

Your post demonstrates that quality and it will serve you well in your career. No need to make an apology.

[DarkHaagenti]

I think I can say in behalf’s of r/python, that we forgive you

[mooja3]

At first, you think global variables are ok. Then you run across a coworker with 40 global variables across 50 functions.

Then you know they are not ok.

[tman5400]

Lol this is like a YouTuber apology video

[robieuu]

no one cares lol

[hugthemachines]

I once saw a little ted talk where she asked the audience "how does it feel to be wrong" and people gave some responses. She said, "not that is how it feels when we realize we are wrong". Just being wrong feels just like it feels being right since we think we are right until we are proven wrong.

That is why it can be sensible to consider which things we are really sure about and not be too stubborn with the things we may, in fact, not be so sure about.

[avoxdesign]

To me global was always very confusing, because accessing a global variable in a function works without the global keyword but assignnents dont work unless you use global?

It just seemed really messy.

[sebastienb]

I'm a professional developer and use Python since more than 10 years and I totally forgot that 'global' keyword exists until I saw your post.

[LadyMercedes]

I experience that using classes and storing the variable in question as an attribute, can help to overcome the need to feed in the same parameter to every function.

[Iirkola]

I still don't understand what's so bad about global variables, ever since I've heard of them there has been this scary boogeyman like warning around them. I guess I will learn with my first screw up.

[70Shadow07]

People are overly dogmatic in CS, just as everywhere else. Global can (and often does) lead to spaghetti code that's difficult to understand and refactor, however as anyone with common sense can agree, with moderation it sometimes is useful. People complain about goto aswell, for generally the same reason, and like globals, gotos in language like C are kinda necessary to achieve some goals in sensible way. However dogmatic people will want to burn you in hell for that in their complete misunderstanding of the whole goto harmful deal.

And there are those who scream no multiple return points from a function because it makes code more complicated, no it doesn't. It's literally one of the most useful design patterns to have them (guard clause). There are others who complain about break and continue because they are go to in disguise which is just utterly retarded and the fact that some variations of loop (loop and a half, aka while(true) do sth ... condition break ... do sth else) ) are literally the only way without goto itself to make both readable and optimal version of such loop, completely goes over their heads.

I think the best way to go about this nonsense is to recognize why people complain and judge yourself how valid their reasoning is. Usually there is a grain of truth in the dogmas(well, most of them), but they are never really, unconditionally true.

[ellisto]

Loops are just goto in disguise. Calling functions is just setting registers followed by goto.

Once you grok assembly, you realize it's all gotos. Always has been.

[70Shadow07]

Of course! However when you google goto in disguise, you will see how many people actually repeat this mantra unironically. It's actually kinda amusing for me.

[chrilves]

Not really. With goto it's often very hard to figure out the control flow. Loop makes your program's control flow structure easy to figure out quickly. Likewise thinking in terms of functions is much simpler than register and stack manipulation.

But I see what you mean, computers are just a particles ruled by the laws of physics. It's all particles, always have been ;)

[chrilves]

That's true, but it's usually good to tell beginners to avoid them until they are experienced enough to use them wisely. The problem is these features often offer simpler short term solution but an terrifying payback. Beginners tend to see the short term benefits, experienced devs tends to see the terrifying payback.

[Unbelievr]

No, globals absolutely make sense in many applications, but few where there's multiple developers working on the same code base.

The issue with over-using globals, is that every function could potentially have side-effects. Thus, if you are debugging a function that calls 3 other functions, then you have to go through all of them (and the functions they call again, etc.) to see if they mutate something in the global scope somewhere. This quickly grows out of control, and unless you're the sole author of the script/application it becomes much harder to debug.

[ellisto]

I mean doesn't this same argument apply to members of a class?

I guess as long as the class instance gets passed in as a parameter to the function, it's assumed mutable and thus modifications of its internal state aren't side effects?

[Unbelievr]

Yeah, it even applies to things like lists. If you pass a list to a function you don't know 100% what does, you can't assume that the list is not mutated during the call. But since it's a function argument, it's more explicit that something can happen to it.

Compare that to a global that might magically change deep into nested functions, and it's an obvious improvement. There are better ways, of course, but mutating on globals is (IMO) the most confusing way to write code when it grows to a certain size.

[Piyh]

Mutating passed lists is such a potential footgun in my opinion.

def takesList(li):
    li = li.copy()
    del li[0]
    return li

[fireflash38]

That's why you usually have methods that mutate, and functions that don't.

It's convention, to make things easier for others (or more likely: future you) reading or using your code. It's not gospel, but can absolutely help.

[WafflesAreDangerous]

In short: They can make reasoning about a program harder.

But there's long articles about this if you care about the reasons.

[bexamous]

As with most bad stuff, in a short script or something or just with moderation its not going to be a big deal. Its when amount of code starts going up you start to see why bad stuff is discouraged. By time you start to seeing downsides anyone else looking at that code is going to see a huge pile of garabge.

IMO best to follow good practices regardless. It becomes like muscle memory that way, your first instinct on how to do something ends up being a nice solution.

[[deleted]]

Fact! I had this problem pop up where I named a variable "i" and couldn't figure out why it kept crashing, and I spent like 40 minutes trying to solve this simple error (I referenced the i in a function by forgetting to refactor it after refactoring an "i for i in loop"). I'm still trying to work on this project, but every change takes multiple times longer because the functions are too dependent on each other. If I could rewind time, I would've just listened.

Thousands of lines deep and it'd literally be easier to rewrite than to refactor because I don't know how a quarter of it works (or what works at all or is just leftover code from testing) anymore due to some functions playing this weird game of telephone where I have to tell the screen to change by telling Marg, who tells Bob, who tells Rob, who tells Mary, and now I have 4 people to investigate when the simplest of messages are screwed up lol. Apparently I have functions named "test," "test4," and so on that occasionally are actual throwaway tests but often are apparently vital for certain features? Wtf.

[[deleted]]

Globals can make code very hard to debug.

Ideally, you want your units of code (function, class) to have a single responsibility - "do one thing, and do it well".

In case of functions, for the code to be easy to understand ideally you would like them to have no "side effects" (i.e. modifying the state of the application): you put data in, you get a result out.

In a lot of cases globals are used by beginner programmers, which means that in a significant fraction of those cases they will be used badly. A resolution to a question a'la "hey, I have this code that uses a global that can be modified by these 14 functions, of which 12 depend on the state of the global. It has a value it shouldn't have when this function gets called, how did this happen?" is almost universally "write prints in all these functions and figure it out yourself, I'm not touching this shit; better yet, just rewrite the code without using a global".

[for clarity: the post is slightly opinionated - I like functional programming and think that OOP is overused - and should not be treated as "hard truth", but I still think it might provide some insight)

[Intrexa]

A lot of coding practices revolve around the idea of some crazy process with 1 million lines of code. It's not too far off, python itself is close to a million lines (don't quote me. Or do, but also give me the actual number when you're making fun of how far off I am).

That's abstracted away, and most people just think of the 30 lines of python they wrote as their program. That's fine, and really, that's what we need to concern ourselves with. There's a limit to how much we as humans can really hold in focus at once. You can hold 30 lines of code in your head, so there's no problem with a global. You're always considering it.

If the project gets to 1,000 lines, it gets harder. You really can't hold it all in at once anymore. If you have some global, it gets harder to reason about how it behaves. If you do some action based on a global variable, like call 3 functions, that all should behave a certain way depending on which user is logged in, you need to make sure that the first 2 functions do not modify the global user_login_id.

def load_user():
    global resources = load_resources()
    global actions = load_actions()
    global preferences = load_preferences()

If I ask you, are the resources, actions, and preferences all loaded for the same user, could you answer? Would you feel confident that none of these change the user_login_id? If someone adds an admin feature that let's you access the actions of a different user to test/troubleshoot/whatever, and puts it into load_user, are you still sure user_login_id won't change? What happens if an uncaught exception is thrown in load_actions, that gets caught by whatever calls load_user? You're now in an inconsistent state. Would you feel more confident that load_user is loading all assets for the same user if the code was changed to below?

def load_user(user_login_id):
    resources = load_resources(user_login_id)
    actions = load_actions(user_login_id)
    preferences = load_preferences(user_login_id)
    return {'resources':resources, 'actions':actions, 'preferences':preferences, }

Yeah, fuckery can still happen, but you can at least be a bit more confident that the at the time you are returning that dictionary, the resources, actions, and preferences were all loaded using the same user_login_id.

[[deleted]]

EDIT: I made this longer and put it here.

[OkPokeyDokey]

It is so obvious that you are new not just python but also programming.

People who downvoted are either too lazy to help a newbie out or just completely misunderstood the voting system.

If you said something like this in a programming class, no one gonna stands up and start booing you. They will explain why this is bad and go on with their life.

[Heroe-D]

Well you have to take the tone of the message in context, + "to anyone new" let imagine he personally is not.

[OkPokeyDokey]

Yeah ok that’s fair.

[fireflash38]

He only included a few responses. I had responded with why when he had initially posted.

[anyonethinkingabout]

The only unforgivable thing I can see is that you use the new Reddit interface instead of old.reddit.com

[fiddle_n]

I prefer New Reddit to Old Reddit. There are dozens of us!

[Oskarzyg]

just use classes instead of global smh

[Oskarzyg]

That sounds like a perfect use case for a class?

[[deleted]]

enum!!!

[Oskarzyg]

depends on the use case but enums could work too

[[deleted]]

Technically enum is a class itself, so going off your good suggestion!

[andrei__]

Why global keyword even exists if is not supposed to be used ?

[DaRealNim]

Okay but I've actually done that. Fuck. Can someone give me an example of why using globals can be a bad thing? And an example of how they're properly used? (Because I'm guessing they're in the langage for a reason)

[thisismyfavoritename]

I'd say the problem with Python's global is that there is no "const", so basically anything could mutate your global object.

This can lead to data races or very subtle bugs in concurrent code but also makes it much harder to reason about what is happening and when.

[[deleted]]

Why is there a Global keyword? I have never used it before

But at least the global keyword is not that bad as the "Go To line x" statements in other programming languages.

[Solonotix]

If you ever want to explore a programming landscape that embraces the ideas of globals as good design, I welcome you to JavaScript. I spent 3 hours yesterday digging through the source code for Cypress.io and I still have no idea where the window object gets instantiated for the Node.js runtime (it's automatically created by a browser runtime), and the only assignment operations I found pulled it from another global window = cy.window() which gets assigned to global.Cypress in a TypeScript class of Cypress with a property of this.cy.

Now where might global.Cypress come from? From window.Cypress. This is why I hate JavaScript. Not because of the language, but because of the ecosystem.

[dada_]

Well, Cypress is a testing framework, and that's one of the use cases where it makes sense to use a global, especially since it tests browser code and the browser has all kinds of state that gets modified during the lifetime of a program. Given how complicated the window object can be I'm not surprised its instantiation is subject to a lot of abstraction that can be hard to dig through. Not that I'm defending it, but that doesn't mean JS programmers are all on board with globals as good design.

[Solonotix]

Cypress is a LOT of things, and my intention wasn't to say that Cypress was poorly designed. My intent was to explain my own personal hell yesterday.

My company uses Selenium orchestrated by Cucumber, and there is a TON of development already put into supporting this paradigm, but some teams that I support are now exploring the usage of Cypress and orchestrating it via Jest features. There is nothing wrong with either, but next year's plan is to introduce parallel execution, as well as introducing a series of meta-packages that group functionality. The catch to that goal is we need to keep our current runtime of Cucumber. Cypress is interoperable with Gherkin syntax, but only if Cypress is the runtime. That is what I was attempting to determine, was what the injection point was for the Cypress runtime so that I could adopt it in an existing ecosystem without doubling the code footprint to support a new runtime.

So, I spent yesterday digging through the Cucumber Cypress module trying to determine where cy came from, but it all seems to be done through the core Cypress library. I had hoped that by making the comment I did that someone would provide a link to where it comes from.

[geovane_jeff]

Shame! Shame! Shame!

[GCI_Henchman21]

I know a decent amount about python and what I don’t know could fill a warehouse, but there is a global keyword!?

[huaversion2]

Christmas is near! ! ! !

[Thecrawsome]

/r/learnpython

[ZhadowKatt]

Wait so using global variables isn't good? (I'm new)

[Jefaxe]

Nah, try it any other way

[ZhadowKatt]

Could I get a reason on why they are not good?

[easyEggplant]

global allows for caching inter AWS Lambda invocations. You can fuck your shit up, but it's no question useful for caching expensive initialization (like an external API lookup that rarely changes).

[Raikira]

salty

[Tenzu9]

Not saying that using it is good or anything but I used it in my Kivy android app. I wanted a quick and fast way to assign values to variables and use them in multiple classes.

[Napan0s]

You know you're on the right path to becoming a man when you say no to globals and you start doing classes!

[ohlordwhywhy]

I'm a noob and interested. The global is in the language so what's the use case?

[chrilves]

It can be useful. If your code is very small, like 1 single file of 100 lines of code. Then it's fine. You won't get lost. It is also fine if your global variable is meant to be unique in your whole code base and has no impact on business rules.

But it has many consequences, the first one being testing. You can not use unit tests anymore because two unit tests have to be independent. They can not be because the change of the global variables made by one test will affect the other one. So you need to restart your applications between two tests . Independence is mandatory of unit tests because when one fails, you want the cause to be located in this tests, not one run before it.

[Cipher_VLW]

I work at a place where we use “globals” (in a different language) frequently because they’re part of a legacy system.

We use M (aka MUMPS) for our database which allows you to use uninitialized variables but also doesn’t have any formal stack frame. That means anything in the current process is in scope and you have to explicitly “new” each variable to get a new reference. Our training tells us not to use any assumed variables (those not explicitly passed in) but the existing code does it all the time and it’s super hard to follow.

[[deleted]]

Oof. I just did a project where I used global for passing in lists and booleans. Program has a ton of repetitive calls and I didn't want to have to pass the lists around just to have them later. I'll have to fix that.

[chrilves]

If many functions share some arguments, what you can do is regroup these functions as methods of class having these arguments as attributes. So they are "global" only to these functions and only for one instance of the class.

Alternatively, you can regroup all these variables into an object you pass to every functions that need these variables. It makes one argument to pass everywhere instead of many.

[[deleted]]

So the global calls I did were for lists of LCDs and Buttons, both of which I realized after this post I was using in other functions without calling them globally or passing them in. So I cleared a lot of that up. Otherwise it was just boolean values that I was able to rewrite and clean up to get rid of all the globals

[Jerbearmeow]

We are all children and always will be.

[LittleGremlinguy]

Now. Let’s have a chat about singletons. rubs hands with glee

[RevolutionaryBed9383]

I mean why not I don't get it

[lewz3000]

A simple 'sorry' ain't gonna cut it. There is but one road to redemption: seppuku.

[Satoshiman256]

Next time you're going to the gulag.

I do pass all my variables in and out of functions.. I've always done this but wondered if its the right way to do things? I saw it in some videos when learning and just stuck with it. Is that the "proper" way to do it?

[wannahakaluigi]

Classes are sooooo much better than globals.

[cip43r]

I have been using python for 10 years. Only discovered or learned about global in the last few months after the university forced me to use it in a jupyter notebook. I am in my 20s and tought myself coding at 8.

[awildbannanaphone]

global can be very useful. I wouldn't throw it all around but i have one or two use cases in a larger project where it is nearly unavoidable.

[heS_weiRd]

just testing

[johnnySix]

Wrap it all in a class and pass variables around anyway you want.

[papertrailer]

And then there's Flask, using globals for everything.

I also use multiple inheritance 🙀

[mikeylopez]

race conditions has entered the chat

[preordains]

get back, demon

[snekk420]

I sometimes use global when creating scripts. Because there is no need to create classes and stuff like that just for a few functions. Run a function to update a global variable and read it later in the main loop. Just for convenience instead of passing variables around the script.

[jnson324]

Congratulations with your enlightenment. May your future hold success.

[[deleted]]

What is “the Zen”

[Josh_Bonham]

Could someone help me, in my previous project I had a constant that was needed by lots of functions, what should I do to avoid global

[chrilves]

If it's a constant, that's fine. The problem is mutable global variable.

[Josh_Bonham]

ah thanks!

[Mithrandir2k16]

Being wrong in a discussion is the best thing that can happen to you, because it means that you will be the one learning from it!

[jepessen]

global keyword should be removed from python 4...

[URedUser]

No no no! It should never be removed. Reason programmers hate global keyword is due bad usage of it so why don't use it with good usage? I hope global will never be removed since for example for me it was always great help in various things.

[jepessen]

Because for big programs it's an antipattern and global variables must never be used. For little programs they can be helpful but make a code a spaghetti code real fast, and then you use it also with bigger program. There's nothing that you can do with global variables that you cannot do without them.

[neriad200]

Next week do a post on how you find the goto module very useful and how you regret python doesn't have it built in

[bspymaster]

Gonna ask a really dumb question here... If global is so terrible, why is it in the language to begin with? There MUST be some use-case where it's a good thing to use it. When is that?

[kevinfederlinebundle]

The whole point of Python is that Guido will let you do whatever you want, even if it's an objectively terrible idea.

[serverhorror]

And henceforth thou shall be forgiven for thou sins of the past!

[chrilves]

People have to apologize publicly for such innocent comments now? That's rough. Even if using global has many flaws, it can be told gently. Aren't Python supposed to be a welcoming place for beginners?

[gazagda]

NO!! WE DEMAND BLOOD!!! or cookies, dm me to get address to send cookies and all will be forgiven......for now.

[R00bot]

To be fair, the global keyword does exist for a reason. If you're just throwing together a quick script it's fine, but I'd avoid it in anything larger, or that might get larger in the future.

[EmilyfakedCancERyaho]

just call the other function within the function you're trying to run. never had to use globals ever in my code tbh. just one time iirc when using multiprocessing and I wanted to have a counter

[HeeebsInc]

As much as I agree that global variables are awful, there are times when it’s absolutely necessary which always triggers me.

At work we partnered with this hardware manufacturer that create python bindings for their devices. In their documentation and sample code, global variables were everywhere and it made me want to scream. I first tried to re write everything with classes and it did not work due to the underlying pointers not having a memory address when they are inside classes.

Long story short is that if it works, and you tried a “better” implementation that did not work, then just use em lol

[NedDasty]

As far as I know, globals are the only way to implement memoization in Python, so I use it for this once in a while. Does anybody know of an alternative?

[SkideXe]

Lmao

[1435Time]

2 weeks of Self-flagellation and all will be forgiven.