MontyCarloHall

It's no different from supervising a naïve junior engineer who also copy/pastes from 15 year old SO posts (a tale as old as time): you need to carefully review and actually grok the code the junior/AI writes. Sometimes this ends up taking longer than writing it yourself, sometimes it doesn't. As with all decisions in delegating work, the trick is knowing ahead of time whether this will be the case.

Forget utterly groundbreaking things, I want to hear maintainers of complex, actively developed, and widely used open-source projects (e.g. ffmpeg, curl, openssh, sqlite) start touting a massive uptick in positive contributions, pointing to a concrete influx of high-quality AI-assisted commits. If AI is indeed a 10x force multiplier, shouldn't these projects have seen 10 years' worth of development in the last year?

Don't get me wrong, AI is at least as game-changing for programming as StackOverflow and Google were back in the day. Being able to not only look up but automatically integrate things into your codebase that already exist in some form in the training data is incredibly useful. I use it every day, and it's saved me hours of work for certain specific tasks [0]. For tasks like that, it is indeed a 10x productivity multiplier. But since these tasks only comprise a small fraction of the full software development process, the rest of which cannot be so easily automated, AI is not the overall 10x force multiplier that some claim.

[0] https://news.ycombinator.com/item?id=45511128

Doesn't Dune take place in ~22k AD? Wiki says "the Butlerian Jihad is a conflict taking place over 11,000 years in the future (and over 10,000 years before the events of Dune)." [0]

[0] https://en.wikipedia.org/wiki/Dune_(franchise)#Butlerian_Jih...

>Instead of installing a container manager or using Unix users, just make another VM.

What is the advantage of this? Unless you need something exotic like different kernel configurations per instance, what's the problem with using containers on the same instance?

BTW, a Hetzner dedicated server with 2 CPUs/8GB RAM that would let me run my own hypervisor is about $14 USD/month. For anyone who's a big enough power user to care about the distinction of running distributed workflows on VMs versus containers, I'm not sure that an extra $5/month is worth your "hypervisor as a service." But then again, HN commenters infamously poopooed Dropbox [0], so what do I know? :-)

[0] https://news.ycombinator.com/item?id=9224

The individual plan says:

— $20/month

— 25 VMs

— 2 CPUs

— 8GB RAM

— 25GB disk

— 100GB bandwidth

Is this 2 CPUs/8GB RAM per VM (in other words, 50 CPUs/200GB RAM)? If so, this is an unbelievable bargain (too good to be true?); other cloud providers charge hundreds of dollars per month for an equivalent VM.

