This isn’t about some feature of the language being good or bad. It’s about Rust being ugly or not. The things I mentioned will always look ugly in the source code.

Enums and nested blocks. I understand the importance of Option and Result, but it’s fucking infuriating when I have to check and destructure the result of every function call and either bubble the result up the stack from six levels of nested if let blocks or risk Cloudflaring my program by using .unwrap(). And while I like being able to extract a return value from an if...else expression, the structure gets really convoluted when multiple if and match blocks are nested (of course each one returning a value), and it gets completely fucked once closures are introduced.

I like Rust, but calling it pretty is delusional.

That’s a poython constructah, __init__?

If this is as significant an issue as you imply, please link some credible sources.

As far as I can tell, the “Chinese server” (or EU server) is just a public ID and Relay server, and necessary for the application to function unless a self-hosted server is used.

Put all of the postcodes in a paginated list that displays only 30 entries at a time (60 and 100 per page for premium users), only has next/previous navigation buttons, orders the entries by popularity, and goes back to the first page if you reload the website. Or an infinitely scrolling page that loads each page dynamically, but returns 429 Too Many Requests if the user scrolls too fast.

I was pointing out a part of the documentation that you may have overlooked. In good faith, I might add, because the documentation is comprehensive but horribly signposted. Everything I wrote in my first comment is there, but in a less human, more technical phrasing.

https://docs.python.org/3/tutorial/modules.html#packages

The __init__.py files are required to make Python treat directories containing the file as packages (unless using a namespace package, a relatively advanced feature). This prevents directories with a common name, such as string, from unintentionally hiding valid modules that occur later on the module search path. In the simplest case, __init__.py can just be an empty file, but it can also execute initialization code for the package or set the __all__ variable, described later.

Quick template: https://files.catbox.moe/g5tcy5.tar

Also, don’t delete this post. Others might need this information too.

If you have to import a directory structure, you should make each directory a module by creating an __init__.py file in them, and use relative import statements. I usually have one main.py as the entry point, which imports a lib module that contains all of the program logic.

├── lib
│   ├── __init__.py
│   ├── module_content.py
│   └── submodule
│       ├── __init__.py
│       └── submodule_content.py
└── main.py

You can import the lib directory as a module:

main.py:

from lib import some_fn

Within any module, though, you should use relative import statements to import from files and submodules, and regular import statements to import packages from the system or the venv:

lib/__init__.py:

from .module_content import some_fn # import from a file
from .submodule import some_other_fn # import from a submodule directory
from os.path import join # import from an installed package

Items that you define in __init__.py or import into it will be available to import from the module: from .submodule import some_fn. Otherwise, you can import an item from a file by specifying the full path: from .submodule.submodule_content import some_fn.

You can also import an item from a parent package using the .. prefix: from ..some_other_submodule import some_fn.

I think you can get some kind of exemption for archival purposes. I know that the Internet Archive has one. But I also know that ultimately Microsoft is responsible for the data hosted on Github, and Microsoft’s interest is to not even risk getting sued.

It’s turtles GCC all the way down.

The best way to avoid a single point of failure is to create multiple parallel single points of failure, right?

A while ago, I wanted to try Home Assistant. Then I realised that I didn’t have a single thing to use it with. The locks are mechanical, the lights are simple LEDs, the irrigation system is manual, my car has push buttons, and I live in a safe enough area (by European standards) to not need doorbell or security cameras. Nothing I own depends on any external services other than the electric transformer down the street.

Never a better time to be a modern Luddite.

All you had to do was google “thinkpad” and pick out a stock photo.

Thus do we invoke the Machine God.

Because it’s a competently-made, new distribution with interesting features. Not everything you don’t understand is a fucking conspiracy.

Jazz 2.0 just dropped

I wonder if anyone’s tried to play Bad Apple! on the branch graph.

(edit) Not exactly, but close. https://www.youtube.com/watch?v=-I8Jis87nmE

Use the guitar controller to branch, commit, and merge to the beat of Through The Fire And Flames and try to get a conflict-free repo.