But by this, I don't wanna say you should. It's also of course newer than what jQuery did, and might be inspired by it (just like Sizzle influenced the QuerySelector API, and CoffeeScript influenced arrow functions).
Isn't the point of a fluent interface that all functions (or methods) return the same interface, thus allowing for the desired chaining?
And obviously, this is a design pattern that fits when a suitable supertype exists or xan be easily defined.
Thus, void methods are already fit for pretty much the same interface, and everything with a return value that shouldn't be of the type of that specific god-interface, doesn't fit well into a fluent interface, e.g. count().
You can be insistent on the pattern and make count() return `this` instead of a number, but that's where the pattern becomes blurry.
When I started web dev, fluent interfaces were everywhere, and the motivations, thinking about it, seem to converge about another, different thing: lazy evaluation.
This is what jQuery has in common with ORMs, I'd guess.
The development experience isn't even the most important thing, it's providing an abstraction between executing a query (hence jQuery) and chaining selectors.
Natrowing down snapshots is completely different from chaining selectors, and this is the common aspect between an ORM and a library working on the DOM.
Where it starts to feel icky, in both cases, is, when mutations are involved.
Then you have potential for confusion around when these mutations are commited.
In other words, since jQuery collections are, well not "live", like getElementsByTagName, also not snapshots, like querySelectorAll is (snapshot regarding the reference, not what it points at, of course).
jQuery combined the best of both worlds for many everyday applications.
But mentally working through an applications with complex mutations only was fun if your colleagues were disciplined.
jQuery "soup" when using many mutations, leveraging the DOM as a snychronized shared state, and mixing in some confusing closures anf loops, was also real.
I admire jQuery, but also don't miss debugging half-working giant files. Not a library issue, you can have similar issues with any library when working on dynamic frontend state.
Circling back to the point: I'm not sure whether a fluent
interface is ideal for DOM manipulation.
But in any case, jQuery was used way beyond "DOM library". It was almost synonymous with "JavaScript" at some point, and putting huge blocks of imperative domain logic nested 5 closures deep into some event callback was an issue with jQuery just as it is an issue with React right now.
Seems like the end game is forcing all ad-financed and tracking-financed content behind login walls.
Feels like we were already almost there because of ad blocking, without even considering AI agents and summaries. And I take no offense in ad blockers, I use them myself.
Sad thing about current public web "content" apps (be it newspapers or other formats) is that the paid versions often share all tracking features with the ad-financed version of the same service, when both are behind a login wall. Only fewer ads, at least hopefully no ads from other vendors / no intrusive brokered ads.
Self-advertisement going through the roof when accepting an offer for a paid subscription is another frequent annoyance though.
I figured the end game would be that Ad companies get heavily into web hosting and turns sites into webASM blobs that handle everything. Single IP addresses so it cannot be filtered and being a binary blob means they cannot be ripped apart easily.
Humans will often fail to take responsibility for derivative works though when they don't know what work the output is derivative of, and how strongly.
And that's assuming they want to make clear what they are building on.
The stakes in the output go both ways: wanting to profit from IP and risking liability because of violating IP licenses.
What you're saying is already the status quo, but reality is that LLMs make it so easy to "paraphrase" code or simply .. ideas, too... so that the whole concept of IP is eroding. Because the sheer scale makes it almost impossible to distinguish specific things that cross the line from "learning from" to "copying IP".
I'm not really taking a specific stance here but acting as if it would be a solved problem seems hard to believe to me, especially since it is not a new discussion.
I thinl you could argue that the solution is that copyright or IP concepts are not working anymore, something many people already concluded before the LLM and AI explosion of the 2020s.
But that's not the state of the current law, right?
In addition, your claim that the user of an AI system is the only person who has any "stakes" also seems questionable to me, because after all, we are talking about output that the AI user already paid an AI company for to generate it.
I agree their phrasing is a little strange but I feel like the meaning is still clear. They are (I believe) saying that an LLM can’t generate anything other than facsimiles of existing content. It can’t actually explore novel ideas and branches, it can’t innovate and create on its own. Everything is inherently derivative yada yada, I don’t mean it in the usual “everything is derivative” way we often refer to when people make music and such. It can’t ideate and express something personal.
I think there’s a lot of nuance and caveats to that kind of claim, assuming I am representing them correctly, but it’s a valid stance and I see where they’re coming from.
All possible books live somewhere in L-space (ook). Exploring that space efficiently is equivalent to creativity. The claim is that the space that LLMs learn is somehow sufficiently limited that it doesn’t contain novel ideas? I never saw a convincing argument why LLMs output can not be considered creative.
But LLMs don't "explore" L-space, the training process just maps all of the available conceptual landmarks inside that space. There are still enormous (infinite?) tracts of unmapped territory that LLMs never reach, and that's exactly the space where novel ideas live.
OK, I still an confused about what point the extension of the analogy was trying to make, because I didn't consider the parent comment to be arguing for or against LLMs being able to be creative.
Seems like this might be true given current implementations but not ANY implementation of the technology.
If we’ve mapped all of English, there are still ways to construct stories that haven’t been told from the mapping. The most simple would be a subtraction of all objects minus all objects that have ever been used as a murder weapon. Leaving you with a list of never before used objects at your disposal.
There are also probably close vectors conceptually but not in semantic use. Or trying to interpolate or extrapolate what exists in voids of space. Turning up the temperature and adding random generation of words. There’s tons of ways to tune these things to be more creative than regurgitative.
This is a very clinical approach to storytelling that I think makes it no longer art or creation. Writing is not just the mere assembly and reassembly of words in new and different orders. It’s about intent and communicating something one wants to say.
It might also have to do with the self-image of developers.
The slice of software development that is purely "finding technical solutions" is shrinking.
You increasingly need to identify with the purpose of the software you are developing.
Spaces of detached "purely technical" software development are shrinking.
So you either say your job is to turn specs into software, then you need to aim at technically demanding tasks. Or you aim at being good at doing this at scale without being particularly involved with the purpose.
The pure "developing an efficient implementation of this clearly defined requirement" part of software engineering is retreating to spaces with really thanklessly complex or tight requirements, and even then, you need to be extraordinaly good.
The gray area between "software where the tiniest bug is a legal liability" and "software that seems cool, fix bugs later" is shrinking.
What an intro. I love it because of the simple statements in favor of "practice before theory":
> Thirty years ago, on November 11, 1996 the young Brazilian student Rafael Sagula posted the source code for his tiny HTTP download tool online. That was httpget 0.1: a little over 100 lines of C code. Bare bones source code with almost no error checks and limited functionality.
> httpget
> When I found the source code of that initial httpget release just days after Rafael put it online, I had no idea how HTTP worked
I guess you're hinting at the difference between model training (including RLHF etc) and models interacting with code, and improving on that.
I guess the real scenario is "simply" a coding agent pointed at code that integrates collected data, likely with the training code using distributed compute. And distributing the training input improvements is surely also already a solved problem, just maybe not OSS.
https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
But by this, I don't wanna say you should. It's also of course newer than what jQuery did, and might be inspired by it (just like Sizzle influenced the QuerySelector API, and CoffeeScript influenced arrow functions).
reply