Blikkentrekker

I don't think it has much to do with rational selfism that Jon McCann did not even know what Xfce was. This isn't some kind of rational decision but is simply symptomatic of much these people live in a complete bubble which by the way I feel doesn't apply to Microsoft devs working on Linux that are simply hired guns to work on whatever their boss tells them to.

It mostly affects the people who started out as volunteers, contributed to a project they cared about and then got hired by it. They were originally people who spent enough time online to actually donate their time to that and it shows. Pretty much everything that started as a hobby project rather than a business feels like it's completely staffed by people who lost touch with the world and what people outside of their specific little online bubble do and think and how people use their computers.

> It is the fundamental difference in the developer's origin/experience in FOSS projects vs commercial software. However, there is an even bigger paradigm difference underneath. Academia survives on one-off projects and FOSS is often recruits students in universities who contribute as hobby, without contracts. The usual POSIX software is all about exposing things with minimal abstractions. It makes developing and iterating on software easier on the developer.

I think it's just the fundamental mentality of the kind of people it recruits and it wasn't always the case either. It felt like the old Unix guard of people who worked at Bell Labs were far better adjusted. If anything, this feels more like a social thing because you just encounter these kinds of people a lot outside of programming on say Reddit or 4chan, as in people who just completely seem to miss what goes on outside of their little bubble and I do feel certain types of FOSS have a higher chance of recruiting those people because they were the people who used to first submit patches for free on github and then rose the ranks. This does not in any way occur with say people being paid by Intel to write drivers for Linux. They seem to know perfectly well what goes on with the world because they weren't recruited through those channels that are just more likely to attract, shall we call it “terminally online” people as the kids call it nowadays?

> To illustrate the difference I'll actually compare Win32 vs X11/Wayland. Win32 is a much better abstraction and much better "narrow waist" point than X11 was. X11 was designed tightly around 80's hardware and people had to add hacks on top of hacks to actually make things like GPUs work. X11's network transparent architecture actually made implementing direct rendering harder. While Win32 already had some ideas that made into Wayland and it designed nice abstractions for allocating windows, direct rendering buffers and compositing. Win32 had baked in concepts like a window or a button or text rendering. So when the devices with HighDPI appeared or when new security boundaries needed the higher level abstractions of Win32 made it possible for Microsoft to make smaller API changes while the whole X11 started to collapse with 90s hardware and then was useless for 2010s.

Even ignoring the future though. It's just the understanding of the “now”. Things like initially libinput having no way to disable mouse acceleration and the developer at first resisting it until receiving a mountain of complaints and finally relenting because “Everyone would want mouse acceleration always on, right?”. Or just in general how these people seem to completely forget that desktop usage is largely just an afterthought for Linux and the main usages are phones, servers, small devices and supercomputers. To them Linux is really just a desktop kernel and they completely don't seem to realize that desktop usage of it is really super inconsequential in the larger scheme of things.

> Well, FOSS is free (also "like beer", i.e. unpaid), so I don't find it surprising that it doesn't follow commercial mindset priorities. People working for free are driven by other motives. While needs of commercial users would be considered and accommodated in many cases, they are not the only priority, as they would be for a commercial enterprise like Microsoft.

“I have no idea what Xfce is or does, sorry.” and Python developers actually thinking that everyone would switch in five years isn't about motivations; it's just about a fundamental lack of understanding of what goes on outside of one's own little world of people who program for fun and love tinkering. This isn't priority but simple ignorance.

> Nobody is going to tell you that Python 2->3 wasn't excruciatingly painful but it's hard to argue with the result. Sometimes you have to rip the bandaid off. Python 3 is by far the better language.

It's not “by far”, the weird part is that they broke backwards compatibility but also didn't fix some of the other issues and many of the fixes didn't need backwards compatibility to be broken and most of all, the way Python works would allow code written in multiple versions to interact and they should absolutely have allowed that and allow Python3 code to call Python2 modules.

> You're right the "commercial" timeline of Python would have supported Python 2 forever because big paying clients demand it but I think that would have led to a worse outcome for the OSS community.

The cost of switching was ridiculous and it still is. “venv” needing to exist is symptomatic of the bizarre ecosystem and developers being expected to maintain like 6 different versions of the same library at times and when they don't as user you are screwed.

With Rust, multiple editions can just compile together. Crates written in one edition can be called from code written in another edition.

Also, the optimism just highlighted how out of touch they were, that they thought people would actually just rewrite everything in 5 years is bizarre and suggests a fundamental lack of understanding to me. Same thing with Wayland and GPLv3 to me. This is so common in the FOSS world. People come with a new version and just expect that everyone will quickly switch because they consider their new version better, not realizing that A) even if others think it's better, they still won't “just switch” because that costs time and money and B), very often they don't even think it's better which they never bothered to even investigate before they got started. They just assumed that everyone will agree because the “I have no idea what Xfce is or does, sorry.” people are completely out of touch with the world to be honest and it's pretty clear they're often living in some very specific online bubble and don't understand the concerns of companies, users, and just everyone outside of their own little bubble.

