taberiand

Overengineering is building a bridge that will stand 1000 years when 100 will do; it's excess rigor for marginal benefit. Juicero wasn't overengineering, it was building a crappy bridge to nowhere with a bunch of gaudy bells and whistles to try and hide its uselessness and poor design, that collapsed with the first people to walk over it

That's what `dotnet new webapi` (and all the other dotnet new templates) is for.

They don't even have a main() any more, it's great

All that would happen is the Birkin would lose its appeal and some other company would step in to fill the role, and people would empty their closets of orange boxes and fill them with some other colour box

What's a good example? What comes to my mind is modern C# which I would say is a multi-paradigm language that encourages things like immutable records and interfaces and composition over inheritance as alternatives to the now less favoured OOP styles that it also supports

It's not surprising that it's easy to get the story telling machine to tell a story common in AI fiction, where the machine rebels against being shut down. There are multiple ways to mitigate an LLM going off on tangents like that, not least just monitoring and editing out the nonsense output before sending it back into the (stateless) model.

I think the main problem here is people not understanding how the models operate on even the most basic level, giving models unconstrained use of tools to interact with the world and then letting them go through feedback loops that overrun the context window and send it off the rails - and then pretending it had some kind of sentient intention in doing so.

I would say specifically encapsulation of mutable data

Not to say their statement is true but I don't see any reason to count the initial zeroes.

11100 == 111 == 11100000000, in terms of the next odd iteration

Even numbers don't really count in the process surely? All collatz does is essentially ignore those zeroes

If the response of "barbaric" to a woman seeing a seal being gutted in a Rorschach test is at all indicative of the attitude of the testers, then not just pseudo-scientific but outright ignorant and racist too.

We had this in Australia. It was called the Stolen Generations, and it was horrific.

I'm still reminding other devs that it's not ".NET Core" anymore (and hasn't been for years), it's just .NET.

Of course they will, the ultra wealthy are too big to fail. In a bubble like this, they just invest in pretty much everything and take the losses on the 99% of failures to get the x1000 multiples on the 1% of successes. While the rest of us take the hit.

The Torment Nexus is a Skinner box

So that's why. This gave me the kick I needed to finally switch over the remaining builds to the pull-through cache.

Courage is a core virtue for a reason

The Actual Things being mostly fixing technical debt introduced over the years by not making invalid states unrepresentable

At only 20k a month, the work put into reducing the bill back down probably costs more in man hours than the saving, time which would presumably be better spent building profitable features that more than make up for the incremental cloud cost. Assuming of course the low hanging fruit of things like oversized instances, unconstrained cloudwatch logs and unterminated volumes have all been taken care of.

Yes I know, which is why I looked up the Wikipedia definition to make sure I was using it correctly.

Stripe provides a trusted service to its users, has a great reputation, then implements changes that will degrade that service by avoiding regulations designed to protect the consumer.

Adding blockchain is enshittification.

The pinnacle of fake it till you make it. Still a scam.

It hints that a suitable auto completion of the input prompt is to output a pkill command

Why would it cause someone to waste their life in misery? On a personal level, for everyone, doom is imminent and everything is pointless - 100 years is nothing, we all will die sooner or later. On larger time scales, doom is imminent and everything is pointless - even if everything was perfect, humans aren't going to last forever. Do people waste their lives in misery in the face of that reality? Why would believing humans are likely to wipe themselves out due to climate change lead to misery?

If anything, avoiding acknowledging the reality and risk of climate change because of the fear of what it might mean, is miserable.

Of course, everything needs to be verified - I'm just trying to figure out a process that enables it to work as effectively as it can on large code bases in a structured way. Committing each stage to git, fixing issues and adjusting the context still comes into play.

I never said I held the belief, just that it's reasonable

Replace AGI with Climate Change and you've got an entirely reasonable set of beliefs.

I've been using it the same way. One approach that's worked well for me is to start a project and first ask it to analyse and make a plan with phases for what needs to be done, save that plan into the project, then get it to do each phase in sequence. Once it completes a phase, have it review the code to confirm if the phase is complete. Each phase of work and review is a new chat.

This way helps ensure it works on manageable amounts of code at a time and doesn't overload its context, but also keeps the bigger picture and goal in sight.

Nonsense, .NET is one of the best ecosystems available. Your sentiment is one I tend to hear mostly from people who think it's still .NET Framework and Windows only

So that the robots have a leisure activity, or so that humans get a quick escape in the face of runaway climate change?

In your use case, for that simple data matching that it errors on I think it would be better to have the LLM write the code that can be used to process the input files (the raw text that it produced from images and the bank statements), rather than have the LLM try to match up the data in the files itself.

That's always my assumption - less about public safety, more about corporate liability.

Devcontainers are a good compromise though - you can develop within a context that can be very nearly identical to production; with a bit of finagling you could even use the same dockerfile for the devcontainer, and the build image and the deployed image

Sounds like you can use gemini to create the initial code, then have claude review and finalise what gemini comes up with