halfcat

One difference is, when the business hits a tough patch, the bank starts asking questions, and whether or not the bank lets it all continue depends primarily on whether there’s a CEO/CFO who:

- Has history with the bank (trust)

- Is willing to put their neck on the line

AI in the current form has no ability to put its neck on the line.

Can you clarify the point you’re trying to make? C-level people are forced out all the time. Even the CEO reports to the board.

There’s at least one

https://en.wikipedia.org/wiki/Paul_Mockapetris

The body can know more than it can tell.

Containers were never a security boundary

DBOS is much less complexity compared to Temporal. That’s the benefit.

Main tradeoff is lower performance. Or at least, you’re going to be limited to what you can push through Postgres. If that’s sufficient for your needs DBOS is great.

> we are transferring value from our current standard of living to pay for retirement checks

Isn’t this just what happens when you have an inverted pyramid (older population is larger than the younger population)?

> One can argue that PEs make the business more efficient

I’ve never seen it (I agree with you). To improve something they’d have to understand the business and do a bunch of work. Mostly they show up at quarterly meetings and want spreadsheets that measure some number that will go up (regardless if that number means anything).

> if you wanna fix or ban PE, solve pensions

How does one solve pensions?

How would one even know if the port of 100k LOC was successful? Are there language-agnostic tests (CLI STDIN/STDOUT) or similar involved?

So what’s the verdict? Was it worth it?

How do you stay aware of all code being written?

Maybe it’s just me, but I’ve never understood how one understands from reading code. Yes you can understand what that code does, but not why it was done that way instead of a different way. In the end I only understand it deeply if I end up writing it. Chatting through it is helpful to me, but having AI crank out code loses all of that context pretty quickly.

I’m not disagreeing. Just curious how you think about this, and if there are key parts of your process that help you stay contexted in.

There was a line in one of The Walking Dead TV show spin-offs, something like:

”I've known men who inspire fear. Do you know what they have in common? They never say how frightening they are.”

And here we are.

”I’ve known companies that work on AI. Do you know what they have in common?...”

People have done this. They call it tablebases [1]. They’ve computed 7-piece tablebases, but not 8 pieces.

”After the completion of the 7-man, some people were curious about the feasibility of building the 8-man. Ronald de Man estimated that without modifying much the generator, the task requires computers with 64 TB RAM and 2000 TB hard disks[10] (cost about $640K and $40K respectively in 2020). The generator can be modified to work on much cheaper computers with 64 GB RAM but that may need a few thousand years of computing”

And to solve chess you’d need to calculate the 32-piece tablebases.

[1] https://www.chessprogramming.org/Syzygy_Bases

Accidental true leadership

Cuts both ways. If supply chain attacks continue recursive self improvement, everyone’s going to be working in air-gapped facilities. Departments also need to be air-gapped from one another. And each team air-gapped. And so on.

There’s a speed limit, because the faster you go the less room for error you have. It’s the same as being heavily leveraged with debt. If you have a cash investment and it drops by 50% you can just wait. If you’re leveraged 100-to-1, a 1% drop forced liquidation and wipes you out.

> had the right idea

Is it no longer the right idea?

> I have a co-worker who's basically not a programmer, but got multiple implementations of applications working sooner than our dev teams

Deployed to production, right?

Right??

(I’m just kidding, of course it’s only on their machine, no different than Excel 5 years ago)

> architect and orchestrate the coding, but 'language' isn't a barrier anymore.

Never was the barrier.

The main risk-of-regret is: How will you feel when/if the $20/month plan costs $2000/month?

May never happen. But be clear with yourself if you’re relying on it not happening.

It’s a hell of a nice risk mitigator to understand the code, in a language you know, if you have to print-debug it yourself at some point.

You need at least 3 for this. People go on vacation, turnover, can’t risk losing that critical institutional knowledge.

Agree with other response, look at Dagster for this.

If you want to roll your own, you build a dependency graph (a dict) of the functions you want to call, Python already has graphlib.TopologicalSorter built in that can do this for you. Throw in logging and the tenacity library for retries and you’re set.

Temporal and DBOS are more around the durability guarantees. If you have tasks that are expensive to restart from scratch, or if you have human-in-the-loop approvals, or you have months between steps (e.g. 90-day warranty inspection after installation), you want that durability.

> better to use a real programming language that compiles into a DAG

Fun fact: a DAG, after topological sorting, is a list

Many people need the efficiency of running things in parallel. But if you don’t (like if you’re running reporting/ETL stuff overnight), you can skip a lot of the complexity and just run a list of tasks in the right order.

Or put another way, before you adopt a DAG orchestrator (and all the time evaluating your options), remember you can just run the same steps as a list and get something shipped, and the DAG stuff is an optimization you can tackle in phase 2.

The entire state is (mainly) two tables in Postgres. Maybe 10 tables total if you’re using all the features.

There’s something about seeing the ground truth, in full, in one place, when you’re trying to understand it, or troubleshoot it.

0 open issues. That means it’s production ready, right?

Right??

> tabbed in under the thing they join to

Tabs or spaces though?

Was this forked from the nocode project?

https://github.com/kelseyhightower/nocode

So if I understand this correctly, there are three main approaches:

1. SKIP LOCKED family

2. Partition-based + DROP old partitions (no VACUUM required)

3. TRUNCATE family (PgQue’s approach)

And the benefit of PgQue is the failure mode, when a worker gets stuck:

- Table grows indefinitely, instead of

- VACUUM-starved death spiral

And a table growing is easier to reason about operationally?

I’ve also wanted something like this. The challenge is with an external appliance you lose awareness of which process is initiating the request.

This is solvable to some degree but requires varying degrees of new complexity depending how smooth of a user experience you’re aiming for.

If you think that’s brutal, wait until you hear about how fiat currency works

If the code is ever visible to anyone else ever, you have no guarantee. If it’s actually valuable, you have to protect it the same way you’d protect a pile of gold bars.

What does “my code...for my clients” mean (is it yours or theirs)? If it’s theirs let them house it and delegate access to you. If they want to risk it being, ahem...borrowed, that’s their business decision to make.

If it’s yours, you can host it yourself and maintain privacy, but the long tail risk of maintaining it is not as trivial as it seems on the surface. You need to have backups, encrypted, at different locations, geographically distant, so either you need physical security, or you’re using the cloud and need monitoring and alerting, and then need something to monitor the monitor.

It’s like life. Freedom means freedom from tyranny, not freedom from obligation. Choosing a community or living solo in the wilderness both come with different obligations. You can pay taxes (and hope you’re not getting screwed, too much), or you can fight off bears yourself, etc.

Society won’t delay reward now for future good on its own. Even if one person will, there’s a line of people who will step in to pollute the lake or kill the whales for a bag of money.

It will just decay until it’s a short squeeze into oligarchy or worse (the corrupt will be forced into an arms race of accelerating corruption as opportunity becomes scarce). Then some other country who isn’t leaving it up to their society to do the right thing will be in charge. Until the same happens to them.

This is the value of religion historically, one of the few ways of coercing a population into doing the right thing for their own good. But every group can be spoiled or hijacked by a small handful of bad actors who are willing to do what others are not.