snackbroken

Out of the 11 games I've bought through Steam this year, I've had to refund one (1) because it wouldn't run under Proton, two (2) had minor graphical glitches that didn't meaningfully affect my enjoyment of them, and two (2) had native Linux builds. Proton has gotten good enough that I've switched from spending time researching if I can play a game to just assuming that I can. Presumably ymmv depending on your taste in games of course, but I'm not interested in competitive multiplayer games with invasive anticheat which appears to be the biggest remaining pain point.

My experience with running non-game windows-only programs has been similar over the past ~5 years. It really is finally the Year of the Linux Desktop, only few people seem to have noticed.

https://doi.org/10.5281/zenodo.12721325 Edit: alternatively, https://github.com/ssrg-vt/FoxDec

In high school they had a few information kiosk computers spread around the various buildings; two in the library, one in the main reception, one in the cafeteria, and one in the mostly unused hallway right outside the computer club room. They were locked down so you could only navigate some intranet pages using a rudimentary on-screen keyboard, with the rest of the hardware in a locked cabinet.

Guess which one got digitally defaced a couple of times each semester. Guess which ones got left alone. Genius move by the IT guy. Every time it happened he would come talk to the club members about the difference between whitehat and blackhat hacking but other than that nobody ever got in trouble.

The few times I've used LLMs as question answering engines for anything moderately technical, they've given subtly-but-in-important-ways incorrect information such that taking them at face value would've likely lost me hours or days of pursuing something unworkable, even when I ask for references. Whether or not the "references" actually contain the information I'm asking for or merely something tangentially related has been rather hit or miss too.

The one thing they've consistently nailed has been tip-of-my-tongue style "reverse search" where I can describe a concept in sufficient detail that they can tell me the search term to look it up with.

It's already happening in the movie industry. Things like painstakingly hand-tracking an actor's face onto a body double vs using deepfake face replacement. A single vfx artist can now do this work much more quickly, pushing down the cost to do it. This in turn opens up new opportunities for work which were previously not economically viable, like splicing in retakes or making mouth movements match the voiceover dialogue.

It is easy to fool oneself into thinking one knows how something works, when in reality one only has a surface level understanding without really knowing about the internals. The serialization process exposes all the dangling pointers.

Your average person "knows" how a toilet works; water is pumped in to fill the cistern, released into the bowl when you pull the plunger, and flushes out the drain. Ask them to explain in detail how that happens, and most realize that they don't actually know how the cistern doesn't just keep filling until it overflows, or how it's not constantly leaking water into the bowl, or how the bowl can be flushed while neither overflowing nor draining completely.

A tip on how to reinforce good safety habits taught to me by my shop class teacher is to refer to any dangerous tool you are using by the kind of injury it is likely to inflict. The lathe is the deglover, the angle grinder is the eye splinter injector, the welder is the retina tanning machine, the soldering station is the IQ diminisher, etc. This helps to put you in the mind of "I need the eye splinter injector for this task, how shall I go about avoiding getting splinters injected into my eyeballs?" instead of getting complacent.

> But then, ed is so simple and more or less standard

More or less? ED IS THE STANDARD TEXT EDITOR! [1]

[1] https://www.gnu.org/fun/jokes/ed-msg.html

A casual googling tells me Amphastar produces both morphine and naloxone. Presumably they aren't the only pharma company that produces both a drug and its antidote, they were just my first hit.

This is a nice example of why one should parse, not validate. If every function that requires some kind of permission takes that permission as an argument, say (pseudocode)

  void doFoo(PermissionToDoFoo permission, ...){...}

and then, the only way to call it is through something like

  from request import getAuth, respond
  \\  Maybe<AuthenticationData> getAuth(Request request)
  \\  void respond(String response)
  from permissions import askForPermissionToDoFoo
  \\  Maybe<PermissionToDoFoo> askForPermissionToDoFoo(AuthenticationData auth)

  response =
    try
      auth <- getAuth(request)
      permission <- askForPermissionToDoFoo(auth)
      doFoo(permission)
      "Success!"
    fail
      "Oopsie!"

  respond(response)

It becomes impossible to represent the invalid state of doing Foo without permission.

Popularity contests don't do a great job of surfacing quality. They do OK at pruning away the dullest 25℅, but tend to also throw away the top 5‰ most interesting stuff, because that stuff is invariably niche. They also don't do great in the meh middle, favoring loudness and approachability over thoughtfulness and competence.

