duncanfwalker

It might not be the perfect analogy, but it does show some important parallels and differences. Compilers reason to some extent - for example type inference is definitely some deductive reasoning that I would have to do if the compiler didn't do it for me.

The hallucinations point is a difference and one that we haven't quite learnt to handle yet. Generally, compilers are deterministic (even it it might not feel like it sometimes) and there's a lot of useful properties that come from that.

I have recently put Claude into a CI/CD pipeline and it's made me realise how much I rely on pipelines being deterministic.

I have been feeling that something - a few things - has to change about Agile rituals given a team is using Claude extensively. I haven't yet found any thoughtful writing on the topic.

The most obvious impacts have been shorter synchronous conversations for planning and refinement because so much more specification is written. I've also found myself doing more spiking.

The thing is, all the changes I see to Agile are matters of degree, not fundamental breaks with the Agile manifesto or tradition. I'm not sure whether that's because a) all that's needed is tweaks or b) because the existing way of doing Agile is so in-grained that it's hard to see that it doesn't fit today's reality.

Reminds me of seeing this presented at a conference years ago https://github.com/braposo/graphql-css

It was a joke but I really like the way it pointed out how we copy and reapply patterns in different contexts and that might enable unexpected things.

I would assess the directionality and rate of the trend. If it's getting better fast and we don't see a limit to that trend then it will eventually pass whatever threshold we set for adoption.

It's not so valuable to assess the current state - what the impact of using AI is today. From personal experience it feels like overall impact on productivity was not positive a couple of years ago, might be positive now and will be positive in a couple of years. That means by assessing the current state of impact on product where just finding where we are on that change curve. If we accept that trend is happening then we know at some point it will (or has) pass the threshold where our companies will fall behind if they're not using it. We also know it takes a while to get up to speed and make sure we're making the most of it so the earlier we start the better. That's the counter arguement that we could wait for a later wave to jump on but that's risky and the only potential reward is a small percentage short-term productivity gain.

Spending is paid for out of tax and all those people will have paid tax. Paying less tax than someone else doesn't make a free rider. Deliberately opting out of an obligation while taking from the group makes a free rider.

I guess it's more clear that it should be a to statically readable value? eg you shouldn't do things like use arguments to build the str

This is spot on. I'd love it if it was possible to get the integration with the QGIS ecosystem. It could open source integrations or even a commercial offering that just joins things up in a cohesive way just something that enables a more smooth collaboration model.

Any tips on smoothing the transition between the two that mean work isn't duplicated?

That's an insightful nuance. I've seen you just create divisions in organisations because while it is a really fully featured desktop application, it implies a way of working that doesn't play well with the cloud, which creates barriers between experimenting and production.

As other comments have said, I'd prefer other solutions to get by all the tests to run faster. It would be interesting to see if it could be used to prioritise tests - get the tests more likely to fail to run sooner.

Oh god, this has just made me reflect that we're in the golden age of generative AI - not in technology terms, in user experience terms. We're in the period where the major products are competing against each other before they switch into enshitfication mode. You're certainly right, there's going to be ads in the answers and probably worse. I'm imagining companies paying to introduce ideas as subtle subtexts to millions of unrelated answers or platforms deliberately engineering the ux to maximise understanding of our drives and preferences purely so it can be sold.

I wonder whether we'll be able to look back on this period in 10 years time and save definitively whether the wide spectrum of responses to LLMs was perception or real feature of our differing jobs.

+1 you're paying for the governance as much as you're paying for the code.

At the start of your comment I thought the 'issues like this' were going to be the 4 year discussions about what is and isn't core.

I think a lot of this is addressed by having a definition of done and more generally being explicit about quality expectations. You don't need to worry whether to polish the readme or add cross-compilation if you conscious about your quality expectations and the drivers behind them - there is no single 'best' project.

It's true that anything that can go wrong will go wrong but I wouldn't use that as a maxim to direct designs - risk is one trade-off and it's significance varies.

I really like it. I particularly like that you've resisted the temptation to include SQL itself or the jq queries in the DSL.

The validation piece makes it feel a bit a bit like the Rails mindset for people who work better in FP.

