Before and after programming

piefed.jeena.net/static/media/posts/5k/eu/5keur…

submitted 4 days ago by Jeena@piefed.jeena.net

Before and after programming
455

Log in to comment

135 Comments

I've learned python after CPP... And I can't #even remember all the cases when I thought "damn, I wish I could've just used pointers"

I've been in industry for a decade, big tech for over 6 years. And I STILL fucking hate Python. I can write in it, but everything about it just feels wrong

Similar story in our team with 2-15 YoE. We do TS and C# but recently did a hostile takeover of the API from one of our providers which is in python We all now fucking hate python. The codebase is fine, the language isn't.

Even our C++ guys won't touch my C code with all the pointer tricks and unions used for hidden castings. Whimps!

But python has worse problems than lacking pointer. Have you ever copied a piece of code from an external source into a python source? It *really* can f-ck up everything if one has tabs and the other has spaces.

Might I introduce you to the wonderful language known as Nim? Python-like syntax, compiles to C, C++, and even JS, has mature libraries and good tooling, and some memory safety features built in! And yes, you can use pointers!

Or a complier that tells me when I mispell a variable in an assignment or use the wrong type for something.

also None is another annoying quirk

How is None a quirk?

The way it's written. Most programming languages call it null

That's pretty low bar for calling something a "quirk". The whole ML family, so OCaml, SML, Haskell, F# and perhaps a the new distant relative Rust call it also it None.

And it's not even the same thing: null means pointer to nothing, while None means no value.

Let me guess. Are the Java and Python programmers happy after because they leave up their technical debt for someone else to resolve? 🤭

that's why it's so addicting. lol

Y'all need Qt Creator: C++ for under the hood and Javascript for the UI. Virtually nonexistent base of coders who can do both competently and if you're not careful you end up moving to Finland because of it.

I worked a bit on the previous version of Neptune UI https://doc.qt.io/archives/neptune3ui/ wit QML and I worked mostly with integration of https://doc.qt.io/QtApplicationManager/ into different cars. But I stayed in Sweden for that.

I know Qt is cross-platform, but cars? Wow! I only ever used it for shitty Skype clones for Canadian ISPs.

Oh it's very popular in the automotive industry, especially for the in vehicle infotainment like navigation, radio, media playerand so on. They even offer a automotive specific version of it:
https://www.qt.io/industry/qt-in-automotive

Sadly most of the OEMs slowly move to Android.

It's the exposure to those languages that reassures Python developers that Python is superior.

Take nodejs for example. you write js on the backend, js on the front end and you're convinced that js is all you'll ever need.

Jesus Christ! No thanks! I can't imagine improperly placing cabinet knobs on closet doors like that

I already hate that style of door but the knobs make it even worse

Fun fact: the negative space in the pattern of the door is a cross. The 2 squares below it (out of frame) make an open Bible too.
Learned that on a field trip to a door factory where I nearly got left behind because I was looking at a very loud door cutting machine.

Is the archinstall script not working?

Idk, it was some image I found on Unix socks

Missing a fursuit or cat ears and a tail plug

Foxgirls are absolutely valid sorry for this erasure

I prefer cat ears and tail plug. Im not a furry, I'm a catgirl :3

(No problem with furrries tho)

Catgirls are cute and I will pet any who will allow

Pink Fedora logo is class

Lmao, bruh. How do people keep praising a language where messing up a space breaks everything and there is no real type system?

The whitespace doesn't bother me. Any IDE worth a damn will manage that for you. As for the type system, yeah, I strongly prefer static typing, but for simpler projects I can see the convenience of it.

My real issue with Python comes with managing a development environment when multiple developers are working on it. Dependency management in Python is a headache, and while in theory, virtual envs should help with synchronizing environments from machine to machine, I still find it endlessly fiddly with a bunch of things that can go wrong that are hard to diagnose.

Python is great for small scripts, proofs-of-concept, and such, but I wouldn't write anything more heavy-duty than that in it.

Yeah, working on python projects professionally is always a nightmare of configuring env variables and trying to get your system to perfectly match the reference dev system. I find Node.js projects to often be the simplest and most pain free to setup, but even compiled languages like C# and Java are often easier to get up and going than python.

