So the bottle doesn’t break, it just pops open? This still sounds like a packaging issue. Maybe unstopper / squeeze / stopper the bottle, so it’s got negative pressure. Maybe replace the cap with some other more permanent type of cap (one that doesn’t have a little flip-top, if the ones they’re including do, just a solid cap and then ship the flip-top one alongside it)? IDK. How is it coming apart in transit? It’s not literally the plastic bottle breaking, is it?
This has got to be the packing, not the bottle. I have never heard of a bottle being shipped that suddenly broke on its own, without impact with its environment being the issue.
Beastie Boys had one of the first and biggest of the anti-Iraq-War songs, I can’t think offhand of one that was more “mainstream” at the time and still explicit and specific about it.
Well I’ll be sleeping on your speeches 'til I start to snore
Cause I won’t carry guns for an oil war
As-Salamu alaikum, wa alaikum as-salam
Peace to the Middle East peace to Islam
And so on. It might not have been the best (IMO that is “Empire” by Dar Williams, with haunting sadness, historical scope, and irony), but it was big.
I thought I had it worked out, how to sort of strike a balance so I can keep my focus intact and let it be helpful without wasting time constantly correcting its stuff or shying away from actually paying attention to the code. But I think my strategy of “let the LLM generate a bunch of vomit to get things started and then take on the correct and augmentation from a human standpoint” has let the overall designs at a high level get a lot sloppier than they used to be.
Yeah, you might be right, it might be time to just set the stuff aside except for very specialized uses.
Certainly possible
I’m also genuinely a little bit alarmed looking back now at my pre-LLM code and seeing the quality vs. the with-LLM code.
IDK, I just popped open a project from 10 years ago and it’s perfectly clean, it’s actually better than some of my modern code because it’s not LLM-ified to save time.
I think it has a lot more to do with whether it was made in that “kind of crappy IDK what I’m doing” phase of programming. Some of your old stuff is going to be in that category sure. As long as you’re out of that, however long it took you to get there or however far away it was in time, your code should be good.
Yeah, that sounds about right lol. All my python projects for years were basically writing C in python. It actually took me all the way up until I got to look at the code ChatGPT likes to generate that I learned idiomatic python. My first database project was based on the Unix philosophy, where everything was strings (no ID keys, no normalization), because Unix is good.
The client wasn’t happy when they looked at the DB code lmao. Whatever, it worked, they still paid us and I didn’t do it again.
I won’t say 100%, but they’re generally pretty good. Big ones I can think of:
The first is a little bit qualified I guess. I was somewhat against replacing Biden for that reason (definitely before the debate), which was absolutely a mistake. But I think in retrospect, the way that they were able to blame Kamala Harris for Gaza and inflation and make it work was pretty spot-on to what I predicted.
The second one, people were furiously telling me how wrong I was, how impossible it would be for anyone to be worse than Biden, and in early days saying that Trump had achieved a cease-fire and it was just proof of how easy it would have been if only Biden had put some slight effort to it.
Am I the only one who likes looking at my old code? Generally I feel like it’s alright.
Usually the first project when I’m learning how to use some new language or environment is super-shitty. I can tell it’s very bad, usually I don’t like interacting with it if I have to make changes, but it’s still not overly painful. It’s just bad code. And that one exception aside I generally like looking at my code.
Yeah. I feel like in a few years when literally nothing works or is maintainable, people are going to have a resurgent realization of the importance of reliability in software design, that just throwing bodies and lines of code at the problem builds up a shaky structure that just isn’t workable anymore once it grows beyond a certain size.
We used to know that, and somehow we forgot.
Yeah. I have no idea what the answer is, just describing the nature of the issue. I come from the days when you would maybe import like one library to do something special like .png reading or something, and you basically did all the rest yourself. The way programming gets done today is wild to me.
I sort of have a suspicion that there is some mathematical proof that, as soon as it becomes quick and easy to import an arbitrary number of dependencies into your project along with their dependencies, the size of the average project’s dependencies starts to follow an exponential growth curve increasing every year, without limit.
I notice that this stuff didn’t happen with package managers + autoconf/automake. It was only once it became super-trivial to do from the programmer side, that the growth curve started. I’ve literally had trivial projects pull in thousands of dependencies recursively, because it’s easier to do that than to take literally one hour implementing a little modified-file watcher function or something.
Yeah, exactly. If you read the Snowden leaks to learn the details of what some of their actual capabilities are (smuggling flawed keys into the DH exchange for most major web browsers for example), it makes this stuff look like kids in their basements fucking around.
I feel like this is kind of the amateur-hour stuff. It’s certainly dangerous, but in comparison to a lot of state-actor activities (or even committed-amateur activities), this kind of supply-chain attack is pretty blatant and easy to spot. Which doesn’t mean it’s easy to spot – I just mean would be trivial to volunteer and contribute some minimal fixes and enhancements to some open source project, and then at one point smuggle in a zero-day that will basically never be detected unless someone detects the intrusion itself and then works backwards from there with a ton of time to spend on it.
If you’ve ever looked at the obfuscated C contest it should be obvious that this kind of thing can be made completely invisible if you know what you’re doing. Some of the interactions and language features that lead to problems are basically impossible for a casual viewer to see, even if they’re paying attention, and the attack surface is massive and the amount of attention that goes into checking it for weird subtle vulnerabilities is minuscule.
What I used to do when I lived in an area with a decent number of homeless people, was offer to get them some food, if I had the time for it. I’d walk somewhere with them, say what do you want I’ll grab it for you, and come out and hand it to them. It was honestly a little bit awkward to do it without feeling like a ponce, making conversation with the person or whatnot feeling condescending, but whatever.
I would say the majority would discount the suggestion. I didn’t feel the slightest bit bad saying no you can’t have any money then. A minority would be really into the idea and clearly fucking light up at the idea of having their hands on a sandwich. Those dudes I felt like it was important that they get their sandwich.
I also knew a guy who used to be homeless, volunteered with homeless services and substance abuse programs and etc, spent a ton of time on it. He never gave money on the street. He got very bitter about the subject, he just said that it doesn’t help them. Make of that what you will, I don’t really know the ins and outs, but that’s what he said.
Why not just replace it with a cap that isn’t a flip-top? Screw it on tight, squeeze the bottle slightly before putting the cap on so there’s a slight negative pressure. That would be my first thing to try.