HNHacker News
TopNewBestAskShowJobs

subhobroto

626 karma · joined January 2, 2012

Like something I said? Hate something I said? Want to talk more?

Feel free to reach out: my handle at gmail.com

Writings from 10 years ago: https://www.quora.com/profile/Subhobroto-Sinha-1

submissionscomments
subhobroto··on Ask HN: Is the Job Market Actually Bad?
> But how do they scale the reviewing of the agentic output? Or they just blindly trust it and worst case scenario they get to write a sob story on HN about how Claude has deleted the production db?

Thats a fantastic question. Here's my take: https://news.ycombinator.com/item?id=47917314 - would love your thoughts on it.

In short, I think you're asking a billion dollar question - how do we solve the verification, validation, and QA bottleneck?

The way I handle it for my personal projects is I invest tremendous time and effort into writing thorough test and validation suites.

I bet the next billion dollar companies will be those addressing this verification, validation, and QA bottleneck.

subhobroto··on California to begin ticketing driverless cars that violate traffic laws
> As a Waymo (and other driverless car) supporter, this seems like an obviously good thing, right? I’m a little surprised this wasn’t possible before given the amount of regulatory scrutiny (correctly) applied to these companies

Not necessarily. I went into a bit more detail in my own comment but it might be useful to think that when regulations are written keeping in mind multibillion dollar automobile companies, what the effect of those regulations on a person maintaining their own vehicles might be.

Consider that your Waymo got ticketed, but you had flashed it with a "no customer telemetry" firmware. Once Waymo gets the ticket, they flag your car as having "unauthorized" software and now the ball's in your court that the reason why your Waymo got ticketed has nothing to do with the telemetry feature that tells Waymo what radio stations you were listening to.

Also, when regulations are written keeping in mind multibillion dollar automobile companies, the ticket isn't going to cost $500.

subhobroto··on California to begin ticketing driverless cars that violate traffic laws
UPDATE (can't respond to the two subcomments below due to post throttling, so I'm updating this comment instead)

> the car is basically a taxi and the taxi service is to blame for any mistakes

@skybrian - Agreed! but if you read the article, the CA DMV is ticketing the manufacturer, not the operator.

None of my concerns hold if the operator was ticketed - infact, existing regulations are set up exactly that way, so no new regulation was even necessary. Something's not adding up.

> Right now, no one can independently own and operate an AV the way Waymo or Tesla does

@ourspacetabs - Sure but the regulation seems to be specifically addressed at the manufacturer, not the operator.

I would have no concern if the regulation was addressed to the operator. The article atleast doesn't imply that's the case.

---

> The state's Department of Motor Vehicles (DMV) has announced new regulations on autonomous vehicles (AVs), including a process for police to issue a "notice of AV noncompliance" directly to the car's manufacturer.

> Under the new rules, police can cite AV companies when their vehicles commit moving violations. The rules will also require the companies to respond to calls from police and other emergency officials within 30 seconds, and will issue penalties if their vehicles enter active emergency zones.

These are new frontiers in automotive regulation. Typically, if a car failed because of a manufacturer issue, the driver would be ticketed. For example: if Hyundai sold vehicles where the engine would explode around 50k miles and that caused an accident, the driver of the vehicle would be ticketed for it.

Now if we take the human out of it, it is Hyundai that would be ticketed for it. Insurance companies are certainly going to take notice and adjust their risk models accordingly.

I imagine there will be a lot of fingerpointing by the manufacturer towards customers.

In the worst case, this is the end of customers servicing their own autonomous vehicles.

If we imagine that most vehicles in the next 15 years will be autonomous, this would mean customers would have to handle regulation aimed at multibillion dollar companies, if they were to service their own autonomous vehicles, or give up on servicing their own autonomous vehicles entirely and just rent them instead.

subhobroto··on Ask HN: Is the Job Market Actually Bad?
There's no monolithic "Job Market", so specific details matter. I have not been tracking details too closely but here are two things I am tracking:

- CRUD generation by running through JIRA tickets and clearing backlogs seem to be replaced by agentic workflows. So if you were an extremely productive dev who would machete your way through CRUD and API integrations, agentic workflows do it better, faster and for cheaper. I can point CC, Codex (Cursor in progress) at design specifications and it can turn those into perfect Django apps with well written test cases like there's no tomorrow. It might not make sense for such a business to continue to hire humans to do the same work

- Tokens for frontier models over the API are really expensive. I am personally aware of some companies that have monthly high five figure token expenses and one company that has a monthly six five figure token expense.

It's still worth it because they are churning out code 24x7 vs a typical human's 8x5 if you're putting in the right workflows, guardrails in place - that's a 4x productivity gain.

You're getting done in a month, what a full quarter would require humans to do. However, the company still has to pay for that and unless they are signing up 4x more paying net new customers every month with 0 churn, engineers have to be let go to pay for those tokens.

subhobroto··on Barman – Backup and Recovery Manager for PostgreSQL
The way I read that issue and the linked discussion was, that pgBackRest handles a lot of details itself that's otherwise handled by Kubernetes. Hence, a lot of functionality in pgBackRest is not only redundant but incompatible with how Kubernetes CSI could be used to provide incremental and differential backups. Hence, Barman and `barman-cloud` plugins are a better, natural fit for a Kubernetes environment than pgBackRest.
subhobroto··on Barman – Backup and Recovery Manager for PostgreSQL
> We use Barman inside Kubernetes via CloudNativePG's plugin, as it is the default backup plugin.

right and here's why CloudNativePG chose Barman over pgBackRest: https://github.com/cloudnative-pg/cloudnative-pg/issues/3077

> WAL limits need to be set carefully or you just end up filling WAL volumes and the database becoming unavailable.

This is true. For anyone getting alarmed that this is due to a bug in PostgreSQL, it's not - it's PostgreSQL protecting the customer from attempting to write data that it cannot durable commit - "I am going to go unavailable because I don't have enough space to save more data".

There are multiple ways to handle this, the easiest, most hands on way is to keep a monitor and alert that watches the WAL size like a hawk and then alerts OPS the moment it breaches a threshold.

subhobroto··on Barman – Backup and Recovery Manager for PostgreSQL
This is a fantastic project that a lot of self-hosters using PostgreSQL use. Specially with pgBackRest archived by the owner on Apr 27, 2026, this is likely the leading option that has been around the block for a while.

Anyone here had considered Barman in the past, used it for a while and went to pgBackRest? Are you revisiting that decision now?

subhobroto··on New research suggests people can communicate and practice skills while dreaming
> in a dream! The eureka adrenaline woke me up

YES! I have never told anyone this (because it feels so random) but it's great to know I'm not the only one. I pretty much expect this when I am in depths of an issue I cant somehow consciously resolve, so much that I keep a pen and writing pad next to me, before I sleep, because the code I saw in my dream often gets lost by the time I go to my office and resume the laptop.

I even figured out a hack - I just force myself to go to sleep if I can't consciously resolve it for more than an hour. It's as if my brain gets an otherwise untapped firepower.

That said, this absolutely destroys my sleep cycle for the next day or two and spikes my BP for the rest of the day to the point where I feel sick.

Although in theory I'm sleeping more than the 8h, I feel horribly mentally exhausted. I can work out, physically just fine but my brain is on empty - because of this, I limit this to critical blockers.

subhobroto··on Does Postgres Scale?
That's a phenomenal script that absolutely belongs on a dba.stackexchange question and even the PostgreSQL mailing list.

I strongly encourage you to post to https://dba.stackexchange.com/, as a HN thread is the wrong place for this discussion (there's a lot of tuning ahead of you and others who are in your situation in the future might skip this nested thread) but be forewarned, the TLDR from dba.stackexchange will either be a quick "you need atleast 64 GB RAM for your PostgreSQL usecase" or there will a better, thorough discussion of increasing max_wal_size and lowering the fillfactor (which is what you're looking for). The ideal answer should even walk you through BRIN (vs btree) indexes. I'm asking you to post there because it will enumerate the WHY of all of these. At that point you can make an informed decision if this all would be worth it.

