eximius

There is more code written in C++, but there are fewer "C++ packages" in the sense of just doing `go get` and you're ready to use it.

> As an example: Most languages have tooling for dependency injection. Most go projects have dependency injection but dont use a library or framework or tooling to do it.

I actually see this as a negative and we've been looking at Uber/Fx for more support. DI frameworks don't do anything you can't do without it, but it takes significantly more experience and technological/organizational maturity that I find the average developer doesn't have to do it without framework support.

In the current zeitgeist of being towards the "micro" scale of the spectrum, that "average developer" support is necessary. If you have more modular monoliths or many high quality examples, maybe its better.

Be still my heart. I would use this so fast at work where we currently use Go.

But introducing a new language is a scary thing.

A car doesn't break down immediately after you maintain it.

I guess my company doesn't host their own website because we use Amazon, then?

I hear you, but, again, it's a spectrum and you don't need your own DC or colocation or homelab to "self host".

Eh, it's a spectrum. On one side, gmail, hotmail, etc, on the other side a box in your closet.

This is clearly in between where you are hosting the domain and services, albeit the compute is leased.

Wouldn't that "just" allow someone to see if a key was present (and any information that informs) but dramatically help prevent secret key extraction?

This is "evaluating" LLMs in the sense of benchmarking how good they are, not improving LLM inference in speed or quality, yes?

Unless you explain this statement, most people here are likely to dismiss everything you have to say on the topic of AI.

I wonder if we really need an explicit syntax or if the compiler just need to disable monomorphization for functions that don't use the interior type e.g., only passing around references like this example.

Without trait bounds there isn't much you can do with it anyway besides generic code like this. I guess the question is 'does Rust emit' or elide an unused generic function with unused interior types?

What does `erase T` mean here? "We don't deref it so don't worry about the type, just erase it?"

Eh, it's a reaction against people making or reaching for the wrong tools or the right tools but at the wrong scale.

Postgres is very very good. The vast majority of use cases work with it with very minor effort. People would, in general, be better off investing in thoroughly understanding a general tool like postgres (or similar dbs, just pick one to learn, but there are reasons why you would pick postgres over, say, oracle).

There are still reasons to use more specialized DBs. But the push for postgres is because very often the people reaching for those specialized DBs do so in error.

20M rows is practically an in-memory dataset, for example.

A bureaucracy is not the same thing as the deep state that Trump and Qanons ascribe whacky shit to (e.g., 5G, controlling the weather, chemtrails, etc).

If I flip three coins and use the results to decide which color balls to put in a bag, I'll have one of these distributions: RRR,RRG,RGG,GGG. If I draw a red ball, I am more likely to have drawn from RRR or RRG than RGG (or GGG), so I have learned something about the distribution more than just how it was generated.

Is that true? You'd still have evidence that the distribution of balls tilts one way, wouldn't you?

True. I think the intent here is "we translate your stuff into non-webviews" which is... pretty much what native means in a mobile context.

My friends joined a startup I was working at. I was their manager.

I had to lay them off (along with myself shortly afterward) in less than a year because our founder let me hire them when we didn't have enough money.

They landed on their feet but it still hurt.

I did a few other things wrong before that. I had a lot to learn. Things I've regretted and learned from.

Average American, perhaps, with our "rugged individualism" and apparent lack of empathy.

It's extremely frustrating to watch our world deteriorating because politicians aren't willing to actually do their jobs and govern.

I'd go even stronger and, for the US, pass regulations that all emissions of all kinds must be captured or the company will be fined double the cost of environmental remediation as executed by contractors employed by the government (scaling from 1% of the fine to 100% of the fine over X years).

Oh good, so we continue to exploit the uneducated for our military so they won't realize how little we actually support veterans until it's too late.

`block_on` seems like the right balance of code duplication and overhead, imo.

It is a somewhat strange compile time jumble of libraries but a compile time overhead isn't so bad.

I don't mind a build step, per se, just that the JS ecosystem's build step is particularly more painful than others.

Put them in jail.

Make the company pay for externalities. If it bankrupts them, they deserve it.

Hopefully many do, but it is much easier to talk about when you learn the terminology.

"Yes, the planet got destroyed. But for a beautiful moment in time, we created a lot of value for shareholders."

I wish we would stop making our lives worse for each other.

Does anyone know of a way to replicate these results at home, even at lower fidelity? I've never found code I could run and it seems to always involve extra bespoke antennas/drivers.

It produces medical isotopes, which is important (but not what I'd have expected from a fusion headline).

Basically.

For our particular use case, I think we're actually not using notify events. We just insert rows into the outbox table and the poller re-emits as kafka events and deletes successfully emitted events from the table.

That part is somewhat poorly explained. That is a motivating example of why having your job queue system be separate from your system of record can be bad.

e.g.,

1. Application starts transaction 2. Application updates DB state (business details) 3. Application enqueues job in Redis 4. Redis jobworkers pick up job 5. Redis jobworkers error out 6. Application commits transaction

This motivates placing the jobworker state in the same transaction whereas non-DB based job queues have issues like this.

No, this is a fairly common pattern called having an 'outbox' where the emission/enquing of your event/message/job is tied to the transaction completion of the relevant domain data.

We use this to ensure Kafka events are only emitted when a process succeeds, this is very similar.