I don't like to be seen as defending Microsoft, they definitely have their share of faults, but as far as business goes, I think Microsoft is the least likely company to screw you over as a (business) customer. Microsoft has kept old software working pretty much unchanged for the last 20 years. I know, I still have software built on early Windows 95/NT4 that works fine on Windows 11...and with some registry tweaks Windows 11 will run on a computer from 2005 without too many issues (sure, 3rd party security software and js-heavy web pages will be slow but that is not directly MS fault). Windows 10 EOL in 2025 is only for consumer level stuff, you can get Windows 10 support for enterprise for another 2 years at least and some versions even up to 2029, so again, if you are a business, you are taken care of (if you are "cheaping" you way with Windows Home and Pro in business then you kind of get what you pay for, I am sure you as a business don't give away free products/services for years on end). And you can keep using your Windows 10 after EOL, not like they lock you out, they just don't support you...just like you don't repair stuff for free after warranty end. Compare that to any other tech company that churns through HW and SW much faster and much more severely where old HW and SW no longer works or cannot connect to the internet or use the latest browser so you cannot connect to the latest HTTPS servers. Even open source software breaks compatibilty with older versions much more oftern than Microsoft, but since that is "free" people just shrug it off.

We're building the business, i.e. setting the foundations we expect to stand on for decades to come. Enterprise license that might be possible to extend into the medium term isn't good enough for our long term commitments and the time to adapt to an alternative family of operating systems is now.

As for stability, if you learned GUI Ubuntu twenty years ago you'll be right at home in contemporary Debian systems, while someone hopping from XP or Server 2000 into 10 or 11 would be quite confused for quite some time. Xenial (2016), Bionic (2018) and Fossa (2020) will likely get twenty years of security updates each, into the beginning of the 2030s.

I think something similar holds for the SoftMaker office suite. If you learned TextMaker twenty years ago I believe you'll be less annoyed by their 2024 release than if you learned Office 2003 and get dropped into the 365 style applications. Personally I'd use something else entirely, likely doing a roundtrip through LaTeX or straight PostScript under the hood, but it will be interesting to evaluate some MICROS~1 Office alternatives in my organisation and see what, if anything, sticks.

Microsoft's primary business is software running on Microsoft platforms. In the past that was Windows, nowadays it's also Azure.

That famous "developers developers developers" video with Steve Ballmer was a prime example of that corporate ethos.

For most other giant companies in tech, either the primary business is selling a product (and killing competitors) or giving products away as loss leaders and making bank on advertisement

They always had that option but somehow it was cheaper to ship there and back than to manufacture in US. So either you get 2x the tariff increase in price or you manufacture locally for something that increases the price by more than 2x shipping. Oh no, indeed.

It’s not that it’s cheaper overseas, rather it’s often not available domestically at any price. People don’t realize just how absolutely gutted America’s commodity/heavy industrial production capacity really is and the whole system makes it nearly impossible to rebuild.

>Can we all stop pretending that they don't abuse of their power and hold your deepest darkest secrets indefinitely? Even though most of us are law abiding citizens. I don't anyone know who thinks powerful don't abuse their power. It is the nature of the beast. And it seems none of us are law abiding citizens: https://www.saponelaw.com/blog/2019/10/professor-says-that-e...

>Can we please start making open hardware without Apple/google backdoors and stop pretending our systems are "secure". Few try...and either fail or languish in obscurity. You comment in itself is the proof that open hw cannot compete since you don't know of these open hw platforms and don't use them even tough you seem to advocate their creation here.

>Can we please write all software in Rust... Rust only eliminates memory safety issues of C/C++. There are large number of languages, some decades older than Rust, that provide various aspects of Rust memory safety without imposing the same limits...and some are being used but people always flock to either new and flashy or the most widely used. Besides, Rust still provides ample foot guns and pushes reliance on 3rd party libraries which replaces memory safety issues with supply chain issues. Not to mention the the very poor ergonomics of the language that purposefully shies away from a lot of syntax sugar that makes writing and reading (understanding) code easier.

