fair enough. My personal opinion might be that it’s evil, but perhaps that’s because I expected some kind of order.

The best advice was gratuitous.

good looking out.

Make a script. I’d use xonsh or python with sh.py.

• create a dict for remote to local filename map
• walk your local collection
  • for each file, determine what the correct remote name (including a valid extension) would be, and add the pair to the dict, with remote filenames as keys, local filenames as values
• make a set like local_munged_names from that dict’s keys
• walk your remote tree, and store the filenames in a set like remote_names
• names_to_upload = local_munged_names - remote_names
• for each name in names to upload, look up the local filename from the remote to local filename map. Then, encode it if it needs encoding, and upload.

Yes, because

In the first kind of language, the thought process is basically: I have the flow of execution, starting at the top of the file. If I want to make a library, I should build the things I want to build, then get out of the way.

Note the “I have the flow of execution”, and the “if I want to build a library”.

If you just want to build an executable, do as you wish, you already have the flow of execution.

If you want to build a library, make the relevant classes and functions and get out of the way (i.e., no IO, no long-running tasks).

If you want to combine them, use the main name check - or, make a package and do entry points that way. Either way works, because both can fulfill the goal of staying out of the way of those importing this as a library.

indeed.

It simply swaps some things around to make things more confusing, then goes into an infinite loop (whether or not you import or execute it standalone). it’s no different than just including in the global scope:

while True:
    pass

I was kinda lazy with the fuckery, tbh. I could have gotten much more confusing, but don’t have too much time today. :-)

came here to see if Fedora had a --download-only equivalent.

yes.

I always use

if "__main__" == main:
    __main__()

…and earlier in the code:

def __main__():
    while True:
        pass
main = "__main__"

This helps to prevent people from arbitrarily running my code as a library or executable when I don’t went them to.

All code needs to have an entry point.

For Python and some other languages, this is the start of the file.

For other languages, this is a special function name reserved for this purpose - generally, “main”.

In the first kind of language, the thought process is basically: I have the flow of execution, starting at the top of the file. If I want to make a library, I should build the things I want to build, then get out of the way.

In the other kind of language, the thought process is basically: I am building a library. If I want to make an executable, I should create an entry point they the execution starts at.

The debate is honestly pretty dumb.

Due to the oneness of all things, I refuse to distinguish between library code and executable code. One and Zero are arbitrary limitations.

Yeah, this is it.

What’s hacky about an introspective language providing environment to all of the executing code, so that the coder can make the decision about what to do?

It would by hacky if Python decided “We’ll arbitrarily take functions named “main” and execute them for you, even though we already started execution at the top of the file.”

For C, this is less so. The body of the file isn’t being executed, it’s being read and compiled. Without a function to act as a starting point, it doesn’t get executed.

isn’t that just normal usage? …or, did I just whoosh and you were sarcastically saying that?

I came here for this. with 200 dvds, you put the ripping system somewhere you pass by often. pop one out and pop one in whenever you happen to walk by.

you can rip all features - though that may not include the menus.

You really might want to consider using this:

https://github.com/automatic-ripping-machine/automatic-ripping-machine

nah, it’s more fun this way.

The alignment of the language and the alignment of the coder must be similar on at least one metric, or the coder suffers a penalty to develop for each degree of difference from the language’s alignment. This is penalty stacks for each phase of the project.

So, let’s say that the developer is a lawful good Rust zealot Paladin, but she’s developing in Python, a language she’s moderately familiar with. Since Python is neutral/good, she suffers a -1 penalty for the first phase, -2 for the second, -3 for the third, etc. This is because Rust (the Paladin’s native language) is lawful, and Python is neutral (one degree of difference from lawful), so she operates at a slight disadvantage. However, they are both “good”, so there’s no further penalty.

The same penalty would occur if using C, which is lawful neutral - but the axis of order and chaos matches, and there is one degree of difference on the axis of good and evil.

However, if that same developer were to code in Javascript (chaotic neutral), it would be at a -3 (-6, -9…) disadvantage, due to 2 and 1 degree of difference in alignment, respectively.

Malbolge (chaotic evil), however, would be a -4 (-8, -12) plus an inherent -2 for poor toolchain availability.

…hope this helps. have fun out there!

deleted by creator

yes. and you can just use any distro that has gparted, like >!Ubuntu!< or similar.