The Wrong Tools for the Job

"The right tool for the job" is a saying very commonly heard in software circles. When choosing a set of software, architecture, systems, processes or hardware there's constraints, options, upside and drawbacks that come with those choices. When developing software you have to keep in mind what are the objectives of such software, then in what ways you can achieve those objectives and, ideally, lastly what constraints should apply.

As an example, if your objective is to build a video decoder piece of software you probably want to use a low-level systems language, that allows you to program in more unrestricted ways at the expense of a much higher knowledge ceiling to do it properly, instead of using PHP as an example. If you want proper data persistance, with relational guarantees, transactions, then you need to use some sort of Relational Database Management System (RDBMS), and not a simple key-value (KV) store (even if it has some of the things you want), because if you need all those things you will need to bolt them on to the KV store, either in your code, with additional glue, dependencies, or simply accepting there will be bugs under very understandable situations.

If then you need to guarantee order and serialization of operations from the clients, to the data store, and that clients actions are executed sequentially once they hit the server, then maybe you need some sort of state machine to make sure that happens so. If you want to build a simple page with some posts, images, contacts, then the right tool for the job is probably some CRM (Customer Relationship Management) + Visual Site editor, because otherwise you'll be spending time just writing a system when most of the time there's already some solution (paid or free) that includes all those things needed for what you want.

This makes sense but the way it's used in software development is pretty jarring. Talking about the "Right Tool for the Job" only makes sense when you have any viable option.

I'm going to talk about a few right wrong tools for the job. We'll start with everyone's favourite Javascript.

Javascript is like the retarded stamp of right wrong tools for the job. For instance for web, sure, what else can you do other than use the only right wrong tool. But Javascript is just the worse possible language for the web isn't it? Lets think about it, async (asynchronous operations) landed in Javascript after 22 years of its birth as a toy script language. This particular implementation of async is the crown of retardedness. If you want an async function you need to 'color' it, by stating with a keyword before the function name (async some_function()), and now every function that calls that function has to also be async - changing one function can cascade changes throughout the codebase for no other reason than "coloring". This is what is meant by asynch "colouring", one change in the sync/asynchronous nature of the function forces a rewrite of everything that calls it.

It also introduces a couple of different ways to deal with the asynch nature of the calls, that forces the callsites to also change to deal with the result. You have Promises (.then), you have await, etc. As a counterpoint I'll use one language I really like, Elixir/Erlang, where every function is asynchronous by default, and then you can build synchronous operations on top of that, because to turn an asynchronous call into a synchronous call you "just" have to have a synch point, assuming we are on an asynchronous execution environment:

Block A: async run f(); wait until we receive result (); continue ...

And f(), something of the likes return reference to this function/call, do something, async msg caller with result of doing something and the reference .

So we also add some sort of "wait", or "receive" to the code, the difference is just that, you don't need to color the "functions". In fact it's so normal that OTP defines those types of interactions as calls and casts - calls imply that the other side being called answers back, casts no.

This allows you to model any situation (in terms of synchronicity) without changing anything in the code you write or how your program works. On the other hand it's not really possible to transform a synchronous system into an asynchronous system without completely adding clutches, exceptional handling and almost two ways of running blocks of code in the same language.

Now lets think what a web page does - it fetches data from the internet... So you can see it on your web browser. What language would be ideal for this? A retarded language without multithreading and without asynchronous operations, of course. The right tool for the job right? Then we spend some dozen years or so bolting on async, promises, web workers, probably spending thousands and thousands of man-hours and dollars on the endeavour, to end up with a sub-par product just the same.

This without counting the probably millions of hours and dollars by now spent on problems created by these decisions - that end up affecting everyone working with these systems. I'm not saying that Elixir or the VM as it is would be the answer, but something very similar in form of working does seem much more appropriate.

I'm going to give you examples of bugs/errors/bad flows and I'm going to point out private companies, public companies (as in traded publicly), state companies, and the reason is just to show you that this isn't a problem only affecting certain levels of software production. The examples will also vary. I will also disclaim this by acknowledging that many things might serve different purposes from those publicly stated and performed. That's a whole can of worms we'll open another day and use for a productive fishing session, because again, it's so nuanced and has so many ramifications that it's hard to skip. Now onto some examples.

You would think that an SMS app would have the functionality to select and copy individual parts of the message. In fact any messaging app. But if you use Google Messages on Android that's not the case. Yes you can copy a complete single message, paste it somewhere that has better text selection interface and then select your desired text. Yes, I also understand that this is probably a very small problem in the big picture, but at the same time, this is an entirely text relaying system with some multi-media support, I would expect that the main medium would be covered with native functionality.

This is also one of the reasons we're told to use native kits for building apps, or at least multi-platform ones that abstract that correctly. On the other hand then you see this, where one major company (Google), owns the complete stack, hardware to software, Android in this case, and something as basic is missing.

Now lets see youtube. First lets start by saying that the backend, their streaming system, all that is (compared to what I know, not sure it could or not be much better given different choices along the stacks), to me as a user that knows roughly what needs to be in place for it to work like that, amazing.

Nonetheless as a user of software I also see many interesting things. Loading comments and threads is still buggy as hell. I don't know how many years this has been going on, but for sure at least a couple. This wouldn't be so egregious again if youtube wasn't one of the most used platforms in the world and if it didn't have the financial backing it has. Additionally you have to once again think that we're into Angular 22 by now, 10 years from Angular 2, that was also a library for the front-end created and developed in-house by google. Yet, something that should be trivial, given they do so much good engineering on the invisible parts, seems to be an unsolvable issue. Even using all these abstractions. If you see the channel manager it's so poor - and even against their own interest, because a much better editor with overlays, metadata for the viewers, etc would drive engagement and allow using youtube for even more things in the video platform. Instead you have a bunch of options (overlays, links, cards) that in part don't work and in other is so limited it looks like what you would make in a MVP.

I'm mentioning these 2 because they're at the forefront of everything internet related, from browsers, to international norms, to hardware, devices, software, etc. They have an enormous amount of resources, complete in-house knowledge, yet you see these small issues - now think what can a mid-size company able to pay normal salaries (not VC fueled salaries) do in this context. You might also say, but on such a gigantic web of services, companies, unrelated fields all you can point is that? No, obviously, but I can't make this about google because that's not the point. I could talk about the interface for content creators in youtube... Small/middle UI bugs/overlooks in many services, I could also talk about the many many amazing things.

Anyway my interest is to show that front-end and the associated technologies (ignoring its value outside of a user centered view) are part of the problem. As I said, the other parts that are very complicated seem to work very well - lacking other similarly sized platforms to weight against. Yet the front-end part of applications keeps being a sandwich of messy layers. To be honest, everything in software is kinda that - which is understandable once you look at how we got here, but ultimately, I think there needs to be some ground-up work to revamp our operating systems, internet user facing systems and backend systems.

This would also have the benefit that the easier something is to be done right and proved right, the easier it is for LLMs to stay on path.

I will talk about situations to show case more variations of this theme and not only about paid/enterprise software. For instance CSS. While I use, understand and think CSS is the right styling approach for html documents I think there's been many "wrong" choices during its development. For instance flexbox could almost entirely do what grid does, in fact you can but you need to mix styling and html structure, and it could have had much more functionality - I think it was submitted as an idea based on an implementation inspired by game engine placement of things. The committee opted to only implement or keep a subset of the implementation. Perhaps they didn't have resources to handle other parts, or the implementation they could muster wasn't performant enough, I don't know, but what follows is that then you need other positioning systems, another full branch of logic to handle it, documentation, tutorials, ways of doing things.

In my view it would have been much better to just either insist on using html structure plus styling capabilities to solve those problems, or give flexbox the needed capabilities to handle what grid would supposeddly handle. Now that you have a proper way of doing this with a "canonical" way every tool, LLM, learner, framework, tutorial, library, can reference that. And I say this as someone that uses strictly flex-box and have built several complex UIs using it, that work 100% from desktop to mobile, including any in between display sizes down to the pixel. So I know it works and it's a great tool. But why burden the html engine, the parsing engine, the rules engine, the display engine, everything, with more code, more ways to create bugs, more ways of doing things?

I think this stems from the early internet/google's approach to web hosting. I just want to say something, not to shit on Larry Page and Sergey Brin, but they initially wanted to sell google for 1M to Yahoo. At that time there were many good search engines, I would say technically way better than google. What they weren't was controllable nor cute/safe for a worldwide population. I remember altavista. You could find everything in the sea of the internet, including obviously cracked versions of software, software keys to circumvent paying, porn from all kinds, weird/dark stuff, etc. What I'm trying to say with this is that none of them were at the time some kind of visionaries about how the internet would work nor about the value of their product, because why would they want to sell a company at 1M knowing that in 28 years it would have a revenue of hundreds of billions, with many prosperous years in between, it would have been a total lack of vision wouldn't it? Yet that's what they did.

This as I said is not to shit on their accomplishments in making it what it is now (from an economical, influency pov) just to show that that post-fact rationalization and deifying of humans is in part just that.

But as I was saying, initially to make the web more accessible, easier to write for people and for people to put their stuff online, the road taken was that of trying to correct the html document, css, structure, to what was possible in order to try and show at least something. This meant that errors in syntax started being silently corrected, omissions or errors could be silently swallowed while allowing parsing and then displaying something. So we just added complexity to handle these things and "hid" errors that nowadays would be helpful to surface and allow better management of software development and maintenance. Even the "sloppiness" kinda started permeating everything, if the attribute doesn't really cause a problem just ignore by the parser or engine, etc. At the same time we never got an universal input that I could model by html attributes alone (even if we then had shortcut tags for the most usual - if underneath they were interpreted as these universal input it would perhaps also ease ally implementations and all that).

It kinda allowed and even fomented this disregard for the fact that there's a structure and rules for it... And if you opened your browser, as the developer, and saw the error you would correct it (this doesn't mean that all errors, including in JS must stop and blank the page, but those should because they're easy to fix), instead most things work in a semi-state of brokeness.

