etbebl

It seems to me that for products that in general are cheap to buy as well as produce, companies would want to make these products somewhat longer-lasting to gain a better reputation and then make more sales and larger profits on more expensive items.

I think the fundamental problem here is that nobody trusts brands anymore because we have been trained by strategies like market segmentation and private equity cost cutting that the vast majority of brands don't consistently indicate quality. That product A could be fine and a very similar-looking product B could be horrible, and any company or even product could become shit at any moment. Breyers in the US is a great example - they sell real (though still watery) ice cream in the cartons that say "naturals," and all the other very similar looking cartons are full of crap artificial frozen dairy dessert. They had a very strong brand, and they decided it was time to cash out that brand goodwill by cheaping out, but deceptively so they could ride it out for a few decades, at which point who cares?

This has led to a situation where companies don't make any attempt anymore to gain a reputation for the quality of their products, because it's futile to convince the public that they can trust you. And also, they have to compete much more equally with alphabet soup brands on Amazon making the absolute cheapest version of products at the lowest margins (and labor costs). So why would anyone make a better lightbulb that no one will buy because it's $2 more expensive?

OK seems interesting. Maybe what I actually want is fully dependent array types. But it seems like you should be able to do something like this:

  x : [{| col = #12 |}]float (* given *)

  x_split : [{| col = [| Top = #5, Center = #, Bottom = #5 |] |}]float = split_dim(x, "col", [| #5, #, #5|]) (* maybe type checking fails if the col dimension is not long enough?? *)

  x_center = \Phi i[{| col : # |}].x_split[{ col = Center i }]

Basically what I mean is, I can see benefits of declaring a sub-structure to a linear dimension using concatenations, rather than being limited to reshaping the dimension which only works if you can factor the length into N equal segments. Because many algorithms have to split a linear dimension in various ways and do something semantically different with the parts, and it would be cool to have the type system reflect and check this behavior. However, I think for it to be useful, it must be possible to "reinterpret" a dimension as having a particular structure (in a checked way), because if you're pipelining some array x through A and B, it's unreasonable to expect the author of A in every case to consider that you might want to apply B next and ensure that its output type permits that. And there are a lot of cases I can imagine where casting e.g. #m to [| #5, #n, #5 |] would only reasonably be considered a mistake, given the declared behavior of the function doing the casting, if m < 10.

Edit: maybe I'm silly in assuming you can't just downcast to a more specific shape type if you want to - still a newbie to algebraic typing.

It says in the paper that a reference implementation is still under development.

I mean, sure, why not, and I'm not opposed to using array languages as a fun hobby (which seems to be the spirit of this). I just noticed that the selling points in the introduction to the manual were not very compelling to me as a Matlab/Numpy user, and since sometimes people bemoan that array languages aren't more widely used, I just wanted to say, hey we do have powerful "array languages" that imo are strictly better on things that matter for most real work, so it's not surprising.

I understand that these languages are older; I meant that in the sense that they are nonetheless still trying to recruit new users, but these potential users may already be using something that does something similar.

I wonder how much overlap there is between users of array languages and of scientific programming languages/dialects like MATLAB, Numpy, and Julia, which are also optimized to operate over arrays. In other words, do K/Klong/whatever proponents realize that there is already a huge community of people who appreciate and utilize powerful operations on arrays to do real work, but just prefer to write something like "max(diff(x))" instead of "|/--:'x"? It's almost the same number of characters and it doesn't require learning a new writing system.

Well not exactly, they are basically gaming machines that we bought and maintain independently of the IT department because we have specific computing needs. At least that is possible and fairly common I think.

Thanks for the link, I had forgotten this existed. Well, the university's technology roadmap officially states there is no support for Windows 10 after 2025. Yet as far as I know there is no program in place to help individual labs cover the cost of upgrading equipment. Maybe we will still be able to purchase an ESU package for our computers on an individual basis, but I'm not sure it will be made available by our software licensing office.

This is awesome. I'd be interested in helping if I could find some extra time.

At the same time, we still have a major problem at work if Microsoft goes through with this. I work in a research lab with 10s of 1000s of dollars worth of Windows 10 workstations that cannot be upgraded. We use Windows remote desktop and plenty of other software that is Windows only. The hardware is still pretty new and capable. With NIH cuts the last thing we need now is to have to spend money and lots of time to replace all that for no good reason.

The real wtf here is templates, right? Am I right in thinking that if Derived wasn't a template, its copy constructor that tries to use a deleted parent copy constructor would fail to compile?

Isn't writing an article like this just daring someone to make the system in question more cursed, more likely to produce errors, harder to reason about, etc.? In the same spirit as, "well technically this common assumption about C behavior is undefined, so let's add some nasal demons to save 2 us (and make me look clever)"?

Am I missing something or is this just evil? I guess I'm taking it too seriously.

Maybe people need persuading to learn Rust not just because they think it's hard, but also because they think it's bad? Not everything hard is worth doing. Difficulty is just one of the factors to consider.

I started to learn Rust, but I was put off by the heavy restrictions the language imposes and the attitude that this is the only safe way. There's a lack of acknowledgement, at least in beginner materials, that by choosing to write safe Rust you're sacrificing many perfectly good patterns that the compiler can't understand in exchange for safety. Eventually I decided to stop because I didn't like that tradeoff (and I didn't need it for my job or anything)

OK, but do we necessarily just care about the central 95% range of the output? This calculation has the weird property that values in the tails of the input correspond to values in the middle of the output, and vice versa. If you follow the intuition that the range you specify in the input corresponds to the values you expect to see, the corresponding outputs would really include -inf and inf.

Now I'm realizing that this doesn't actually work, and even in more typical calculations the input values that produce the central 95% of the output are not necessarily drawn from the 95% CIs of the inputs. Which is fine and makes sense, but this example makes it very obvious how arbitrary it is to just drop the lowermost and uppermost 2.5%s rather than choosing any other 95/5 partition of the probability mass.

This is more limited. I just tested and for one example, exponentiation seems not to be supported.

I think what you're missing is that the premise of a hardware bug is just a frame story for a lesson in manipulating logical statements, which is the main point.

Just one data point but my father is in his 70s and has never owned a smartphone, when he wants to Google something he goes to the computer in the basement. On the other hand there are landline extensions all over the house. So yeah it would be more convenient for people like him.

Doesn't the flat line in this context mean that you're at a local minimum, which is where you want to stay? Where being less careful would take more time due to increased number of incidents.

My point is, wouldn't most of these people be fine with coding in Python/Matlab/Fortan/whatever?

Not that it isn't a cool idea!

I may be missing the point, but I'm not sure there is really an audience for this...obviously nice math typography is important for publishing, but I doubt the set of people who are comfortable with advanced math but who see translating those operations into a traditional plain-text programming language as a barrier, but would be fine with a more math-like syntax, is very large.

What gets me is that even if you don't code much, if you're using a spreadsheet with formulas, in that moment you are writing code, and doing so in an awful, awful language. Sure, "SUM" is easy, but the moment you have any kind of conditional logic it gets pretty hairy. Maybe there's something about traditional spreadsheet languages that makes them easier than, say, numpy for non-coders, but I don't see it.

I guess I wasn't around to see it; do you mind saying why it's failed? Well, I don't know if it's commercially viable, but just speaking for myself I've been looking for something like this for a while.

Maybe I'm in a middle generation? I'm certainly comfortable with programs where you have to save to a file, but for as long as I can remember, always every program I've used that doesn't autosave warns if you try to close it without saving. Web apps mostly autosave these days, but those that don't will also usually trigger the browser's "you may lose changes, do you really want to navigate away?" warning.

In my (I guess biased) opinion, this is a reasonable affordance to expect; throwing up a confirmation dialog is a lot less burdensome than implementing autosave. I would consider not doing so in this day and age an antipattern.

Am I the only one who cringes at the name of this tool? The implication being that it's a way to churn out low-quality papers, probably with some p-hacking along the way.

> These aren't things that a computer has trouble with

They are irrelevant for executing the code, but they're probably pretty relevant for an LLM that is ingesting the code and text and inferring its function based on other examples it has seen. It's definitely more impressive that an LLM can succeed at this without the context of (correct) variable names than with them.

It's true, this type of nuance usually doesn't make it into papers for every paper they cite (otherwise, they would be 10x as long), but ime researchers take every study with a grain of salt in real life. I guess someone whose only interaction with science is through reading research papers would never know this and have the impression that many questions are much more settled than they actually are (although there are also opinion and review papers that attempt to assess the actual state of evidence at a given point in time).

It can be more efficient when combining both Alt-Tab and Alt-` - if you have several windows open in multiple different apps, it's easier to first Alt-Tab to the app you want and then Alt-` to the window you want rather than Alt-Tabbing through like 20 individual windows.

That being said, I don't really strongly prefer one system over the other; the main cost is in switching between them and using the wrong shortcut for a while (more a problem on the OS with 2 shortcuts, i.e. Linux). This would be helpful to avoid that, but so would configuring whatever Linux windows manager I'm using to only use Alt-Tab.

Can't you just install it in your environment in another terminal and then import?

A lot of people wear airpods around even if they're not actively using them, right? So if that's the case, you could use the microphone to eavesdrop on an in-person conversation. Although since it has to be within Bluetooth range, might be easier to just eavesdrop normally.

It seems like you're using "enclave" and "exclave" interchangeably, which is causing confusion. What you're referring to is an exclave; an enclave is when one region is completely surrounded by another, like Lesotho or Vatican City.

Interesting that the new string library mirrors the introduction of variable-length string arrays in Matlab in 2016 (https://www.mathworks.com/help/matlab/ref/string.html).