shmolyneaux

I love plain text, but the calculus of being able to access the content in 50 years is much more interesting in the age of agents. They can infer the meaning of structured data without schemas, decompressed archives, find embedded files, etc. It's not perfect, but the durability of binary formats is better now than it has ever been.

It's not baked-in to the weights of any model, but agents can write their own tools to work with arbitrary binary formats and get many of the benefits of off-the-shelf unix utilities.

I love that the Godot game engine has a textual scene description. That's a stark contrast to Unreal Engine's binary format for blueprints (visual scripting).

This is the Pareto Front [1], rather than the Pareto principle. It's the idea that anything that's more intelligent is more expensive and anything that's less expensive is less intelligent.

[1]: https://en.wikipedia.org/wiki/Pareto_front

For reference, the glut of Erlang posts was due to pg posting "Why HN is slow lately": https://news.ycombinator.com/item?id=512145

> it would be better to have posts about the innards of Erlang than women who create sites to get hired by Twitter

Here's a follow-up video by Ben Felix posted more recently about the case for home ownership: https://www.youtube.com/watch?v=16eA5ebWMQQ

In the end, home ownership is more based around the kind of life you want to live than costs/benefits of the house as an asset. As a Canadian I see that many of my friends would choose to pay a lot more each month on the principle of a mortgage than they would ever save in a registered account.

I definitely appreciated your post about Nano Banana Pro. It's also a genuinely useful time-capsule for how these systems evolve and where they fall short. I've preferred the output of ChatGPT Image 2. I think a post would be very helpful for folks to see what they're missing.

There is a bit more to the story than a 1% wealth being "equivalent" to a 20% income tax. The primary difference is that unrealized gains are taxed by a wealth tax. We need a mechanism for assets to be sold by the richest in society. If those with assets keep accruing more assets the median person will suffer. When we're talking about real assets (housing, retail shops, warehouses, land) we don't need to be concerned about capital flight. The assets are still there on the ground. Reducing the cost of those assets is exactly what we need to help a local economy.

That being said, the richest are effectively _not_ paying the highest marginal tax rate considering all the tax structuring they do. Claiming that they would be paying the highest income tax in the world is misleading, for one. Secondly, the richest in the world _should be_ paying the highest income tax.

I think more people need to see this. This is how the creator of C++ thinks we should be writing code. This is what he thinks code should look like. To split a string by whitespace we should use `while (cin >> s)`. We should have a `typedef` in the middle of functions. Iterations should use `.begin()` and `.end()` everywhere. There might even be a bug with a trailing "+" appearing in the output?

Imagine if this was a new language that the dev community was seeing for the first time. It's hard to imagine it gaining much traction.

It's true that it's shorter, but I suspect that the if-return, if-return pattern compiles down to much faster code. Separately, this code was originally written in C then ported. There are reasonable explanations for why Matz has the code written this way besides the typical AI slop.

Github Copilot changed to token pricing earlier this week

Opus was the reason I paid for GitHub copilot, but they had the pricing model completely wrong. I could assign copilot to a substantial issue using Opus and have it handle 30 minutes of work with many subagents with iterative testing. With 300 "premium requests" a month I could have copilot do substantial work for 3 premium requests per issue. It was very clear that this was unsustainable for Microsoft to pay for, so I expected change to come.

However, I never expected Opus 4.6 to be removed for the cheaper plans. I expected the pricing model to change, but not to lose access to the model. Moving to being token-based makes sense. It makes the cost more closely aligned with user pricing.

It was nice while it lasted. I got Opus 4.5 to do a lot of work from the beach by assigning it to detailed issues. With this news I've cancelled my Pro subscription. That will help a bit with their capacity issues.

If you want an architectural overview of the DS, this is a fantastic overview: https://www.copetti.org/writings/consoles/nintendo-ds/

That seems like a GDPR violation waiting to happen. It shouldn't be possible for them to store an email address like that forever and be in compliance.

That's noted further down the page:

- `_*` = any string

This was a fun read, but it's a shame it hasn't gotten more attention. I wouldn't have guessed that Bun was using a custom fork of Zig. Since the feature has been closed, I strongly suspect that they'll eventually need to need to go back to upstream and revert their usage of private members. Using Python style `_members` seems like it should be good enough. If you're already manually managing memory it seems like respecting those privacy hints should be reasonable enough.

Are there output formats that are more reliable (better adherence to the schema, easier to get parse-able output) or cheaper (fewer tokens) than JSON? YAML has its own problems and TOML isn't widely adopted, but they both seem like they would be easier to generate.

What have folks tried?

While people can nitpick, the article is pretty clear that there isn't a single answer. Everything depends on how you constrain the problem. How much experience does the developer have? What time constraints are there? Is it idiomatic code? How maintainable is the code? You can write C with Rust-like safety checks or Rust with C-like unsafety.

When you can directly write assembly with either, comparing performance requires having some constraints.

For what it's worth, I think coding agents could provide a reasonable approximation of what "average" code looks like for a given language. If we benchmark that we'd have some indication of what the typical performance looks like for a given language.

I would encourage you to give it a try anyways. Unfamiliar syntax is off-putting for sure, but you can get comfortable with any syntax.

Coming from Python, I needed to work on some legacy Perl code. Perl code looks quite rough to a new user. After time, I got used to it. The syntax becomes a lot less relevant as you spend more time with the language.