Now I empathize that MySQL is doing a phenomenal job at only a quarter of that (16 GB you said?) but not for the reasons you might think (and one can certainly argue, nor should an end user care!). MySQL's method of buffering (InnoDB change buffers) and its clustered index gives you the performance you like when suddenly doing bursty writes aka "write sprint". I need you to be aware of that (and dba.stackexchange responses will certainly address that).

I would have written a lengthy post on what to do next but I must first ask:

- Why are you evaluating PostgreSQL in this case when MySQL seems to work well? For example: does it feel like your aggregations are getting slower? As you can see, with PostgreSQL, you will have different set of tradeoffs (RAM, tuning, VACUUM)

- Are there real, limiting business constraints that force you to operate on less than 64 GB of RAM given your volume and throughput expectations (like FF limitations, or these are smaller machines on the edge, etc)

- If you can, as an experiment, while you write your dba.stackexchange question and for the PostgreSQL mailing list, you can tweak multiple parameters and tell me what you see:

- I'm concerned you have a `shared_buffers = 128MB`. Set it to `shared_buffers = 8GB` (give the B-trees room to live in RAM)

- Increase `max_wal_size = 16GB` (stop the checkpoint flooding and let Postgres "breathe" during your batch inserts).

- Increase `checkpoint_timeout = 30min` (set 30min to the actual window it takes; also, this is temporary but this should push checkpoints out so they don't interrupt your "write sprint").

- Set `maintenance_work_mem = 2GB` (should speed up index creation and vacuuming).

- Lower `fillfactor` on those specific 8 indexes from the default 100 down to 70. The B-trees should now have the ability to absorb those inserts better.

This should get you in the right direction, googling for the right documentation, but there's even more ahead of you, including a separate discussion about BRIN (vs btree) indexes.

> defers persisting new index data so that the DML can be finalized as quickly as possible

"defers persisting" might get misread as if it doesn't write to disk - it does but you're close and you will uncover more :)

MySQL defaults are specifically tuned for your "write sprint" usecase, infact, to actually mask the IO latency of secondary index updates but if your real usecase is not just large sudden bursts of writes to a table that has a btree index, you certainly will appreciate this effort. Happy weekend!