If, OTOH, it's 2 CPUs/8GB total, Hetzner offers an equivalent VM for about $5/month (with much more disk and bandwidth), and I'm not sure what the exe.dev value proposition is. (I'm also not sure why one would want to split 25 VMs across so few shared CPUs/such little memory.)

   My brother's electrical company needed hundreds of Schaltpläne (circuit diagrams).
   Drawing each by hand = 5 hours per plan
   100 drawings = 500 hours = 12 weeks
   Professional CAD work? Unbezahlbar (unaffordable).

   The secret weapon: AutoLISP
   A programming language built into AutoCAD

   The Result: 99.5% time saved
   100 drawings: 12 weeks → <1 hour

This is a general pattern of how automation (including the recent wave of gen-AI) reshapes the labor landscape. Automation rarely replaces jobs wholesale (i.e. very few people get fired because their position was "outsourced" to automation). Rather, automation lets people who are proficient in Domain A who need some work done in Domain B become proficient enough in Domain B with sufficient ease that it's cheaper for them to pick up the requisite Domain B skills themselves versus hiring a Domain B specialist.

Nobody denies that someone like Matteo is extremely privileged to have been born in the wealthiest country in the world, attend one of the best public schools in that country, and therefore be exposed to a research program that connected him to the Caltech professor that made his work possible.

That privilege may well be a necessary condition towards being able to publish a paper that shows extreme computational sophistication for a high schooler (and indeed, IMO would be a middle-of-the-road graduate-level paper). But it's certainly not a sufficient condition, as you seem to be implying when you say that blindly giving a kid $10-$20k is "effectively the same" as having Matteo's background. If you just handed $20k worth of GPUs to a rich dilettante child, they would not be able to achieve anything close to what Matteo accomplished.

They're not. For some odd reason, the comments on this post are full of bitter people who cannot possibly fathom that brilliant young people not only exist, but also achieve amazing things on their own merits.

Please stop repeating this lie. He went to the public Pasadena High School.

Pasadena High School, where Matteo went to school, is public.

And indeed, that's exactly what happened [0]: the kid in the OP was in a rigorous research program for high schoolers, which connected their talents to PIs who could nurture and support them. GP shouldn't reactively tear down the success of exceptionally talented kids because of their own unfortunate n=1 life experience.

[0] https://www.justinmath.com/math-academys-eurisko-sequence-5-...

From the paper [0]: "The computer used for this paper contains an NVIDIA Quadro RTX 6000 with 22 GB of VRAM, 200 GB of RAM, and a 32-core Xeon CPU, courtesy of Caltech."

That GPU was first released in 2018, and can be had for ~$1500 today. The computer as a whole sounds exactly in-line with what a lab would have as an old spare machine. The student is lucky for sure to have access to such an institution, but it's not like he had rich parents who casually handed him $10-$20k. Much more likely he got access to Caltech resources because his exceptional talent caused a professor to take interest in him:

"I would like to acknowledge and thank deeply my mentor Davy (Dr. J. Davy Kirkpatrick) for introducing me to astronomy at IPAC and providing guidance throughout this project, aiding in data analysis and the collection of known objects for the test set."

[0] https://iopscience.iop.org/article/10.3847/1538-3881/ad7fe6

This dedicates at least as much time to discussing the eccentricities of the underlying Rust implementation (and the Rust language itself) as it does to discussing the underlying low-level hardware/software concepts. Since this is very much still a work-in-progress (only the first three sections have been fully fleshed-out), I have a suggestion to make: please make it more language-agnostic, with a greater focus on the fundamentals versus the implementation.

Whenever someone says there's no such thing as a 10x programmer, I point them to Fabrice and they usually change their mind.

I doubt it. Shor's algorithm relies on the quantum Fourier transform, which requires the complex phase information encoded in the quantum wavefunctions. The quantum probability norm (L2) accounts for interference between the complex amplitudes of these wavefunctions; the classical L1 probability norm does not.

Good question. Why hasn't there been a profusion of new game-changing software, fixes to long-standing issues in open-source software, any nontrivial shipped product at all? Heck, why isn't there a cornucopia of new apps, even trivial ones? Where is all the shovelware [0]? Previous HN discussion here [1].

Don't get me wrong, AI is at least as game-changing for programming as StackOverflow and Google were back in the day. I use it every day, and it's saved me hours of work for certain specific tasks [2]. But it's simply not a massive 10x force multiplier that some might lead you to believe.

I'll start believing when maintainers of complex, actively developed, and widely used open-source projects (e.g. ffmpeg, curl, openssh, sqlite) start raving about a massive uptick in positive contributions, pointing to a concrete influx of high-quality AI-assisted commits.

[0] https://mikelovesrobots.substack.com/p/wheres-the-shovelware...

[1] https://news.ycombinator.com/item?id=45120517

[2] https://news.ycombinator.com/item?id=45511128

Funnily enough, Spotify did recently introduce a miniplayer [0]!

[0] https://community.spotify.com/t5/Community-Blog/Introducing-...

Unlike the Hot Dog Stand theme, the "Plasma Power Saver" theme also featured in the article actually was function over form, not just an aesthetic choice (or lack thereof). It was to reduce burn-in on the plasma displays of old portable computers, e.g. here [0].

[0] https://retro.swarm.cz/20170331/windows-31-running-on-ibm-ps...

>I only write around 5% of the code I ship, maybe less.

>I do thoroughly audit all the code that AI writes, and often go through multiple iterations

Does this actually save you time versus writing most of the code yourself? In general, it's a lot harder to read and grok code than to write it [0, 1, 2, 3]. For me, one of the biggest skills for using AI to efficiently write code is a) chunking the task into increments that are both small enough for me to easily grok the AI-generated code and also aligned enough to the AI's training data for its output to be ~100% correct, b) correctly predicting ahead of time whether reviewing/correcting the output for each increment will take longer than just doing it myself, and c) ensuring that the overhead of a) and b) doesn't exceed just doing it myself.

[0] https://mattrickard.com/its-hard-to-read-code-than-write-it

[1] https://www.joelonsoftware.com/2000/04/06/things-you-should-...

[2] https://trishagee.com/presentations/reading_code/

[3] https://idiallo.com/blog/writing-code-is-easy-reading-is-har...

Smartphone keyboards dynamically adjust the "hitbox" of each key based on what's previously been typed and overall letter frequencies of the language. So when typing "Paris is the capital of Fr..." [*], the A key becomes much easier to hit than its neighbors. Fun fact: back in the day, when this tech was less refined, certain letter contexts made the hitboxes of some keys effectively nonexistent [0].

I wonder if an approach like KKeyboard with larger but statically combined keys leads to faster typing than the current approach with smaller but dynamically "combined" keys.

[*] In reality, the context is modeled using a simple Hidden Markov Model with a much smaller effective context window that could not associate "Paris" and "France." But you get the idea.

[0] https://forums.macrumors.com/threads/impossible-to-type-okee...