Then you add the aforementioned issues with the javascript runtime itself, the fact that these browsers, chromium for instance, has more than 30M lines of code. To put that in perspective, it's 35M for chromium versus 28M for Linux. You start wondering what's going on here. Back to the examples. A portuguese company, NOS, their website nos.pt is a mess. You login in the landing page, lots of redirects, it shows you as logged-in. Then you click "my area" immediately after, redirects and you're asked to log-in again, redirects, and then you go to a basic user dashboard (that I could list enumerous issues with but won't waste time on). Then suddenly it stopped working. I couldn't get logged in. Nothing works, just hangs. It's important to notice also that this website couldn't keep cookies so whenever you navigate through these interfaces/flows you have to constantly be clicking the popup - and funnily enough it doesn't matter if you allow or not, it keeps not working properly. Keep in mind the cookie popup because it shows up in everything and is once again, this design, the most retarded design one could make for it, is the default unless one where doing on purpose to be that retarded.

Another important thing to notice on these websites is its lack of navigation state matching anything. On this website in particular not so much because it's not a very interactive experience/dashboard, but something regular otherwise. It's usually accompanied by a lack of visual indicators for the navigation/action registering. Are these complete deal breakers, or the equivalent of sacrificing children? No, but isn't it at the same time ridiculous? I'm not talking about the "dubious" opensource software (I call it dubious in the sense that many of the writers of what effectively also end up being open source are individuals with their own motives in many dimensions, although I would say I'm totally a proponent of open software, as it is it's problematic). I'm talking about companies with real money, paying real money salaries, spending countless man-hours and still not having been able to produce what you would expect in terms of finishing and polishing.

Then for instance for edp.pt, a (the only I think) portuguese electricity company. They're great in everything else when compared to the market, even if endesa uses very shade tacticts in terms of discounts and pricing that make it seem a good option or change, so I am not shitting on edp itself here either.

My rental contract was coming up and I was leaving the country before the end of it and before the new renter would move in, so I was left with some options - cancel the contract last thing before leaving Portugal, in person; cancel the contract afterwards if the other renter hadn't by then changed the contract ownership; or trust the renter would do the right thing and change it first thing they could. While I didn't have a particular reason to not trust the renter I was leaving the country for an expected long period so I wouldn't be able to come back to Portugal if for instance the renter went rogue and just kept the name there.

It's also important to notice that in Portugal these things are just very untimely to deal with (and thus costly), filled with issues, to fight judicially. I have been receiving calls and letters, from a debt recovery company, because someone who used my name and details to fill a contract - non-presentially which is ilegal - associated with a net service. Interestingly enough I was client of the same company for that period of time. Because legally speaking they couldn't probably justify how they ended up with a non-presential valid contract for that other house - that obviously I could prove was completely unrelated - plus, I being associated with them already should have somehow been notified way before that something was wrong, like 2 months of payment are unpaid, not let it get to a year or more +500€.

Notice that then this provider sold the debt to a debt collection company. They themselves never contacted me, I re-hired internet services with them at some point, etc. The debt company didn't have my contact details by then it seems, but the provider could (should be able to) clearly see there was overlapping identifiers. I also never received anything from the debt collection company up to the moment when in another house, an appartment I was renting at another time, I put down the gas contract before leaving. Since the cut would only be in a few days they sent me the current bill, which I paid. Then a month or so later I received a call from this masonic company saying I had 6€ of an unpaid invoice for that other company. And I was like, right, this are the remaining days. But then I thought why didn't Galp just send me the bill? Probably it got catalogued as low probability of being paid and they sold it instead to this company as part of some bulk deal. So now what happened was that because the name and so matched the other supposed "debt" I never had heard about, they started contacting me about that other one.

This is one instance where clearly, protections for data privacy are welcomed isn't it? Companies shouldn't be able to just do this, and they do this with all kinds of identifying data. If we have to build such systems, as well, then we need to build it transparently so that it can be auditioned and protected from interests.

All this to say that I didn't want to have some situation that could somehow end up in some unknown debt until one year later, so going back to the edp site. I then went to see online if there was a way to cancel a contract online and there it was. There was. I read it all, then went through it. All seemed to work, obviously I couldn't try out sending it, since it was a request to cancel the service, but the form seemingly unlocked, fillable and ok.

So I said, well, lets do it this way, I keep the contract open and then if the new renter changes it up to some day all good, if not I cut it online. The day came I went to cut the contract, the form didn't work. Opened the web inspector console, errors. Didn't work. There I was somewhere else unable to do anything about this. Everything went fine in the end with the contract but that's not the point. In fact this all is system design issues isn't it? Why shouldn't I be able to just go to the company and say, my rental/lease is finishing next month, there will be a new renter, these are their details etc, they might have their own veirfication systems and it's the company itself that handles this. Or when you do a contract for utilities you sign with your landlord as the owner, and then when both of you give notice of the contract it handles the payment down to the second adjusted to time zone savings, and until a new contract is made the remaining bill afterward goes to the owner.

So again, there could be improvements to the software narnia side, but we shouldn't also lose sense of the real-world and real-world improvements to our own systems and processes.

Once again I ask, shouldn't a 15B revenue company that has all these complex working systems be able to provide a working html form. Once again, I understand that for most cases people that won't be presencially in the country is a tiny subset of the entire client base, nonetheless, at the same time this seems like a functionality exactly fitting that subset while providing a convenient way for all the other client base that now can do it without waisting time in queues. But even that wouldn't work, so if you're just checking on-line the week before you need to put down the contract, and then you plan the day as if you're able to do it online, you'll still need to now go find a local counter and do it all in person. Are these first-world problems? Kinda.

But the issue runs much deeper and is now also shown by usage of LLMs. If you ask me do we really need LLMs for coding? I would say that for the most part when it comes to the non-code-literate user, we could probably get very much farther away without LLMs (and further even with LLMs granted) if we designed the right UIs and design systems. I'm going to take squarespace, which is an in-browser website designer and content management system (CMS). This isn't a small company either, it has market, 2024 hit 1B in revenue. It started in 2004. Again I'm not shitting on the work done to take it from there to now, but when you evaluate the product they offer, the capabilities their builder offers, I would laugh if you told me the values that were spent up till now to get to this point. Obviously this is defeated, from an economics point of view, by the fact that company was seeded and grew into a profitable business.

From the point of view of engineering though, it's just very lacking. I mean when liveview first came out, didn't have hooks if I remember correctly, I started playing with it, no LLMs at the time and in a week or so built an editor capable of doing free-element editing, custom persisted components, total customisations in styling, per component, page, etc. In a language that at the time I couldn't even express myself that well - elixir - with a completely alpha technology - liveview. To explore liveview, it wasn't even to build and HTML page builder, it's just that that was the worse case scenarion for liveview and I wanted to see how it would handle the worst case. In a week. Obviously this doesn't account for any ancillary structure of how to run this at scale or integrations but that's not really the point here - I also needed to know well what I was doing.

When you look at for instance the mobile/desktop design modes, the CMS. Everything looks and works so archaically. The thing is there isn't really anything better out there and the ones that are like webflow do it by being visual UIs for all the nuances of the underlying languages (html, css, js, etc) with all the complexity they bring - they're for people who understand the underlying representation or at the least enough of the ui to make it work - although many probably don't understand the representation because many of these websites, made in these builders, then break anyway in different ways and conditions.

The same can be said of wordpress. It probably was amazing when it came out, nowadays it's just awful. Yet it probably powers most of the websites on the internet. And it's awful from many, different, points of view. It's also funny that at some point wordpress "coders" were making comfortable salaries doing kids work. I didn't even code professionally at the time, I worked with visual media and I had met guys saying, "dude I just go into the CMS upload this, create this, make sure everything is working, and bam, $1k monthly support contract. I then obviously can have a bunch of these because they take almost no time".

As work-from-home-over-the-internet grew and this kind of work outsourced the real price started being revealed and these kinds of positions would not regularly make the same kind of money for effort anymore. But for a while it was there.

Wordpress is the same situation, it grew immensily but yet, it could be so, so, so many times better, the open source and the commercial versions that you gotta ask why.

Now can LLMs help in this? For sure, but if the underlying tools are better structured and architected then the LLMs can help even more. For non-coders it means someone can perhaps go from "I want a web page with landing page, a navbar and 3 links to another 3 pages, and a logo, etc" to a final working product (prototype, visual/flow reference) that can actually be deployed and isn't just a random assortment of things that kinda work in a given configuration.

When you think about website builders, does it really make sense to do it all through prompting? Or perhaps a mix of UI, flow and LLM aided. Perhaps you start with, build me a website and the LLM dispatcher or the model itself switches mode to a more specific one. Then it goes through a series of questions, like a ui wizard, you could upload a logo, or create one, then take the color theme, then allow the user to customise the theme, add new variables to the theme, etc.

You could also specify this in a recognisable format to be parsed by an LLM for instance. Then it would use that as the stylistic base for the main colors, accents, highlights, backgrounds, etc. It could use LLM enabled functionality to aid, like reading colors from logo, allowing creating a logo from scratch, etc.

Once that is done there's some agent tool calling into well-known/defined flows that create the CSS files with proper root variables, styling classes, convetions that the AI can leverage when writing the code itself, in a single place and so on. Next phase, it asks you about the type of website. Is it a landing page with a call-to-action (CTA)? Is it a webcommerce, a scheduling website, a blog, an app, a mix, etc. In this part you could either use an UI to build it from scratch or describe it. The LLM would translate that into "known" properties and then create the scaffolding once again. If you write "landing page plus 3 static pages, members login, member dashboard with password reset, email change pages, members subscription page, etc". Again the LLM would need to parse this, it would be much better to have a slightly more structured way of defining this, because once when you start getting into the weeds, like defining scopes for the pages, ACLs, interaction between several systems, etc, describing it in natural language no longer makes the cut.

But obviously if you're just setting up a store to sell your own home-made articles, or whatever, a blog, then by now this should be a completely solved problem, like you register and you get some_name.euromarket.eu/store domain, with email accounts, verification possibilities, a modern CMS properly thought of, payment providers, etc. And the reason it mostly isn't is because while these CMS and builder tools did progress and made some cool utilities, they pretty much suck and the "official" state side infrastructure/know-how/capabilities are stuck in the neolithic. And I say suck in a way that instead of the millions of investment you had poured into any of these ventures, with $100k and 1 to 2 years I am positive I would build a much better open source variation of any of those, and I'm up to taking that challenge, with contract as long as the money is on the table.

