frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

Apple vs the Law

https://formularsumo.co.uk/blog/2025/apple-vs-the-law/
85•tempodox•1h ago•39 comments

OpenFront: Realtime Risk-like multiplayer game in the browser

https://openfront.io/
30•thombles•1h ago•4 comments

Show HN: Pangolin – Open source alternative to Cloudflare Tunnels

https://github.com/fosrl/pangolin
221•miloschwartz•10h ago•34 comments

Postgres LISTEN/NOTIFY does not scale

https://www.recall.ai/blog/postgres-listen-notify-does-not-scale
422•davidgu•3d ago•165 comments

Batch Mode in the Gemini API: Process More for Less

https://developers.googleblog.com/en/scale-your-ai-workloads-batch-mode-gemini-api/
92•xnx•3d ago•27 comments

LLM Inference Handbook

https://bentoml.com/llm/
48•djhu9•5h ago•1 comments

The ChompSaw: A Benchtop Power Tool That's Safe for Kids to Use

https://www.core77.com/posts/137602/The-ChompSaw-A-Benchtop-Power-Tool-Thats-Safe-for-Kids-to-Use
158•surprisetalk•3d ago•94 comments

Btrfs Allocator Hints

https://lwn.net/ml/all/cover.1747070147.git.anand.jain@oracle.com/
9•forza_user•1d ago•1 comments

Show HN: Interactive pinout for the Raspberry Pi Pico 2

https://pico2.pinout.xyz
39•gadgetoid•3d ago•5 comments

What is Realtalk’s relationship to AI? (2024)

https://dynamicland.org/2024/FAQ/#What_is_Realtalks_relationship_to_AI
252•prathyvsh•16h ago•84 comments

Series of posts on HTTP status codes (2018)

https://evertpot.com/http/
35•antonalekseev•2d ago•6 comments

FOKS: Federated Open Key Service

https://foks.pub/
221•ubj•19h ago•45 comments

Flix – A powerful effect-oriented programming language

https://flix.dev/
265•freilanzer•18h ago•122 comments

Graphical Linear Algebra

https://graphicallinearalgebra.net/
236•hyperbrainer•16h ago•18 comments

Show HN: Cactus – Ollama for Smartphones

https://github.com/cactus-compute/cactus
140•HenryNdubuaku•13h ago•55 comments

Apple-1 Computer, handmade by Jobs and Woz [video]

https://www.youtube.com/watch?v=XdBKuBhdZwg
48•guiambros•2d ago•15 comments

Show HN: Open source alternative to Perplexity Comet

https://www.browseros.com/
211•felarof•14h ago•74 comments

Underwater turbine spinning for 6 years off Scotland's coast is a breakthrough

https://apnews.com/article/tidal-energy-turbine-marine-meygen-scotland-ffff3a7082205b33b612a1417e1ec6d6
166•djoldman•17h ago•154 comments

Show HN: I built a playground to showcase what Flux Kontext is good at

https://fluxkontextlab.com
51•Zephyrion•1d ago•14 comments

Red Hat Technical Writing Style Guide

https://stylepedia.net/style/
200•jumpocelot•17h ago•86 comments

Grok: Searching X for "From:Elonmusk (Israel or Palestine or Hamas or Gaza)"

https://simonwillison.net/2025/Jul/11/grok-musk/
303•simonw•7h ago•161 comments

Orwell Diaries 1938-1942

https://orwelldiaries.wordpress.com/page/2/
107•bookofjoe•14h ago•60 comments

Foundations of Search: A Perspective from Computer Science (2012) [pdf]

https://staffwww.dcs.shef.ac.uk/people/J.Marshall/publications/SFR09_16%20Marshall%20&%20Neumann_PP.pdf
23•mooreds•3d ago•0 comments

Measuring the impact of AI on experienced open-source developer productivity

https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
598•dheerajvs•15h ago•393 comments

AI coding tools can reduce productivity

https://secondthoughts.ai/p/ai-coding-slowdown
151•gk1•8h ago•135 comments

eBPF: Connecting with Container Runtimes

https://h0x0er.github.io/blog/2025/06/29/ebpf-connecting-with-container-runtimes/
53•forxtrot•13h ago•7 comments

Analyzing database trends through 1.8M Hacker News headlines

https://camelai.com/blog/hn-database-hype/
143•vercantez•3d ago•71 comments

Matt Trout has died

https://www.shadowcat.co.uk/2025/07/09/ripples-they-cause-in-the-world/
190•todsacerdoti•1d ago•57 comments

Diffsitter – A Tree-sitter based AST difftool to get meaningful semantic diffs

https://github.com/afnanenayet/diffsitter
119•mihau•19h ago•29 comments

Launch HN: Leaping (YC W25) – Self-Improving Voice AI

59•akyshnik•14h ago•33 comments
Open in hackernews

Just make it scale: An Aurora DSQL story

https://www.allthingsdistributed.com/2025/05/just-make-it-scale-an-aurora-dsql-story.html
134•cebert•1mo ago

Comments

glzone1•1mo ago
Early dsql had some weird limits I think - anyone actually using in production with feedback on current corners and limits?
Marbling4581•1mo ago
I don't use it, but have been keeping an eye on it.