It says below that that in cases of things like `io::Error` it should be used as that though, as in “cases of ambiguities”. It specifically speaks of not using `regex::Regex` but just `Regex` which seems more reasonable to me.

This kind of neglect for backwards compatibility is honestly why quite a bit of free software is failing, and also why quite a bit is not that understands it.

Like the fiasco with Python3 and Wayland. It's so clear the developers just thought “Wow, people will just switch” not realizing how much people demand an absolute drop-in replacement and then maybe later you can think of slowly deprecating features to discourage new users from adopting them. Rust realizes this with editions. Yes, it's a big investment for them to continue to support it, but the alternative is that Python library maintainers now have to have this big investment themselves because they have to maintain like 6 different versions of the same library because Python doesn't understand the value of backwards compatibility. z/OS still supports 50s COBOL frameworks and for good reason. No one is going to rewrite that.

These developers when you talk about them really do not seem to understand that people aren't jumping to rewrite code or maintain different versions at the same time and very often even call them “lazy” for not doing it like they're not using their time for other things. Say you're a company, and you can pay a developer for his time:

1) Have him develop new features that make you more money.

2) Have him fix bugs that cost you money.

3) Have him rewrite existing code that will do nothing new, and will probably introduce new bugs again so you can later go to 2.

Which is more attractive?

If you don't make copyright contagious under derivative works then people can just change a few things to get around copyright.

Also, do you really want a world where big film studios can just adapt books of writers without compensating them?

To be honest, I think this is a very unbalanced take. Better illumination stops crime and traffic accidents and I'm not willing to pay with human lives to see the stars obviously. The effect on wildlife and plants is certainly to be considered but this article is from the U.S.A. and I live in a country with far better illumination than that place and I've seen stories multiple times from foreigners who moved here and noticed that immediately, they stopped being afraid at night because the country is so well-lit and crime numbers are low as a consequence.

Human lives are a big price to pay to see some stars.

Yes people have to service the use case of a single person. All sorts of models exist that are designed to be ran at home. Yes, you need a relatively beefy graphics card for it but if your machine can handle the latest video games at good graphics it can handle these local models. How well they compare against these things remains to be seen but apparently OpenAI released gpt-oss-20b which is comparable to o3-mini apparently in terms of reasoning power. There's also oss-120b which does require at least a company server to run but this should well be within the budget of a university.

That they do it is just concerning to me in that it says that home-ran models just aren't good enough. Surely researchers like this have the processing power to run them at home, they just don't have the processing power to train models of comparable level.

This is something I feared would happen and where open source would be left behind. Maybe they can do something with crowd-sourcing computational power from volunteirs. They were after all able to get Leela Chess Zero to be comparable to AlphaZero by training from volunteer processing power but it seems to me we live in a world now where the best models keep their stuff closed.

In imagine generation too. I'm not sure how well Stable Diffusion can compete in following instructions with all those advanced models that are kept secret.

Yes it will. But that doesn't mean that “making students read” doesn't arouse a very different impression. “Making students do homework.” does not imply “Making it free for them to do it.”.

Yeah, I got that from the abstract too. I just don't understand where the “making teenagers read newspapers” angle comes from.

I don't understand. The way I read the text one group was simply given a free subscription no? They weren't made to read anything?

It's really not clear whether Rust does it or not and it just sidesteps the issues by calling them “structs” and “enums” but fields can be private of course.

Scheme Structs are rather interesting, when you define a struct the language by default also exports getter and setter functions with a predictable name though you can override the default name to give them any name, privacy is simply created by choosing to not export these getter and setter functions from the module.

Privacy on the module level rather than on the class level is a far better pattern to be honest. As in other classes defined in the same module can still have access to them.

> After the dust has settled, it seems like the most valuable parts of OOP are private data, convenience (no need to repeat the class name in a method call), good fit for some domains, and interfaces.

Kay also considers CLOS and related things “true OO” and those do repeat class name in method call.

There is a general culture that one sometimes sees which treats anything related to Japan as highly remarkable. Ancient Japanese swords can literally cut through diamond like butter by being folded over 1 000 times after all.

The issue is that these functions in Lisps are variadic and can accept more arguments than one. `map`, and `zipwidth` in lisps are actually the same function.

I feel languages should just have some kind of sugar or operator for this, in fact in Ocaml the |> operator exists where

   <exp> |> <exp2>
   <exp2>(<exp>)

Are just one and the same