You can totally write heavy duty things if you know what you're doing: use type hints, static checkers, tests, etc. It just takes a bit more effort and care.

But why would I use something that takes more effort and care?

I'm sure you're right and it's possible, but if I don't have to fix another python project at work I'll be in heaven.

Because "more effort and care" in Python is still *way* less of a pain in the ass than the minimum enforced boilerplate necessary in most other languages.

I mean, is it? I personally haven't found Python using much less boilerplate. It's possible, but you end up with something inflexible that's hard to maintain.

it's more effort and care compared to a throwaway script, not necessarily compared to other languages

Personally, my estimate doubles when we're asked to implement something in Python...

That's a proficiency matter. Python is the language I can get something done the fastest today, but 6 years ago that would be Java or even JS for me.

Eh, it's most definitely part of it, but the biggest time sink that I expect when working with Python is fixing the build system every two weeks on different devs' PCs. I do imagine, if you eventually find a solution that works on most PCs that this workload will go down, but we had a substantial Python part in my previous project and over the course of the 1½ years that we worked on it, it really felt like we were making negative progress. Near the end of it, I couldn't use PyCharm anymore, because I couldn't figure out for the life of me, how to make it recognize the dependencies again.

Nah it's also a language matter.
People complain about Rusts complexity, meanwhile I complain about everything else in other languages, and am faster than in *any* other language, not necessarily because writing code is faster, but because I am *able* to just focus on writing code. I cannot tell that about other languages, because e.g. the packaging system is bad, or configuring an environment, or debugging stuff which a strong type-system would have caught already. Also IDE experience I think is the one thing that keeps me away from dynamic languages. Rust analyzer is so much better than anything else I've tried, and it keeps getting better (e.g. recently it was added to show whether a trait is object safe or not, and why it is not).

Another thing that is often missed when comparing static with dynamic languages is just performance, python heavily relies on stuff written in a system language, as soon as a hot-loop is written in python, things get *bad*...

Any IDE worth a damn will manage that for you.

Yeah in like 10% of cases. I'm copying something from a pdf my prof gave. The only ones able fix spacing now are me and God

You, god, pretty much any Formatter and ide.
Black Formatter: "All leading tabs are converted to spaces, but tabs inside text are preserved."
Vscode has a command to convert between the two,
and non-leading tabs are a simple replace/regex away from being converted.
If you mean unorthodox spacing, if you have code with like 7 leading spaces, then that's a matter for a priest.

Haha: "A space breaks everything." Fuck YES! Are you kidding me‽ It's one of the best features!

Why? Because *it's so easy to see*. In other languages you've got semicolons which are surprisingly difficult to notice *when they're missing*. Depending on the situation (or if you're just new to programming) you could spend a great deal of time troubleshooting your code only to find out that you're missing a semicolon. It's frustrating and *it makes you feel stupid* which is never a good thing for people who are new programming.

Types are in a different category altogether with seemingly infinite reasons why you'd want a feature-rich, low-level type system and also why you'd want to *avoid* that.

IMHO, the *point* of Python is to be a simple language that's *quick to write* yet also very powerful and speedy when you need it to be (by taking advantage of modules written in C or better, Rust). If it had a complex type system I think it would significantly lower the value of the language. Just like how when I see an entire code repo using Pydantic and type hints everywhere it makes the code unnecessarily complex (just use type hints *where it matters* 🙄).

I'm not saying using type hints on everything is a terrible thing... I just think it makes the code harder to read which, IMHO defeats the point of using Python and adds a TON of complexity to the language.

The *promise* of type hints is that they'll enable the interpreter to significantly speed up certain things and reduce memory utilization *by orders of magnitude* at some point in the future. When that happens I'll definitely be reevaluating the situation but right now there doesn't seem to be much point.

For reference, I've been coding in Python for about 18 years now and I've only ever encountered a bug (in production) that would've been prevented by type hints *once*. It was a long time ago, before I knew better and didn't write unit tests.

These days when I'm working on code that requires type hints (by policy; not actual necessity) it feels like doing situps. Like, do I *really* need to add a string type hint to a function called, parse_log()? LOL!

I don't mean this insultingly because lots of programming jobs don't require this and for the ones that do we still tend to all start here, but in all honesty this sounds like it's coming from someone who's never worked on a large project maintained by multiple people over time.