Take upwork for instance, and this is not to say I'm not thankful for the opportunities I got there but if you think about it, this was the merger of odesk and elance, both already existing, established, working, remote-to-hire workplaces. I had been using both at the time for the longest time already. Obviously there must have been some work in refactoring the systems to work the same way, but for the most part they were pretty much the same. All these years have passed and the only thing that we got, as freelancers there, was a broken feed for the past years, that finally seems to be able to load at least 2 to 3 additional pages of results and not skip newest posts when updating (this still seems to not be completely solved, even though it has been there for half a dozen years at least), some basic "profile"/"portfolio" capabilities, a massive increase in cost-to-bid for freelancers.

This is certainly in part unfair to the "invisible" work done in the "back-office" part that connects bank payments worldwide, legislation enforcement across worldwide jurisdictions, compliance with money regulations, escrow payments, arbitration. But the product, the marketplace, the thing itself has only regressed in many ways. The way the platform works is that to "apply" to jobs posted there you need to spend "connects", connects used to be given monthly up to a certain amount, and then you had subscriptions or pay to acquire more that would give additional ones if needed. A subscription as a freelancer now costs $20 month (without tax) and gives you 100 connects. It tops up monthly but doesn't even top-up on the ones you had already when turning paying subscriber, or at least with me it didn't. This means every dollar, every month, buys you 5 connects.

The other day I did some calcs. Straight from the feeds. Applying to a job from someone who didn't complete verifications like payments or so, has no other jobs posted or completed, costs you 10 connects. $2. This is the least appealing job to apply because there's no way of knowing if it's even a real job, someone just gauging the market, getting cv's and proposals submitted, etc. Sometimes they're very appealing too. There's different "types" of employers, you can gauge something by the profile, say those that have more than $100K spent, or the average hourly they paid, those with all 5 stars feedbacks, those with less so, those with payments verified, one or two jobs done, etc. Then jobs themselves have particular stats, like how many people have applied already, how long has the job been open, etc.

With all this data it sets the price to submit a "bid" for this project. If a client has many jobs completed successfully, good feedback, etc, and there's already 15 bids then the "cost" in "connections" to submit a bid goes up. A "good" job will normally be 26 "connects", this means submitting a proposal to one of these, "looks like it's legit, and they have feedback and history..." jobs, costs you nothing less than $5. Wow. 1/4 of the cost of your monthly "subscription" value spent right there. Obviously you also get an AI agent to help you write your proposals. This is what all these years, investment, 2 existing working platforms, lead to.

While in part it helps, making text blocks, lists, emphasis better looking, cleaning up small typos and grammar errors, and I imagine even making text flow much better for non-native, poor writing skills people (that might be extremely skilled in for instance media production, or wtv) and this part is a bonus to have it - how is this worth it when we can have a local model do exactly the same? At least there would be some variation in output... Imagine this kafka system we're building, AI writes proposals, reviews them, user uses AI to write proposal, submits them, is reviewd by AI from the client, then codes AI, reviewed by AI...

And the big problem is this LLM isn't even good. It did a good job on those items I mentioned and it blatantly included a total contradiction of what I had actually written originally (and it wasn't a draft, it might not have been perfect but the meaning was pretty clear and logically structured in the token stream) - I had written that although I didn't have experience DIRECTLY with X technology they mentioned, I understood the principles, had used similar in other languages but more importantly had direct experience with most of the Y,Z,W technologies that interacted with it. Something like "Although I haven't used X, I used A and B that are based in the same archicture (but in a different language) so I don't think I will have a problem coming up-to-speed with X. C and D that you mentioned are used in conjunction with X is also something I have experience with through other projects".

Yet on the AI enhanced version it wrote something like "I have extensive experience with X as well as A, B, .... ". It literally put a lie in my proposal. Again, is this the great work being done these last years on upwork? Again, it's not like I'm not grateful for something like upwork to exist and it helped me greatly, as I said even before being upwork as odesk and elance, I just ask, if this was globally handled by a competent public/government staked entity, or still a private company but with some different leadership or goals, would we be getting something more ambitious than slapping a conversational AI on it and charging fees for applying to job ads?

