Zoom free tier calls end after 40 minutes.

Idea: pwyw conference software where the call ends after 40 minutes if the host isn't paying €5 more monthly than everyone else in the call. There is no way to discover whether this is a limited call until the 40 minute mark, and there's no way to discover who outbid the host at all except by getting everyone to show their bank statement.

My department head is shitposting in the company slack on the middle day of a 3 day weekend. I guess it doesn't really count as encouraging overtime because it's not work-related, but come on, does he really have nothing better to do?

What's the message passing IPC with the least RTT for messages that are in the 16-32 byte range? It's gonna run approximately once per command in an interpreter.

My new favourite RUNTIME c# error, evidently thrown by the standard library because the string is not present in the project:

"no parameterless constructor defined for this object"

group policy prevents me from installing browser plugins at work. For crying out loud, I'm a dev! Any set of permissions that enables me to do my job would include an escape hatch for this! I can just rebuild Firefox without group policy support! What the fuck is this meant to achieve besides waste company resources!?

I made a very obvious realization since the last time I rewrote Orchid; the 3 year project that has now become an eloquent documentation of my learning process; Types aren't free. Sure they're free at runtime, in fact the more you have the less the language has to work to separate values, but they generate significant cognitive load.

Oftentimes it's better to have one enum with 12 variants 3 of which are specific to a narrow case to be able to define operations for this enum once, than it is to have 3 distinct enums of 10, 11 and 8 variants respectively, and to have to define common operations (or the dispatch part anyway) thrice.

As for my previous observations about catchall abort acting like the new type abort, I still think that, and I still think that this is only justifiable if the number of invalid variants is low enough in every case that you can list all of them before the abort.

some of the smartest people I know are about to fail a CS bachelor's

what the absolute fuck is up with Hungarian higher education

I know it's pedantry but I flinch whenever I read "please RSVP"

I specifically asked my employer when fix time is, whether I get a work laptop, and whether WFH is optional, because

- I'm a night owl and don't function until 10am
- my personal laptop is slow as shit and I don't want to put Windows on it
- I don't have a decent chair at home yet

- client team agreed on fix time starting an hour before what's in my contract, and PM made it clear that they expect to be able to call us an hour before and two hours after (that's what fix time means unless I misunderstand)
- I got a crap backup laptop after a week of moaning, with promise of a better one two weeks from now
- I won't get an RFID card for weeks, so I effectively can't enter or leave the client offices

I've been trying to define a trait `Inherits<T>`, a trait `Extends{ type Parent }` and an arbitrary amount of scaffolding around it such that

- the scaffolding for a given type only has to acknowledge that type, its parent and the types of which it is a parent
- `T: Inherits<U>` if a chain of `Extends` leads from `T` to `U`

I suspect that this is impossible, but I'd seen Rust traits bent to do crazier things, so if you know of such a system or can come up with a way to implement it despite the orphan rules, I'd be over the moon.

My bandwidth is ordinarily a few hundred kbps, but whenever I torrent it can reach up to 2 mbps, while all other traffic from me and my housemates is stuck in the single digit kbps range.

What does BitTorrent do so fucking well, and how can other protocols replicate this success? Would the total available bandwidth be different if every protocol did whatever enables BitTorrent to summon bandwidth from thin air?

I'm looking for a licence

I'd like to publish open-source projects with a licence to the extent of "free without restrictions for noncommercial use forever, contact me for anything else", the idea being that if you intend to make a profit you should care enough to email the authors of complicated things your business relies on and agree on a fee or share of profits.

I'm unsure how to handle pull requests. Asking for right to relicence the patch could be an option.

do you know a licence with similar ideas?

So apparently I'd been hired 2 emails ago, only because the email said "I've been told that you're starting with us in April" and not "you're hired" I didn't realize it. Extremely neurotypical behaviour.

Diesel is an incredibly beautiful ORM, but the size of the DSL means that despite Rust's state-of-the-art IDE integration I'm back to editing code, waiting for it to compile (as soon as I stop typing) and changing random shit if there are red squiggles.

The error messages are totally unreadable, all in-code references point me to meaninglessly generic abstractions, and a good portion of the impls are generated by macros so I can't even look at an actual final definition.