First of all, the hysteria over semicolons is ridiculous when JavaScript, Typescript, C#, Java, Go, Swift, etc. etc. wil all automatically highlight missing semicolons, if not automatically insert them for you when paired with an IDE and standard linter. On top of that, JavaScript and Typescript do not require semicolons at all, but they are still used alongside braces, because they make your code more scannable, readable, and moveable.

Secondly, without type safety your code is no longer predictable or maintainable. If you're working to quickly sketch out some new fangled logic for a research paper it's one thing, if you need to write test code so that your codebase can be tested an infinite number of times by other coders and whatever CI/ CD pipelines to make sure that nothing's broken, then all of the sudden you start seeing the value in strict typing.

Honestly, complaining about type safety adding "extra code" is a complaint that almost every coder has when they start out, before you eventually realize that all that "extra code" isn't just boiler plate for no reason but is adding specificity, predictability, reusability, and maintainability to your code base.

When defining types looked like this it was one thing:

String name = new String("Charles Xavier");

But when it looks like this, there's no reason not to use strong typing:

const name = "Charles Xavier";

Anyone who thinks a strong type system is a drawback has never worked on any real project where you actually have to collaborate with others.

I started out with Visual Basic using the Variant type all the time, and even though I was usually just working on one-person projects it was a fucking disaster. You don't even have to collaborate to see the virtues of strong typing.

Yeah, the alternative to static typing is to write tons of unit tests, which definitely adds a lot more code to your codebase.

That's not an alternative, you always need tests

Right, so this is the part where I get to sound like a smart ass, because I snuck a "tons of" into there.

What you do always need, is tests serving as a specification of the intended behavior, to document it for your team members and your future self.
But the thing that static typing is an alternative to, is integration tests for many code paths. For example, in dynamic languages you have no reassurance that a call to your database library still works, unless you have an integration test which actually calls into the database. Similarly, you hardly know whether the many error-handling code paths are working, unless you write tests for those, too.
In static languages, we don't test this stuff outside of the specification-like integration tests, because the database library and the error handling library are already separately tested, and the type system ensures that we interface with them correctly.

without type safety your code is no longer predictable or maintainable

This sounds like someone who's never worked on a large Python project with multiple developers. I've been doing this for almost two decades and we *never* encounter bugs because of mismatched types.

For reference, the most common bugs we encounter are related to exception handling. Either the code captured the exception and didn't do the right thing (whatever that is) in specific situations or it *didn't* capture the exception *in the right place* so it bubbles up waaaaay too high up the chain and we end up with super annoying troubleshooting where it's difficult to reproduce or difficult to track down.

Also, testing is completely orthogonal to types.

This sounds like someone who's never worked on a large Python project with multiple developers. I've been doing this for almost two decades and we never encounter bugs because of mismatched types.

Have you worked on major projects in other languages in that time period to be able to compare and contrast?

The last two python projects I had to work on didn't have bugs because of type issues, but it was much harder to come into the codebase and understand what was going on given that you didn't have type information in many many places which forced you to go back and comb through the code instead.

So the code did have type hints, just not consistently. Sounds like bad code.

It’s kinda funny that Godot’s custom language GDScript is, at least on a surface level, pythonic (no list comprehensions, context managers, decorators, etc, it’s mostly syntactical similarities). But type hints do make it run faster!

I was blessed to get to skip most of the old pains in python. I only had a handful of scripts that ever needed to be ported from 2 and they didn’t rely on any libraries. The ecosystem is easy to work with and I’m looking forward to working with Python for the foreseeable future

What are you writing your code in? Windows notepad? How the fuck do you not see the semicolon missing?

