Remember the good old days, back in 2022? ChatGPT had just been released and I, along with the rest of the internet-connected world, was having a great time playing around with our new… friend? Toy? Whatever this thing was, it was certainly entertaining. And probably useful. But mostly fun.

Me introducing my family to the latest internet-craze

Eventually, we learned that we could do more with this tool than cook up imagined dialogues between our favorite non-contemporaneous personalities or generate lyrics for an “uncomfortable lullaby” (a personal early request). It could draft our emails, help us plan trips, and teach us new information. Occasionally that information would be false, but it usually seemed to check out.

Of course, we all used our newfound, variably competent personal assistants in different ways at work. As a software engineer, I could now feed error messages that I encountered directly into ChatGPT, and I could even copy in chunks of code as extra context. After reading my input, it would suggest a solution. Often that solution did not work. But the tool was useful enough that I kept coming back.

From there, things mostly plateaued for a while. Every few months, a new version number or model name would appear and some new quirk would start showing up in the AI’s output. Still, there were plenty of times when I preferred to get answers from a real human. AI was another tool in the toolbelt. Not always reliable, but good enough to be helpful.

Towards the end of 2025, my interactions with AI took a dramatic turn. Around November, my team and I began integrating something called “coding agents” into our workflow. That essentially meant having tools like ChatGPT and Claude that live inside the code editor instead of in the browser. They can read all of the relevant files directly and are able to edit those files on their own.

To illustrate the point, I’ll move out of the world of software engineering. Imagine you are writing a 400 page novel and, for whatever reason, you decide you want to edit a certain side character out of the story. You can’t just search for every time that character’s name appears and delete it. You’d end up with disjointed sentences. You would need to go through each instance individually and figure out how to best smooth over the text.

In this imagined scenario, you wouldn’t be able to copy your entire novel over into ChatGPT. The prompt would be too large. But what if there was a ChatGPT feature built into your text editor? You could ask it to make the change and it would search through and smooth over the text on its own. It wouldn’t be perfect, but it would probably make a solid first pass. That’s what coding agents are doing for software development. (I don’t use Microsoft Word much these days, but from what I understand something like this already exists.)

This was the crucial turning point for me. AI had quietly transformed from a glorified search engine to a strange twist on a junior software engineer that somehow also seemed to have decades of experience. In other words, it was actually doing my job, or at least trying to.

Slowly, I settled into this new reality and started to build a routine around it. I would feed the AI descriptions of features we wanted to build or bugs that needed fixing in plain English and it would explore the existing code and take a first pass. Inevitably I would need to correct, improve, and sometimes completely redo its work. Like a good engineer, I played around with my prompting strategies to try to make things flow more smoothly. But I sensed that something big had just happened – something that would take more than prompt-tweaking to address.

After a few months of winging it, I finally decided to sit down with Claude to try to understand what new skills I needed to stay ahead of the curve. It pointed me in two general directions. First, it suggested that I brush up on my management skills, since there was something analogous between managing AI tools and managing less experienced people. It also recommended that I level up on my bigger picture software engineering skills, like knowing how to organize a large codebase to keep it easy to navigate in the long term, because the AI tools had some clear gaps in thinking at that level. Both of these made sense to me, so I gathered some resources and started digging in.

Before long, though, another thought started bubbling in the back of my head: How long would these new skills remain useful?

If the technology were to stay where it was, I would be fine. My day to day workflow had already been turned upside down, but I would figure things out. The trouble was that all signs seemed to be pointing towards AI continuing to improve. I had heard people argue that AI development will hit a wall some time in the near future. Either the chips won’t be able to process more data, or the software will hit its theoretical limits. One way or another, the models’ capabilities would max out, leaving plenty of work for humans to do alongside them. But it seemed like, as a society, we were pouring all of our energy and resources into finding ways for those things to not happen. Sure, maybe they would, but that wasn’t part of the grand plan. If the stability of my career, and my financial future, rested on the assumption that “AI will stagnate soon”, I could be in for serious trouble.

And, of course, these concerns weren’t just about me. This new generation of tools had only entered my world a few months earlier. I hadn’t seen it coming, but suddenly I was calling the long-, and even medium-term stability of my career into question. It seemed at least plausible that similar shifts would come for other professions, and that they would arrive faster and hit harder than most people are prepared for.