The confidence that if it compiles it'll run is stil there, but nothing else.

I love the Rust community but this can't seriously be part of an example as in expected usercode for Yew.

A production build of the hello world example for Blazor takes 5 seconds to launch. Half-baked, rickety sad excuse of a technology built in a crunch and never rebuilt correctly.

The simple yet surprising reason why it's so fucking slow is that Microsoft couldn't figure out a way to compile C# to webassembly while also beating others to market so they compiled the runtime to webassembly instead. The Fucking IL interpreter.

Every tool in the JS ecosystem goes out of its way to support faulty or outdated variants of every interface, yet nothing is actually forgiving or fault tolerant. Publishing packages is exactly as agonizing as consuming them, even though both sides have tens of switches and probably hundreds of automatic heuristics to align themselves to any hypothetical setup on the opposite end.

A datagram connection supported by all major browsers

https://developer.mozilla.org/en-US...

I'm still not over how LINQ is defined as a thin wrapper over both IQueryable (which can be efficiently queried) and IEnumerable (which can only be iterated), but IQueryable extends IEnumerable, so if you execute one unserializable operation anywhere in a query issued to your database it'll merrily pump whatever temporary collection happens to reside on the boundary through the C# program to execute that call on each row and process the rest as an IEnumerable.

For the past 5 odd years my Bluetooth headphones wouldn't connect to my laptop properly and I had to issue a second Connect command while the first was pending to get it working. I even wrote a script to automate this: https://github.com/lbfalvy/...

Today Bluez finally released a patch for this. That's right, after many years, today the issue got fixed; Connect now returns an error if a call is already pending.

My headphones still don't work, but my workaround is now correctly recognized as invalid input.

ITS PUBLIC OKAY

You know that experience when you update a modern desktop app that uses a zillion abstraction layers and the first time you do anything it freezes for a little bit while the heavily deferred metaprogramming and asset transformations are executed and cached?

I always imagine polystyrene balls flying all over the place.

Thanks, that smiley is direly needed to cope with the bizarre language that is the ABI stable subset of Rust.

Okay, my initial revulsion for ABI has receded. All things considered, my options aren't that bad. I just had to change my perspective from "huge downgrade from static linkage" to "huge upgrade from a message channel".

Just like a web API, I have to draw a continuous line through the program that separates specific concerns of interest that must fall on one side or another, and which can only cross through things with specific properties.

There are several crates shipping a number of different binary-compatible types, even generic types. Not everything can cross, sure, but maybe not everything should cross either. Maybe a DLL should receive an opaque handle for certain things, such as interpreter internal code representations. Maybe having these separated is important enough to justify having a translation layer.

I'm sure there's much woe ahead, but I'm learning to stop worrying and love the ABI.

I keep forgetting what a massive pain in the ass it is to use dynamic libraries in anything other than C. I'm genuinely contemplating defining a serialization-based API and talking to plugins with a blob->blob function pair.

OrchidLS milestone: syntax highlighting partially works, and the server no longer deadlocks, crash-loops, or forks itself to hell if you don't stop typing and wait for it to catch up, so from this point onwards its impact on DX is a net positive.

Now to figure out how to publish a VSCode extension.

My production build has a bug that the debug build doesn't. A bug that makes no sense, while all unsafe code in the program is on dead paths, and my recent changes should only affect niche multithreaded scenarios but the bug appears in the single threaded case.

Thread-local static variables in expression scope are so cool. You can initialize them with heap-bound datastructures, they retain their value like statics but you don't need a mutex to interact with them, and you can define them with macros that are called in expression scope. The perfect building block for unobtrusive caching.

I used to really hate statics in C++ when I was starting out with programming because I felt that they introduced unexpected persistent state, but I guess I have grown to appreciate locality a lot more since.

I have a recurring problem with Typescript where I can't search types for errors because all search engines are flooded with questions and articles about type checker errors.

I can't tell if I didn't understand an important detail about Rust traits or the system is badly underdesigned, but I keep bumping into situations where the most general correct implementation of an std trait on a container clashes with one of the std implementations, and I would need a very obvious negative statement to make them mutually exclusive (for example that T in MyPtr<T> can never implement Borrow<MyPtr<T>>)