because semicolons are tiny characters that oftenhave to be appended to the end of lines (precisely the worst place for them to be easily visible, since they'll blend in with the previous character)

whitespace meanwhile is very easy to notice that it's missing, as i'm sure you noticed when reading the above sentence.

In both cases, you press compile and the compiler goes "you missed a whitespace/semicolon HERE"

Exactly! I've wasted more time hunting missing semicolons in languages that use them, than wrong indentation in Python.

Not even the worst. This function declarations with separations between positional and enum variables... Or the infamous global...

I have never once, in nearly 20 years of using python, encountered IndentationError. Until today actually. I tried to make it happen because I couldn't remember the class name.

A statically typed Python would be my dream programming language.

Can someone please make Typethon?

Pyright language server makes Typethon out of your Python at the cost of massive bugs and performance. I used to like it, until I got really sick of waiting about 10 seconds for a suggestion to appear when typing open() and really fucking sick of the entire server crashing after I type pow()

Type checking for python is not bad these days, just run pyright (or mypy, I would like to prefer the non MS solution, but we have found pyright much more rigorous) on your code. Yes obviously you can still get out of it with an ignore statement, and that might occasionally be necessary for some libraries, but if you enforce no errors in pre-commit or CI then it's only a little worse than compile time.

because it's easy to use. I don't like strangling my code because it's screaming about semicolons again

To me it's as natural as using periods

where messing up a space breaks everything

Messing up some character breaks everything in any language, skill issue

there is no real type system

What does "real" mean? It's pretty robust these days.

Yes, I love rust and use it regularly, but it is suitable for totally different use cases than python. Have you worked on a python project using strict type checking enforced in CI? It really isn't so bad.

I haven't, but everytime I try python I want to quit it so quickly because of the messed up packaging system and more importantly IDE experience (and I don't think unless you are extremely disciplined with type annotations, that you're getting even close to rust-analyzers performance). I enjoy just exploring dependencies with go to definition, and the trust I can have in the type system.

I'm swearing everyday in my job about typescript, which is just javascript with leaky and unnecessary complex type annotations. So yeah I even consider typescript bad (and I doubt that python is better with type-checking).

You can't see the C one because it went by too quickly.

Rust is a scrappy pimply kid vs a US Marine (still with pimples).

Ada is just two redacted pictures

I have worked with TypeScript for about 6 years now, professionally, and I really enjoy it. It's got all the nice things from JavaScript, obviously, and almost eliminates all the bad stuff/uncertainties from JavaScript. That's my opinion. I feel very confident working with TS.

Every time I use python it makes me want to throw my computer through my window. Doesn't happen with other languages. Pip fucking sucks it seems like every time I want to install dependencies for a project there is one that throws a compilation error when installing it. Like, why does it not try to download the version of the package that works with my version of python?? It doesn't even tell me why it failed!!!

i still do not fathom what on earth you people are doing to get these issues.
The worst annoyances i've had with python is just running the correct commands to install stuff, which is no different from working with git.

Yeah that's annoying but it's a short-term problem. Python *just recently* cleaned up some long-standing issues that broke backwards compatibility *in packaging* (for certain things). Most public modules that broke made *trivial changes* to fix the problems (once they learned about them) and life went on.

However, *for some fucking reason* a whole bunch of dependencies related to AI are dragging their feet and taking *forever* to fix their shit. Insisting that everyone "just use Python 3.10" and it drives me nuts too.

This problem started to become a real thing almost *two years ago* (so they had plenty of warning and time to fix things) and yet here we are with still a handful of *core dependencies* that won't install for things like Stable Diffusion, Flux, and various LLM stuff because they're dragging their feet.

I blame *corporate culture*: Enterprises *hate* upgrading their shit and they're as slow as glaciers sometimes. There's probably tooling at Nvidia, for example, that needs a ton of work for Torch to work with new versions of Python and since all their documentation *already* was written for running on Python 3.10 (and Ubuntu 22.04 LTS) they've *created* a lot of work for themselves.

*Any day now* they'll finally finish fixing all these little dependencies and then we'll have another two years of ease before the problem rises again with Python 3.14 and it's massive GIL-free improvements that require big changes in code to actually take advantage of them.

Yup. The fact that the "proper" method to develop is to work in a sandboxed environment tells me everything I need to know. I feel like the only thing you learn from python is how to fight python instead of anything about programming. Personally, I think we need to stop recommending it as a first language.

So... The proper way is... Global installs? What are you saying here?

Just use poetry or something, install the environment in your project directory and you're done. The versions of your dependencies are fixed, so are consistent across installs, and because it's sandbox you aren't polluting your system, and vice versa.

And if you're using a language that installs the dependencies localy, guess what? That's what you're already doing, only with less security.

There's another one?! What's wrong with venv, pipenv, virtualenv, flit, conda, etc. I just want to write code, not fight with silly tools. It's a scripting language after all.

a) poetry came out 6 years ago, though UV is the new kid on the block, it's easier to complain about that if you want to.