I'd make a could of suggestions for the docs: Maybe a bit more discussion of how we'd test our webpipe code. I see why you've called them 'middlewares' but, maybe the term 'macros' or 'pipeline functions' might avoid confusion with express/connect middlewares

I think it depends on the API - we do this with AWS Secret Managers. I haven't seen it fail but if did it would only effect new instances coming into service so I think we'd have to be pretty unlucky for it to have a noticeable impact.

Yeah, I'd agree with that. Validation rules are like an extension to the type system. Invariants are useful at the edges of a system but also in the core. If, for example, I can be told that a list is non-empty then I can write more clean code to handle it.

In Java they got around the external-dependency-in-the-core-model problem by making the JSR-380 specification that could (even if only in theory) have multiple implementations.

In clojure you don't need to worry about another external dependency because the spec library is built-in. One could argue that it's still a dependency even if it's coming from the standard library. At the point I'd say, why are we worried about this? it's to isolate our core from unnecessary reasons to change.

I get that principled terms it's not right but, if those libraries change on API on a similar cadence to the programming language syntax, then it doesn't impact in practical terms. It's these kind of pragmatic compromises that distinguish Python from Java - after all, 'worse is better'.

I mainly see this wtf pages as a hook to talk about the internals of a language/interpretor/etc. As you say, there's no point reading them as a criticism of the language because that's just not what production python looks like. I read the line of code and think 'can I imagine why it does that?' if I can I skip the explanation but sometimes I have absolutely no idea what's going on and they're the ones I like to read the detail on

The --no-verify example is interesting because I can imagine the same hint being useful for junior engineers. In general it's hard to give the the right level of advice in cli docs because you don't always know who the consumer will be and so what knowledge can be assumed. The think that makes LLMs different is that there's no problem to being verbose in the docs because you're not wasting any human's time. It would be cool if you could docs that provide extra advice like in the example and then the interface adapted for the users context - for LLMs provide everything, for human users learn what they know give them just the right level of advice

100% - for me the fact that hasn't been picked up throughout the research undermines the credibility of the rest of the paper.

> Comments per PR [...] served as a measure to gauge the depth of collaboration exhibited during the development and review process.

That sounds like a particularly poor measure - it might even be negatively correlated. I'm worked on teams that are highly aligned on principles, style and understanding of the problem domain - they got there by deep collaboration - and have few comments on PRs. I've also seen junior devs go without support and be faced with a deluge of feedback come review time.

The skew you mention for mass transit exists for individual vehicles too. In New York it's baked in that the avenues, running north-south, are wider than the east-west streets and have longer greens at intersections.

The 15-minute city idea is now a real trigger issue. It's originally urban planning concept so I understand it's more about design the city in such a way that you /can/ live most of your life within a 15mins journey rather than assuming that's already the case (or worse as some conspiracy theories assume).

Nice idea to make that accessible in the browser.

If you made the default query something that has some variant-specific syntax or functions new people would be about to see the value more quickly

I'd say it was The Full Monty and Brassed Off. I'd say it was almost a mini-genre at the start of the Blair years.

There's also Made in Dagenham. There's probably lots of french language films with workers struggle. The one that springs to mind is the hilarious satire Louise-Michel

There's a few different things in there that I think have different answers. I'd draw a distinction between banning and curating to cover the quality points.

I don't know what it's like in other parts of the world but I'd say in the UK there's a clear consensus that people shouldn't be able to incite violence - and that covers books.

Suicide and self-harm is a bit more tricky, there are books that deal with those topics that might be important to include in a curation depending on the context - e.g. the readers age and how vulnerable they are.

For me the point is that __init__ is special - it's the language's the way to construct an object. If we want to side-effecting code we can with a non-special static constructor like

class Foo @classmethod def connect(): return Foo()._connect()

The benefit is that we can choose when we're doing 1) object construction, 2) side-effecting 3) both. The downside is client might try use the __init__() so object creation might need to be documented more than it would otherwise

The comparison with Closure is really interesting. They make the point that they do less reinvention of Lua than Closure does with Java - functions, standard library, tooling. I'd love to know why. Is it just that Lua has less problems than old-Java