Original author here: These skill have been adding a lot of value in very less time. After debugging a knarly bug for 4 hours, you might be exhuasted to explain in it a good way, this helps with that.
I personally think the Commodore 64 as it was best price to performance you could buy. There is a reason why they call it the VW Beetle of Computers. Heck they are making new ones.
I don't know anyone that doesn't use a combination of at least one simple, one feature laden, text editor. Most of us via notes apps, etc., routinely move between a range of text complexity, suitable to a range of things we want to write.
Having the simplest to the most powerful apps be consistent between each other, where they have commonality, would be really nice.
Is there really for the ML boom, or is it just a way to make computers more and more expensive to push people towards mobile? Because looking around, that's the effect I'm seeing, regardless of the causes.
I see a future where most people will buy tablets to save money and the desktop will be for only a few, a very few, just when self-hosting is becoming trendy and people are saying "it's time for GNU/Linux to take Windows' place"...
They're being asked, in this case, to solve a problem that business has already shown able to solve. More competition will also solve that oligarchy problem too.
Having tax reduction as a primary goal is terrible for society, because taxes are the primary mechanism for converting money from rich people into services for everybody, particularly poor people.
> The three problems frameworks solve (or claim to) [..] Simplification [..] Automation [..] Labour cost
and he misses _the most important problem frameworks solve_
which is correctness
when it comes to programming most things are far more complicated in subtle annoying ways then they seem to be
and worse while you often can "cut away" on this corner cases this also tends to lead to obscure very hard to find bugs including security issues which have a tendency to pop up way later when you haven't touched to code for a while and don't remember which corner you cut (and with AI you like did never know which corner you did cut)
like just very recently some very widely used python libraries had some pretty bad bugs wrt. "basic" HTTP/web topics like http/multipart request smuggling, DOS from "decompression bombs" and similar
and while this might look like it's a counter argument, it speaks for strict code reuse even for simple topics. Because now this bugs have been fixed! And that is a very common topic for frameworks/libraries, they start out with bugs, and sadly often the same repeated common bugs known from other frameworks, and then over time things get ironed out.
But with AI there is an issue, a lot of the data it's trained on is code _which does many of this "typical" issues wrong_.
And it's non-determenistic, and good at "hiding" bugs, especially the kind of bugs which anyway are prone to pass human reviews.
So you _really_ would want to maximize use of frameworks and libraries when using AI, as that large part of the AI reliability issues.
But what does change is that there is much less reason to give frameworks/libraries "neat compact APIs" (which is a common things people spend A LOT of time one and which is prone to be the source of issues as people insist on making things "look simpler" then they are and in turn accidentally make them not just simpler but outright wrong, or prevent use-cases you might need).
Now depending on you definition of framework you could argue that AI removes boiler-parts issues in ways which allow effectively replacing all frameworks with libraries.
But you still need to review code, especially AI generated code. To some degree the old saying that code is far more read then written is even more true with AI (as most isn't "written"(by human) anymore). Now you could just not review AI code, but that can easily count as gross negligence and in some jurisdictions it's not (fully) possible to opt out of damages from gross negligence no matter what you put in TOS or other contracts. I.e. I can't recommend such negligent actions.
So IMHO there is still use for some kind of frameworks, even if what you want from them will likely start to differ and many of them can be partially or fully "librarified".
More like giving formula for free to new mothers to begin with, and when they wouldn't produce their own (as there was no "demand") they would later need to buy more formula.
Facebook and Twitter are far worse sources of extremism. There are entire groups dedicated to genetic comparisons between races, 'who would you do' groups that do nothing but photos of young women in bikinis farmed FROM facebook/ig.
4chan is where you go too far. 4chan users typically don't foster extremism, they are the extreme. They don't post pictures of young women, they post addresses and walkthroughs of their apartments.
Ship faster with one tool for your engineering team. Track issues, plan sprints, and write documents. Connect AI agents via MCP to automate your workflow.
In my opinion one inherent property of languages is how large the largest program is that can be written in those languages. There's languages that work well for short programs. Bash, perl are examples on one end of the spectrum. Then you have things like lisp and Python where the largest programs are a lot larger already, but still hit obvious limits. And then you have the languages that support really large codebases. Java, C++ are ones currently in use.
There's new languages where it's a bit of an open question still where they lie on the spectrum. Go would be one of them. I'd guess somewhere between Python and Java. Javascript I would argue is between perl and python. And Rust ... well ... good question.
An office suite is a gigantic application, which will need feature upon feature upon feature upon feature. If you want it working on the web, I'd propose something like C++ and WASM.
I would think that frameworks make more sense than ever with LLMs.
The benefits of frameworks were always having something well tested that you knew would do the job, and that after a bit of use you'd be familiar with, and the same still stands.
LLMs still aren't AGI, and they learn by example. The reason they are decent at writing React code is because they were trained on a lot of it, and they are going to be better at generating based on what they were trained on than reinventing the wheel.
As the human-in-the-loop, having the LLM generate code for a framework you are familiar with (or at least other people are familiar with) also let's you step in and fix bugs if necessary.
If we get to a point, post-AGI, where we accept AGI writing fully custom code for everything (but why would it - if it has human-level intelligence, wouldn't it see the value in learning and using well-debugged and optimized frameworks?!) , then we will have mostly lost control of the process.
It'll be interesting if MS allows to write e.g. WFP callout drivers via LiteBox and not requiring attestation signing. It'll still work in kernel mode, unlike NetworkExtensions in MacOS.
But humans react to this extremely differently than a self driving car.
Humans take responsability, and the self-driving disengages and say : WELP.
Oh sorry were you "enjoying your travel time to do something useful" as we very explicitely marketed ? Well now your wife is dead and it's your fault (legally). Kisses, Elon.
The rest of the article answers that question. The followup article answers it more directly, and compares polar to rectangular. https://blog.szczepan.org/blog/monte-carlo/
Short answer: yes it’s uniform in area. In the absence of the specificity you want, area makes the most sense, right? Uniformly sampling independent Cartesian variables yields uniform sampling in area, unlike polar where a uniform sampling of the independent variables gives you a non-uniform sampling of area.
I don’t understand what you mean about it not being an area problem, but I guess at some level this actually is an area problem. I’ll speculate wildly there might be a way to transform the question/setup into a different but equivalent problem that can be directly visualized as solving for area, and perhaps have a more intuitive solution that involves fewer determinants of Jacobians. Maybe, maybe not, I dunno.
I think the only solution is territorization if you want to preserve the human. If you don't care about that (or think that it's not possible anyway), then yes, accelerate.
Do you really think a company that typically builds base systems with small storage in order to upsell storage upgrades (both local and cloud) is concerned with the bloat of its OS install?
That article is seemingly all about the perf of the complex frontend app with a custom renderer running in the browser, nothing to do with what’s happening on the server.