b) so, you are fighting with silly tools, but don't want newer, hopefully better tools? If you aren't fighting with silly tools, then more options is bad? I guess it's a bit confusing for beginners?

c) how are you fighting with the tools? This is a genuine question, I don't remember the last time that the tooling caused a problem and I've been working professionally with python for the last 5 years, on both small and larger projects, first I used conda, and in the last few years poetry. In poetry, it's two commands to create a new environment, and install everything. The only time I had a problem was with an internal library that had misconfigured dependencies.

d) here's the rundown on the dependency tools:

  • Virtualenv is one of the oldest, from the python 2 times
  • venv is just a subset of Virtualenv that was integrated into the standard library to have venvs available without external tools
  • conda is not python specific, it also does R, Ruby, some DB stuff, etc... It tries for maximum compatibility with various systems. This is apparently very useful in bioinformatics which use very disparate tools.
  • Pipenv is an attempt to implement ruby-like dependencies. I don't know much about it, it's not used much.
  • flit is lightweight, for publishing packages *only*
    -poetry is what I am currently using. Simple toml based dependencies. Installs the packages wherever your want. Since it uses toml, it's compatible with other tools like dependi to check for updates. It's got a pretty good set of commands that you don't need to remember because init and update is what you need 90% of the time. Can also publish packages, and has separate dev/prod dependency groups.
  • uv is the new one, written in rust (of course) and very fast. Also installs python versions, meaning you no longer need a separate tool/docker images to manage your python versions. No multiple dependency groups yet. Aiming to become the only tool you need to do anything in python. Still

I mean, every one if these has a reason for existing, and is an improvement of the previous one (pdm started as a personal project, let people have their fun) . It's also a good few years between them, so it's not like they're spamming them.

My bad. I personally can't stand Python, and am just a python hater. If I used python professionally as a general purpose language, I would probably want all the tools. Though.. I never needed a virtual environment in another language.

In the codebases I work in, python is occasionally used as a cross-platform scripting language, which is where its bread and butter should be. Never more than 200 lines. Every time I crack open a codebase, if there is any python, it doesn't work. That will be the thing I have to fight before I get to work on the real problem. If it has been a year, it's broken. If it's a Linux project, you're better off using Bash if you want it to run a year from now. On Windows, well..

I can't speak for others, but the python3 transition wiped the smile off my face for awhile there.

Why? The most annoying thing that I remember about it was popular modules that hadn't been ported yet. In essence, a temporary problem; growing pains.

The Unicode/string/bytes changes were welcome (to me). But that might just be because I had actually *encountered* situations where I had to deal with seemingly endless complexity and *ambiguity* related to Unicode stuff and encodings. Python 3 made everything much more logical 🤷

looking at python2 code these days is very uncanny, just the fact that print is a magical keyword is so *wrong*: what is this? bash?

yep, that's how major version changes do be working. if they didn't decide to implement breaking changes to improve the language people would have been complaining about how terrible python2 is to use

If Python has no haters I'm dead.

I fucking hate python. Fuck your stupid tabs/spaces bullshit.

And fuck your versioning system. And you dependency management. And tooling. Why are there like five different projects trying to lock down the python environment? Conda? Venv?

Even Ubuntu tries to lock down python so that it doesn't brick the install due to dependency conflicts.

Java is in a completely different leagues to the rest of these.

Whatever you think Java sucks at, the other languages mentioned here suffer from much worse.

A language is only as enjoyable as the hellish legacy projects that you'll actually spend your time maintaining.

That’s why the Java programmer looks happier in the “after” pic. Not as much as Python but it’s still there.

The jpeg is strong, but if you look closely she is covered with scabs and sores.

Does Java have an elegant way of compiling to native machine code now? Genuinely asking.

Not java itself, but GraalVM can do this https://www.graalvm.org/latest/reference-manual/native-image/

I can't confidently tell you it's production ready as I have never used it myself.

I’d rather use a language that doesn’t treat me like an incompetent child, removing unsigned ints because “they’re a source of bugs”.