Instant startup times are really nice. You definitely notice the difference. It also means that you can be a bit lazier when creating wrappers around those tools (running 1000's of times isn't a problem when the startup is 1ms, but would be a problem with 40ms of startup time).

Distribution can also be a lot easier if you don't need to care about the user having a specific version of Python or specific packages available.

I don't really do much in the web ecosystem, but I'm surprised how many people have a strong dislike for tailwind. I've had a lot of success using it.

I'm really suspicious about the performance concerns brought up in the article. Does the author think that long strings are really such a huge issue for the size of the JS bundle or processing time in the browser?

From my experience it's much easier to refactor the styling of a page using tailwind than modifying CSS. Needing to name a bunch of classes in HTML to reference in CSS adds a lot of obfuscation and it can be difficult to come up with those names. When the structure of the HTML changes the CSS inevitably breaks. I find that it's easier to keep the styling working when using tailwind.

I think that the value of keeping styling DRY is overblown. The author gives an example of some tabs that all use `font-medium` and how bad it is to need to modify all the uses at once. This seems like a non-issue to me. If you see the web page you would immediately see the issue if you forgot to change anything. Alternatively, you can still use `@apply` and classes if you don't want to repeat yourself. Even further you probably want to create reusable components anyways.

Tailwind is very easy to debug. I've never had an issue understanding why styling wasn't working when using it. In CSS I found that getting the styling right was a constant struggle.

The author mentions the issue of setting the text to red and blue in the same class attribute. He compared it to using `!important` in CSS, which is so far from the truth. You can immediately see the issue if the color isn't what you want. Inspecting the element in the browser would immediately show you that you set the text to multiple colors.

Tailwind solves a bunch of problems for me. Components are more self-contained. The class names are much easier to remember that the underlying CSS. The set of attributes you can use are focused to a small set of usable features. Animations are much easier. Responsive designs are easier to create. Flexbox (the most useful part of CSS) is easier to use. I work with a number of older developers (very smart folks that just haven't done web development) and I have a much much easier time getting them proficient with tailwind than CSS.

I strongly believe that tailwind is better for individuals, better for teams, better for beginners, easier to set up, and easier to maintain. If you're already a CSS expert or if you have an existing design system I can imagine that you wouldn't want to pick up tailwind. But for most websites and most teams I expect tailwind is a great option.

The problem for newcomers is something I faced when trying to use Zig, particularly for the build system. I heard a lot about how much nicer the build system is in Zig compared to other tools. However, as someone unfamiliar with C/C++ build systems I found it very hard to get anything configured.

In contrast, I tried to learn CMake after. Despite my gripes about the CMake language itself, I found it relatively straightforward to do everything I wanted. Docs, backwards-compatibility, and LLMs made it all easy to set up. I have a hybrid C++/Rust project that compiles to desktop/WASM with debug/release builds.

When the build system for Zig stabilizes I'm sure things will be better, but the breaking changes are rough based on my recent experience.

Blender is licensed under GPL, which makes it incompatible with most commercial game development.

What do you think of the Screen Actors Guild? That seems to have been a huge win for workers in the industry, seemingly without the negatives you describe.

I'm not in a position to help get you an interview at the moment, so I'd feel uncomfortable asking for your resume. Participating on Hacker News and GitHub is an avenue for networking. Without linking to information about yourself you may not be able to take full advantage of that.

I'm sorry to hear about your stress. The worst part about the recruitment process is that it doesn't put folks in a typical development situation. I hope you're about to find something!

If you're willing to associate your username with your personal identity, you could link to your projects/CV in your profile. Other commenters may be able to identify what recruiters are looking for and why your resume was dismissed.

Also, to the point of the post, do you consider whiteboard interviews to be good or bad for your situation? With covid it's harder for companies to find which applicants should be interviewed in the first place, and short questions are helpful for filtering out people who can't code at all.

The Jetson Nano[0] seems like it would be better for students, it's only $99.

[0]: https://developer.nvidia.com/embedded/jetson-nano-developer-...

Python runs the gamut. You can make small scripts that automate simple tasks and you can make huge websites that service millions of people a day. As projects get bigger, they can adopt tools to help them manage the complexity of the project.

These tools make complex projects simpler without complicating simple things. Personally, I wouldn't want to use Python on a large project without these tools.

Thanks for the reference.

Just so it's clear, the definition of "malware" used here is in-browser crypto mining and obfuscation. Only 1 in 600 of the top 1 million sites use WebAssembly. WebAssembly doesn't actually provide a new vector for malware.

An important thing note is that the weights that go into the rankings can be fully customized: https://spectrum.ieee.org/static/interactive-the-top-program...

The ranking shown on the linked article shows a weighting that's deemed to be relevant to IEEE Spectrum readers, which have a focus on Electrical Engineering.

Setting the weighting to be 100% Hacker News, Ladder Logic ends up in the middle and JavaScript is nearly at the bottom. Like most other Top X programming articles, this one should be treated as a bit of fun and shouldn't heavily inform your choice of language.

One issue that isn't capture by that quote is that an escalator cannot be used while being repaired. If the maintenance person is away while the escalator is part-way through being repaired it's very reasonable to see a "Temporarily Out of Order" sign.

I suspect that most new college grads have never used cash to buy gas (myself included).