Nothing makes you hate cars more than living on a busy street, forced to listen to their din day in and day out. >:(

Cities Aren't Loud: Cars Are Loud — Not Just Bikes

Urban noise is a common problem, and the vast majority of it is created by motor vehicles. Noise is far too often dismissed as a minor nuisance, rather than the legitimate health issue that it is.

The book "Curbing Traffic" has a chapter about the health impacts of noise pollution. I explore the research in the book, and visit Delft, the city that is highlighted in the book as being a shining example of what can happen when noise pollution is taken seriously.

This video explores the problem that farting cars, farting motorcycles, and farting mopeds create in our cities.

#FuckCars #urbanism

From here:

There is no 'free' market, and there never has been. The 'free' market is predicated on the belief that all players will act honestly, and make informed choices based on available information. This is a completely false assumption, and has been proven so time after time.

It completely ignores human nature whereby someone will always lie, cheat, and steal to achieve their own ends -- this is what we see here.

Industry players will always form cartels and collude in anti-consumer behavior -- price fixing being the prime example.

Without someone to keep corporations in line, the market would steadily skew to all of the power being in the hands of a few.

There is no such thing as a 'free' market, and there simply never has been. It's a utopian myth which can never be true.

People who go around spouting about the 'free' market are either naive, self deluded, or actively lying.

#capitalism

Bouncy Castle is Australian in origin and therefore American restrictions on the export of cryptography from the United States do not apply to it.

owo

#Java #programming

The #Python standard library sure is something. :P #programming

(This is in the types module.)

try:
    raise TypeError
except TypeError as exc:
    TracebackType = type(exc.__traceback__)
    FrameType = type(exc.__traceback__.tb_frame)

Modern shell #scripting is weird. :P #programming #bash #linux

#!/usr/bin/env bash

function parse_options () {
    declare -n result="$1"
    shift 1
    result['verbosity']='4'
    result['memory']='24G'
    result['volumes']=''
    result['device']='/dev/st0'
    result['write-rate']='250M'

    local opt
    local OPTARG
    while getopts 'vm:n:i:' opt
    do
        case $opt in
            v)
                result['verbosity']=6
                ;;
            m)
                result['memory']="$OPTARG"
                ;;
            n)
                result['volumes']="$OPTARG"
                ;;
            i)
                result['device']="$OPTARG"
                ;;
            r)
                result['write-rate']="$OPTARG"
                ;;
        esac
    done

    if [[ -z "${result['volumes']}" ]]; then
        echo "-i VOLUMES is required"
        exit 1
    fi
    return 0
}


declare -A CONFIG
parse_options CONFIG "$@" || exit 1

exec mbuffer \
    -v "${CONFIG['verbosity']}" \
    -m "${CONFIG['memory']}" \
    -n "${CONFIG['volumes']}" \
    -p 30 \
    -s 65536 \
    -A 'sh /usr/local/bin/tape_wait.sh' \
    -f \
    -R "${CONFIG['write-rate']}" \
    -i "${CONFIG['device']}"

Doesn't using an #LLM to create large portions of your codebase mean that you end up with a lot of code that nobody understands unless they put in the time to go through it and learn what it's doing? If so, it's not much different from writing the code from scratch in the long one. :/

(Yes, I know about boilerplate and do think that's a valid use case as long as you know what the boilerplate is doing.)

#AI #programming

Any #Kotlin lovers here? :3c

#Java #JVM #programming

Had quite the time working on a personal project recently. It changed my life forever.

• Learned the hard way that the (default on most POSIX) fork context is bad news.
• Wrote a Unix domain datagram based log infrastructure.
• Wrote an algorithm that operates kind of like concurrent.futures.as_completed(), except it has a priority queue and doesn't eagerly load the list of futures.
• Discovered that it's possible to overload concurrent.futures.ProcessPoolExecutor with futures, preventing any actual background processing after a point.
• Got TONS of practice optimizing stuff for large datasets.
• Learned that taking breaks is important for reasons than most people are aware of.
• My life was permanently altered by this project. I basically nerd-sniped myself.

#Python #programming

Doughnut Lollipop 【記録係】:blobfoxgooglymlem:

2024-09-23 03:21:07

Never, ever, use the fork context in multiprocessing. POSIX OSes (aside from macOS) have that as the default. Always use the spawn context!

Of course, unless you have an extreme edge case. (Yes, the names are funny. )

#Python #multiprocessing

multiprocessing — Process-based parallelism

Source code: Lib/multiprocessing/ Availability: not Emscripten, not WASI. This module does not work or is not available on WebAssembly platforms wasm32-emscripten and wasm32-wasi. See WebAssembly p...

^{Python documentation}

PEP 703 – Making the Global Interpreter Lock Optional in CPython

CPython’s global interpreter lock (“GIL”) prevents multiple threads from executing Python code at the same time. The GIL is an obstacle to using multi-core CPUs from Python efficiently. This PEP proposes adding a build configuration (--disable-gil) to CPython to let it run Python code without the global interpreter lock and with the necessary changes needed to make the interpreter thread-safe.

#python #programming #gil

@contextmanager
def func(…):
    resource = …
    try:
        yield resource
    finally:
        …