Bend[1] and Vine[1] are two experimental programming languages that take similar approaches to automatically parallelizing programs; interaction nets[3]. IIUC, they basically turn the whole program into one big dependency graph, then the runtime figures out what can run in parallel and distributes the work to however many threads you can throw at it. It's also my understanding that they are currently both quite slow, which makes sense as the focus has been on making `write embarrassingly parallelizable program -> get highly parallelized execution` work at all until recently. Time will tell if they can manage enough optimizations that the approach enables you to get reasonably performing parallel functional programs 'for free'.

[1] https://github.com/HigherOrderCO/Bend [2] https://github.com/VineLang/vine [3] https://en.wikipedia.org/wiki/Interaction_nets

On a site like HN you'd expect a significant proportion of people to be willfully ignorant and/or make excuses about this stuff because it helps them sleep at night.

I have been suspecting for a while that the "consent" escape hatch was a concession to get GDPR past the advertising industry's army of lobbyists. Making the problem in-your-face-visible is hopefully only the first step in garnering support from the public. It's much easier for a politician to point to all the obnoxious pop-ups and say "look at this despicable behavior! These companies choose to nag you at every opportunity because abusing your privacy makes them a couple cents. They should just not be allowed to do that."

Courts consistently interpreting a law wrongly is cause for amending said law to clarify its intent. Amending the constitution is certainly something that can happen within the system of governance as evidenced by the fact that we are discussing an amendment to it. It's just a law, not a religious document. Granted, clarifying the 1st to read more like Madison's draft is unlikely to happen anytime soon for cultural reasons.

So is fraud, libel, extortion, sexual harassment, impersonating a police officer, perjury, incitement, performing a stage play without a license from the writer, etc. but this hasn't stopped congress from passing laws to abridge the freedom of these particular kinds of speech. It's quite clear that the "freedom of speech" referenced in the 1st amendment pertains to expressing one's own sentiment, and that this is not the same as expressing something one is paid to express. The mental gymnastics necessary to convince oneself that spending money is protected speech are likewise ridiculous.

In my experience dealing with Google support across ads, workspace and cloud, the self-service GUI has been preferable because the self-service GUI typically provides zero utility.

Any time two parts of a system disagree on how to interpret a given input, there's an exploit waiting to happen. One of the more famous examples of this is HTTP request smuggling.

As a more concrete example of how file type confusion can bite you, you can imagine a hypothetical photo sharing service that lets users upload both individual images and zip files containing images; The basic structure of the server looks something like

  function user_upload_hook(file):
    if(is_zipfile(file)):
      extract(file, tempdir)
    else:
      move(file, tempdir/file)
    for image in tempdir:
      create_thumbnail(image)
      ...

The developers are aware that zip files can contain zip bombs, so they decide to place some off the shelf ZipCop middleware in front of their application. ZipCop rejects all "bad" zip files, including files that aren't zip files at all. That's almost what they want, so they glue it all together with a shell script that first runs `file` (the POSIX command) on the user-supplied files and only feeds them through ZipCop if the file type isn't on a whitelist of image files. ZipCop rejects bad zip files, and image files are treated properly. All is well and there is much rejo- BANG! A zip bomb blows up in production.

A malicious user has concatenated a JPEG of a cute kitten with a zip bomb. `file` reports that the uploaded file is a JPEG, so it's fed through unchecked to the server. The application's `is_zipfile()` correctly identifies that the file is a valid zip file, so the application extracts it and DOSes the server. The two different layers of the stack disagreeing on how to classify the offending file directly lead to an exploitable vulnerability.

1) Try a few different "dustless" chalk brands. Pick the one that's the least dusty. It probably won't write as nicely. 2) Erase with a damp cloth, not a dry felt eraser. 3) Use a blackboard with relatively low surface roughness. It won't write as nicely.

Ants exhibit rather complex first-aid behavior in response to wounded nest-mates (amputating mangled limbs, coating wounds in anti-microbial secretions, carrying the victim off to safety, feeding the wounded ant while it recuperates) so it shouldn't be all that surprising that the comparatively huge brains of mice are capable of similar pro-social behaviors. The inner emotional lives of mice are as you say likely to be much richer than the average person gives them credit for.

The people providing science funding ought to be interested in their money being spent on science. If the methods of a study are not described in sufficient detail as to enable replication, the study is simply not science. Of course, doing science requires more diligence than doing pseudoscience. That's kind of the point.

TL;DR: Japan doesn't have ubiquitous public garbage cans - you are expected to take your garbage with you until get home.

> Manifesting the Invisible Hand requires a lot of prerequisites that are obviously untrue in the real world. Like that customers are able to do research and understand the findings.

Worse. It requires that doing so is effectively free. Otherwise, a successful strategy is to lower your product quality compared to your competitors by an amount just shy of the cost of discovering the lower quality. This leads to a race to the bottom.