I went back to Claude and shared my thoughts. After some back and forth, it pointed me to the names of a number of people and organizations that I might want to look further into. One of those names was Erik Brynjolfsson, an economics professor at Stanford of whom I had never heard, and the director of the Stanford Digital Economy Lab. Claude told me that he “takes the displacement question seriously” and left it at that.

A quick YouTube search led me to a CNN interview between Brynjolfsson and Richard Quest about a project called The Digitalist Papers. This sounded like it was right up my alley. Brynjolfsson and his co-editors had assembled thirty of “the top technologists, policy-makers, economists” – people like former Google CEO Eric Schmidt and Nobel Prize winner Joseph Stiglitz. This esteemed group was given the task of writing essays about “transformative AI,” its anticipated economic impact, and what we might be able to do to smooth out the transition into this brave new world.

I’m not going to use this space to summarize the content of those papers. If you’re interested, feel free to check them out here: https://www.digitalistpapers.com/. I haven’t finished reading them myself. For the moment, my focus is more on their “In the Media” page, and the surprisingly small number of links featured there – eight, to be exact. To be fair, I have never been treated to a seven minute interview on CNN, nor has any project of mine ever been featured in the New York Times. But I’ve also never been the CEO of Google, and I don’t have a Nobel Prize hiding in my back pocket.

From what I could tell, the general conversation around AI was not where it needed to be. Experts and academics were talking about changes at the scale of the industrial revolution and how we should prepare for them. Aside from a few brief pieces in major news outlets, hardly anyone seemed to notice or care. The reaction felt on par with those towards other “what if” disaster scenarios – things like nuclear war or another pandemic. Disturbing images, perhaps, but not something that many people feel compelled to actively prepare for. The difference, of course, is that as a society we at least pretend that we are trying to prevent those other scenarios. AI development, on the other hand, is something we actively encourage.

To be clear, I am not here to advocate one way or the other on any particular AI regulation or policy initiative. And I recognize the possibility that the technology will reach a plateau, or at least slow down enough to give us time to gradually reorient ourselves. My point is only that AI has the potential to trigger enormous changes quickly, and not nearly enough people seem to understand how sudden and dramatic those changes could be. We should be thinking and talking more seriously about what that might look like and how we should prepare for it.

In lieu of answers, I'll close with a question, echoing Will MacAskill in episode 213 of the 80,000 Hours Podcast, where he builds out a picture of AI developments causing a “century in a decade.” Think of all the changes you expect to occur in the world by the year 2126 – technological advancement, economic upheaval, scientific discovery, geopolitical conflicts. Now imagine all of that happening in the next 10 years.

Are you ready?

Will my spammer read any of this? I don’t know. In the past, responses to messages like this have led to longer conversations, and I hope this one does too. If nothing else, I saw an opportunity to jot down a quick thought, and I took it:

Hi ____,

Thanks for your submission through rally4israel.com, which I've copied below. I'd love to engage in a more substantive way, as I have done with previous "across the aisle" respondents in the past.

As some initial food for thought, I am attaching an excerpt from Reza Aslan's No God but God: The Origins, Evolution, and Future of Islam, which I happen to have just finished reading this past week. I picked up the book as part of a broader attempt to gain a better understanding of Israel's neighbors, and a large portion of its population. Towards the end of the book, Aslan gets into a discussion of modern Islamic governance, and how that ought to be balanced with democratic values. To my surprise, he points to Israel as a model, however imperfect, of the sort of society he wishes to see more of in the Islamic world.

I don't know what news sources you have been following over the past two-plus years. I assume some of the stories you have seen have been true, some have been false, and a large portion have been missing an enormous amount of context. (The same could, of course, be said of many pro-Israel news outlets as well.)

Please take the opportunity to read more about this conflict, and consider why Aslan would want the Islamic world to in any way emulate a "terrorist state" full of "genocidal freaks."

I would recommend starting with Benny Morris' Righteous Victims, perhaps followed by Micah Goodman's Catch 67 for more on the aftermath of the 6 day war.

If you have any titles you'd like to recommend to me, I'd be happy to add them to my list.

Thanks again,
Ari

\============================
Original submission:

Chant:
B-llsack b-llsack eat my n-ts
Israel is a terrorist state and should be slapped on the b-tts

Notes:
Hope netanyahu gets s-d-mized you genocidal freaks

My armor is my argument.
My weapon is my word.
No blade upon our battlement;
The sheath shall stay its sword.