Python managed to turn me away before I wrote a single line of code.

Running an already functional project took me nearly two hours and three separate tutorials.

What's so difficult?

import project as p

p.run()

Hmm, I follow the package's readme and only get invalid command errors.

Gotta install the pip dependencies.

Oh but first you need to create a venv or everything will be global. Why isn't that local by default like with npm? Hell if I know!

Ah but before that I need to install the RIGHT version of Python. The one I already have likely won't do. And that takes AGES.

Oh but even then still just tells me the command is invalid. Ah, great, I live CLIs. Now I've gotta figure out PATH variables again and add python there. Also pip maybe?

Now I can follow the readme's instructions! Assuming I remember to manually open the venv first.

But it only gives me errors about missing pieces. Ugh. But I thought I installed the pip dependencies!

Oh, but turns out there's something about a text file full of another different set of dependencies that I need to explicitly mention via CLI or they won't be installed. And the readme didn't mention that, because that's apparently "obvious". No it's not; I'm just a front-end developer trying to run the darn thing.

Okay. Now it runs. Finally. But there's a weird error. There might be something wrong with my .env file. Maybe if I add a print statement to debug... Why isn't it showing up?

Oooh, I need to fully rebuild if I want it to show up, and the hot reload functionality that you can pass a command line argument for doesn't work... Cool cool cool cool.

yeah, all that setup sucks even after being writing python for years.

Nowadays I've been running every project with uv and it's a much better and faster experience, usually in 3 steps: 1. initialize, 2. add dependencies, 3. run project:


# if the project doesn't already have a pyproject.toml with dependencies, initialize it
# uv will also install the right interpreter if not present:
uv init --python 3.13

# anything you would install with pip, use uv add:
uv add dep1 dep2

# run the project / script
uv run main.py

Then in future runs (as long as you have the pyproject.toml), you can just do uv run main.py (shorthand to uv run python main.py), even when there's no venv created. No more activating virtual envs. No more long interpreter installations. No more accidentally messing with system's packages or the PATH variable. With the uv.lock that's also a lot more reliable to reproduce than requirements.txt and similar.

Yeah package system is a nightmare in python I'm so spoiled if Rust that I find it hard to enjoy another language...

This does not reflect my experience with python at all. Except the version thing used to be a thing. Not really any more.

This has way more to do with that specific project being poorly written/not documenting things well than any shortcomings in Python

Is that not just the post?

I think they jpeg'ed it up.

Thanks, went over my head. I was thinking they had maybe thought they were on mastodon or something and tried to repost it and were actually on Lemmy.

Is there a term they use for that? Like people used to say retweet... Do they remasta it?

Im not on mastodon too much but i think they call a tweet a toot and a retweet a retoot

I think the official therm is to boost a post.

The JavaScript boy became a sexy mysterious wizard.

Checks out.

Python with ESModules would be neat.

Every time I type if typing.TYPE_CHECKING a part of me dies inside

I dont mind Python, in fact I kind of like it. Its easy enough, works fast enough and has a huge community backing. Open up notepad and start typing. The space thing is kinda stupid. I prefer braces and semicolons but apparently new programmers cant remember to use them so Python just got rid of them.. not my thing but whatever, I can live with it.

However, I'd never really want to create a large project in it. The dev tools arent there, .net style project management isnt there. I can see how it just becomes a mess if you try to make something that isnt just downloading some data, parsing and importing to somewhere else. Its great for simple stuff. It can do larger stuff - though not as good. It cant do enterprise, performance heavy, commercial stuff.

Pick the right tool. Yeah you can make a website in x86 ASM and you can make embeded systems for the space shuttle in Python. The question is why.

It cant do enterprise, performance heavy, commercial stuff.

It can, I've been doing it for almost a decade. I've never noticed a lack of dev tools, and I'm not sure why .NET style project management is a prerequisite for creating enterprise applications. Obviously you *can* write more performant code in other languages, but I've found that 90% of the time, python's performance is good enough.

Agree on picking the right tool for the job though. Most of the time though, unless you're dealing with an extreme edge case (like writing embedded firmware for the space shuttle), that just means picking the language your team is most comfortable with.

Why does JavaScript before-guy look like Alan Kay? 🤔

Coding space characters?
Fuck no