subhobroto··on Credit cards are vulnerable to brute force kind attacks
> another in Chicago in 2005 (don't do what I did) when were starting Matasano

Uff. I perhaps can imagine what you were going through the next 10 years.

PS: I actually would like to hear your thoughts on where cybersec is headed in the age of LLMs (Mythos or not), would it be OK for me to reach out about it (unless you've written about it already)?

subhobroto··on Credit cards are vulnerable to brute force kind attacks
> Under the law, credit card issuers actually have more time to deliberate before making you whole, not less.

Could be but in my personal experience, it has been the exact opposite. That said, I don't use banks. I work with credit unions exclusively. Maybe they have very different rules when it comes to handling debit card fraud.

The only time I have needed a debit card are when a place doesn't accept credit or charges a heavy markup for credit. Someone here mentioned Robinhood virtual credit card - I need to look into it, but I use a similar service and I keep my debit card locked only to unlock it for the exact window I am actually using it.

> rented cars, all that stuff. There's really been no point I can think of where I felt like having a revolving credit card would have made any of it more manageable.

I'm unaware when you last rented a car but when I rented a car last month, the company put a $500 hold on my credit card. That credit card hold went away after I returned the car in good condition a week later. I imagine, if I had used a debit card, that $500 hold would have made $500 disappear from my bank balance during that time. When my nephew rented a car, they put a $2000 hold on his credit card, I'm assuming because he's younger than 21. He certainly doesn't have $2000 to spare in his bank account.

The same credit card got me a free upgrade on the rental car, primary insurance protection during the rental period (I didn't have to buy the $40/day rental insurance) and got me 5% cashback on the full rental amount essentially undoing state taxes. The estimated cash value of these would have been ~$500 for the week. Using the debit card from my credit union would have got me exactly $0 (plus a reduced balance the whole time).

OTOH, a credit union shipped me a chipped debit card preactivated. The debit card shipped via regular USPS mail and was stolen along the way. I always keep $400 in my checking account, so the theif emptied my card at Target and 7/11. Within hours of receiving text about the charges, I called my credit union, informed them of the detail. They sent me a binder full of documents to sign. The whole time the money wasn't refunded. They took a month to review evidence and refunded me $50 (of the $400) and told me I would have to provide additional evidence that needed wet signatures, notarizied to receive the rest ($350). Every notarizied page in my jurisdiction costs $150.

> EFTA Reg E gives banks 10 days to make you whole

Interesting - any idea if this applies to credit unions too (because then you just got $350 back into my pocket!)

> I presumably still somehow owe them $40, and it wrecked my credit score.

> People say it will impact your ability to get a mortgage or a lease, but: not my experience!

Are these mortgages or a leases after you became wealthy or around the time when your credit score was wrecked? I imagine the effects of the Nordstroms credit card wore away 5-7 years (I don't recall exactly which) after the $40 was reported as late. So if more than 7 years passed between these two events, you might have a perfect FICO score now, even though you don't know it. I imagine you can just go to CreditKarma for free and use their free "dispute" charge option to permanently erase that Nordstrom black spot forever. I don't think anyone cares a multimillionaire had a forgotten $40 invoice when they were 19.

Also, for anyone above $1MM in liquid networth, most financial institutions treat the credit history as a signal and not the primary signal. I believe you have been above that by a healthy amount for a while now :)

PS: I am a HUGE fan of yours. I wrote all of the above expecting you absolutely wouldn't have a second to read a word but if you do, Thank You not only for reading (I hope atleast some of it helps you) but for your comments on HN from which I have learned a lot.

subhobroto··on Show HN: My Private GitHub on Postgres
I've struggled with this decision myself but I came to the opposite conclusion as you:

- Gitea's (I use Forgejo) reliance on disk storage for `.git` is perfect for me because files are well understood as a concept by most people. (To be clear, Gitea/Forgejo stores non `.git` artifacts in PostgreSQL.)

Every battle hardened linux tool knows how to backup files. Plain old `rsync` can backup and restore files. I have heard people put their `.git` on something like Dropbox and have tit work both for sync and backup (I've never tried it myself).

You can run checksums on files and ensure they are exactly how you expect them to be.

There are multiple, well tested, well understood options to reliably backup, snapshot and restore files.

Also, remote/cloud storage for files is really cheap. In most cases, if it's less than 10GB, you likely don't have to pay anything at all, as in $0 every month for having a backup on servers that won't go up in flames even if your laptop or house did.

- OTOH, PostgreSQL backup and restore feels like they are less popular or accessible to the general population vs files' backup and restore.

Infact, for non DBA folks who don't necessarily understand PostgreSQL WAL, backup snapshotting, what asynchronous and synchronous WAL replication means and how they affect RTO and RPO, there are definitely multiple and non-obvious ways to get more things wrong than right, and lose your data - something you wouldn't have to worry about when using files backup and restore.

> Whereas with this, I could just handle it as part of the database backup process

What's the database backup and restore process you follow right now and what are the tools you use?

subhobroto··on Does Postgres Scale?
This is a good question! No, it's not like docker compose (I imagine you implied the swarm and hub pull limits?)

DBOS Conductor is an out of band management service that IIRC helps you mainly observe your DBOS and recover failures in a seamless way. As far as I could see, it's not necessary, for you to use DBOS workflows and queues. Don't quote me though and reach out to their forum and verify in case I'm missing certain usecases.

Personally, I do not use DBOS Conductor - I have my own observable setup using Grafana/VictioriaMetrics as my workflows are instrumented with OTel. I had initially set Conductor up for development (and it looked to be free for development although I recall some major limitations on how many workflows etc - which is why I put my own alternate monitoring setup).

They also have a very reasonably priced cloud hosted DBOS Conductor. I think my first 30 days were completely free and then they moved me to a "hobby" tier. It's a fantastic way to help decide whether it's for you.

I believe DBOS Conductor is how DBOS pays the bills but you can use DBOS workflows and queues unlimited without DBOS Conductor. If you don't want to pay for Conductor - their out of band management service, you can put together your own just fine, like I did. My own Grafana/VictioriaMetrics setup answers my questions but I would imagine Claude/Codex/Cursor should be able to put something fairly useful if you didn't want to go down my route.

> executor elasticity appears to be locked behind license purchase

DBOS has designed their system to be extremely flexible and extensible. While yes, Conductor can absolutely manage your executors for you, it's not the only thing that can. You're not limited to using Conductor. As I said, I manage my own - everything you need to know to do so is in the code and documentation. They even have a document for LLMs and agents. I have had to interact with the DBOS team 0 times to set everything up.

I prefer this business model (an optional tool - Conductor, is paid) vs. DBOS offering just everything across the stack on a "free tier" but with caps on DBOS workflows and queues. In their current business model DBOS workflows and queues are completely uncapped (atleast from what I can make out).

If you do reach out to them, I would appreciate if you let me know anything to the contrary.

subhobroto··on Does Postgres Scale?
Another pretty good reason to do distributed computing is to move the computation closer to where the data is or where the data will be consumed.
subhobroto··on Does Postgres Scale?
These are good suggestions but I'm apprehensive they might come back and say they have 64 GB (or less) of RAM or they are using PostgreSQL RDS on AWS or something.

I asked them for specifics.

subhobroto··on Does Postgres Scale?
You've given us some idea of the volume of your data but there's no mention of what's ingesting it or how.

> during these stress tests the hardware is nowhere close to over-encumbered, and there's consistent headroom on both memory, CPU and disk I/O

This assertion is likely wrong - you're likely skipping over some metrics that has clues to what we need to know. Here are some questions to get the discussion moving.

- Is this PostgreSQL managed or self-hosted?

Your mention of "consistent headroom on both memory, CPU and disk I/O" gives me hope you're self-hosting it but I've heard the same thing in the past from people attempting to use RDS and wondering the same as you are, so no assumptions.

- Are you using COPY or multi-row INSERT statements?

- How much RAM does that server have?

- What is the fillfactor, max_wal_size and checkpoint_timeout?

- Is the WAL on NVMe?

- What's the iostat or wa during the slowdown?

- Are random UUIDs (part of) the index?

Have you posted to https://dba.stackexchange.com/

If I were you, I would create a GitHub repo that has scripts that synthesize the data and reproduce the issues you're seeing.

subhobroto··on Does Postgres Scale?
You might be thinking of Pigsty?

Atleast I hope you are! Nothing else has been as well battletested. Unfortunately, perhaps because if its name, it gets no facetime on HN. Its last few mentions here barely received attention it deserved.

subhobroto··on Does Postgres Scale?
DBOS is amazing when it comes to Durable Workflows. There are others in the space - the most popular one being Temporal but I argue, Temporal is also the most complicated one. I often say Temporal is like Kubernetes while DBOS is like `docker compose`. (and for those taking me literally, you can use DBOS in Kubernetes!)

I don't realize why DBOS is not nearly as popular as Temporal but it has made a world of difference building Durable Queues and Long Running, Durable Workflows in Python (it supports other languages too).

As they show in this article, Postgres scales impressively well (4 billion workflows per day, on a db.m7i.24xlarge, enough for most applications), which is why, if you have your PostgreSQL backup/restore strategy knocked out and dialed in, you should really take a close look at DBOS to handle your cloud agnostic or self hosted Durable Queues and Durable Workflows. It's an amazing piece of software founded by the original author of Ingres (precusor to Postgres - the story of DBOS itself is captivating. I believe it started from being unable to scale Spark job scheduling)

subhobroto··on Moss-Audio: an open-source audio understanding fine-tune of Qwen3
MOSS-Audio is an open-source audio understanding model from MOSI.AI, the OpenMOSS team, and Shanghai Innovation Institute. It performs unified modeling over complex real-world audio, supporting speech understanding, environmental sound understanding, music understanding, audio captioning, time-aware QA, and complex reasoning.

The current release has four models: MOSS-Audio-4B-Instruct, MOSS-Audio-4B-Thinking, MOSS-Audio-8B-Instruct, and MOSS-Audio-8B-Thinking.

The Instruct variants are optimized for direct instruction following, while the Thinking variants provide stronger chain-of-thought reasoning capabilities.

subhobroto··on A good AGENTS.md is a model upgrade. A bad one is worse than no docs at all
Simon, I really enjoy your live coding sessions. If you do another one, would you mind showing this part as well? It would be extremely educative.

I haven't been able to do without an `.MD` - no agent (CC, Codex, OpenHands) was smart enough to figure out my layout unguided. So much so, a few weeks ago, I had Claude write the guideline below to document the way I like to lay out my tests and modules. I make extensive use of uv workspaces and don't ship tests to production deployments:

```

- uv Workspace Architecture (`uv` v0.11.8+, `packages/` members):

  **Build tool:** Exclusively `uv_build`. Never `hatchling` or any other build backend.
  Pin as `uv_build>=0.6` in every `[build-system]` block.

  **Naming convention — flat, distinct package names (NOT a shared namespace):**
  Each workspace member uses a *flat* Python package name that is unique across the workspace.
  The `uv_build` backend auto-discovers the module by converting the project name (hyphens → underscores):
  `base-constants` → `src/base_constants/__init__.py`
  `base-domain`    → `src/base_domain/__init__.py`
  `base-geometry`  → `src/base_geometry/__init__.py`
  etc.
  No `[tool.uv.build-backend] module-name` override is needed because the project name already maps directly.

  **Why NOT a `base.*` namespace package:**
  `uv_build` cannot support PEP 420-style namespace packages across workspace members.
  It maps each project name to exactly one module root; only one member can own `base/__init__.py`.
  Attempting `module-name = "base.constants"` treats the dotted name as a nested directory,
  not a namespace — it looks for `src/base/constants/__init__.py`. Confirmed by binary string
  inspection of the `uv` binary. NEVER attempt namespace packages with this build backend.

  **Import style (locked, never change):**
  `from base_constants import CONSTANT_A`        
  `from base.constants import CONSTANT_A`          (namespace layout — abandoned)

  **Tests member:** `package = false` in `[tool.uv]`, no `[build-system]` block at all.
  Tests are never shipped in production; the member exists solely to isolate test dependencies.

  **Microservice split story:** When a member needs to become a standalone repository,
  only the `[tool.uv.sources]` entry in the consuming `pyproject.toml` changes
  (workspace source → PyPI or VCS source). The package code itself is unchanged.
- *Future-phase features: stub, NEVER implement.* When a feature is explicitly scoped to a later phase (e.g., "Phase 4"), write a one-line stub that raises `NotImplementedError` plus a docstring describing the Phase 4 contract. A full implementation spends tokens on untested code that may never ship in its current form. Exception: if the full implementation is ≤ 5 trivial lines and directly validates the current phase's math, implement it outright.

```

Similarly, I find it annoying that every agent uses f-strings inside logging calls. Since I added this, that hasn't been a problem:

```

- NEVER use f-strings or .format() inside logging calls. This forces the string to be interpolated immediately, even if the log level (like DEBUG) is currently disabled. You should NEVER do this and if you notice this in existing code, FLAG IT immediately! By passing the string and the variables separately, you allow the logging library to perform lazy interpolation only when the message is actually being written to the logs. It also increases the caridinality for Structured Logging rendering observability useless!

  BAD:

  ```python
  # The f-string is evaluated BEFORE the logging level is checked.
  # This:
  # - wastes CPU cycles if the log level is higher than INFO
  # - increases the caridinality for Structured Logging rendering observability useless!
  log.info(f"denominator {denominator} is negative!")
  ```

  GOOD:

  ```python
  # The ONLY right way - logging module only merges the variable into the string if 
  # the INFO level is actually enabled.
  log.info("denominator %s is negative!", denominator)
  ```

  Note: Using this "Good" pattern ALSO helps with Structured Logging. Tools like Sentry or ELK can group logs by the template string ("denominator %s is negative!") rather than seeing every unique f-string as a completely different error type.
```
subhobroto··on Ghostty is leaving GitHub
You have been a tremendous influence on my professional life. Vagrant made VMs easy to use. You were very gentle with my Vagrant PRs. We disagreed a bit and I migrated some of those rejected Vagrant PRs into VeeWee. Then Hashicorp happened and I was over the moon. (Full transparency - not everything was perfect, I lost 50% of my Hashicorp equity which hurt real bad but that's not your fault, just saying there were ups and downs!)

This is all to say I have tremendous respect for you. Which is why I say:

You also have the resources to fix this. You not only have the resources and skill Mitchell, to make it happen - You know everything that it takes to be the CEO of a Billion dollar unicorn - you have the connections, you have the vision.

More importantly, Mitchell, you care.

Make it happen. You have done it a few times before. Do it again.

subhobroto··on The Prompt API
Thank You stranger! I would have assumed the size would vary based on whether your hardware supports the high-quality GPU backend (4 GB) or defaults to a smaller CPU-compatible version (3 GB) but the 22GB note on that page is really confusing. Even if it was including the model server where's the remaining 18GB going towards?
subhobroto··on The Prompt API
> `> Storage: At least 22 GB of free space on the volume that contains your Chrome profile.`

Yes, I can read and comprehend English and you should assume I read the page. Because of the "At least" wording, I was curious what a person who has actually used the feature has noticed, aka, learning from people who have actually done it already.

subhobroto··on An AI agent deleted our production database. The agent's confession is below
> Streaming replication whether from RDS

Are you using AWS RDS Custom to receive the WAL Streams or are you using something like Pigsty? Really curious about the actual specifics

subhobroto··on The Prompt API
> It works, I've shipped this as a "local inference"/poor person's ollama for low-end llm tasks like search

fantastic!

> the model download is orders of magnitude greater than downloading the browser itself, and something that needs to happen before you get your first token back

sure but does this mean the model is lazily downloaded? that is, if I used this and I am the first time the model was called, the user would be waiting until the model was downloaded at that point?

that sounds like a horrible user experience - maybe chrome reduces the confusion by showing a download dialog status or similar?

also, any idea what the on disk impact is?

subhobroto··on Dear friend, you have built a Kubernetes (2024)
right - that's precisely what I meant. I read your comment "Containers are just statically-linked programs for the rest of us." as "containers can be replaced by statically-linked programs".

If you didn't imply that, I apologize.

If you did mean that, I disagree with you precisely because your point works if you only care about dependency management - it falls apart on system state. A static binary is a process on the host and shares the same process space, network stack, and filesystem.

OTOH, a container is a jail (the primary usecase): I can't cgroup a static binary's memory usage or give it a virtual network interface without reimplementing "container lite". Containers aren't just 'statically linked programs' - they allow me to use the kernel as a hypervisor for isolated environments.

What they are though, a messy but practical compromise to Unikernels - which was my last point in our GP.

subhobroto··on Dear friend, you have built a Kubernetes (2024)
I have a suspicion you're using Headscale? If so, I urge you to consider Ionscale. I use it with Authentik as the IdP.

Personally commiting to using Tailscale as a core foundation of my infrastructure and Ionscale is my hedge against getting Hashicorped.

> Service discovery is basically just Docker's internal DNS. Caddy-docker-proxy can use it to find healthy upstreams

Do you have a writeup of this somewhere? I'm unaware of being able to manage Docker's internal DNS over some kind of an API (would appreciate if you know a way to). The only way I know is to manipulate network aliases via Docker Engine API. As a result I use Hickory DNS with RFC 2136. That coupled with Caddy-docker-proxy gets me extremely close.

subhobroto··on Dear friend, you have built a Kubernetes (2024)
> Kubernetes, in the form of k3s, was a critical success factor for us with the onprem deployment of our SaaS product.

What surprises and gotchas did you have to deal with using k3s as a Kubernetes implementation?

Did you use an LB? Which one? I'm assuming all your onprem nodes were just linux servers with very basic equipment (the fanciest networking equipment you used were 10GbE PCIe cards, nothing more special than that?)

subhobroto··on Dear friend, you have built a Kubernetes (2024)
I am a big fan which is why I am saying this: you're dismissing the kernel and ABI surface is a huge assumption that must hold true for your comment to hold stavros.

If you had said "unikernels" I would have had no arguments to make.

subhobroto··on Dear friend, you have built a Kubernetes (2024)
> Suddenly you have to become Sysadmin/SRE

I don't you made that argument but could a valid conclusion of your comment be that, because Kubernetes is so ubiquitous, using it frees you from being a Sysadmin/SRE?

← PreviousPage 3 of 16Next →