I come to make a measure
Not of muscle, nor of might;
I come to raise a reckoning
With what you say is right.

I hear your “should”s and “mustn’t”s,
See your stormy, steady eyes,
And I —
I ask a simple question:

Why?

Why is it that your sentences
Strike down with such conviction?
Perhaps the thoughts you think are true
Are nothing more than fiction.

Show me why your reasoning
Rings truer than my own.
Tell me why the things you say
Should shake me to the bone.

Come fight the war not won with guns;
The battles where the dead are none.
Come fight with me, but not to death.
Come fight with but your thoughts and breath.

After last week’s wild and crazy monitor adventures, I thought I would be done writing about computer screens and instead focus on what I generally try to use those screens for: work. But there were still some loose ends to tie up. Spraying the treadmill cut down the flickering, but it was only a temporary fix. Once the water dried, the flicker returned and I had to spray again. Not terrible, but not ideal.

Also, I wasn’t wearing shoes and all of this spraying was making my socks wet, which is never a good thing.

At this point I knew the problem had to do with static electricity buildup. I figured the socks weren’t helping with that, so I tried putting my sneakers on. The flickering seemed to stop. That was good, but could I do better?

I searched around a bit more and discovered a whole community of people with similar treadmill-caused monitor flickering issues. Among them, this guy (flickering at 5:30):

I wasn’t going to start playing around with wires the way he did (again, I’m a software guy). And the static discharge bands didn’t look like they would be any better than my current sneaker solution. But Mr. ElectroBOOM’s talk about electrical grounding — basically, giving stray electricity a safe place to go — got me thinking.

There was something about my treadmill’s power cord that I had noticed a long time ago and then promptly ignored: the plug was not a standard Israeli plug (I live in Israel). To compare, below is a picture of standard 2- and 3- pronged Israeli plugs, next to the thing I found attached to my treadmill:

It was unusual, but I plugged it in and, hey, it worked. I hardly gave it a second thought. Until now.

I knew that the third prong on a 3-prong plug is usually meant for grounding, but this plug didn’t have a third prong. It just had a metal strip going down the middle. Maybe that was the problem. I fed a picture of it to chatgpt. This time, it gave me some darned good information:

Ah — this is actually a Schuko plug (Type F, common in Europe).

It’s not just a “2-prong” plug. The two round pins are live and neutral, and the metal strips on the top and bottom edges (you can see them on your photo) are the ground contacts. When you plug it into a proper Schuko socket, those strips touch the grounded clips in the socket and provide a full earth ground.

So your treadmill does support grounding — it’s just that the ground is on the side rails, not a third pin sticking out.

Again, for comparison, below is a standard Israeli outlet (left) and a Shuko outlet (right):

The Shuko plug fit in the Israeli outlet. It was able to power the treadmill, just the grounding mechanism didn't have anything to attach to. I thought I might be on to something. I went back to Google and discovered the nifty product pictured below: a Shuko to Israeli plug adapter. I ordered one.

