Venezuelan here. It’s not that simple: Maduro was an _absolutely_ horrible dictator and yes many Venezuelans (myself included, and likely many of the 8+ million that left) are overjoyed with him being ousted, we haven’t seen any change in over two decades. And yet, it is transparently clear that the Trump admin is here not to save Venezuela, or Venezuelans… it’s here to line its pockets and that of its shareholders.

There was a very evident omission during Trump’s press conference: Any mention of Edmundo Gonzalez Urrutia, the duly elected president-elect of Venezuela (who won with a super majority last July - backed by Maria Corina Machado). Instead, Trump bad mouthed Maria Corina saying that “she does not have the support or respect of the country to run it”. They ousted Maduro, but they kept his VP (Delcy Rodriguez - which along other things is in charge of running the torture centers for political prisoners) as “she will do anything we ask her”. Trump doesn’t care about democracy or regime change - these things take time and are a long, thorny road (this wouldn’t be the US’ first rodeo). Instead they’ve chosen to keep the regime obedient with the threat of force, and instead just come in and extract as many riches as humanly possible…

Dark times ahead for Venezuela and the Venezuelan people

Really wanted to like Dlang but I just did not have a good time with it.

One of my projects has a really simple server written in nodejs that's basically (in terms of complexity) just an auth'd chatroom, and I wanted to switch it from using raw tcp sockets to websockets. And since the server is so simple, why not refactor it to another language and see if there's no some performance gains from that? I ended up doing something pretty similar to that "Comparing 10 programming languages. I built the same app in all of them." video from Tom Delalande (https://www.youtube.com/watch?v=-MbTj8DGOP0). I had several working versions of the server in:

- Bun, using Bun APIs (https://bun.sh/docs/api/websockets)

- Dart, using Dart APIs (https://api.dart.dev/stable/latest/dart-io/WebSocket-class.h...)

- Java, using Java-WebSocket (https://github.com/TooTallNate/Java-WebSocket)

- Kotlin, using Ktor (https://start.ktor.io/p/ktor-websockets)

- Rust, using tokio-tungstenite (https://docs.rs/tokio-tungstenite/latest/tokio_tungstenite/i...)

- Zig, using websocket.zig (https://zigistry.dev/packages/karlseguin/websocket.zig/)

- D, using serverino (https://code.dlang.org/packages/serverino)

And Dlang was, by far, the worst experience out of the lot. Firstly is the lack of adequate, comprehensive, and centralised tooling. I almost gave up when dmd could not even compile a freshly init'd project. The impression I got is that you're not really meant to use dmd directly, you're meant to use dub, like how you compile Java projects with Maven/Gradle, not javac. Except that there's also apparently three competing compilers (https://wiki.dlang.org/Compilers)? And good luck remembering the names of the tooling because they're all some random three-letter combination.

Serverino makes heavy use of mixins and attributes (think Java annotations), which is not ideal. But what really killed the deal was (despite using the recommended intellij plugin (https://wiki.dlang.org/IDEs) with the recommended tools installed and setup) not being able to inspect[1] serverino's mixin or its attributes. So I look at serverino's source code, except its source also has mixins... which I can't inspect. I'm not going to use something when I cannot easily ascertain its control flow. And while, yes, I probably should have gone with vibe-d (https://code.dlang.org/packages/vibe-d%3Ahttp) in the first place, mixins and attributes are nonetheless part of the language and the tooling should be able to tell me about them.

- [1] When I say "inspect" I mean requesting the IDE to show me the source/definition so I can see what it is, what it does, and where it's known to be used.

Empty slots in arrays are weird.

    >>> let xs = [,'foo']
    <<< undefined
    >>> xs
    <<< Array [ <1 empty slot>, "foo" ]
    >>> xs.map((x, index) => index)
    <<< Array [ <1 empty slot>, 1 ]
    >>> for (let x of xs) console.log(x);
    undefined
    foo
    <<< undefined
    >>> for (let x in xs) console.log(x);
    1
    <<< undefined
    >>> xs.length
    <<< 2 
    >>> delete xs[1]
    <<< true
    >>> xs.length
    <<< 2
    >>> xs
    <<< Array [ <2 empty slots> ]

Empty slots are skipped in map() and for-in, but not in for-of and the new array from map() will have the same empty slots. delete will change a slot to empty, it won't change the length of the array.

Still, much saner than PHP arrays.

The next law I want passed:

The "Cars can't require a network connection" law: Any external network connection must be disclosed to the user. The car must come with instructions how to disable it, (which must be a user serviceable physical hardware switch, fuse, jumper, etc). All functions of the car must remain permanently operable with no nagging of the user to reconnect, other than an optional initial prompt to inform the user of the change. 0 repercussions may be brought on the user for disabling the network connection, such as 'we can't diagnose/fix your steering because it can't connect to the network' or 'we can't update your infotainment system with your network connection disabled', as those updates could easily be done via the OBDII port.

Hell while we're at it, pass this same thing for robot vacuums, garage door openers, and 1000 other "smart" devices.