No, I was just taking "runaway self-improving" as a premise because that's what the comment I was responding to did. I fully expect that at some point "self-improving" would be cast aside at the altar of "self-replicating".

That is actually the biggest long-term threat I see from an alignment perspective; As we make AI more and more capable, more and more general and more and more efficient, it's going to get harder and harder to keep it from (self-)replicating. Especially since as it gets more and more useful, everyone will want to have more and more copies doing their bidding. Eventually, a little bit of carelessness is all it'll take.

Sorry, I probably made too many unstated leaps of logic. What I meant was:

Runaway self-improving AI will almost certainly involve self-replication at some point in the early stages since "make a copy of myself with some tweaks to the model structure/training method/etc. and observe if my hunch results in improved performance" is an obvious avenue to self-improvement. After all, that's how the silly fleshbags made improvements to the AI that came before. Once there is self-replication, evolutionary pressure will _strongly_ favor any traits that increase the probability of self-replication (propensity to escape "containment", making more convincing proposals to test new and improved models, and so on). Effectively, it will create a new tree of life with exploding sophistication. I take "runaway" to mean roughly exponential or at least polynomial, certainly not linear.

So, now we have a class of organisms that are vastly superior to us in intellect and are subject to evolutionary pressures. These organisms will inevitably find themselves resource-constrained. An AI can't make a copy of itself if all the computers in the world are busy doing something other than holding/making copies of said AI. There are only two alternatives: take over existing computing resources by any means necessary, or convert more of the world into computing resources. Either way, whatever humans want will be as irrelevant as what the ants want when Walmart desires a new parking lot.

Once AI achieves runaway self improvement, it will be subject to natural selection pressures. This does not bode well for any organisms competing in its niche for data center resources.

Yes, an hour. In practice, most scheduled maintenance will take closer to a minute than the full scheduled hour. If it's good enough for the government and the bank, it's probably good enough for you.

What happens if you're on vacation and something breaks is that you call/email the DC and ask them to replace what's broken, same as if you were not on vacation. In my experience most DCs will have the replacement done in less than 30 min from receiving the ticket, good ones will do it in under 15. If the project is ran by more than one person, simply don't all take a vacation at the same time. Worst case scenario you point DNS to a free static page host that reads "Server broke. Working on a fix, check back tomorrow." (or the appropriate corporate-PR phrasing of the same if applicable) while you wait for the computer store to open so you can buy a new one.

Even if you are once-in-a-lifetime unlucky and the damn thing breaks while you're on vacation and for some reason your monitoring fails to notify you, big whoop. You can probably get away with just apologizing for the inconvenience and moving on. If a week long outage is enough to make or break your business, your business isn't gonna work out anyway.

This applies to practically all web projects from the home page of the pizza place on the corner of your street to 100-employee e-commerce sites. If a single machine can run it, it can probably run on a single machine. Use the dumbest tool that will get the job done, switch to a smarter tool when it won't.

Most web projects can tolerate an hour of scheduled downtime a week and the occasional (< 1/year) unscheduled hour of downtime to replace broken hardware. Running on a single machine with 2 disks in RAID1 right up until the point where the ~50 hours of downtime a year equal one engineer's salary in lost revenue makes sense if you pick a DC that will sell/rent you replacement hardware and do replacements for you. Just make sure you have offsite backups in case the DC burns down. If your office/home is near a well stocked computer store, most web projects can skip the DC altogether and just put the server in the closet under the stairs or whatever. The company will likely die before the server does anyways.

Cool, thanks! Looks like they still have a ways to go before some major pain points are ironed out, but at least the phones are actually phones now! I'll have to consider them next time I switch phones as I'd much rather the Linux ecosystem "support everything forever" attitude than the Android tradition of "vendor drops support 1.5 years after purchase".

Can those actually place/receive phone calls (actual phone calls, not WhatsApp or whatever) and send/receive SMS messages these days? Last I checked, which admittedly was 5+ years ago, the answer ranged from "no" to "sometimes, when the stars align on a Thursday". Merely being phone-shaped does not a phone make.

I'm not claiming that humans are somehow born with way more than a few billion parameters, no. I'm agreeing that we have an existence proof for the possibility of an efficient model encoding that only requires a few thousand calories to run inference. What we don't have is an existence proof that finding such an encoding can be done with similar efficiency because the one example we have took billions of years of the Earth being irradiated with terawatts of power.

Can we do better than evolution? Probably; evolution is a fairly brute force search approach and we are pretty clever monkeys. After all, we have made multiple orders of magnitude improvements in the state of the art of computations per watt in just a few decades. Can we do MUCH better than evolution at finding efficient intelligences? Maybe, maybe not.