>Can we please use distributed systems to avoid censorship or holding our private information in the hands of the rich? Even if you managed to persuade a lot of people to use these, some nodes will become popular/trusted and be targeted for censorship and propaganda and that will achieve the same result as the current model. Again, it is the nature of the beast.

What can be done? I don't know, probably nothing...things have to get to the point where most people are compelled to act because the alternative is death or worse, until such time there will just not be enough support for action to matter. Just how people are.

> Rust only eliminates memory safety issues of C/C++

According to Microsoft, about 70% of all security bugs in their products are memory safety issues.

These could be all be eliminated with a language that doesn't allow it in the first place.

https://www.zdnet.com/article/microsoft-70-percent-of-all-se...

What is currently advertised as AI (LLMs) cannot replace all software developers. It is a tool that can make software developers more productive so there will be less need for low level positions but there will still be a substantial need for senior developers. LLMs, if tuned for software development, present an opportunity for a company, that can plan beyond the next couple of quarters, to produce software of unprecedented quality and with as yet unseen features and usability. Of course, there will be companies which will use LLMs incorrectly and replace most developers (and other people) and create products that are even worse than what is currently available since they don't understand what LLMs are or how to utilise them correctly. Those companies will either realize and fix their mistakes or go bankrupt.

> LLMs, if tuned for software development, present an opportunity … to produce software of unprecedented quality and with as yet unseen features and usability.

Given that I can barely get LLMs to produce an error free couple of functions I doubt that. Though I suspect it’ll boost the median quality of software.

IMHO software quality requires care and skill along with a management that values quality.

Take Meta, they had billions of dollars and spent it freely. Yet the Metaverse software is mediocre at best. They had John Carmack in their rosters and the Mets developers reportedly ignored him. Giving those developers the ability to make more code won’t make the results magically good.

Otherwise you make good points. Companies like Intuit using AI as a justification to lay off lots of devs will face issues later when it comes about that it doesn’t scale.

Hang on. Off by one issues are the argument frequently given in favour of zero-based indices, not the other way around. For example, let's iterate through items placing them in 3 different groups;

JS:

    for (let i = 0; i < items.length; i++) {
        groups[i % 3].push(items[i]);
    }

Lua:

    for i = 1, #items do
        table.insert(groups[((i - 1) % 3) + 1], items[i])
    end

Don't get me wrong. I like Lua, I've made my own IDE for it, https://plugins.jetbrains.com/plugin/14698-luanalysis, but this is definitely not an argument in favour of 1-based indices.

Off by one issues are also an argument given in favour of no indexing.

    groups=new Array(3).fill([])
    items.reduce(function(a,x,y){y=a.shift();y.push(x);a.push(y);return a},groups)

Array languages typically have a reshaping operator so that you can just do something like:

    groups:3 0N#items

Does that seem so strange? 0N is just null. numpy has ...reshape([3,-1]) which wouldn't be so bad in a hypothetical numjs or numlu; I think null is better, so surely this would be nice:

    groups = table.reshape(items,{3,nil})   -- numlu?
    groups = items.reshape([3,null])        // numjs?

Such a function could hide an ugly iteration if it were performant to do so. No reason for the programmer to see it every day. Working at rank is better.

On the other hand, Erlang is also 1-based, and there's no numerl I know of, so I might write:

    f(N,Items) -> f_(erlang:make_tuple(N,[]),Items,0,N).
    f_(Groups,[],_,_N) -> Groups;
    f_(G,Items,0,N) -> f_(G,Items,N,N);
    f_(G,[X|XS],I,N) -> f_(setelement(I,G,X),XS,I-1,N).

I don't think that's too bad either, and it seems straightforward to translate to lua. Working backwards maybe makes the 1-based indexing a little more natural.

    n = 0
    for i = 1,#items do
      if n < 1 then n = #groups end
      table.insert(groups[n],items[i])
      n = n - 1
    end

Does that seem right? I don't program in lua very much these days, but the ugly thing to me is the for-loop and how much typing it is (a complaint I also have about Erlang), not the one-based nature of the index I have in exactly one place in the program.

The cool thing about one-based indexes is that 0 meaningfully represents the position before the first element or not-an-element. If you use zero-based indexes, you're forced to either use -1 which precludes its use for referring to the end of the list, or null which isn't great for complicated reasons. There are other mathematical reasons for preferring 1-based indexes, but I don't think they're as cool as that.

Yes, that is what is so frustrating about this argument every single time it comes up, because both sides in the debate can be equally false, or equally true, and its really only a convention and awareness issue, not a language fault.

It’s such a binary, polarizing issue too, because .. here we are again as always, discussing reasons to love/hate Lua for its [0-,non-0] based capabilities/braindeadednesses..

In any case, I for one will be kicking some Luon tires soon, as this looks to be a delightful way to write code .. and if I can get something like TurboLua going on in TurboLuon, I’ll also be quite chuffed ..

You need the first three elements to go into the first group, the next three to go into the second group, and so on. How would you write it?

That’s not what that loop does, it puts one item into each next group and loops back over the groups after every three items. Really it ought to be a by-three stepped loop over items, inserting each into each group inline:

groups[1], groups[2], groups[3] = items[i], items[i+1], items[i+2]

If the group count is dynamic, you can just loop over groups instead, and then step through items by #groups, inserting.

If it is dynamic one of the loops will also suffer from an off-by-one issue. You can't add 1-based indices together like you can zero-based indices.

It's also worth noting your solution exhibits similar off-by-one behaviour. The left hand side constants (integer values) do not match the right. It's error prone.

  >You can't add 1-based indices together like you can zero-based indices.

I think you are right but I am unable to articulate why. But I think 0 based indexes are able to fruitfully capture "going nowhere" iteratively than 1 based indexes, which do require a decrement in that circumstance.

sorry, where is the off by one? the code offered is of course only a solution for the fixed-size groups

Fair enough, for some reason I thought it was i/3 and not i%3. Still, I think the point stands.

why not just iterate in steps of three over items for each next group? seems a bit contrived.

Because it's a simplified example to demonstrate the problem. If you do as you've described you need three separate assignments. What happens when the number of groups is dynamic? Nested loop? This is suddenly getting a lot more complicated.

Yes, that’s what I was saying:

for each group:

for i in steps of #groups:

assign item to this group

I think that’s a lot easier to comprehend than the modulus trick

For a lot of people the modulo approach isn't a "trick", it's just the intuitive way to split items into residue classes. And it's likely a little more cache-efficient.

well clearly your comment is meant to demonstrate that it’s a clumsy approach in a 1-indexed syntax, so perhaps a different technique would be more facile here… such as a counting method :)

Having done fairly extensive parsing work in Lua and Julia on the one hand (one-based), and Python, Javascript, and Zig on the other (zero-based), the zero-based semiopen standard makes intervals dramatically easier to calculate and work with. It's really the semiopen intervals which make this the case, but as the Word of Dijkstra makes clear, zero-basis comes along for the ride, to combine semiopen intervals with a one-basis is perverse.

Naturally it's true that for collections and naïve indexing, 1-based is more natural. But those are rare places for bugs to occur, while interval calculations are a frequent place for them to occur.

Clearly I'm far from allergic to the other standard, but I come down on the side of the zero basis for that reason.

I have a really hard time understanding why people like 1-based indexes! 0 is the smallest unsigned integer in every programming language I know of that supports the concept of unsigned integer. Why shouldn’t an array at the smallest possible index correspond to the beginning of the array?

It’s also very natural to think of arr[i] as “i steps past the beginning of arr”. With one-based indexing arr[i] has no natural interpretation that I know of. It’s “i-1 (for some reason) steps past the beginning of arr”. The only reason I can think of to prefer that extra -1 in your formula is just because human languages (at least the ones I know of) work this way — the 42nd element of a sequence, in normal colloquial English, means the one 41 steps past the beginning. But I’m not sure if there is any logical justification for that.

I also, despite being American, find the convention used in many countries of numbering building floors starting with zero to be more logical. I’m on the third floor, how many stories up did I travel to get here? Three.

> Why shouldn’t an array at the smallest possible index correspond to the beginning of the array?

Because then there is no good way to refer to the index before that point: You are stuck using -1 (which means you can't use it to refer to the end of the array), or null (which isn't great either).

> every programming language I know of that supports the concept of unsigned integer

Surely you know Python which uses a signed integer as an index into their arrays: list[-1] is the last element of a list. If they only used one-based indexing then list[1] would be the first and that would be nicely symmetrical. It would also mean that list[i-1] would NEVER refer to a value after ‹i› eliminating a whole class of bugs.

> It’s also very natural to think of arr[i] as “i steps past the beginning of arr.”

I think it's more natural to think of arr[i] as “the ‹i›th element of arr” because it doesn't require explaining what a step is or what the beginning is.

The exact value of ‹i› matters very little until you try to manipulate it: Starting array indexes at one and using signed indexes instead of unsigned means less manipulation overall.

> find the convention used in many countries of numbering building floors starting with zero to be more logical

In Europe, we typically mark the ground-floor as floor-zero, but there are often floors below it just as there are often floors above it, so the floors might be numbered "from" -2 for example in a building with two below-ground floors. None of this has anything to do with arrays, it's just using things like "LG" or "B" for "lower ground" or "basement" don't translate very well to the many different languages used in Europe.

The software in the elevator absolutely doesn't "start" its array of sense-switches in the middle (at zero).

> In Europe, we typically mark the ground-floor as floor-zero,

_Western_ Europe. Eastern Europe prefers 1-based numbering. The reason, typically assumed, is that thermal isolation, required due to colder winters, causes at least one stair segment between entrance and the sequentially first floor.

Python might have used array[~0] instead, where ~ is required, to indicate end-of-list 0-based indexing.

But I guess they wanted to iterate from the end back [-1] to the start [0], making it easy to implement a rotating buffer.

> Python might have used array[~0] instead

This is what was once added to C#: arr[^idx], when this ^idx is mapped to a special object, typically optimized then out. arr[^0] means the last element.

[^n] indexing is mapped to an 'Index' struct by Roslyn which can then be applied to any array or list-shaped type (it either has to expose Index-accepting indexer, or a plain integer-based indexer and Count or Length property. There really isn't much to optimize away besides the bounds check since there are no object allocations involved.

A similar approach also works for slicing the types with range operator e.g. span[start..end].

> I think it's more natural to think of arr[i] as “the ‹i›th element of arr” because it doesn't require explaining what a step is or what the beginning is.

Yes, but if you will eventually need to do steps on your array, you better opt for the framework that handles them better. I agree, that if your only task is to name them, then 1 based indexing makes more sense: you do that since diapers, and you do that with less errors.

In India too, the floor at the ground level is called the ground floor (probably that is where the name came from), the one above it is called the first floor, and so on. The convention is probably from British colonial times.

Also LED floor numbers in lifts (elevators) in India start from 0 for the ground floor, as do the buttons that you press to go to specific floors.

Also, Ground Zero.

https://en.m.wikipedia.org/wiki/World_Trade_Center_site

https://en.m.wikipedia.org/wiki/Hypocenter#

> I also, despite being American, find the convention used in many countries of numbering building floors starting with zero to be more logical. I’m on the third floor, how many stories up did I travel to get here? Three.

Alternatively the ground floor is the first floor because it’s the first floor you arrived at when you entered the building.

The same point of view applies to 1-based indexing.

That said I prefer 0-based in programming and 1-based in buildings.

I never understood why they didn't picture the building, with the buttons and the room/apartment numbers at each floor... That would make all conventions clear. Going negative would be obvious, and just indicate which floor the elevator is at with LED's of backlighting.

They never heard of making a UI, and just slapped buttons.

> They never heard of making a UI, and just slapped buttons.

I suspect that floor numbering predates lifts (elevators) by centuries.

Stairs are ancient.

I mean, zero itself is a non-obvious concept. Its invention is a matter of historical record:

https://www.open.ac.uk/blogs/MathEd/index.php/2022/08/25/the...

... and we still use counting systems which predate the invention of zero, such as Roman numerals.

> find the convention used in many countries of numbering building floors starting with zero to be more logical.

Ukrainian here. Multi-floor buildings always have at least one stair section to first floor due to need of thermal basement isolation. (I guess this is not pertaining to Western Europe due to more clement winters.) And, yep, it is called "first" floor. Using zero number is rare but possible (in this case it is called "tsokolny" floor) if a real "basement floor" is present, but in this case still 1-based numbering is preferred.

I'd argue that 1-based indexing is the "natural interpretation". Mathematics is inherently 1-based, and it isn't surprising that languages designed to do mathematics like R, Matlab, Mathematica, Julia all do 1-based arrays because that makes modeling paper mathematics in programs easier.

Sequences in math start with 1 by convention, not for any fundamental logical reason. It’s a reach to say that math is “inherently 1-based”.

I don't think it is.

Mathematics as a discipline predates the invention of the digit zero. The concept sure, but the notation and building positional representations around it is around 2000 years old.

https://en.wikipedia.org/wiki/0#History

> [0-based indexes] are a relic of C style arrays

I don't think this is true. They exist in other disciplines (maths for instance) that have no relationship with C or other programming languages from the 1970s.

> for 0 to count/len/num - 1

I will counter saying that such a for...to syntax is a relic of BASIC.

> or even better range syntax that is start inclusive BUT end exclusive

I know that your "better" is sarcastic, but I actually find left-inclusive+right-exclusive ranges fantastic. They allow perfect partitioning, easy calculation of lenght, etc.

> Arrays should start and end at whatever start index is required

I agree. An accommodating language would let you define both lower and upper bounds of an array, instead of its size.

IIRC some BASIC(s) I've used in the past had a statement called:

OPTION BASE 1

or something like that, to change the starting index to 1.

APL has ⎕IO←0 or ⎕IO←1 to change the starting index (only between 0 or 1, not arbitrarily). It doesn't apply system-wide so different code blocks/files/modules(?) can set or reset it, and portable code has to either set it or adjust for it.

APLCast podcast has an episode mentioning it where they all seem to agree that this is the worst of all worlds, makes sharing code and integrating codebases needlessly bug-prone, and the language picking a single indexing and sticking to it would have been better, even if the choice hadn't gone the way they would have personally chosen.

Interesting. Never used APL, though I tried J a little a few times.

Yes, that seems bug prone, somewhat like having to have a config file per module.

There are 360 degrees in a circle, and the first entry is 0 degrees. The first time element of a day is 0:00:00(and enough 0s to satisfy whatever resolution you require). These were not established in the 1970s, and somehow pretty much everyone understands and works quite well with these systems.

> There are 360 degrees in a circle, and the first entry is 0 degrees.

To be pedantic, "first" is associated with 1. And a circle does not have a "first" entry, whatever you mean by entry. I think what you're trying to say is that a circle is a continuous arc going from 0 to 360 degrees, but you should recognize that the "starting point" is arbitrary, any point will do, so there isn't really a "first", and that this is not the same as counting because counting is done with natural numbers, which are non-continuous. The problem of 0 VS 1 makes sense only in counting exactly because it's subjective whether you prefer to count from 0 or from 1. Because zero is the absence of anything, I find it hard to start counting from 0 (when you do, your "first" item is actually your zeroth item, and the next item would be the "first"??!), to be honest, despite being completely familiar with doing so since I've used 0-index programming languages my whole life.

If you cut up a circle into n slices (maybe you're drawing a diagram on screen), it's vastly more helpful to think of one of the segments as segment 0 because then the start angle of every segment is index*360/n and the two segments whose border is at your initial angle are the first and last. If you start counting segments at 1, your “first” segment would be some way into the circle, and the two segments whose border is at your initial angle would be the last and the second-last.

Don't you see that what you're talking about is a range, not counting?? A range indeed starts at a zero point because if you don't have another point, you just have an empty range: and that's the equivalent of a zero range. When you have two points in a range, then the "first" point ends up being zero, that's correct, because it's being treated as the beginning of it. An "origin" is always associated with zero. It's perhaps incorrect to use the word "first" in this case exactly because it "breaks" how ordinals actually work (i.e. 1=first, 2=second, etc.). A better word is the "initial" point of a range, and the "other" point is the "final" point. Each segment you consider will be a pair [initial, final]. Here's where your mistake comes in: you assume that you can just take each segment and assign it a single number, but instead of using the ordinal numbers which start from 1, you decided to, arbitrarily, take the initial point of the range as your number instead, which is where the zero comes from. Notice that the zero you chose comes from the pair [initial, final], but the zero only makes sense when it's in a pair (alone, zero means the absence of something, i.e. there's no range... I thought that concept was well understood at least by fellow programmers, but apparently not).

I really don't see how your comment helps reduce complexity. It seems to me that you're introducing a new concept, “ranges”, just to maintain traditional 1-based ordinals, instead of realizing that when you count from 0, counting and ranges simply become the same thing and you don't need such a distinction.

No, "first" infers a sequence and is associated with the beginning of that sequence. In the case of a relative heading, the existing heading is 0 degrees. Any change is relative to that origin point. Zero is also not the absence of anything, that would more properly be considered a NULL or NaN.

You're wrong.

Also, how many years old are you when you're born? Zero. (at least in mainstream Western culture).

Some countries consider the 1st floor to be the ground floor, others consider the 1st floor to be the floor above the ground floor, which the formerly mentioned countries consider the 2nd floor… I think 0/1-based indexing is more subjective than simply being a “relic of C” or a “horrible kludge” :P

I've been in the US for over a decade and it still occasionally makes me double-take when a room numbered 1xx is on the ground floor

Here’s the ultimate authority on why computer languages should count from zero:

<https://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF>

I find that argument to be written in a terse "mathy" style that makes it a bit hard to follow. So let me try to restate it in more concrete "programmy" terms.

To iterate over an array with "len" elements, it’s most elegant if “len” appears as a loop bound, rather than "len+1" or "len-1". Thus, in 0-based languages we use half-open ranges, whereas in 1-based languages we use closed ranges:

  // real C
  for (int i = 0; i < len; ++i)
      process(array[i]);


  // C-like language with 1-based indexing
  for (int i = 1; i <= len; ++i)
      process(array[i]);

But the second is inelegant when len is zero, because 0 isn’t a valid index at all, so it’s weird for it to appear as a bound.

Dijkstra, being one of a handful of luminaries in the field of computer science – indeed, he can be said to have created the field itself – can be (provisionally) taken at his word when he claims something. You, on the other hand, being an anonymous user on a discussion forum, will have to present some pretty strong arguments for the rest of us to take you seriously. Your mere disagreement counts for approximately nothing.

>They are a relic of C style arrays

Doesn't it predate that by a good amount? I would think it is a relic of the EEs who built the digital world, those early languages show a great deal more relation to the bare metal than modern languages. Creating an array whose index starts at 1 just doesn't make sense from the discrete logic point of view, you are either wasting an element or adding in an extra step.

But in this day and age how can a language not have ⎕IO ← 0?

I honestly think that most of the problem arises from the fact that we just culturally start counting at 1 when talking about everyday things. As it stands, we're all used to it that way, and then computers come along and show us that counting from 0 is often more useful. So we adjust, but only for computer programming purposes.

If our species had established counting from 0 as the norm right away (element #n is the one that has n elements before it; you think of the number as the number of steps you have to move away from the starting point), then I suspect the reverse would not be true: I don't think anyone would find a situation in which counting from 1 is so much more convenient that it's worth going against the grain of established norm.

So in summary, I think we only think of counting from 1 as natural because it's in our culture. And it's in our culture because ancient superstitious humans had an irrational problem with the number 0.

I absolutely agree with you. People want to start with 1 because English (and presumably a lot of other languages) happen to use the word "first" to refer to the first element of a sequence, and not for any logical reason independent of arbitrary human language.

Slam! Now this guy really knows how to hate on a zero based index!

It's funny that nearly half of all comments are below your comment. The topic seems to unsettle people much more than a new programming language. This is also another example of how a downvote button is primarily misused in practice.

> Arrays should start and end at whatever start index is required

That's what you were indeed able to do with Pascal and also Modula-2, but with Oberon, Wirth came to the conclusion, that other index ranges than 0..n-1 were not needed. In his 1988 paper "From Modula to Oberon" he considers it "inessential" and providing "hardly any additional expressive power", but causing "a hidden computational effort that is incommensurate with the supposed gain in convenience". I think, in the end, it is in the eye of the beholder.

Dijkstra said that 0 was better for reasons.

Like everything in life, it depends... For example: Storage has 5 items that need to be processed. 5 items need to be split equaly between available processes. There are currently 0 available processes so 5 / 0 = 0 items to be processed is more correct than either 5 or Nan or infinity.

Your example is quite vague (e.g. are we dealing with an integer number of items and processes?) and in general if something looks kinda like a division it doesn't mean it is exactly division. Just like in math, we have the power to simply say: if COND -> divide normally, else -> do something else.

"Fixable" in computer hardware has for many years meant that the computer can be disassembled without having to melt glue and that memory, network card, and disk can be replaced without having to replace the motherboard. GPU and CPU are a bit special. In desktop system I would argue that GPU and CPU must be replaceable separately from the motherboard. In space constrained systems like laptops I can see the need to solder those two to the motherboard so when while not ideal it is tolerable. But disk and memory must be replaceable on their own or the computer is simply not repairable. Replacing a screen, hinges and alike should be possible but I can see that parts may not be as readily available. I have replaced a screen on my HP Zbook and it was just a matter of popping off the bezel, removing 4 screws and unplugging the connector, then doing the same in reverse with the new screen - 15 min job. That is repairable.

Why should all other companies and developers spend money to help $2T company make even more money when it was that company that broken all the existing software? Apple users will through their money at Apple every opportnity they get but won't spending any money on new version of 3rd party software that Apple has broken with their changes. I would abandon Apple if had any software released on their platform.

LLM can only provide statistically most likely diagnosis based on the training data. If used by the experienced doctor LLM can be a valuable tool that saves time and maybe even increases accuracy in majority of cases. The problem is that LLMs will be used to replace experienced doctors and will be used as 100% accurate tools. This will result in experienced doctors becoming first rare and then non-existent and outcomes for patients will become increasingly unfavorable due to LLMs always producing a confident result even when it would be obviously wrong to an experienced doctor or even just a student.

Advertising isn't typically more valuable than the product being advertised (though that depends entirely on the consumer), but what is the product being used by Twitter?

Twitter is using a headline and maybe an image, provided by the news organizations specifically to act as an advertisement to get people to click on it and a link.

In this case, the value being provided to the news organizations is almost certainly higher than the value provided to Twitter. Meta certainly seems to have thought so.

Certainly news organizations should be paid by those who find their products valuable, but demanding payment for small quotes, something supposedly protected by international treaties as fair use, seems rather hypocritical for news organizations who are in the business of quoting others.