That's what makes this so funny: the AI was earnestly attempting to predict the future, but it's so bad at truly out-of-distribution predictions that an AI-generated 2035 HN frontpage is hilariously stuck in the past. "The more things change, the more they stay the same" is a source of great amusement to us, but deliberately capitalizing on this was certainly not the "intent" of the AI.

It's because none of those companies is considered "Information Technology" according to the official GICS criteria [0] used to classify companies in the index. For instance, Meta and Google are in the "Communications Services" sector; Amazon is in "Consumer Discretionary." There are 69 total companies in the S&P 500 in the "Information Technology" GICS sector [1], and all are excluded from SPXT.

[0] https://en.wikipedia.org/wiki/Global_Industry_Classification...

[1] https://en.wikipedia.org/wiki/List_of_S%26P_500_companies

The SPXT [0]/XMAG [1] ETFs are exactly what you're looking for.

[0] https://www.proshares.com/our-etfs/strategic/spxt (S&P minus tech stocks)

[1] https://www.defianceetfs.com/xmag/ (S&P minus "Magnificent 7")

In a similar vein, e^pi - pi = 19.9990999792, as referenced in this XKCD: https://xkcd.com/217/

>scalable, high throughput, low latency, reliable, durable, low operational overhead, high uptime, encrypted, distributed, replicated storage with multiple tier1 uplinks to the internet

If you need to tick all of those boxes for every single byte of 20PB worth of data, you are working on something very cool and unique. That's awesome.

That said, most entities who have 20PB of data only need to tick a couple of those boxes, usually encryption/reliability. Most of their 20PB will get accessed at most once a year, from a predictable location (i.e. on-prem), with a good portion never accessed at all. Or if it is regularly accessed (with concomitant low latency/high throughput requirements), it almost certainly doesn't need to be globally distributed with tier1 access. For these entities, a storage cluster and/or tape system is good enough. The problem is that they naïvely default to using S3, mistakenly thinking it will be cheaper than what they could build themselves for the capabilities they actually need.

Lots of things can get to that much data, especially in aggregate. Off the top of my head: video/image hosting, scientific applications (genomics, high energy physics, the latter of which can generate PBs of data in a single experiment), finance (granular historic market/order data), etc.

Assuming those 20PB are hot/warm storage, S3 costs roughly $0.015/GB/month (50:50 average of S3 standard/infrequent access). That comes out to roughly $3.6M/year, before taking into account egress/retrieval costs. Does it really cost that much to maintain your own 20PB storage cluster?

If those 20PB are deep archive, the S3 Glacier bill comes out to around $235k/year, which also seems ludicrous: it does not cost six figures a year to maintain your own tape archive. That's the equivalent of a full-time sysadmin (~$150k/year) plus $100k in hardware amortization/overhead.

The real advantage of S3 here is flexibility and ease-of-use. It's trivial to migrate objects between storage classes, and trivial to get efficient access to any S3 object anywhere in the world. Avoiding the headache of rolling this functionality yourself could well be worth $3.6M/year, but if this flexibility is not necessary, I doubt S3 is cheaper in any sense of the word.

Very cool. tl;dw: an inverted triple pendulum has 2^3 = 8 equilibria, since each arm of the pendulum can either be up or down (naturally, all but one equilibria are unstable), and this controller is able to make all 8*7 = 56 transitions between them.

Control theory is one of those things that shouldn't possibly work, yet here we are.

Twitter's failures are solely due to Musk's changes in corporate governance (e.g. boosting fringe right-wing content causing its existing userbase and advertisers to flee the platform), not due to any engineering problems caused by reducing headcount. Strictly from an engineering standpoint, Twitter works just as well as it did before Musk took it over.

As I wrote in another post, if Musk had never purchased Twitter and Jack Dorsey performed the same reduction in engineering staff, I doubt the site would be materially different from how it was pre-Musk.

"Bullshit job" has a specific meaning that's less about being in a pointless field-of-work (like adtech or many parts of fintech) and more about occupying a pointless role, regardless of the field. David Graeber (the originator of the term) gave the following examples [0]:

— Flunkies, who serve to make their superiors feel important, e.g., receptionists, administrative assistants, door attendants, store greeters

— Goons, who act to harm or deceive others on behalf of their employer, or to prevent other goons from doing so, e.g., lobbyists, corporate lawyers, telemarketers, public relations specialists

— Duct tapers, who temporarily fix problems that could be fixed permanently, e.g., programmers repairing shoddy code, airline desk staff who calm passengers with lost luggage

— Box tickers, who create the appearance that something useful is being done when it is not, e.g., survey administrators, in-house magazine journalists, corporate compliance officers, academic administration

— Taskmasters, who create extra work for those who do not need it, e.g., middle management, leadership professionals

[0] https://en.wikipedia.org/wiki/Bullshit_Jobs