For a variadic language you'd need something more involved though. But some kind of syntax can probably be invented in some language.

That JSON prohibits trailing commata makes it an absolute pain to work with in practice.

I also like how in Haskell:

   something =
     { element
     , element1
     , element2
     , element3
     }

Is an actually idiomatic way to deal with the lack of trailing commata.

> It's tough to answer because you want to hedge for both an AI enthused employer and an AI hesitant employer

That this doesn't have a clear and obvious answer one can expect shows how the issue is politics, not strategy.

When you apply as a mechanic, there is no such weird political debates about certain power tools where people have passionate opinions on which tool to use.

I think even the biggest hard drugs should be legal, again just because “people enjoy it”.

I'm fine with taxing it more in subsidized single-payer healthcare systems though but I also feel that should be done more consistently. I for instance also believe that say high heels should be taxed more because they're bad for one's health for similar reasons or unhealthy food but that's not “socially controversial” enough for that I get which is ultimately what it's always about. “health” is always just an excuse.

The same can be said for anything that's dangerous. In fact, one can make this argument simply for people who elect to study some field that isn't really very financially viable.

The thing with “harmful to society” is that in practice it's so arbitrarily decided what is “harmful” and in practice it comes down more to “arbitrary moralist reactions”.

Many dangerous things are legal simply because “people enjoy doing them” though.

People die during parachuting and climbing mount everest. What's the upside really beyond “People enjoy doing it and it's their own life.”?

> Every function takes one argument - a list.

That's one way to look at it, but the major difference is that one can also pass a a list as one argument, as in `(f x y z)` and `(f (list x y z)` are not the same. The thing with tuples is that a tuple of one datum is the very same as that datum itself and the same is true with the currying situation. `(f x) y` and `f x y` are truly one and the same in Haskell and Ocaml, just as `f(x, y)` and `let val a = (x,y) in f x` are one and the same in SML. This is not the case in Rust where `f(x,y)`, a function called with two arguments, and `f((x,y))`, a function called with one argument that is a tuple of two arguments are two different things.

There is also a difference in Scheme between returning a single value that is a list containing multiple values, and actually returning multiple values, In Rust however there is no difference between returning two values and returning a pair of two values. So Rust functions actually do properly take multiple arguments but always return a single one which may or may not be a tuple. In SML, Haskell and OCaml all functions technically take only one argument and return one value.

That person obviously did not want to be at risk for legal issues from Blizzard by publhsing it though. I personally wouldn't take that risk either.

I always felt Monads were an utterly disgusting hack that was otherwise quite practical though. It didn't feel like mathematical beauty at all to me but like a hack to fool to the optimizer to not sequence out of events.

> Simplicity: Every function takes exactly one input and produces exactly one output. No exceptions. If you didn’t care about the input or output, you used Unit, and we made special syntax for that.

Seems like a disaster to use s-expressions for a language like that. I love s-expressions but they only make sense for variadic languages. The entire point of them is to quickly delimit how many arguments are passed.

In say Haskell `f x y z` is the same thing as `(((f x) y) z)`. That is definitely not the case with s-expressions; braces don't delimit; they denote function application. It's like saying that `f(x,y,z)` being the same as `f(x)(y)(z)` which it really isn't. The point of s-expressions is that you often find yourself calling functions with many arguments that are themselves a result of a function application, at that point `foo(a)(g(a,b), h(x,y))` just becomes easier to parse as ((foo a) (g a b) (h x y))`.

In SML I believe. I never used SML but from how I understand it in ML all functions technically take one argument, which may be a tuple. In Haskell and Ocaml, all functions technically take one argument and just return a function that takes one argument again.

I never understood why the latter was so popular. Just for automatic implitic partial application which honestly should just have explicit syntax. In Scheme one simply uses the `(cut f x y)` operator which does a partial application and returns a function that consumes the remaining arguments which is far more explicit. But since Scheme is dynamically typed implicit partial application would be a disaster but it's not like in OCaml and Haskell the error messages at times can't be confusing.

I don't get simulating it with tuples either to be honest. Nothing wrong with just letting functions take multiple arguments and that's it. In Rust they oddly take multiple arguments as expect, but they can return tuples to simulate returning multiple arguments whereas in Scheme they just return multiple arguments. There's a difference between returning one argument which is a tuple of multiple arguments, and actually returning multiple arguments.

I think automatic implicit partial application, like almost anything “implicit” is bad. But in Haskell or Ocaml or even Rust it has to be a syntactic macro, it can't just be a normal function because no easy variadic functions which to be fair is incredibly difficult without dynamic typing and in practice just passing some kind of sequence is what you really want.

Well, it's otherwise “free” to read the article so I guess this is how one “pays” in the end.

I wonder how this works on mobile data though which is significantlym more expensive than home network data.