Hacker Newsnew | past | comments | ask | show | jobs | submit | budro's commentslogin

Well poor design can require you to peel off multiple layers of optionals, and so they're often a significant smell just like onions are.


Shrek would argue the layers are a feature not a bug


Yeah this drives me up a wall. You ask any AI to make a change and then it thinks polluting your README.md with those details is appropriate. No I don't think "this project deliberately does [random detail]" is needed when that detail is irrelevant outside of recent context.

I'm to the point where I don't trust it to do any writing. It's only allowed to tell me what it thinks I missed. Because inevitably when I ask it to edit my prose, it destroys the text and I basically need to rewrite it all again.


This is exactly what made me bite the bullet and buy a Claude subscription back in February. It was very easy to evaluate how good the AI was if I _already knew_ what I was trying to build. A linter and its very well defined rules fit this perfectly. Plus the upside of building something that already exists is that you can scrape the internet for repos using the dependency, and compare your results to the original. I ended up finding a few bugs in the original linter rule this way!

Pretty much all of my recent projects have been focused on re-implementing or opening up the lid on some piece software. I have opted to not go the decompilation route (in some instances I can't even download the original software!), and instead reverse engineer using publicly available files that the programs create. Definitely a lot slower, but it's fun to build your model of how these opaque binary formats work and slowly watch your golden tests trend towards 100% matching. Also it's super cool to see the variety of use cases people had with the original software, and I definitely wouldn't have been exposed to many of these things had I not scraped all of Google for everything I could find related to the software.


Semi-interesting concept, but it's initially _very_ hard to get into because of how AI slop-coded the intro is. Do your own writing! Also the game was way too manual, you can't just call any game with conveyor belts Factorio. Not once in the game did it feel like I automated any process.

If you can get past all of that, the game does get somewhat interesting. The first level is just a game of APM, replacing your components with higher quality components until 100% and you win. The 2nd level puts reliability behind identification which has a cooldown. This was pretty neat because you discover how to use the markers + feedback loops to actually create a useful reliability comparator. You then use that to only identify candidates with known-higher reliability.

Unfortunately I think that's where the game (and maybe even the concept?) peaks. The 3rd level is basically identical, but with a longer cooldown on identification. That does teach you to use counters as an early source of high quality components to sort against (reliability% = components counted / total components on conveyor) but the winning strategy remains the same. The added Marker-Gate component doesn't really become useful until your reliability is high enough (or not without cascading 5+ or more of them) so the way to beat level 3 is exactly the same as level 2.

It would be cool to see this evolve into something more meaningful, but I have a feeling you'll quickly find out why all automation games have 100% reliable machines.


Same feedback - conditional probability until you eventually straight pipe a 100% reliability sorter to the solution. I think one workaround is to have a max reliability for the level - say 95% - requiring actual infrastructure in the long run.


I appreciate the feedback!

It sounds like you are a bit of an enthusiast and very good at these types of games. If you join the discord there are 3 harder levels, the last two have no manual identification whatsoever, which may be more interesting to you.


Your maze demo gave me the idea to try out the "speculative fan-out" pattern [1]. It seemed interesting to try solving mazes in one-shot. Unfortunately it seems like Jev can't reliably solve basic mazes even with a step count of 1! [2] I was very surprised. Could you point me in the direction of your maze solving code so I can see if it's a skill issue? The only other explanation I can come up with is that Jev was not trained on spatial reasoning tasks at all, and on the other hand DiffusionGemma has a vision tower and significantly more spatial data in its training set.

[1] https://docs.typesafe.ai/patterns/fan-out [2] https://github.com/Bud-ro/jev-demos/tree/master/packages/maz...


There's a Joel On Software post [1] in the same vein as this, which totally changed the way I think about writing software. You should aim to write software which can be verified locally with the smallest window of context. It's informed a lot of my decisions around linters, static analyzers, assertions, etc. I'm always looking for assertions that narrow state and reduce the number of lines you need to read to verify the correctness.

Rust has definitely caught my eyes a few times here, since most of what I described is manual. Particularly in the embedded space RTIC [2] has some really neat stuff going on. Other languages have good type systems and spatial memory safety, but nothing else seems to have Rust's killer features around concurrency.

[1] https://www.joelonsoftware.com/2005/05/11/making-wrong-code-...

[2] https://rtic.rs/2/book/en/


> Isolated QA should not exist because anything a QA engineer can do manually can be automated.

I almost entirely agree. You'd certainly want a majority of QA responsibilities to fall to devs since that keeps the feedback loop tight. Also with the amount of compute we have you can trivially outpace a typical QA team with a single dev working on fuzz tests and property based tests. If you really still feel the need to outsource then there are cool tools like Antithesis [1] which let you trade money for compute in their complicated fuzz testing suite.

Where that falls apart imo is when your software interacts with hardware in any non-trivial way. Fuzz testing doesn't really work when your system is spinning big and heavy things for example. Real hardware that interacts with the world will always create this gap where the devs don't know how to fully test it. Your systems engineers are best equipped to handle this and ensure certain controls follow the right curves, but they typically don't have the bandwidth or are very inexperienced with software. I think a QA organization _can_ fill this gap and deliver value. But I'd almost always prefer hiring another 1 or 2 system engineers who can work towards this problem full time instead. It's much easier to train someone in software than it is to train them in motor control or sealed systems.

[1] https://antithesis.com/


But they're not willing. And they'll often just cause more damage/loss than they provide in benefit to the company. Even the most benign drug which people claim is fine is one that makes you lazy and slow. Why would you employ someone so addicted to it that they can't abstain for a few weeks?

"Piss tests" filter out a lot of anti-social behavior.


>But they're not willing.

This is bullshit.

>And they'll often just cause more damage/loss than they provide in benefit to the company.

That's for the company to decide.

>Even the most benign drug which people claim is fine is one that makes you lazy and slow.

If you need someone hyper to do it, then hire the meth freaks.

>Why would you employ someone so addicted to

You seem to have misread my comment. I haven't deleted it, go back and check. I didn't say "companies should be forced to hire them". I promise that's not what you saw. But no need to take my word for it, move your eyes upward about 2 inches and check it out.

>"Piss tests" filter out a lot of anti-social behavior.

No, it literally causes people to steal copper wiring and pipes, turning salvageable houses into wrecks, causing millions in property damage, and in some cases causing deaths. Piss tests let them decide to not hire people who were borderline enough that the only way they could tell they were using drugs was to use piss tests. And I don't know how you can't see this, you're being irrational.


I think it mostly comes down to the standard library guiding you down this path explicitly. The C stdlib is quite outdated and is full of bad design that affects both performance and ergonomics. It certainly doesn't guide you down the path of smart design.

Zig _the language_ barely does any of the heavy lifting on this front. The allocator and io stories are both just stdlib interfaces. Really the language just exists to facilitate the great toolchain and stdlib. From my experience the stdlib seems to make all the right choices, and the only time it doesn't is when the API was quickly created to get things working, but hasn't been revisited since.

A great case study of the stdlib being almost perfect is SinglyLinkedList [1]. Many other languages implement it as a container, but Zig has opted to implement it as an intrusively embedded element. This might confuse a beginner who would expect SinglyLinkedList(T) instead, but it has implications surrounding allocation and it turns out that embedding it gives you a more powerful API. And of course all operations are defined with performance in mind. prepend is given to you since it's cheap, but if you want postpend you have to implement it yourself (it's a one liner, but clearly more expensive to the reader).

Little decisions add up to make the language feel great to use and genuinely impressive for learning new things.

[1] https://ziglang.org/documentation/master/std/#std.SinglyLink...


Antithesis talks about some very particular use cases, but they're not the first to explore this. SQLite has something similar in the form of their `testcase` macro. [1]

What's most shocking about their whole website is how it goes to show how unserious the software industry is at large with regards to testing. It's not surprising when a good chunk of the programmers I know are vehemently opposed to "adding too many assertions", let alone something like this.

[1] https://www.sqlite.org/testing.html#testcase


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: