Sure, and you could program all your code in punch cards to not depend on those fancy new video screens. Double plus if you codify it in assembler so that you don't depend on compilers.
4,474 karma · joined September 28, 2012
I hope the spam filter will respect it!
As I understand the Expression problem, the limitation of programming languages is that they force you to modify the previous existing types even if the new behavior is a generic method that works the same for all types, so it should be enough to define it once for all classes. A virtual method in the base class should be able to do that.
I know inheritance has its own severe problems, but adding a generic abstract method at the base class could create reusable code that can be accessed by any new class that inherits from it.
P.S. ah ok, it's mentioned in the article at the Visitor section.
You can locally run pretty decent coding models such as Qwen3 Coder in a RTX 4090 GPU through LM Studio or Ollama with Cline.
It's a good idea even if they give slightly worse results in average, as you can limit your spending of expensive tokens for trivial grunt work and use them only for the really hard questions where Claude or ChatGPT 5 will excel.
All rational thought depends on its axioms/premises, and there's no rational way to define a new axiom - by definition they are asserted from scratch, so you need to depend on gut feeling to choose a good axiom over a bad one.
Rationalism "only" works to discard or modify some subset of your axioms when you discover that they lead to incompatible conclusions; which is a good outcome if you want to achieve a consistent theory, of course; but it doesn't help in selecting one consistent theory over a competing one. Again, those preferences are led by emotions.
As I understand, the protocol penalizes users that don't contribute to the upstream, although I never checked the details.
Or do this kind of app keep changing the identity to avoid getting downgraded? Does Stremio work like this too?
But, but, what it just she wanted to see her in a Spice Girls costume??
So, the true meaning of the "Year of the Linux Desktop" was that in the end there would only be a single unit left?
It's a very good interaction pattern, it would be more and more viable given increasing computing power and better understanding of context thanks to LLM, and would increase productivity and reduce boredom with little intrusive effects.
So why is nobody offering this feature in data-heavy UIs? (Except for Excel's column auto complete, which it's hit or miss but incredibly useful when it works).
It looks like everything old is new again.
But in doing that, aren't you simply moving the complexity of the abstractions from the functions code into the data structure? Sure you can use generic operators now, but then you need to carefully understand what the value pairs represent in terms of domain logic and how to properly maintain the correct structure in every operation. Someone reading the program for the same time will have just the same difficulties understanding what the code does, not in terms of primitives, but in terms of business domain meanings.
I mean there is an improvement in your approach, but I don't think it comes from putting the complexity at a different place, but because this way you get to see the code and the actual actual values at the same time.
I have the insight that what makes complex programming easy is this juxtaposition of runtime data and code operations visible together. That's why IDE tools have building better and better debuggers and inspectors to let you see what the program is doing at each step.
In that context, creating new good concise abstractions is a good thing, wether you abstract parts of the operations or parts of the data structure.
The high regularity of APL operators, which work the same for all functions, force the developer to represent business logic in different parts of the data structure.
That was a good approach when it was created; but modern functional programming offers other tools. Creating pipelines from functors, monads, arrows... allow the programmer to move some of that business logic back into generic functions, retaining the generality and capacity of refactoring, without forcing to use the structure of data as meaningful. Modern PL design has built upon those early insights to provide new tools for the same goal.
(1) https://secwww.jhuapl.edu/techdigest/content/techdigest/pdf/...
LLMs are not used for notation; you are right that they're not precise enough for accurate knowledge.
What LLMs do as a tool is solving the Frame Problem, allowing the reasoning system to have access to the "common sense" knowledge that is needed for a specific situation, retrieving it from a humongous amount of background corpus of diverse knowledge, in an efficient way.
Classic AI based on logical inference was never able to achieve this retrieval, thus the unfulfilled promises in the 2000s to have autonomous agents based on ontologies. Those promises seem approachable now thank to the huge statistical databases of all topics stored in compressed LLM models.
A viable problem-solving system should combine the precision of symbolic reasoning with the breadth of generative models, to create checks and heuristics that guide the autonomous agents to interact with the real world in ways that make sense given the background relevant cultural knowledge.
What matters is if the current output after each request complies with the given specifications, and if it's possible to solve the bugs until the code converges into stability.
I believe that problem can be solved, and will be with the correct new tools.
I think a new type of "low-code" programming language will evolve tailored for domain experts that don't know coding, but understand how to guide an LLM.
The development environment should be a crossover between a project-management tool (Jira or Azure devops style) with literate programming: something that allows organising all the separate parts that compose the program in a way understandable by the human and the AI bot.
Online notebooks are a good first step in that direction, in special the "reactive" kind where the runtime logic does not depend on the order you change things in the page.
This is quite true for LLMs. They can do basic arithmetic, but they can also read problem statements in many diverse mathematical areas and describe what they're about, or make (right or wrong) suggestions on how they can be solved.
Classic AIs suffered the Frame problem, where some common-sense reasoning depended on facts not stated in the system logic.
Now, LLMs have largely solved the Frame problem. It turns out the solution was to compress large swathes of human knowledge in a way that can be accessed fast, so that the relevant parts of all that knowledge are activated when needed. Of course, this approach to flexibility will need lots of resources.
You may want to ignore what words have come to mean and try to derive a literal meaning from their constituent words, but then you need to fight established common use.
That's why we have judges and lawyers, so that the outcome can be decided as a communal process instead of just one person deciding what is punishable - even if the person is the developer building the automated justice dispenser and they'll be not around when the decision is taken, it would still be made by the whims of a single enforcer.
A good marketer could give a catchy name to sell the advantages of that system too. Top of my head I can think of "near-fi", but certainly could be done better.
This Pantograph somewhat reminds me of that lightweight structure editor, though Lapis is able to find regularities on the fly without a need to follow a perfect tree structure, just by finding bottom-up syntax of language elements (mostly HTML and basic data types).
https://en.wikipedia.org/wiki/Lapis_(text_editor) (Look at the links for an archived download page)
I learned about distributed incrementally -monotonic logs back at the late 90s, with many other ways to do guaranteed transactional database actions. And I'm quite certain these must have been invented in the 50s or 60s, as these are the problems that early business computer users had: banking software. These are the techniques that were buried in legacy COBOL routines, and needed to be slowly replaced by robust Java core services.
I'm sure the Restate designers will have learned terribly useful insights in how to translate these basic principles into a working system with the complexities of today's hardware/software ecosystem.
Yet it makes me wonder if young programmers are only being taught the "build fast-break things" mentality and there are no longer SW engineers able to insert these guarantees into their systems from the beginning, by standing on the shoulders of the ancients that invented our discipline, so that their lore is actually used in practice? Or am I just missing something new in the article that describes some novel twist?
That sounds like the classic "if all you have is a hammer, all problems look like nails".
It's true that decentralised decision making can make good use of local information. But you're ignoring the kind of problems that are created by decentralisation itself, so they can't be fixed by more of it.
A system that is being optimized with only local information is prone to getting stuck in local minima, situations which can be very far from the true optimum.
To escape from the local minima you need to gather global information compiled from the whole system, and use it to alter the decisions that individual actors would make from just their locally achievable information.
That's the role of regulation, and why regulated markets work better than chaotic ones. Regulation can make individuals coordinate to achieve larger goals than what's possible without it. And to enforce effective regulation you need some kind of authority, which is centralised.
Of course that raises the question of how that authority is created and what goals does it set; for that, we get politics, with various groups trying to influence what the authority will decree and whose interests it will pursue harder.
This framework based on cybernetic science provides good heuristics to both understand and design complex social structures.
[1] https://www.amazon.com/Fractal-Organization-Creating-sustain...
Generatove AI has all but solved the Frame Problem.
Those expressions where intractable bc of the impossibility to represent in logic all the background knowledge that is required to understand the context.
It turns out, it is possible to represent all that knowledge in compressed form, with statistical summarisation applied to humongous amounts of data and processing power, unimaginable back then; this puts the knowledge in reach of the algorithm processing the sentence, which is thus capable of understanding the context.
It happens to matter a lot, in large part by a cognitive principle that most programmers should know, but very few do: recognition vs recall.
Text prompts in general are much harder to use because the user needs to remember the name of the command they need to type, which is a cognitive task way more difficult that recognizing the shape of a UI control with a recognizable command name on it.
> What, like this doesn't happen with GUI applications?
You're right that GUIs are not immune to terrible design, I still remember when open source developers but UIs for their software that were mere a front-end layout of the command line, and you needed to understand in full the inner workings of the app to use the UI.
However nowadays anyone who builds GUIs for a living has been trained in the principles of usability and has some knowledge of mental models and putting user needs upfront, so that style is avoided by everybody but the most isolated do-it-yourself programmers.
You're not alone, but that doesn't make it right; rather it puts you in the large bucket of developers that have no idea of:
1) how and why common non-technical people use computers, and
2) why asking them to perform actions they don't understand is a terrible idea both in terms of usability (because the process is difficult, intimidating and error prone) and security (because you're training them to follow instructions that can easily put their system in risk when requested by a malicious actor).
If the actions to follow are really that simple, they should be automated in full; there's no reason why you would show the users anything more complex that a start button to trigger a script, and a confirmation dialog explaining the risks (and maybe requesting elevated permissions).
But if the process is not so simple that it can be automated behind a single button, then why on heaven would you expose them to an interface that requires a complex interaction (copy/paste various large texts from a web page), shows cryptic messages as feedback, and gives no clue on what to do next if any step has errors?