At launch, they limited the number of affected tuples to 10000, including tuples in secondary indexes. They recently changed this limit to:

> A transaction cannot modify more than 3,000 rows. The number of secondary indexes does not influence this number. This limit applies to all DML statements (INSERT, UPDATE, DELETE).

There are a lot of other (IMO prohibitive) restrictions listed in their docs.

https://docs.aws.amazon.com/aurora-dsql/latest/userguide/wor...

pzduniak•1mo ago
Who would use Preview products in production? I'm building out some software that would fit perfectly into the constraints set for DSQL, but I realistically can't commit to something with no pricing / guarantees.
EwanToo•1mo ago
This blog post appears to be part of the scheduled launch marketing, it's now generally available

https://aws.amazon.com/blogs/aws/amazon-aurora-dsql-is-now-g...

mjb•1mo ago
Which features would you like to see the team build first? Which limits would you like to see lifted first?

Most of the limitations you can see in the documentation are things we haven't gotten to building yet, and it's super helpful to know what folks need so we can prioritize the backlog.

avereveard•1mo ago
indexes! vector, trigram and maybe geospatial. (some may be in by now I didn't follow the service as closely as others)

note, doesn't have to be pg_vector pg_trgm or PostGIS, just the index component even if it's a clean room implementation would make this way more useful.

loginatnine•1mo ago
Views and foreign keys!
mjb•1mo ago
Thanks. The team's working on both. For views, do you need updatable views, or are read-only views sufficient?
loginatnine•1mo ago
For me it's RO views.
tigy32•1mo ago
I believe views were added to the preview a little while ago

edit from the launch: "With today’s launch, we’ve added support for AWS Backup, AWS PrivateLink, AWS CloudFormation, AWS CloudTrail, AWS KMS customer managed keys, and PostgreSQL views."

mjb•1mo ago
Correct: https://docs.aws.amazon.com/aurora-dsql/latest/userguide/wor...
tomComb•1mo ago
The lack of JSONB is what stopped me.
sgarland•1mo ago
Why does it not support TRUNCATE?
jashmatthews•1mo ago
My understanding is the way Aurora DSQL distributes data widely makes bulk writes extremely slow/expensive. So no COPY, INSERT with >3k rows, TRUNCATE etc
sgarland•1mo ago
TRUNCATE is DROP TABLE + CREATE TABLE, it’s not a bulk delete. It bypasses the typical path for writes entirely.
loevborg•1mo ago
Which ones? It seems eminently usable from the outside now, at least for greenfield work. The subset of Postgres it supports is most of good/core/essential Postgres. (But I haven't tried it)
geodel•1mo ago
Good read. I like the part that both writing low level as well as high level component in Rust was proven worthwhile.

Maybe one can transform slow code from high level languages to low level language via LLMs in future. That can be nice performance boost for those who don't have Amazon engineers and budgets

SahAssar•1mo ago
> Maybe one can transform slow code from high level languages to low level language

I think you are describing a compiler?

geodel•1mo ago
I mean reading this article:

1) Kotlin code --> Java byte code --> JVM execution (slow)

vs

2) Kotin code --> Rust/Zig code --> Zig compiler --> native execution (fast)

Compiler is involved in both cases but I was thinking of 2) where slower code in high level lang is converted to another lang code. The compiler of which is known to produce fast runinng code.

dhosek•1mo ago
You’re describing a transpiler, but the problem is that idioms in a GC language like Kotlin don’t necessarily translate to a non-GC language like Rust or Zig. Add in the fact that Rust doesn’t have OO inheritance which is essential for a lot of JVM code to work (I don’t know much about Zig) and I’d be very suspicious of code generated by a Kotlin to Rust transpiler. (On the other hand, one of the first transpilers I ever encountered, web2c, worked well because the source language, Pascal, could be fairly easily translated into functional C without much if any sacrifice of speed or accuracy.)
mjb•1mo ago
> Maybe one can transform slow code from high level languages to low level language via LLMs in future.

This is one of the areas I'm most excited for LLM developer tooling. Choosing a language, database, or framework is a really expensive up-front decision for a lot of teams, made when they have the least information about what they're building, and very expensive to take back.

If LLM-powered tools could take 10-100x off the cost of these migrations, it would significantly reduce the risk of early decisions, and make it a ton easier to make software more reliable and cheaper to run.

It's very believable to me that, even with today's model capabilities, that 10-100x is achievable.

geodel•1mo ago
I remember many years back one of Go language author wrote C to Go trasformer and used that to convert all compiler, runtime, GC etc into Go.

Now in today's time some experts like above could create base transformer for high level language and frameworks to low level language and frameworks and this all get exposed via llm interfaces.

One can say why all this instead of generating fast binary directly from high level code. But generating textual transformation would give developers opportunity to understand, tweak and adjust transformed code which generating direct binary would not.

bee_rider•1mo ago
Python -> C -> Assembly

Probably looks a lot like

Pseudocode -> C -> Assembly

Although the first is easier to run tests on and compare the outputs.

