Blikkentrekker

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.

The issue is that it's a special case that acknowledges where there are cases where the indentation level it logically requires isn't what programmers find pleasant, there are many more, that just don't have that special case, so it forces indentation that's unpleasant and unintuitive.

That's just because most languages go by braces and have optional intendation that is just ignored by the compiler.

I'd reckon that in a language where stuff is done by indentation but optional braces exist that are just ignored so many errors would also have been caused by braces being misplaced by the programmer to queue other programmers who thought some scope happened as a consequence but the compiler disagreed due to the indentation, which by the way was caused by tabs and spaces being mixed in the code and it not properly showing up for another programmer with tab with set differently.

Functional hardly matters Haskell has plenty of indentation which is by the way interchangeable with `{ ... }`, one can use both at one's own pleasure and it's needed for many things.

Also, famously `do { x ; y ; z }` is just syntactic sugar for `x >> y >> z` in Haskell where `>>` is a normal pure operator.

I like how Haskell does it. One can do both but not mix, as in either indent or use `{ ... }`.

The issue is that you find you very often want to break those roles. Python basically has `elif` because `else if` would make each branch nest one level deeper which isn't what one wants, except Python uses exceptions for flow control so you find yourself having to use `except ... try` as an analogue to `else if` but not `excetry` exists to do the same and stop the indentation.

There are many other examples. It exists to give people freedom. Also, while humans only go by intendation it's very hand for text editing and manipulation without requiring special per-language support to move the cursor say to the nearest closing brace and so forth.

> Indeed. And what many seem to fail to notice is that at it's core it's exactly the same mistake being made all over again. A mistake that I've seen so many times over and over again, increasingly commonly in recent years, which can be summed up thusly:

Yes, just as the idea of “We will start anew because the codebase is a mess and this time we'll make it clean.”. 10 years ago, whenever I saw something like that I would've said that person has zero actual experience working as a programmer. I've seen teams go through this multiple times but at the end, the new codebase when all the features are added is just as much of a mess as the old, at best a slight improvement. People who say this just underestimate the scope. But these people have experience. They're just optimistic and full of wishful thinking maybe?

> See, I don't think you're giving them enough credit. Or is it too much credit? These are not stupid people. I say they do understand this, they just don't care about your time enough to do anything about it.

I disagree. I've talked with many of those people both online and in real life who don't understand that for most people time has value. They really just don't get it. They're not stupid; they just don't really think about it that way and don't have much to do in their lives aside from this one specific hobby.

Yes, that, or the “Use case for <extremely useful and obvious thing>?” memes. Ebassi once got father angry at me after finding out that I did not run Polkit or a system dbus on my system and alledged that I must not know what they do because everyone would want that.