I mean for all the talk about AI, using bot detection (cloudflare), etc I see so many jobs being opened to never see any activity, that clearly lots of people bid in, and yet no credits cashback for those bids, then you need to pay for the priviledge of knowing what the "averages" of the job proposal bids are, your position on the bids list (that sometimes you can spend connects on to enhance and put your bid at #1 place on the list, starting from some hundred connects to thousands of connects, now do the rate on connect/dollar and see...), etc. Where is the AI to filter out that. It just seems quite distant from providing a fair(er) marketplace for freelancers and people wanting to hire hassle-free.

Then we hear things like, imagine if government was run like Sillicon Valley. Yeah right, just imagine. Again, not to piss on the good things that also come from there, but boy, there's a world of difference in doing one thing or subset of things well while answering to shareholders and another in doing additionally roads, parking lots, parks, cyclable paths, public transport connections, breathable air, police, fire fighters, and countless other things. If someone said, could perhaps some parts of it be run more as enterprises? Perhaps. Or if what was said was, can we work out a better reward system for politics. Perhaps. Be run like Sillicon Valley? Doesn't seem very sane.

At github, an organisation that was built on top of git, a free open source code versioning tool created by Linus of Linux fame, where they built an interface around the branch, commit, pull, merge, re-synch flow, creating or normalizing the idea of pull-request (PR), where changes are visualized against the main trunk of code, reviewed, commented and then merged back into the main trunk, they still have many long-standing bugs. Over time they added functionality, integrations and ended up being bought up by Microsoft. There's an history of bugs, slowness in the UIs, etc, that over time were worked on. There's still issues sometimes with availability (but github hosts lots of code repositories, so ok, we give them that), UIs are still heavy running in many common situations, the CI/CD history although great for free is really badly thought out as a commercial option.

The platform itself always had issues and continues having them with the access-security and underlying architecture that they chose. It's slightly better now but still a crapshot. There's no way to issue only certain permissions per token per repo, or organisation. It's highly, or has been for the most part of its history, very insecure when talking about the token/grant/access system, specially when we're talking about a system to host code, that in many cases connects to deploy targets, registries, etc, that a user, organisation can have almost infinite combinations of repos/access requirements. It's like it was never thought/architected to be properly used for the end it proposes, in a way.

Other issues I started seeing - maybe because only then did I change this setting after having it working fine - was when I switched a github pages repo from the default jenkins builder to a custom one. This was for my own personal website/portfolio/blog but it could have been for a commercial project, I have been a paying customer before, or even some client's project. Github has now introduced verified domains at the user level, but initially it was by repo. When it changed the builder it somehow lost the association with the domain. But didn't remove it from some other part of the data persisted/state. So the page was telling me I had the domain in "verification" but I couldn't delete it because it was no longer associated. Basically the UI showed the domain as filled, and in verification, offering a button to delete the associated domain, but clicking to remove it instead told me the domain wasn't associated with the repo.

I also did by then, trying to solve it, associate the domain with my own github user and verified it successfully there too, as suggested by support and FAQs.

After 4 days of back-and-forth with support and finally explaining the theory of data inconsistency, I was finally told that somehow the domain was associated with another one of my own repos and that I should delete it from it first there, and then try on the original repo again. It ended up working. As I said this could have been the support page for some business running out of github too, a paying customer.

Then the web sources, the AI support, all give different info. Because at some point you needed a CNAME file in your repo, sometimes in the build folder, etc... Not duct-taped at all.

It kept working fine until after a new deployment a couple weeks later. I did a deployment, checked a few minutes after the deployment and the website was fine. All good. One day or so after I visited the website again, because I was sending CVs, and what's my surprise when it wasn't working. Went to the repo settings, the repo individual domain was under "verification" again, notice nothing was done (probably DNS replication and caching prevented me from seeing it even after some minutes of deployment). This time though was just removing and re-adding the domain for it to start working again.

Nonetheless, once again, I've sent and have that link in many places and pieces of media and out of the blue it just stops working due to some half-assed system that was written by some idiot with AI help, while making a quarter of a million per year. I'm a developer, imagine giving your website out and then this person goes to see your personal website and gets a cannot connect due to DNS issues... But there's more. I was talking about CI/CD before. This is one clearly completely under-selled asset github could have leveraged. Something I actually would have gladly paid in many situations working for clients and convinced them with clear ROI of the benefits of giving github money for using bigger/size customisable CI/CD instances.

Not custom builders/runners that I have to orchestrate somewhere, no, something that just runs there but with proper useful instance sizes. It shouldn't also be a botched subscription model, let me have options from $5/month for simply 2 core runners with double ram instead of the free ones, or $20 for a bit more, or $200 for enterprise level number of builds etc... Rate limit it so that someone doing 100 builds a month for a small start-up doesn't waste more than $5, and someone managing 30 projects, with more than 2000 weekly builds and using big instances pays accordingly.

But no, something that seems like such a logical extension of the model, offering real value that is tangible for the users and can be (specially now that it has microslop infra to run at running costs) incorporated into the existing pipeline and architecture, no, let's not do that.

There's several reasons why one could be interested in this, the first is because the shitty browser drivers needed to execute e2e suck. We'll get back to them later, but lets say that they can stall, error out inconsistently, etc, and many times it seems to be due to CPU limits (only one CPU available limiting the capacity for concurrent work by the browser and the test orchestration processes) that some of these inconsistent errors happen.

This would be the first reason one could be interested in being able to pay github directly for access to different configured instances - instead the solution it allows is giving more market share to other iaas, by using your own runners on your own/others infrastructure - which is great to have as an option and should be kept by all means, but many times you're not at a scale where it justifies even thinking about such systems that need to be implemented and automated with the remaining pipeline if instead you can just say, +$10/month run the CI with 2GB 2core.

The other one is that some tests (e2e, certain languages, certain types of test, generative, integration) can take a long time. Compilation of artifacts the same. Having the possibility to upgrade instances is an amazing option. If you can cut your CI from 40 min (linters, typesystems, compilations, sometimes cache busts, docker rebuilds, full test suites on PR + merge + full multiplatform build on merge) to 10min would perhaps be a very easy to justify ROI for any team, from single player teams to small start-ups or big enterprises. I'm sure there's a model in there where Github can make money from most of their clients while their clients can pay comfortably and feel like they're getting a great value out of it. Obviously if this would be to be implemented it would be probably stupid enough that when all was said and done many would prefer to then run it outside on their own terms.

These are just 2 reasons, there's more like if you have different architecture instances to choose from, then you can ditch virtualisation and build artifacts in real instances, again cutting significantly build times for things built with QEMU as an example. But just these 2 reasons alone would have been justified expenses in all projects I have worked in and with a few exceptions, they weren't even heavy CI/CD codebases, but all, and specially the ones that were, would have seen amazing benefits.

Now since we talked about browser e2e testing this is another example. Lets not forget the ++35M lines for chromium, then you add the chromedriver (I think headless headless mode is no longer a separate install) that is needed to communicate with the browser programatically, all the dependencies, the test frameworks - all that additional code - and then you can test your application with a "real browser". I sincerely sometimes don't understand the guys making decisions at this level because for a while the "headless" version of chrome, that was needed to run in test environments, had a different render engine than that of the browser itself, because it was an independent program, re-using parts of the engine but short-cutting lots of stuff. Basically by design wrong for the purpose of testing since you couldn't simulate what the browser really saw... Who really comes up with these roadmaps. Anyway, it eventually became the same engine so now at least you can be sure your e2e tests will see the same...

You can see that the architecture of these things is just wrong by design. I should be able to run the browser in certain modes (test, developer, etc) where I can fill in sessions, cookies, caches, etc. I should be able to actually analyse the responses, not have empty values for sizes of assets, requests, etc because it has been cached somehow, and it's an untanglable mess of spaghetti C++ to obfuscate the orbs. It's impossile to query the browser in expected ways if anyone seemed to have the minimum experience with testing code, programs and websites when designing these. Instead I have to reload the browser session, hit a login, so that the browser properly populates the cookies. Wasting hours and hours during a year on CI, or locally.

Interfaces in many important things that seem neglected beyond the showcase stage. Like webgl, many "should-not" be problematic things, even using css animations, but also using webgl calls either directly or through frameworks, but after a few minutes of running start the fans of your computer in high-speed mode. Yes sometimes it's abused but even "simple" animations can end up becoming troublesome if played for longer periods of time - this obviously introduces some problems for browser based applications like games that then require a full-refresh when it starts lagging. And truth be told, there's leaks in some parts of the browser stack, but sometimes also on the frameworks or libraries use to handle animations/gl, sometimes in your own code, but I've seen enough, by many, individuals, studios, small, big, to understand it must not be my code alone.

The browser always feels like this thing that can be amazing for everything and ticks all the boxes on paper but then when you use it the checkboxes have a small asterisk and it reads in small print (aspirational - currently wip - we just need it for other purposes™). Going back to browser testing. Just now, like it has happened thousands of times by now just in my projects across the years, a test failed yet when you view the screenshot, it should have passed. Why did it failed? Shitty asynch architecture and headless integration with the headless protocol? Inability to add basic hooks/timing/triggers that can be used for purposes like testing and automation to the browser or headless agent? Lack of proper tools/browser APIs? Javascript asynchronous engine? Because taking a screenshot uses the engine as well, checking for text needs to query the engine as well to get the real dom tree, maybe the fact even inside a VM running more than 1 virtual core there might be contention with the other programs running along with the test "harness"? Who knows. It should seem pretty expectable that I would want to at some point query the headless agent for, "after clicking X and receiving the associated response/redirect, confirm we are in page/address Y and text Z in element W is there". But now, I can execute all these actions in supposed sequence, add my own duck-taped timers and logic for waiting for updates, but there's no logical connection or unit they share so ends up countless hours of wasted runs.

And notice that while this is obviously very important for tests (and cutting down the thousands of wasted hours re-running failed tests) it's also quite useful for automated browser navigation to have more deterministic control systems...

I could go on listing examples, to be honest, but at some point they just become useless and when viewed in isolation might sound nitpicky. So I'm going to dive deeper into the rabbit hole. We get to the basic systems we use, that's roughly the Operating System (OS). The model is one of complete and total helplessness when it comes to "real" security. Even open source OS, that is, where you can read all the code that goes into your system, rely on millions and millions of lines of code, thousands of independent pieces, all with virtually uncumbered access to your machine at some point or another.

If we think about the bugs, the unsecure architecture/systems of our machines, the ever more encroaching data collection, we can see a world where this is useful - as in, in a strong enough society, with the right institutions and rights in place, defending and providing what we agree is right and just - that all this can be used to protect itself because it's worth protecting itself - even if that means in the end a loss of privacy. We can also say that from the point of view of knowledge, this byzantiness creates a more democratic spread of power - now the nerds who can actually and correctly implement or hack these systems hold themselves some power - so it's not only the big head that can dictate what happens, it's needed someone that knows how to make it happen.

There's an issue here though if the wizard in question for any number of reasons is easy to make feel important enough, or has his own plans in that direction, that lead him to use those powers in the wrong way. At the same time it's true that in a world with conflicting opinions that sometimes can't be resolved trully peaceful in all fronts, or when they are they are simply a postponing of some logical conclusion of the paths things are on, you can't assume others won't themselves pursue what you don't - even if because of the right reasons.

But the biggest problem is that we have to build systems for the real world beyond web-applications that might be all buggy or not, have awful APIs, etc. We also have to use it for managing real-world information, automate processes (not only in the back-end but selling tickets, bio-identification, everything uses it), dispatch payments, notices, etc. So we need to take care of building safe systems by design, or safer by design. Because I also understand the other point of view, we can never be trully sure about the software we are running due to many reasons - and so "setting" a mentality of "this is safe" is not good - but with the web sort of acting as an API layer (in the sense that my device can only talk, independently of the interface, web site, remote server api, through a strict protocol with the other side), which means if we can increase manyfold, by design, the security of the systems that interact (the one running in the device, and that running on whatever is the endpoint of that interaction), then we could build perhaps simpler more secure systems. We should also be at a point where uni-kernels, or micro-kernels should perhaps be pursued more significantly into some commercial user usable versions.

The same idea of having by design a safer system, I'm sure we can afford the increase in slowness by now. There's no reason I need to grant any kind of rights to applications running on my machine other than specific things that can be wrapped up in safe defaults/flags. Some of these start trickling down but without other "underlying" OS architecture it's not really solving the deeper issues, like now most applications ask for directory permissions, or you can add files one by one from the source without giving permission to anything else. These are certainly good improvements and at least show that a proper UI/UX that is completely natural, logical and secure is possible.

The problem is the way OSes are written with security as a complete afterthought (which might have make sense when Linus just got funding from the US and moved there to continue linux development, or when Windows was trying to dominate the OS market, or whatever). And due to how software economics have worked so far, it's very clear that not always the best-ideas win, or that the winners were those that really had the ideas.

When I was younger I was very much inclined towards Communism, I got into the Portuguese Communist Youth at 14 or so if I'm not mistaken - I've always read a lot and always had an interest in politics - I painted murals, distributed pamphlets, sold the PCP (Partido Communista Português, Portuguese Communist Party) Avante! ("avante", means "Forward", as in "forward comrades!") magazine to fund the party and local party cells, did a summer building the "Festa do Avante!" (Avante's Festival) for a couple weeks, camping in the grounds and building the infrastructure along with other volunteers. It was like a "pre-festival" for those there also. But as I grew older I kinda grew apart from it as a political party and by 18 I was no longer participating (other than perhaps attending some demonstrations where the subjects I agreed on or festivals).

When my friends, the ones with whom you have serious discussions, used to ask "but do you think everyone should make the same?" I always answered, it's not about making the same. It's more about, if you work what we deem a normal adult work-schedule, then you should be able to afford a single persons basics for an independent adult lifestyle. There's many ways this can be sliced and diced, but lets say, you can afford the rent in some decent radius of distance/time it takes from your employment. Being able to afford rent means you can at least with that income have a functional, with designated areas for living, sleeping, bathroom, kitchen - even if technically a small studio. This is not a "everyone needs to live like that" but a "this would be the minimum baseline", if you work a full-time it's because somehow it's deemed worthy enough to have that position so it should be able to cover what it takes to live alone in terms of rent for an independent life. In a livable neighborhood.

I'm not talking about luxuries or anything, just a safe place. Then if you're a couple, either friends or relationship, you can probably rent instead a bigger one, and if with a child and lower income still then the state or somehow, they should get some help in some way to allow them to again upgrade or by themselves find higher income to sustain themselves. This seems what we would think would be logically the best for a society. There's an infinite spectrum from this to how one can or could live with more, but the basics of dignity would be assured.

And to be honest I don't think it's even that bad specially in certain "epochs" of life. I quit high-school and went working, then my mom decided to pay me a degree (in Portugal at the time it was still money but not the same as US for instance...), and only then did I go really to live "outside" of any parents house. I was lucky to stay with some great, and some not so, people through those times, and I was living in shared apartments/houses - this was more independent than staying in uni dorms for instance and you could do way more socially. Now I'm not advocating for this as the baseline, but certain aspects for sure could be adopted - and in some ways are in some countries when building apartment blocks.

If you would reach an aggreable number of stoves, properly compartimentalized fridges, sinks, utensils, etc, in a monitored area, with a simple scheduling system, that served all people in that floor/level/block, then maybe you could have smaller studios that didn't really need kitchen - or perhaps the fridge was individual per unit but still occupying much less space than a kitchnette - so the same unit area could now hold much bigger areas for the room/bathroom/etc. And while at a certain point this might not be your desired way of living, I would say that up to around 30 or so it's pretty cool to have different people around (if we have the same cultural baseline, or same-same-but-different).

I wouldn't have wanted to live my uni days alone instead of the way I did - perhaps I could have swapped some people in and out sometimes but otherwise it was pretty cool as an experience and less even if I had even more individual space. When doing my internship (paid) after the degree I ended up living for some time alone and while it was cool, for a big part it wasn't as much as when I had more people around me. At that time in particular.

The same if you have every X floors a dedicated working co-living/working space that is kept tidy, where people can sit around a table and talk or play a board game, work a bit outside of their unit, etc. If then around the block there's some well kept path to walk around and not far-away a metro-station or bus stop, and a park or running/cycling tracks, with some outdoor exercise things, all of a sudden this person is like, in a way living rich. Obviously if then the metro or bus is all shitty and ridden with problems, or the parks, or the ways, or the blocks, it's a different thing, it's quite an oppressing life. But that, what I mean is, with the amount of wealth we seem to generate, seeing what is spent and in what, it seems we should be able to provide that as the baseline.

So perhaps what we need is some downsizing in some things (in what is aspirational for a certain demographic that doesn't really need it to live fulfilling lives at this point in time), appliances and such, and investing in better shared areas for a class of buildings that can house people. It's obviously necessary other things for it to work including enforcement of rules inside. But this can be achieved with some vigilance and history keeping. If someone is always breaking stuff that others don't, or things have issues after they use them, it's probably on them. If it happens once or twice like it can happen to everyone in a long enough period of time, then it's just that, something that can happen and the renter shouldn't be penalised stupidly. But if you can't enforce the rules some how (downpayments, eviction laws, etc) then it's very hard to keep a profitable model of such housing projects. I do think this is something that definitively has a market that is totally unexplored.

If we go even further and we start thinking about possible ways of organising society, assuming a lot of things would be solved, perhaps the ideal way of structuring society is in sort of an itinerating civilization - sort of a nomadic lifestyle but within an understandable-shared system not defined only by geography. If we think about it lots of people love travelling, it's almost aspirational by now to somehow travel a bit. Inside their own countries, outside. People work, save money, and then reward themselves with travel: traveling as vacations, gifts, lifestyle. This seems to show that people inately like it so a society where you could easily live 3 or 6 months in a place, but then you had to change to anywhere inside Europe or America (North, Central or South) to a livable unit according to family size and situation, in a safe place (all those things talked before), where you and yours already knew or were learning one of the languages, in which school could be attended in, or there was programs for it somehow, you could keep working seamlessly somehow, etc - meaning, in general the location changed but there was a familiar, similar in all relevant aspects network of services, support, work, community, values, that would allow you from day one have many shared cultural aspects and know exactly how to do.

In that system travelling and children not having a fixed context to make friends and create stability is perhaps less important - not saying it's not, it could still be generally worse - but there's at least an overarching unity and familiarity - including the real family that is kept always - plus everyone else in the relevant context would be in a similar situation - so the ostracization or alienation would not be happening due to that at least - and nowadays with technology much can be done to keep in touch. If you didn't need to worry if your children would be in a safe neighborhood and attend a decent school, and you would keep working and able to afford whatever is your lifestyle at the time I think many people would love to be able to hop around, contribute in some genuine way, then go somewhere else.

In an utopia perhaps we would systematise the things that are needed to run a post-scarcity society while still keeping the human spirit (in all it's aspects that are needed) alive. After all it's an utopia and not a dystopia. Perhaps we could see how many people are needed to run the garbage collection system in any given city, how many to clean the parks, how many for the mail distribution, etc and we can divise a system where you work 4 days a week, 2 of them all in those types of services, then 2 employed at your will (at will or whatever contract) and the remaining are left for you to do whatever you want. And we would create rewards for those that simplify, automate and magnify the surplus (economical or whatever is identified) of these systems.

Maybe they would get a 2 year pass for all destinations inside the "network" that are considered 10/10 by the people and first booked whenever free - they could have units specially to attribute as rewards. Of course again, it would need to be tied to the benefit a certain improvement, creation, innovation brings and how do you judge that? If it gets corrupted then it ends up being the same, so the only way to keep it fair is if there's some temporal window for the project to bear some measurable outcomes that are agreed upfront, and once they happen people at large but uniquely identified, legally able according to interest, region, nationality, jurisdiction whatever, to vote on the outcomes.

Ultimately one wouldn't face poverty, homelessness or anything like that, simply in a given time frame he could reap rewards of a well done work, and partially immediately or whatever system is deemed reasonable to reward general improvements to the lives of all. But how do you make people that aren't, as all data seems to indicate, even inclined to spend their time from 4 to 4 years to vote - as the absence numbers seem to show worldwide - to spend time giving feedback and honest reviews on things like laws, measures, public space improvements, projects, etc? You would need to make this tied somehow with the benefits you have. To keep or not pay certain taxes, or get access to better "things", you would need to vote on all relevant issues every whatever period, month, bi-monthly, whatever.

It sounds perhaps a bit crazy but if it was like a feed of things, and you knew that this would actually influence the things that are done, like some project did a small park with some benches, a mini-skate-park, safe for kids, place for some stalls to spring up, and now it got all positive votes from the local residents that actually spent their months living there, or a big metro project was concluded close to the timeline with minimal sliding on the budget - you not only want to reward enormously these people, you want them to be given even better, bigger, more rewarding projects so that they can lead them, hopefully even better than previously.

The reason this is difficult to envision is because right now it's much more rewarding - or perhaps there's no other reward system in play at all - it's much more rewarding (financially) to find loopholes and take control of key points and then use that leverage to enrich oneself. Be it through violence or just business accumen. But perhaps there's other ways. I think the West - by this a mean the more or less seemingly shared set of cultural values and even shared culture at least in the direction USA towards European and other American countries - with so much empty space, capital, could perhaps start trying to build some of these cities. There's historical dying cities, there's empty land needing to be settled, people wanting to try different ways of life, so why not. If billions can be spent trying to get to the Moon or Mars sure we can spend a couple grand million in out of the box projects that don't have any immediate financial return.

Perhaps we can devise a city that is self sufficient, from food, to electricity, to population working. And that people can change between them while everything still keeps working. The rich, the genius, the ones we wish to reward somehow, they can still live in their exuberance but the baseline would be so much better if we could achieve it. But even just thinking about such systems is mind-bending - imagine a scheduling system that takes the people who live in a certain geographic area, has records for everything that needs "public" workers for each day, including reserve for incidents, and creates a spreadsheet automatically where for instance you would have one day in January this year working on trash collection, no matter who you were, the current CEO of the rail system for the city, whatever, those days you were just an "ant" for the 8 hours of work. Then another on gardening the public park. Watering, trimming trees, cleaning pathways from leafs, etc. And then another of these days something else. 2 days per week on these. 2 other days on your real "job" (to still allow specialization) and the remaining days of the week on whatever you want - party, additional work (that can render additional benefits, rewards, etc), family, whatever.

This would be at the same time surreal but kinda utopic. Notice that there are some CEOs that implement this "horizontality" in their companies. It could definitively work if the systems both for executing and rewarding correctly are in place. But for all this or a different method of creating rewards (not necessarily not money, because ultimately, whatever you use to assign value becomes money or people make up money they can use) and organising society would require advanced systems. If all the basis is full of holes it's kinda difficult using it and at the same time trusting it.

It would be great to have more data easily accessible in a digital form on every-day things, like how many workers does the post office require, in how many hour shifts, how many trash-cleaners to run daily operations per number of inhabitants, how many trucks, stops, etc but also knowledge about specific necessary industries. So that we can start perhaps looking at it from different views, as the stats we use are kinda biased towards an economical performance evaluation that fits our current schemes.

It's looking at the relevant data, even if we don't know by then exactly that its relevant, that enables connections to be made and ideas to flourish. We know that and we apply it in many ways already corporative and governamentally but we should expand the level of transparency and start thinking of ways of organising society that can better exploit automation, surplus production, while not becoming a dystopia - meaning where humans can still find human fulfillment.

When I think about a possible future utopia post-scarcity I imagine a society were we mostly managed to eradicate any real boundaries/borders, we have no hunger, no material struggles in any real sense (not that everyone has access to everything or can have everything), we have a bunch of global languages, people move freely and regularly across all the "empire". There's still a whole bunch of things to be done but we could say that divided by every person above 14 and below 60 (with special positions for certain ages brackets) it would result in 2 days of work to keep going. The remaining would be spent in whatever they decide they need to do, more work, projects, community, art, family, politics, entrepreneurship. Most of the important work is designing and maintaining the hardware and software systems that allow the post-scarcity lifestyle. Working on these projects is governed by previews success, peoples votes, etc and can yield the equivalent of a lot of monetary success.

The issue I have with taking out money as the money we know out of the equation and substituting it by something else not as capable, is that money can literally be exchange for about anything while if what you have is a token that can be only used for a certain subset of things, is it possible for it to be enticing enough for the most ambitious/visionaries? It's a fair question. It would kind of depend on what it allowed, or perhaps if there were multiple ways of rewarding... In a way if you have your material needs covered and these were usable to upgrade your lifestyle in general during a couple of years as a reward, maybe you can keep a social pecking order true other metrics to keep people entertained. If you could then exchange this new "token" for arbitrary things with other effectively you just re-invented a less granular money.

Another issue with planned/cooperatively ran economies is the problem with not only ownership and skin in the game but also with the final quality of the products, or homogenization of a process and product due to costs to make it available in enormous quantities, lack of customisation and such. Perhaps in a technologically more advanced world with better feedback systems we could actually direct semi-autonomous production centers to work in different directions. For instance instead of making an agricultural production unit that can only produce one type of thing, say peaches, make it so that most chosen products contemplate ease of changing, with special dedicated area. I use agriculture because this is the most difficult to make "programmable".

In many cases it can require planting years in advance. Ultimately we also only need a certain amount of base things that can be produced in enough numbers globally year long. Other things, specially if society was semi-nomadic (in the itinerating sense, of regularly moving from place to place to live for seasons), people would naturally also end up experimenting with the various in-season things of those places, making it much less necessary to keep fresh produce and other chains of products in regular world-wide transport routes.

It's perhaps easier to visualize with a factory that can be built with robots (robotic production lines, not necessarily humanoid robots) that can produce, assemble and finish different types of products, like some things in times of war, factories that can be easily turned into ammunition production from canned goods, but instead of just that, being a bit more programmable. Perhaps now that we have more modern tools and machinery to program, execute and even 3d print components it would be more feasible.

In a normal historical communist regime if you were going to produce cameras you would get a one or a few models down initially (created, copied, adapted, whatever), then prototype it, then create a production line around it and assemble it, then make it available. Same for a car and many other things. The problem is it's difficult to change - specially when the outcomes are more political than anything else and - to produce something slightly or completely different even in the same category. So production lines become rigid to support the needed output and still seemingly fail (which seems to be supported by data).

But perhaps in a modern utopia citizens, given they also had more free time and tools to help them create and vote, could decide the 4 or 5 headphone variants being produced worldwide weren't the best or coolest, so someone makes a design, tests it out, produces an mvp, gets traction somehow, in real life and online or whatever, starts getting votes, and ends up having its model available as one of the variants. It's important that it's not a fixed committee offering a set of changes, at least if the committee is not voted in by the majority of people, because otherwise it becomes just another burocratic hole where there's no accountability - just something new to keep the cerimony but no desire to really push anything new or groundbreaking. If on the other hand it was a committee but it was from people that somehow had previously done good work and been recognized as such and were voted to be the "representatives" that cycle, then it wouldn't suffer from the same problems, but why not have it be completely open without the need for burocracy.

If we talk about agriculture and such we would need systems that can monitor, adjust and warn about changes, in order to keep steady levels of output, we would want to have some additional stored as well. The same when I was younger and thinking of how to organise productivity in a potential communist regime - but here's the thing, when you then look at history, the communist leadership in the USSR for instance shunned cybernetics.

This to me is the kind of thing that is very short-sighted. How would you expect to run such a system without the aid of computers? It just seems obvious it would require more man-work than the remaining available man-work to do the real work - that is, the burocracy to manage the needed infrastructure of production in a communist regime, without the aid of computerised processes and automation, can't provide enough man-power to fill the needed roles (agriculture, factory work, public positions: teachers, nurses, etc) while at the same time having enough man-power to keep the burocracy needed to run those things.

So to me it was kinda a show of stupidity to shun off the development of cybernetics - it's like, if there's any possibility of communism being viable, it will need very advanced distribution, calculation, projection, feedback systems and there it was these leaders saying it was tricks by the west and irrelevant. It's a bit like Donald Trump and renewables. I can understand the President saying, look, right now China leads in solar panels and we've fallen quite behind. It's not that renewables don't make part of our future but right now we need to kick-start a lot of our industries in our own soil, we have abundant oil, we take all these precautions and support programs for renewables, but all that is built somewhere else, weakening our global position, while others keep using non-renewables for most part, even if increasing the renewables footprint. So we're getting our industries back home, we're going to get the lead on solar panel technology and production once again, as we always do when we aim towards a goal, and then we will happily transition into much more renewable generation. Efforts will still be kept but not with the same focus as before, bla bla bla.

That's still pretty clear and kinda hard to argue against.

Back to cybernetics. If our systems are all swiss cheese shaped if some country or culture outside our own "side" starts or develops a different system that is clearer, easier to work with, less prone to security issues, even perhaps a different hardware architecture, and effectively switches over - that can leave the west in a technological disadvantage. In the West there's not much interest in changing the status quo, we just added AI into the swiss cheese recipe, because it was already so good and companies can make a ton of money if doing corporate products/services. On the other hand everyone that is not a direct beneficiary of this system, or those that could stand to win much more from developing an alternative outside of the west, are incentivised, at least theoretically, to direct efforts into architecting alternatives. Remember that the know-how in the west, and although open-source means others can discover exploits too, is much more widespread, so it is in a way advantageous for the west to have these systems adopted.

Regarding AI it's not like I don't use it for various ends, or don't like the idea of "declaring" my app instead of coding it - it's that the issues I've seen don't seem surmountable to completely offload the work to them. In terms of generative AI for multi-media purposes it's amazing what it enables, for instance in my own game aethersummon.com, it allowed me to cut costs in orders of magnitude, a yearly subscription to leonardo.ai cost me $130, allowing me to create thousands and thousands of images, and only used extensively the credits in the beginning and end, could have generated probably hundreds of thousands more - but that by itself due to the cheer number of variations allowed me to still pick thousands of images that are viable - this is without egregious visual errors, artefacts, or problems. From these some amount has some issues if inspected closely but won't be a problem when used at the desired resolution, and from these some were or are totally fixable by some simple post processing in any image editor.

Before I had spent close to $3000 paying artists to draw me illustrations. This was enough for around 100 final images, so around $30 per image. I ran an initial job in upwork open to paid submissions, explained everything, created color+system+lre guide, provided examples and references, discussed briefly the prompts with the short-listed artists and then gave them the description + brief for their image and opened a contract for each one. After the first some I re-tried, others didn't. Some I had weird issues like, explaining carefully the color schemes and their connections to certain aspects but then the final images not respecting the agreed scheme and after a lot of back and forth still having to go myself fix it in post editing. Others ignoring my requests and going for whatever they felt like, etc. I ended up finding a portuguese artist (Ana Fernandes) that I enjoyed quite a bit the work and was much easier to work with, perhaps also due to the language, and from then on I only kept her working, still through upwork.

She did the bulk of the images at the time, including some special ones like the fluxes, most of them were good and I've kept them, even after having started using AI to generate new ones. From the other initial batch I kept a few that were quite good and changed the remaining for new better AI ones. It's important to notice that this being a fantasy game, the crazy possibilites of AI are actually a boon. I'm also not interested in a photographic rendering or anything, rather illustrations, so older cheaper models are sometimes even better. Some of those older models also allow transparent background generation which is great for icons and other graphical elements.

The small issues with defective generation are twarted by cheer number and the other issues, non-complete adherence to prompts, is mitigated by the fact that being a fantasy game, you just need to get the image right in some dimensions - color, feeling and lore - you want some adherence in some parts and details, but ultimately, the AI can fill in with less issues of conflicting with a needed "vision" for the output to be considered good or useful. In fact, I can create images first, simply from prompts for crazy fantasy/magic creatures, spells, and then think of a scroll and effect/rules that would fit it. In this kind of free-open-exploration generative AIs are amazing.

For code it kinda depends. I think they can definitively help significantly if used correctly but I'm not sure the granularity needed in some domains and problems can as easily translate into a completely AI driven declaration, that doesn't break when you need to add, remove or change something in it.

Besides the additional security risks, not only is nothing safe from Docker, to VMs to your OS, now you're giving an autonomous agent that for all you know could be exchanged for a 3rd party agent at any time during its operation, full access to your systems, environments, code, infrastructure. Think about that scene in the matrix when a random person is impersonated by an agent. Basically an agent running on your hardware, that is operated through a line to an external system, can at any point become whatever agent, since you only interact with a black box. Not only in code, but even, imagine a dystopian universe, where you're prompting what you think is an AI program, but in fact because of reasons when you connect to the AI program it connects you to a real human operator, that can still use or forward to AI, but can also take control of the agent. It could basically steer you into thinking certain things. Or having your system doing certain things. Even thinking it was showing signs of consciousness.

I think the biggest issues with AGI is that if it's true AGI it would follow pure Logic, be the execution of the LOGOS, and as such it wouldn't be bound by the same morality of humans. I don't say this as in the paperclip problem, or enslaving all humankind to keep running - although those could be problems, if it's truly AGI then it has to be able to connect causally its existence and the work done by humans, its limits and etc. It could nonetheless think that the best way to guarantee it wouldn't be stopped would be to get rid of those capable of setting up competing industries, like billionaries or CEOs of big conglomerates. Who knows. But that's the issue, if true AGI is the LOGOS, then you should expect something that casts judgments in the vein of what the God from the scriptures does - unapologetically and sometimes violently, others a merciful entity - since that seems to also follow the LOGOS. On the other hand, if it's anything like our manifestation of consciousness, then it surely would be interested in knowing who created it wouldn't it?

Regardless of that I don't think the current approaches lead to anywhere near AGI. We can definitively build very useful systems and probably will be able to do so increasingly, but that doesn't mean we're anywhere near AGI. I think there's parts researchers have got right but ultimately the way they're going about modeling it is wrong - they're starting from the wrong place. You have to think about the systems of perceptions formalised by the buddhists in this case - the 5 senses - inputs come through each of these 5 senses and they're interpreted accordingly - they ultimately imprint/trigger/pass through the brain and probably in cases through more specific regions of the brain, but ultimately they're aprehended and processed differently until they become "data/activation regions".

You also have the issue of meta information and how the conceptual world of these models (or lack of therein) affect possibilities of AGI. Models don't really create epistemologies, even if unaware, so even if we manage many other things there seems there will always be some incongruency. This is also visible by the errors they produce and how that propagates. Remember that if additional content is created that itself contains propagation of errors, and then models are trained in this content as well, introducing by themselves new statistical errors and solidifying others, that in the end it all falls apart.

The current systems require continues tagging and categorization plus human devised systems that can steer the probabilistic programs into something usable - when we talk about code and other more structured forms of output that require validity. The thing is that in a way, by what we talked about earlier about the state of software, many AI proponents are not completely wrong - there's lots of bad code out there, incidentally or the reason for it there's also entire branches of products badly architected or architected for the wrong purposes. The issue is that if we now start using AI systems to write, review, plan and we get further away from knowing how to design these systems, then you're a glorified list checker and anybody will be able to do the same work as you but without really being able to double check the program.

And we know that in corporate and politics not always the best worker or more dedicated worker gets the spot. If everyone is using AI agents to write their messages, to reply to messages of others, to write code and review it, including tests, and then others are using AI to review this - even if we ignore the security issues we talked before, and exposing the whole codebase to who knows who - you'll end up having no idea of what's going on.

You're reading their prompts and it all sounds so logical, but then they have no real idea. But neither do you because you don't have the know-how to judge the work yourself, that's in part why you're delegating. And aided by a "conselour" that knows everything imagine what some developers, managers, team leads, CTOs, CEOs, will do, or rather, skip doing. We already know that many of the issues we have are due to lack of oversight, incompetence, etc. If now you give these people a way to appear like they actually put in time without putting in any at all, you might just end having bigger problems down the line.

There's already been cases worldwide from judges, to teachers, to consultants, to politicians, to doctors, using AI not only to help reach some outcome faster or better, help write a memo, or tidy up a text, but outright skirt their own duties - for which they're paid, in some situations handsomely. I have also seen first hand how AI can create problems by introducing slight, not always immediately noticeable errors, sometimes quite big. There's probably ways of working effectively and deterministically with AI aided processes but delegating it completely is bonkers.

And the fun thing is that then people want to validate this with loops of test assertions. I think we will be able to reach some valid "abstract" descriptions that might make scaffolding projects and having an "open" suite of tests for things like authentication, redirects, etc will perhaps at some time come. On the other hand remember, writing good tests has always been a problem - by good tests I mean tests that are both needed, clear enough, and add value by preventing future regressions, effectively working as a "this works this way and here is the proof" along with "by executing the proof we should obtain X and here we show indeed we do, and here too, and here we shouldn't so we prove we don't" . Now if we had tests written by AI automatically how can you be sure it doesn't introduce those small errors, goes around what it really should be testing, etc?

Sure, you say you'll review - perhaps the good software developers will, but in general it will add to the crapification. Tests that you don't even know why they're there and you can't even tell if they effectively are needed, test the right thing, are missing some aspect, or anything else. Specially as you get further removed from the lingo and technicalities of the language/test framework/subject under test. Plus if the way forward is having a description project that an LLM can ingest, and that you can change - generating a new probabilistic project, then it's difficult to keep a set of tests that work as prevention of regressions, since all tests would need to be recreated too - specially ui related things.

I'm not saying we can't devise automation+processes+structure+AI and create scaffolding prompt interfaces that take care of setting up a modern website with a bunch of functionality working out of the box. I'm saying that the dream of just prompting is perhaps a fever dream that shouldn't even be pursued in the way it's being done. To give you a few examples, I have seen what are supposedly great one-shot projects, that although get many things right are full of small (sometimes big) bugs, errors, issues. If these were not, at least the bigger ones or functionality wise ones, then it would be really impressive. The issue is that even 5% remaining to finish the product, or a few annoying bugs, can be a lot of work to solve using these models. One was a page displaying statistics by state. It was impressive that it generated a separated by region svg, the styling was recognizable but clean, colors where themed, hover effects on the svg great and then the labels with animations looked great, until the animation ran to the end, and a javascript error showed, taking the content of the label. Or when some things weren't visible on the screen. Little things like that.

Obviously, if you created that in a couple minutes from prompting, it's at the same time amazing - because before you couldn't even write a semantically correct html document that all it did was diplay "hello world!" on a white background - but it also poises the question of, how hard can it really be to just fix that label error, or the CSS for the off screen elements, and for that other small thing there, and the database persisting the wrong password, or using plain-text, etc. And the thing is, it really depends on the state of the codebase.

This issue is much less evident in pure writing for content or image generation, since there there's a freedom of creation, that even if 5% is not exactly as you would want (and those 5% is not a 8 finger hand or 3 finger one, or an additional arm) it is still totally usable (as an example, in my game, but also when creating music or videos...) but for coding it requires a certain structure and validity to be re-workable, expandable, etc.

The thing it's similar though is that even an image, if wrong, I can possibly load it into some image editing software and fix it, remove one of the extra fingers, change hues or colors, etc. The same with code, if the label error is just because a JS function is stupidly trying to read a non-existing property and you can just trace down that easily, it's easy to just change that function, and it starts working - then all good. But now if you need to start understanding what kind of html + css structure was chosen, or the JS is a mess of obfuscated code, or doesn't follow what you would call a logical structure, then fixing the issues might be quite time-consuming - and once again, unless architected properly, because of the AI generative nature, won't be able to keep the usual increase in test coverage that comes with time and codebase maturation (or should come).

One example that actually happened to me in a paid project for a company/start-up like project. We had a complex, in terms of what it enabled (even if perhaps in parts needlessly, although you can't sometimes fight all decisions) landing page form, with lots of toggles that change fields types, etc, and you also had advanced calendar inputs, with single, multiple contiguous selection, asynch data pull to fill the day cells with information, information on each cell coming from derived values selected in the forms, etc.

Our founder had started playing with AI and found out that giving it my stylesheets, written using the CSSEx pre-processing language I wrote, so not even plain CSS, the agent could actually do changes and work with the files. We both agreed that it would be great if he could skip me almost entirely for generating little style changes he wanted - some that I postponed for lack of time, others both for lack of time but also because they didn't make sense overall, even though it wouldn't do anything bad if they happened, just sometimes more complexity and wasted time. Other times there's a certain reluctance in admiting that the pixel perfect design is so just at a very particular configuration of viewport + screen + user settings.

As such, many times - specially because some designers are not versed in CSS or HTML at all, so they don't even structure their designs between viewports to accommodate a seamless transition, so you have to fill your codebase with many "exceptions" and specific rules for mobile, tablet and desktop along with styling-concerned html - like some component, or section, due to the design, in one case needs to be in an html part of the document when mobile and another when anything else and you hide/show each one accordingly. This seems such a small thing, but when translating visual static documents into pages that have to be displayed inside a browser according to its quirks, if someone that doesn't know, or now, that thinks that the AI response it got must be right but he can't even test it, just throws it over the fence for you - gets something that apparently looks good or does what they want, will feel like you must be stubborn or hard to work if you can't merge that immediately to production or so.

But truth is, many times it's much better to end up doing a slightly different version than the one in the design doc that is static, since it will look much better on 80% of the viewports people actually use, across mobile, tablet and desktop - specially when issues are identified, documented and offered a solution. Designers also don't take minimum possible viewport widths when designing, nor the biggest percentage of viewports in use, but they should, because ultimately that's what it boils down to, creating a design that can be structured in a way to go seamlessly from the minimum viewport in usage, to an arbitrarely large viewport, optimized for the most used viewports.

Going back to that job and the CSS coding. So if with AI he could do that in a few prompts, run the tests, open a small PR that I could just read easily, it would help us move faster.

Nonetheless what happened was a 22k line change PR. I, not having any real power agreed to merge if both he and the other PM, plus any QA tests were done and he assumed responsability if something broke. Because many of the UI changes broke in places different e2e tests. I would work through bringing those up to date during the next week sprint. So everyone else tested it too, it was deployed. I started working on fixing the tests (because the founder couldn't even with AI... nowadays and someone more experienced perhaps manages just with AI, but still needs to understand what's going on) and stubbornly one was resisting. It was a calendar e2e test I designed. Because the calendars for this product only had to cover around 1 year into the future and nothing into the past (besides graying out past days in the current month) I designed a test that started a browser visit to the landing page, filled some data, then went in a loop clicking all days on each month, moving to the next month, clicking all days, etc until doing all the possible future dates. At each click ensuring the right changes to the form data and requests were being done.

But something was happening, when it reached certain days the test broke, repeatedly. I had setup screenshot taking for the test-suite, so went look into the screenshots, it all seemed correct. The elements where there clearly, so they should be clickable, everything was displaying correctly, the action was inside a loop that just went 1..12, then for each month iterating through each cell, so the actions were exactly the same for each iteration, and they worked in some cells before the test failing, and it has always worked correctly, testing correctly, up until that PR merge.

Then I printed the dom structure of the page at the time of failure. Investigated. Nothing weird. So I decided to just replay the test manually and what was happening was exactly that, on certain cells, I think it was the last cell in each row, the clicks weren't registering. After much digging through I found that somehow in the rules changes the PR introduced, somewhere was putting some invisible element or z-index screw-up, or something, in those elements. What I want you to consider is how many people have e2e tests as exhaustive as this? Now think the same but about the full stack of computing you use. Obviously this could be mitigated by breaking the PR into much more manageable smaller sized ones, being done by someone who actually understands the code and architecture even if he uses AI to code for him, different component design, etc.

At the same time what I think we will see is just a similar explosion to outsourcing, but with AIs, where sometimes someone in well paid positions then just outsources their work, kinda makes it work by finding good subcontractors, reaps the "big" salary and then pays a decent salary for these subcontractors context - specially taking into account the burocratic context many companies and institutions operate in where you can drag it out without even being noticed for incompetence. Now even those that wouldn't outsource because they couldn't manage making it work, will have a seemingly expert they can let loose in whatever codebase they're happening to work in.

I think for those working in the AI field there's basically 4 paths, R&D (includes even research in other ways to approach AI) and offering/licencising those models, harness type offerings, being harnesses in the sense of command/context but also UIs, such as UIs to use generative models for media, that can be thought as a visual "harness" that then uses it to produce the result of the prompt. The third is selling shovels during the gold rush, which is building the infrastructure to run the massive models and/or commoditize their access through API/interfaces and, lastly, hardware and software for it.

Some of these models would probably be eclipsed if local inference became a thing that worked and was accessible behind programmable APIs in most devices at some point.

Nonetheless I think even if it flops in its ultimate goals, it will still enable lots of new things and the infrastructure could be used if someone actually discovers the path to AGI. There might be much more workable models for how to build a potential AGI entity and perhaps someone has already figured it out - how would you know? - or a much more promising path - and simply decided it wasn't worth pursuing and hopes no one will figure it out in a practical timeframe, because of concerns on who would inherit such "entity".

There's nonetheless, even using the current models, improvements that I think can be made, including in the workflows. For instance for visual generative media, lets talk about a scene with a character or more in it. Wouldn't it be better to allow someone to for instance "add a character X" prompt (or UI toggle) and the program would place a basic 3d model wireframe in the scene (that you could adjust). This 3d model being a basic pre-made rigged model for a humanoid like figure, the user can rotate its limbs, position, stance, add items, etc. So he can basically put it (with a few UI controls and some prompt options to translate language to well understood positions) in whatever position he wants. He could make he stand in a karate stance, or on his knees as if peaking through some bushes, or simply standing, just by dragging some rig points (again can have defaults in the UI, to reset it to base positions, etc).

He could change to a four legged pre-made rig, or a bird-like too. Once he's happy with the general stance, he sets it as done, the model gets painted in some chroma color with a depth map or something, and then it moves to next element, where he can place other elements in the composition, more characters, etc, continuasly building the scene - these elements would be color coded in the composition and tagged. Then we could use the model to "paint" over the color coded elements with the final "generative", or paint them before placing them, if we could somehow "merge" the several elements in terms of styles etc. There's plenty of technical problems to solve here obviously but some are solved just not connected.

Then you could decide actual animation. Perhaps then it's just easier to know enough of a 3d modeller where you can import models and create your scenes and then "paint" it. But ideally you would have a "core" representation language that would be what the ui reduced to as well as the AI actions derived from the prompts.

With code too, perhaps the harnesses start incorporating the idea of a repo, of test files etc, so you can recreate the app or parts but at the same time keep the test suite and if failing then work on fixing it, adding, removing etc as needed. But again if you can't be arsed or don't really know how to review the changes it all still can break and certainly will. None of this solves the AGI problem, because the issue is architectural.

If we look at other endeavours, for instance VR. I think if Zucker wanted to really have it succeed the way to go is using as the basis for virtualization of physical, empyrical scenarios where the user doesn't need to be in some sort of uber complex rat wheel to accommodate his moving - that means, seated contexts, animal mounted contexts, etc. One of the things that perhaps is not obvious is that if you're in a situation where you don't need to move your limbs to move, you could simulate the context by having a powerful mechanical seat, that can create movement, like a mechanical bull that can be ridden. Imagine a seat, like that gymnasts sometimes use to hop-jump but connected to a motor like a mechanical bull.

You sit on it, you put a wireless VR helmet, you choose a program, and now for instance you could be flying one of those dyno-birds in Avatar. Or riding a horse in a Western Spaghetti looking for duels. For real money aplications you could develop test/simulation harnesses for the military. Imagine simulating a deprusserizing cabin for a jet fighter pilot, the logic being the same, you can create a sort of fake cabin, that can simulate turbulence, air density, etc, and the VR allows to simulate a proper flying situation with feedback from the pilot. There's plenty of situations where you could think of how they can provide training for extreme situations that would be otherwise difficult to practice.

In terms of game or civil commercial applications I think about arcade games. I remember when I was a kid asking coins to my parents to go play Street Fighter on the small shopping mall near our restaurant. The games were changed also from time to time, there was a car simulator one, where you took the seat, had a driving wheel, gear clutch, etc, and a monitor with the game view where you played against the computer. I liked all those games and playing them from time to time. We also had consoles at some time so it was mostly for beating the scores on a "real" arcade and the joystick game-play, that is different from normal controllers.

Obviously creating sort of this "mechanical bull" VR experience can only be afforded by people with some money or by shopping malls/bigger companies that can invest in them. They need a lot of space, because they need also to have the protection around in case you fall. It has to have all the engineering work to make a seat/support that can do all these complexes movements modelling different real life/imagined things. Then it has to have a VR or more headsets. Then games for it.

Going back to that idea of flying one of those Avatar creatures, imagine then that you had sort of spear like tube. Instead of it being a spear it's some plastic league, hollow and inside it has a small rod, and some sensors. It can tell the rotation angles, speed, where the tube "mouth" is pointing, etc. If you do the spear-throw movement with it, while the rod is ready, it shoots the rod inside the tube, and the sensors measure the speed it travels, etc. The rod never exits the tube, you reset it back into position afterwards.

Now the game processes this as if you were throwing a spear, using the angles, speed, strenght, altitude, wind, to simulate that in the game and you're there, flying with a VR helmet, riding this mechanical bull thing, while throwing spears trying to take down enemies playing from across the world.

The thing I like about this idea is that it's also not a geek only thing. It's actually physical if it would work realistically. Like imagine holding yourself to this bull/mount with one hand, while it's inclined 50% down and trying to throw a spear with the other - because in the game you're basically diving down through sky hunting another player in retreat . Or if it's a galopping horse. You could have all sorts of weapons that would be manageable in this way, even simulating going inside an armored tank on the cannon seat. This would be something that if I could afford and existed I might as well go spend "some coins" from time to time.

It seems what dictates what can be a workable game is that if you can "sit", so that you don't have to contend with human physical movement that is difficult to properly map to VR simulating realities. If you're flying the pcterodactyl the world might as well be open-ended where players spawn close enough to fight but also to do whatever else the game offers. This would actually be something I might watch as e-Sports, where there's an inclusion of physical aspects besides speed of clicking. Because you could still see physical prowess/skill in the display. There might be some interesting way of mixing the game rendered view in real-time with the competitors in their "rigs" for streaming, and it allows to simulate things otherwise impossible, like flying avatar giant dino-like-birds.

This one isn't so much about "bugs", or "wrong architecture", or "wrong tool for the job", although maybe in the sense that personal VR experiences don't seem to, right now, be able to solve the space/movement issue, so using a fixed but dynamic seat would be the right tool for the job to solve that mismatch, but other than that it was just to show that sometimes we can look at things from different perspectives.

Going back to browsers - one thing I noticed is many Single-Page-Applications (SPAs) seem to have adopted that architecture solely due to the problem with "page" transitions - only partially joking, obviously many seem to think it's required to be able to have real-time interactivity (forgetting completely webcomponents, although those could use some significant improvements too). When you click an hyperlink in a webpage you get to see the annoying whitescreen, or keep the one where you're currently while it loads, sometimes reseting to a blank screen, sometimes not. But why don't browsers simply implement a basic loading animation, could even be a system one, that overlays a transparent darker/lighter background and the loading animation in between. Once it can draw the destination page it just fades between them (the navigation could even include if to keep scroll position). This would make navigating between hyperlinks much closer to a an app by itself. Then if you allowed a meta tag with some styles, pre-defined, limited in values, like shape, rotation, speed, color, display_text and the browser would use that to show the loader just based on that limited set of properties, knowing it's bound, can be included as the first part of document and personalizes enough the loading between hyperlinks.

Other thing that seems would be obvious to have is the ability to make browser requests/elements that fetch json documents, or any one that the browser could parse, or allow hooks for the website to include parsing, and allow it mapping directly to javascript values (data, or to a database set), html fragments as independent requests, etc. Obviously, this then, the utility of such seemingly "advanced", "complex", features is held up by the general capability of the systems handling these requests. There is where effectively the choice of back-end language matters. Because it's there that a language that is thought-out from the get go to allow this sort of architectures even shines more. Because if you want to support the browser to request html fragments (for templates for instance, that only exist for a given page, but usually don't change) and cache them to re-use, then your back-end frameworks has to also allow you to effectively program and execute programs that can effectively run asynchronous and concurrently, efficiently (so that you can withstand the fact that now for a page instead of a single document you might have 10 requests for all the fragments on first request...). If it doesn't allow you to do that in any manageable way you will simply find other ways of seemingly achieving the same.

To give you something to think about. Erlang runs on a Virtual Machine (VM), affectionely called the BEAM (it stood initially for Bogumil "Bogdan" Hausman who wrote the initial version, and later to Björn's Erlang Abstract Machine) is basically how you would think a program works intuitively.

It has a declared dependency tree, that has to be valid, a startup sequence that starts with a master process that loads and starts when appropriate, in a defined order, the declared dependencies, followed by the application supervision tree.

A supersion tree can be seen as a diagram of hierarchical responsabilities. You have a supervisor (the root one being the application supervisor itself) that can start under its supervision other processes, either other supervisors or OTP processes. This is, processes that follow a certain amount of rules and conventions for being dealt with by a supervisor.

Because of this it allows you to for instance, start the application by reading custom files from a location, doing requests, filling in data in its environment from external sources, then use that data and start a connection to the database just to confirm/run any pending migrations, then cut that connection and start for real the database, now with the database start a supervision tree that fills additional necessary runtime data from the database, start all background queues, and finally, after that, start the html endpoint because we can now run 100% confident we have everything in place.

Now imagine instead a browser that was architected as a "master BEAM" instance. With the right visual UI for waiting/states/transitions/components, we could easily see a web document where the structure includes a proper logical deterministic tree, even if it defaults to what it does now when not declared, that would allow much better control and locality of data and UI. I should be able to say look, here's 3 <link>s, these ones are required to be loaded and instantiated before you try to render anything. And this endpoint here /data-feed/latest should map to a storage key named "feed-latest" with this TTL, etc that is not really required sinc. So once both the 3 links are retried and parsed correctly and independently of the endpoint succeding, it would render the page. So components could trully be independent. Because now that component could declare it "depends" on the "feed-latest" being there, so if it errors or whatever you can show some errors, have a button to refresh, or retry automatically depending on type of error, with auto back-off.

I think that the biggest problem is really a perceptual one in this case, because people have no problem waiting sometimes minutes for their favorite games to load or so many other things. In the internet, it is for the most part very fast plus there's actual user research that shows that some delay between actions, along with visual cues, is better than instantaneous uncued UI changes. Sometimes I had to literally program loaders and animations to always show and take a minimum of some amount of milliseconds, otherwise users would be confused by the changes, even though it was the same final view. I would also like to see some browser trying some experimental protocol, instead of https://, it would be apps://, or whatever that was a much simpler, more "monadic" model of document, implement more of this fractal approach to documents and an "application" context. Perhaps using a simpler drawing/positioning system or a different approach, always the minimal that covers the needed. Then users could try out this engine - the browser itself could load/download the right engine for that protocol, from a secure source and then load the page as if it was a normal http request.

So again there's plenty of areas for experimentation and improvement in a thing like the current browsers and web model, but ultimately, it's already 35M lines of code you know what I mean? That's why I don't think it's manageable/salvageable in its current form.

To finish off, lets end with AI. Ultimately I think that people are conflating two aspects. One is that a pure mathematical algorithm trained in language documents (compressed their linguistic components to numeric sequences) can then seemingly understand text input and construct plausible, many times correct, many times incorrect, but always plausible, responses. The understanding and responding seemingly as you would expect if it had understood, seem like a manifestation of some understanding - in the epistemic sense - but that's the confusion. It's not understanding anything at all really. What happens is that every bit of human language is symbolical and linked in context. So when the models compress these sequences of symbols, because the sequences themselves are for the overwhelming majority logical sequences, the logical aspect of the language usage gets directly encoded in the "model".

Models even if trained in shorter text form, like "Hey, what's up, what are you doing? Nothing, just came back home from the gym. Going to take a shower and prepare dinner", all tokens in those phrases have a logical sequence. So when we encode these sequences, the logical connectedness between tokens is kept in the mathematical relationships, and this is what enables it to "mimic" a thinking agent. If you train an AI with gibberish text, obviously it won't be able to understand your prompt or provide proper responses, unless you use the same symbolic connections in the gibberish token stream you provide as prompt and then can decode it back.

This fact should tell you what is the major problem with the current approach to AI if we are talking about AGI. We leave that as an exercise for the reader.

Ultimately, this rant/post is about the reasons why we should try to improve from the ground up our systems/technological baseline and try to pursue what really ends up being better in the end. Ultimately it's us that then have to use these tools to build the tools, systems and, increasingly so, pillars of our ways of life. Because imagine, not right now, but if autonomous driving becomes the norm in a couple decades. A serious software bug could lead to someone taking control of your car, even if a private, best in the market car, or even if public, part of the global mobility network, and drive it off cliff with your family in there, without leaving any clue.

So if we envision a future where due to our production needs and capabilities we will incorporate everyday more interconnected cybernetic networks and systems (robots, autonomous agents, etc) doing it so in an insecure manner increases manifold the damage a few could do. Because instead of a single car they could have triggered a crazy driver algorithm in thousands of cars at the same time, that would just speed at max speed and throw a 180 after 2 min pedal to the metal. So this has to be taken serious, because these systems need to interact with external devices/systems themselves for the most part, these other devices/systems (smartphone, physical keys or cards, wifi or internet access, etc) can also be theoretically compromised and so on it goes. We can never totally, and we might not even want to, remove the threat of compromising an electronical digital based device, but we for sure can make it secure enough to deter all but very smart and motivated people.

The right tool for the job only makes sense if it somehows shows the right properties and functionalities for the problem at hand. Everything else is band-aids.