Demiurge•1mo ago
Many interesting things, for instance, I've been hearing a lot about how fast Java is, that it can be as fast as C++, and then I see this:

> But after a few weeks, it compiled and the results surprised us. The code was 10x faster than our carefully tuned Kotlin implementation – despite no attempt to make it faster. To put this in perspective, we had spent years incrementally improving the Kotlin version from 2,000 to 3,000 transactions per second (TPS). The Rust version, written by Java developers who were new to the language, clocked 30,000 TPS.

I feel like there is more to this, like some kind of a bottleneck, memory footprint, some IO overhead?

> Our conclusion was to rewrite our data plane entirely in Rust.

The point is well taken, figuring it out is not worth it, if you can just "rewrote" or have green field projects.

> These extension points are part of Postgres’ public API, allowing you to modify behavior without changing core code

Also, interesting. So PostgreSQL evolved to the point that it has a stable API for extensibility? This great for the project, maintain a modular design, and some stable APIs and, you can let people mix and match and reduce duplication of effort.

anarazel•1mo ago
> So PostgreSQL evolved to the point that it has a stable API for extensibility?

Not across major versions, no. I seriously doubt we will ever make promises around that. It would hamper development way too much.

Demiurge•1mo ago
I see, then they're probably saying they found the internal APIs that are just more naturally stable, perhaps because they are close to the APIs used for extensions.
ramanh•1mo ago
> I feel like there is more to this, like some kind of a bottleneck, memory footprint, some IO overhead?

blocking/nonblocking IO can explain this numbers

karl_p•1mo ago
The JVM can relocate memory to avoid fragmentation. Rust can't, at least natively. Are they not worried about this regression?
geodel•1mo ago
Well Java need it because it fragments memory a lot. With Rust one has value types and stack allocation which takes care of one of the biggest cause of fragmentation.
kikimora•1mo ago
Writing code that would not fragment memory over time is arguable much harder than writing GC friendly code.
geodel•1mo ago
Yeah, cooking food in kitchen is much harder than having it delivered from restaurant at doorstep.

Reasonable people will see if cost makes it worthwhile.

tigy32•1mo ago
I haven't found that to be the case in my experience: just for example in java you tend to end up with essentially a lot of `Vec<Box<Thing>>` which causes a lot of fragmentation. In rust you tend to end up with `Vec<Thing>` where `Thing`s are inlined. (And replace Vec with the stack for the common case). I find it more like Java is better at solving a problem it created by making everything an object.
mrkeen•1mo ago
With 10x the throughput (TPS) and the lack of GC pauses (which were the cause of the rewrite), how would they measure such a regression, let alone worry about it?
kondro•1mo ago
It would be really great to get more context on what a DPU is for pricing: https://aws.amazon.com/rds/aurora/pricing/

I understand that AWS did one TPC-C 95/5 read/write benchmark and got 700k transactions for 100k DPUs, but that’s not nearly enough context.

There either needs to be a selection of other benchmark-based pricing (especially for a primarily 50/50 read/write load), actual information on how a DPU is calculated or a way to return DPU per query executed, not just an aggregate CloudWatch figure.

We were promised DSQL pricing similar to DynamoDB and insofar as it’s truly serverless (i.e. no committed pricing) they’ve succeeded, but one of the best parts of DynamoDB is absolute certainty on cost, even if that can sometimes be high.

belter•1mo ago
> one of the best parts of DynamoDB is absolute certainty on cost

That depends if its On Demand or Provisioned, even if they recently added On Demand limits.

kondro•1mo ago
You still have absolute certainty. Read or write x amount of data and it will use exactly y R/WCU.

It then just becomes a modeling problem allowing you to determine your costs upfront during design. That’s one of the most powerful features of the truly serverless products in AWS in my opinion.

ejkra•1mo ago
Absolute certainty is challenging with a cost-based optimizer in the mix. DDB doesn't face this challenge. Although, cost for some query patterns in DDB would shift into your application layer - so you may not have exactly the cost certainty you imagine?

Would you be willing to pay more for certainty? E.g. rent the full server at peak + 20% and run at 15% utilization some of the time? Provisioned capacity or pre-committed spend seem like reasonable, but perhaps more costly, ways to get certainty.

mrkeen•1mo ago
Where can I go to read about distributed SQL and big JOINs or WHERE IN clauses? I was hoping this article would cover that elephant in the room, rather than Rust being significantly more performant than JVM languages.
louis-paul•1mo ago
Marc Brooker has written and spoken about DSQL quite a bit. It’s still rather high level. I’d expect one or more papers to come out in the next few months, similarly to other Amazon databases.

https://brooker.co.za/blog/2025/04/17/decomposing.html (includes talk)

https://brooker.co.za/blog/2024/12/03/aurora-dsql.html

https://brooker.co.za/blog/2024/12/04/inside-dsql.html

https://brooker.co.za/blog/2024/12/05/inside-dsql-writes.htm...

https://brooker.co.za/blog/2024/12/06/inside-dsql-cap.html

https://brooker.co.za/blog/2024/12/17/occ-and-isolation.html

mrkeen•1mo ago
That's a lot of links for 0 info on distributed JOIN or WHERE IN.