Shuko to Israeli plug adapters (https://shop.super-pharm.co.il/electricity-and-electronics/cables-and-adapters/electric-cables/מתאם-חשמל-מתקע-גרמני-(Schuko)-לשקע-ישראלי-כולל-הארקה-3-פינים-עד-16A-קבוע/p/mp-00106831)

The adapter arrived a few days later. As a test, I turned on the treadmill one more time without the adapter. It was still flickering. So I attached the adapter, held my breath, and… it kept flickering. Oh well. At least I had the sneaker solution. It beat the spray bottle, and I got to learn a bit more about plugs and outlets along the way.

P.S. While doing all of this, I decided to give my homemade docking station stand (mentioned in my last post) a slight upgrade so it looks a bit less like what it is: a piece of garbage. We’ll call this version 2.1:

Thinking the docking station might be overheating, I built a cardboard stand for ventilation. My mother-in-law happened to be around and suggested upgrading to a piece of plastic food packaging. That became version 2.0 — and it worked, at least for a few days. The docking station got a bit cooler and the flickering seemed to taper off.

Versions 1.0 and 2.0 of my homemade docking station stand

Yesterday, however, the flicker frequency suddenly picked up dramatically. The screens would blink multiple times per minute, interrupting my work and making them essentially unusable. The problem had to be re-addressed.

I had run into a similar issue about a year or two earlier. Somehow the mysterious flickering had been resolved, but I did not remember how - if it disappeared on it’s own, or if I found a fix, or what that fix might have been. Unfortunately, two weeks prior to the more recent incident, my group lost a large portion of our Teams chat history due to unrelated and unforeseen circumstances. I was on my own.

My first thought was to make sure this didn’t happen again next time. I started a new page in Notion so I could jot down whatever I was about to find out.

I thought this still might be an overheating problem, so I found a small fan and pointed it at the docking station. It made no difference. The flickering continued apace.

Then I got to work trying to isolate where the problem was really coming from. I swapped out my work laptop (system76, popos) for my personal one (lenovo, kubuntu), and the flicker continued. Whatever was happening probably did not have to do with the laptop’s hardware, since it persisted on two different machines. And if it was a software problem, it had to be something affecting both laptops.

I posted about the problem on my group’s Teams channel. Someone asked if I had done any system updates recently that might have unintentionally caused the problem. I hadn’t — certainly not anything that would have affected both computers. Still, I thought I’d try switching Linux kernels. (For context: in Linux, the kernel is the core of the operating system. Hardware-related bugs sometimes appear or disappear between versions, so trying a different kernel is a common troubleshooting step.) However, I knew that finding the right kernel might turn into a wild goose chase, assuming that was the problem at all. So before going down that path, I searched around and found a suggestion to tweak some Intel driver frame delivery settings (https://www.reddit.com/r/Ubuntu/comments/1cfzjpj/comment/lpc77o7/). Unfortunately, that didn’t help.

So I moved on to kernel hoping. I tried 5 different versions (6.0.19, 6.5.6, 6.8.12, 6.12.42, and 6.16.1), but the flickering persisted across all of them.

From there, I launched into a long back and forth with chatgpt. It suggested checking logs from various sources on my machine, using journalctl and dmesg. Nothing particularly insightful came from that. It then suggested updating the linux-firmware on my machine. I dutifully obliged. The flickering dutifully continued.

I then tried to clarify that chatgpt understood what I meant by “flickering,” realizing that the term could refer to different screen-related issues which might stem from different causes. It did understand. It just couldn’t figure out what to do about it.

At some point in all of these attempts, I noticed that the flickering followed an odd pattern. I normally stand when I work, and I have a desk treadmill that I use so I can walk at the same time. The flickering only happened when the treadmill was turned on. Strange, but consistent. The easy solution, without understanding what was happening, would be to stop using the treadmill. Of course, I didn’t want to do that, and I had been using the same treadmill and monitors for nearly four years with (almost) no issues. Why had the flickering suddenly jumped today?

I told chatgpt about the treadmill epiphany and it started talking about “electromagnetic noise” and “voltage dips.“ This was not my area of expertise, but I stuck around for the ride. It suggested rearranging the cables or moving the treadmill to another room (which would obviously defeat the purpose of a desk treadmill, but what can you expect from an LLM that doesn’t have to worry staying active during the workday?). I moved a bookcase to gain access to a separate outlet that I could plug the treadmill into. I threw in an extension cord and attached it to an outlet in the bathroom across the hall. Still no difference. The flickering continued.

Chatgpt recommended several other pieces of hardware I could buy that might (might) solve the problem — a more “well shielded” HDMI cable, an Uninterruptible Power Supply (or UPS), or a line conditioner — but I was hesitant to do any of these things not really knowing that they would solve the problem. It suggested “twist[ing] the cable on itself.” Easy enough, but also ineffective.

Finally, I went back to Google and updated my search: “monitor flickering when treadmill on“. The first result led me to a reddit user with the same brand of treadmill, complaining that their screen flickers when the treadmill turns on:

I just bought a walking pad so that I can work while getting my steps in. I was super excited to get started, only to realize shortly after that walking on the treadmill while using the computer causes my monitors to flicker…

Update: I have found a silly, but useful solution to this problem. I figured that the issue was caused by static electricity. I googled how to get rid of static electricity, and it said to create more humidity in the room. I have a spray bottle of water, and I just spray it on the track of the treadmill. Don’t spray too much so that you’re slipping and sliding, but just enough that it is a tiny little bit wet. This is seem to solve the problem for me. I’ll probably get a humidifier.

— https://www.reddit.com/r/Monitors/comments/10jfbfh/monitors_flicker_while_using_walking_pad/

And then it hit me.

A few days earlier, I had discovered some mold growing in my office. Among the measures that I took to address that, I put a *de*humidifier in the office. By now, the dehumidifier had been sitting there for just about 24 hours and, together with the treadmill, created the perfect atmosphere for screen flickering. I had found the answer.

I found a spray bottle, and sprayed a bit of water on the treadmill. The flickering stopped.

And with that, I was back to my regularly scheduled programming (pun very much intended).

➡️ Part 2 (there’s more!?) here: https://ariabramowitz.me/the-tale-of-the-flickering-monitors-part-2-youre-not-grounded

I recently ran into the error above while trying to start up my dual-boot Lenovo laptop (Kubuntu + Windows 11). These are the steps I took to fix it.

1. Starting with this SO post, I did the following:

   1. Start up the laptop with a bootable drive. I used a popos one that I happened to have on hand

   2. Open a terminal and run sudo blkid, which gave the output below:

      

   3. Ran sudo mount /dev/sda3 /mnt and got the following error: mount: /mnt: wrong fs type, bad option, bad superblock on /dev/sda3, missing codepage or helper program, or other error.

2. Ran sudo file -s /dev/sda3 to check the filesystem type. Output was data, suggesting this was likely not the right partition. No other partition seemed to be the one I was looking for.

3. Went to BIOS to check various settings

   1. UEFI/Legacy Boot: UEFI only

4. Went to Lenovo boot menu and selected “Ubuntu” → was able to start up (?!)

5. Ran the following to reinstall GRUB Bootloader:

    sudo grub-install
    sudo update-grub
   

6. Ran cat /etc/fstab to make sure things looked right: ✅

    ~ 
    ➜ cat /etc/fstab
    # /etc/fstab: static file system information.
    #
    # Use 'blkid' to print the universally unique identifier for a device; this may
    # be used with UUID= as a more robust way to name devices that works even if
    # disks are added and removed. See fstab(5).
    #
    # <file system>             <mount point>  <type>  <options>  <dump>  <pass>
    UUID=2799-345B                            /boot/efi      vfat    defaults   0 2
    UUID=29b53720-ce06-4cc4-8465-fd9ac544f52d swap           swap    defaults   0 0
    UUID=421b7727-75b0-4825-a330-c620b04dcb64 /              ext4    defaults   0 1
    /swapfile                                 swap           swap    defaults   0 0
    tmpfs                                     /tmp           tmpfs   defaults,noatime,mode=1777 0 0
    ~ 
    ➜
   

7. Saved a backup of my fstab in case this happens again:

    sudo cp /etc/fstab /etc/fstab.backup
   

8. Rebooted the laptop to see if the fix held: ✅

9. Removed several old popos entries in the laptop’s boot order. Not clear if those had anything to do with this, but can’t hurt to remove

"a" in "abc" is True will evaluate to False (!)

This is because the [Python] interpreter reads this as "a" in ("abc" is True), which is the same as "a" in False.

The first problem here, which I did not catch until later, is that "a" in False does not in fact evaluate to False. It raises an exception because False is not iterable so the in operator does not work:

"a" in False

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: argument of type 'bool' is not iterable

Having overlooked that issue, I was about to respond with this link giving more details about operator precedence in Python. However, after looking more closely at the explanation there, I noticed something else: in and is have the same precedence and have left-to-right associativity (they get processed left-to-right). Following that, I would have expected the example to evaluate to True:

"a" in "abc" is True # -> ("a" in "abc") is True
"a" in "abc" # -> True
True is True # -> True

But when I actually ran the code, it returned False.

Something wasn't lining up, so I decided to do some more digging. I started with a conversation with ChatGPT that went something like this (full thread here - https://chatgpt.com/share/67c629cb-38e8-8013-8daf-290abec2600a):

Me: Hey, ChatGPT, what's going on here?

ChatGPT: Simple. It’s operator precedence.

Me: But don’t is and in have the same precedence?

ChatGPT: Good point. This should evaluate to True.

Me: But it doesn’t.

ChatGPT: Oooohhh. Riiiighht. It’s operator chaining.

This was a good reminder that ChatGPT is still not a Python expert. I would have expected it to catch both of the points I mentioned above, unravel the incorrect assumptions, and then give the correct explanation. Instead, it played along with the provided explanation and only corrected itself after two rounds of prodding. Oh well.

Needless to say, my conversation with ChatGPT was not the most confidence-inspiring one I’ve had in my life, so I went to Google next. I found a Stack Overflow post with a similar question and the same explanation that ChatGPT eventually gave: https://stackoverflow.com/questions/31487806/a-in-abc-true-evaluates-to-false

Essentially, because of "operator chaining" the example above, "a" in "abc" is True, translates to the following:

'a' in 'abc' and 'abc' is True

Since "abc" is not True, the right half of the expression, and thereby all of it, evaluates to False.

This is similar to how Python evaluates 1 < 2 < 3 as (1 < 2) and (2 < 3). Alternatively, using the example from the Python docs:

x < y <= z is equivalent to x < y and y <= z

I had known about this rule generally, but did not realize it applied in a case like this.

Lessons learned:

1. If two or more comparison operators are "chained" together, Python inserts ands between them to interpret what's going on.

   • "Comparison operators" include: <, <=, >, >=, ==, !=, is, is not, in, and not in

2. ChatGPT is not a Python expert... yet.

For more on this, check out these links:

• GeeksForGeeks on operator precedence: https://www.geeksforgeeks.org/precedence-and-associativity-of-operators-in-python/

• Stack Overflow on the example covered here: https://stackoverflow.com/questions/31487806/a-in-abc-true-evaluates-to-false

• Python docs on operators: https://docs.python.org/3/reference/expressions.html#comparisons

• PEP 535 – Rich comparison chaining: https://peps.python.org/pep-0535/

What happens behind the scenes in a python import statement? Glad I asked. Here’s how it works:

1. Check sys.modules: Python first checks sys.modules to see if your module has already been loaded.

   • sys.modules is a regular python dict that is used to cache modules. The keys are strings of the modules’ names and the values are module objects (i.e. objects of type ModuleType)

   • If your module is already in sys.modules, python adds the cached version to globals() and skips the steps below.

2. Create a module object: If python does not find the module in sys.modules, it creates a new ModuleType object and loads the module’s source code into it

3. Cache the module: The new module objects is added to the sys.modules cache

4. Compile and execute: Python compiles and executes the source code from your module

5. Add to globals(): Python and adds your module to globals(), making it available for use going forward.

Key Point: It is often said that importing a python module will execute all of the code in the module. That is only partly true. Python only executes a module the first time it is imported, then caches it in sys.modules. Subsequent import statements throughout your code, even in different files, will refer back to the cached version and will not execute the module again.

Below is a bit of code to bring all of this home. We will:

1. Create a simple module (module1) with a print statement so we can see when the module gets executed.

2. Import module1 into main.py, which will execute module1.

3. Delete module1 from globals(), then try accessing it to demonstrate that it is no longer available.

4. Re-import module1. This will add module1 back to globals(), but will use the cached version from sys.modules and will not re-execute module1.

5. Access module1 again to demonstrate that is has in fact been added back to globals()

# module1.py
print("Running module1")

# main.py
print("======== Running main.py ======== ")
print("Importing module1")
import module1
print("Deleting module1")
del globals()["module1"] # Deletes from globals(), but not from sys.modules
try:
    print("Accessing module 1 after deleting from globals()")
    # This will cause an exception. module1 is still cached in `sys.modules`,
    # but the reference to the cache has been removed from globals()
    module1
except NameError as e:
    print("NameError", e)
print("Re-importing module1")
# Adds the cached version of module1 back to globals(), without
# re-executing the module
import module1
print("Accessing module 1 after re-importing from globals()")
module1
print("Done!")
print("=================================")

Output from main.py:

======== Running main.py ========
Importing module1
Running module1
Deleting module1
Accessing module 1 after deleting from globals()
NameError name 'module1' is not defined
Re-importing module1
Accessing module 1 after re-importing from globals()
Done!
=================================

Dr. Baptiste's way around the problem relies on the __new__ method and the __defaults__ property, neither of which typically get much air time:

• __new__ is a built in method on all classes. It creates an instance of the class (before __init__ gets called)

• __defaults__ is a property on all functions that stores the default values, and it's writable

  • if there are fewer defaults than function arguments, the values get "right aligned". See the screenshot:

    

If you're on python 3.7+, stick with the built-in option. If not though, good to know you can do this:

from collections import namedtuple

Point = namedtuple("Point", ["x", "y", "z"])
Point.__new__.__defaults__ = (2, 3) # Default `y` to 2, and `z` to 3. `x` has no default

print(Point(1))
# Point(x=1, y=2, z=3)