skysight-inc/HackerNews huggingface dataset:
Pretty ironic that you're actually listing more things why I would not use AWS at all. You mention: "stay away from", "ensure that you", "reasonable caching", "bandwidth is the only real nightmare" are all huge red flags.
I’m really going through it, trying to get legacy Theano and TensorFlow 1.x models from 2016 running on modern GPUs due to compatibility headaches due to OS, NVIDIA CUDA, CuDNN, drivers, docker, python, and package/image hubs all contributing their own roadblocks to actually coding. Ideally we would abandon this code, but we kind of need it running if we want to thoroughly understand our new model's performance on unseen old data, and/or understand Kappa scores between models.
Will the move towards freeing Keras from TF again potentially reintroduce version chaos, or will it future proof it from that? Do you see a potential for something like this to once again befall tomorrow's legacy code relying on TF 1.x and 2.x?
What I meant was, I thought I had a proposal that was both impossible, fringe, and at least somewhat novel. Seems it was neither.
And we're still awaiting any of their benefits.
Significantly faster compilation means less friction to iterate ideas, try things, which in the end lead to more polished results.

A nice interface is agreable, but maybe there are diminishing returns when you pay it with large compile time. I remember pondering about that when working with the Eigen math library, which is very nice but such a resource hog when you compile a project using it.
Technoreligious wars are emotional / black-and-white / stupid thinking / herd mentality, a priori. There is more than one way and one tool in the toolbox. You might not "like" every thing, but other things exist, function, and accomplish work.
More like the fact that Elon Musk literally bought himself a cabinet position and basically the president himself in almost the most blatant and transparently corrupt way possible.

> it's sad

Even more sad when people lack the concept of nuance and see the world as entirely black and white.
Although it seems async/await is based on multithreading, this is not the case. To learn about this, read this blog post: https://blog.stephencleary.com/2013/11/there-is-no-thread.ht...
Please let me know what you think.
Which classic games are better on Steam than they are on GoG?
And yet most people swarm around AWS and similar providers like there is no tomorrow despite this barrier for adoption. People ARE irrational...
Async is equivalent to the io monad. It is in itself a monad, I know, but I’m saying it’s just like the io monad. It pollutes everything it touches. It’s literally only effective when paired with IO. So it’s actually in many ways identical.

And that’s a good thing.

In attempting to avoid the pollution u end up implementing the imperative shell/functional core pattern.

Most programmers don’t know that pattern. But for those in the know, the pollution is a good thing.

If you programmed in Haskell you know what’s up. The way you avoid the io monad from polluting everything is part of what makes the program so modular. Async does the same thing. Literally.

await b(await a())

The above is roughly equivalent to this in haskell:

a >>= b

How do you avoid pollution? The answer to this question makes your program better.
Only in poorly designed code you have problems like this where Async Await goes viral. It can be avoided by spiting libraries into an IO part that uses Async/Await and a protocol part that is sans-io. Using async code to access data that is already in the application memory is inefficient and should be implemented synchronously with regular functions instead of asynchronously.
Here are more arguments against async/await: https://www.youtube.com/watch?v=449j7oKQVkc

Ron Pressler always was an advocate for blocking code and even joined oracle to add virtual threads to the JVM, thus invalidating the performance argument of the async/await/non-blocking crowd.

I really wish young developers would be taught about the actor model and communicating sequential processes before falling for the false promises of async/await-land.

And I wish JavaScript runtimes had a way of expressing continuations /blocking threads on their eventloop.
Tl;dr the author doesn't understand why having "async operation running in the background" is a useful primitive in a language.

Well, for one example, it means the syntax for kicking off dozens of IO requests and collecting all the results is trivial.

Also I'm tired of people saying "async is infectious!" as if it is something clever.

Having concurrency be part of the type system is a good thing!
Increased supply will cause prices to fall, meaning the rate of profit will not be too extreme, especially how much easier sending stuff to space is getting

I cant wait, too many rare earths are dominated by BRICS countries
https://www.prad.de/ is a very reputable resource for display reviews (and to some extend, tvs and beamers)
Yep, since Heroic started supporting savegame sync and achievments, GoG became a really good option for Linux gamers (and Steam Deck) again.
It's been reduced to q in lazyvim, at least at the intro screen.
Although it seems async/await is based on multiple threads, this is not the case. To learn about this, read this blog post: https://blog.stephencleary.com/2013/11/there-is-no-thread.ht...
Please let me know what you think.
A Simple Serialization System
Programmers who are not aware of the pitfalls will use the sync version and build apps that have terrible ux, so it’s better to not give them the option unless there’s a really good reason to, so what’s the use case here?
function sleep(ms) {
return new Promise((resolve) =>
setTimeout(() => resolve(), ms)
);
}
That's awesome to hear! I'm really excited to see the framework ecosystem grow.
A quick fix to the problem would be to allow synchronous functions to use await.
I had a similar issue but with a 3D mouse, which I rely on heavily for design work. Most remote desktop setups don’t support USB connections.
After some research, I found a tool that turned out to be exactly what I needed. You can find more details here https://www.net-usb.com/features/usb-to-cloud/
Both depend on whether you believe in the government actually. When we say "Chinese state media", we're really talking about a media controlled by the government, especially for those political topics
Very insightful to have a number from him here:

> LLMs are trained on much more than the whole Internet -- they also consume handcrafted answers produced by armies of highly qualified data annotators (often domain experts). Today approximately 20,000 people are employed full-time to produce training data for LLMs.
Yes, I am a US software developer with nearly 20 years. You are very clearly not talking to your employer and not thinking this through.
That's not true at all - the games are still downloadable from the website and every single one of them is a standalone app.

Which game are you talking about?
Correct. If you ever have the chance go to close to one of those enormous displays you would see at a convention center or hanging above a sports arena. They often have LEDs about the size you’d expect when you think of a typical LED.

But with those you’re far enough away that the apparent size of them is similar enough to the sub-pixels in your monitor, so your visual system combines them.
Automatic AA Battery Charger
I need one today!
AWS has good base building blocks (ALB, EC2, Fargate, RDS, IAM etc). But it takes knowledge to put the pieces together. Thus AWS tries to create services/tools that orchestrate the base blocks (Amplify, Beanstalk) for you, which in my experience always becomes a mess where you don't actually understand what you are running in your cloud setup.

I'd recommend either learning the basic building blocks (these skills also transfers well to other clouds and self hosting) or using a higher level service provider than AWS (Vercel etc) - they do it better than AWS.
You underestimate the "it looks bad on my numbers" effect. For example, if you have real state that you can't get rid of, for the company it doesn't matter if the people use it or not if it doesn't affect productivity. But it sure does matter for some accounting department close to the CEO.

It is like that old adage that goes along the lines "Tell me the incentives and I will tell you the outcomes"
Probably depends where you are.

Here in Western Australia there still seems to be a “Bush Doof” party scene. I’m way to old to know the details of that though.
I still don't know why that isn't just provided for you.
Or it should be called Caelus to be consistent with Roman names
Yeah that's why in nodejs I made functions as async unless I know really well that it won't need await. Though that seems bad, it's not the worst due to how good async/await actually is.

Unpopular opinion, it makes me want to have a setting where all function is async by default, and all function calls are await by default. With `nowait` and `sync` as the opposite
app -> terminal
It means in your country people trust companies more than in mine. We use pre-paid system and optionally you can connect a card account for automatic billing (but the company cannot charge a card if there is no money left).
But using `await` is fundamentally what makes a function async
I am not sure what 'ads' you are referring to, we don't have ads anywhere on our websites and demos.

Anyway, click on the "Apps" button on the top menu, then click on "Terminal". An xterm session will open for you.

You could be interested in the terminal-only version of WebVM, based on Debian: https://webvm.io
The accounting teams of many orgs would want this feature to be enabled, but the tech teams wouldn't. Asking AWS not to add this feature means the tech teams win the debate before it starts.
There have been multiple times where I read a comment somewhere; thought to myself, wow, this guy is brilliant, let me see who wrote it so I can see if there are other things they've written; and, lo and behold, gwern.
Parent didn't say that "async/await" is based on multithreading, they said "it is multithreading", which is definitely correct. It is a form of cooperative multithreading with the statically enforced restriction that you can only yield when the thread stack contains a single stack frame.

It is true that an async/await task doesn't map 1:1 to an OS thread, but that's neither here nor there.
The function coloring post[1] covered this very nicely some time ago. It's definitely still an issue in any "monadic" approach to IO.

People who use progressive languages[2] will be using effect systems in a year or two, and this problem will go away.

[1]: https://journal.stuffwithstuff.com/2015/02/01/what-color-is-...

[2]: Unison, OCaml, Scala, and maybe more I don't know about.
Except it can’t happen in that environment. Twitter always was and is inherently unsuitable for any semi-productive discussion due its format.

However that is besides the point any discussion in such “free” environment will be drowned by noise and bigotry (from both sides). Pretending otherwise is silly.
To me, the title seems a bit extreme, but I think of it as really just synchronous programming.

True threaded programming is difficult. I find modern closure syntax, where closures can access parent contexts, to be the most effective way to write concurrent stuff.

In either case, you still need to worry about things like thread contention/locks and whatnot.

Those of us, of a certain age, can remember “refCon” (reference context) parameters. I haven’t had to use one of those, in ages.
any source for "everywhere" ? aka "science can't be trusted", hinting at "anywhere" ?
tl;dr author discovered blue/red problem, then went on to discover coroutines and likes coroutines better. Same old discussion, nothing new.
Spending a few months in Iceland it was really easy to see why they have so many gods and mythical beings in their history. The place is MAGICAL.
> It means that you can't spin up a stack for an hour if the system calculates that leaving it online for a whole month would breach your limit.

Sort of related, another wishlist feature I have is a way to start an EC2 instance with a deadline up front, and have the machine automatically suspended or terminated if it exceeds the deadline. I have some programs that start an EC2 instance, do some work, and shut it down (e.g. AMI building), and I would sleep a tiny bit better at night if AWS could deadline the instance as a backstop in case my script unexpectedly died before it could.

> Also you have variable costs (like s3 traffic)

Yeah, that's what I mean by it wouldn't solve the problem of usage-based billing. There they could just cut you off, and I think that's the bargain that people who want hard caps are asking for (there is always a spend cap at which I'd assume something had gone horribly wrong and would rather not keep spending), but I agree that the lack of real-time billing data is probably what stops them there.
One Prompt – Structure, validation, and reliability to prompt engineering
Nue 1.0 (RC) – Can it outshine Next.js/Astro?
So have a “Starter” account with spend limits then, don’t understand how an individual is supposed to learn this stack and actually sleep at night without waking up panicking something has been left running.
Obligatory link to “What Color is your Function?”

https://journal.stuffwithstuff.com/2015/02/01/what-color-is-...
This is the way, everyone else is wrong.
What problem would arise if synchronous functions could use await?
I’ll check it out - so you think this had some noteworthy real world applications?
Author here. I'm happy to answer your questions.
That performance argument never was a real issue for most applications anyway. You rarely have context switching as a bottleneck in a run of the mill web app, usually it's suboptimal queries, accidentally quadratic naive algos. I think even memory access patterns are more of an issue if you are compute heavy. Considering that "performance" matters at all for the applications purpose. Not everything is a high throughput load balancer.
Yeah. Nick Szabo used to show up a lot, too.
If they await, they’re no longer synchronous functions
Two things and one question:

1) While being a fantastic resource to get a first impression of what's out there, the Defense Universities Tracker has not been updated since about 2019. So it is starting to be outdated and anyone using it should be well aware of it. It seems that an update is in an early stage.

2) In order to assess the actual risks, the sources that are provided at each institution's page are crucial. These are ommitted in your version. Please consider linking back to each institutions page under https://unitracker.aspi.org.au/

The question: What is the value added of your page over the official page https://unitracker.aspi.org.au/ ? I only see the map. Am I missing something?
From one François to an other, thank you for you work, and all the best with your next endeavor!

Your various tutorials and your book "Deep Learning with Python" have been invaluable in helping me get up to speed in applied deep learning and in learning the ropes of a field I knew nothing about.
All you need to know about this, is that the clowns professing about "government efficiency" have just announced that they're going to create a second government department tasked with keeping the government efficient. Sounds super efficient, two departments to do the same thing.

As with everything it's an excuse to deregulate pesky things like the environment, public safety, etc.
or submit a screen recording of their writing process.

seems hard to fake that. and you could randomly quiz them on it .
I’m walking the Camino in Spain. After A single day out in the wilderness the smell of traffic is terrible and very noticeable.

Flying from my home in the Yukon to LAX is like landing in Mordor. The air is disgusting, the brown smudge, etc.
This seems a no true Scotsman argument. In actual real applications it is not always possible to split IO from non I/O parts and the virality of async prevents composition and encapsulation without significant refactoring.
Apple peelers are more artistic license than not to prove the point, but there are other real examples.

The chief example are mobile phones, the poster child of Galapagos Syndrome[1]. Once Japan figured out mobile phones they stopped moving. They kept reiterating and ended up with the craziest mobile phones known to man, but they got 1HKO'd in broad daylight by the invention of the smartphone and haven't been relevant since.

Another is the Mitsubishi Regional Jet. With expertise building licensed F-15s and the pride of restarting Japanese domestic aviation manufacturing since the YS-11, they built one of the best regional jets ever and failed to sell a single one because they couldn't figure out how to document how the thing was made and thus the required certifications from the FAA and other authorities.

Both examples are of Japan simply not understanding what a good purpose made tool is, because they don't need to. Why would anyone want a smartphone? Why do we need to explain how this jetliner is made? Of course they realize why once they're crashed in the dirt, but by then it's way too late.

While not immune (eg: the ancient state of US banking), the rest of the world and the United States in particular on the other hand respect good products that shake the markets, people and companies who don't (eg: Boeing and Intel for recent examples) are tarred and feathered for their insolence.

[1]: https://en.wikipedia.org/wiki/Gal%C3%A1pagos_syndrome
Speaking with Whales
trivial grammar/spelling mistakes are worse than running analogies into the ground without hitting the "context" button, or even the reductio ad absurdium train HN has been on lately.

yes my latin half-Freudian trans-alliterations can be tempting to pick out, i had another tab with stylometry obfuscation described, incident, and mitigated.

also giigles spellcheck sucks ass, and im tired of being gaslit of my word choice/spelling by giigles, who should know every word by now, in all languages

>don't possess deeper level knowledge

umm besides error-correcting codes reducing the bitrate, compression, and random byte padding to fend off correlation/timing attacks, there is no where to hide data, outside of the shannon limit for information thru a medium.

but its easy to hide data you cannot perceive; and everyone being conscious of this feat/fingerprinting, even if barely, does more towards efficacy to deter leaking via second-order "chilling effect" than the aftermath; I.P theft is hard to un-approximate

also stenography, ironically still being the only "real" signature, is still security thru obscurity with more steps; your literal stenographic signature is unique, but not preventable from duplicity, so it is un-obscurable.

also i know rsa != ECC plz dont
Review all code you ship to production or get burned. Every single dependency.

Security is expensive. Pay for it now or pay more later.
People think too much about these things.
Both your arguments seems a bit tinfoil-hat.
Grandparent is implying that all the execs making the RTO decisions are personally invested in business real state (why would multiple execs own a bunch of downtown real state?). Although a point could be made for companies who own their real state wanting to prop its value up before liquidating (so a pump and dump) it still stretches believability.

You are implying most companies really think that much about long-term unquantifiable effects.

I can see a better argument being made about executive with big ego likes sitting at the top of his ivory tower (his top-level corner-office) looking over the masses below him.
There is no data, just hyperbole from those same "visionaries" who keep claiming their stochastic parrots will replace everyone's jobs and we therefore need UBI
> Tl;dr the author doesn't understand why having "async operation running in the background" is a useful primitive in a language.

Isn't that covered in the paragraphs starting with?

And if so you could create some other way to run it asynchronously like Go’s go foo().
I don't have this setup myself, but I imagine Caves of Qud would work great. Its turn based so you don't have the problem of needing perfect control, in fact sometimes I need a good minute or so to think about my next move. I can easily sink hours into it anyway, might be worth me looking into
async/await allows multiple stacks to be active at once within a single thread. It's not a form of multi-threading, which implies the presence of a thread scheduler.
Didn’t say that.
If you posit that the future of the corporation is having a visionary CEO with a few minion middle managers and a swath of AI employees, then tell me, what do you do with the thousands of lost and no longer existing salaried jobs?
Or are you saying that the future is a multitude of corporations of one?
We can play with this travesties of intellectual discourse as long as you like, but we’re really one step removed from some stoners’ basement banter
You're returning a promise, that's a red function. It's async

https://journal.stuffwithstuff.com/2015/02/01/what-color-is-...

Sleep() should halt, this returns immediately

If I want my code to actually halt, I can either make myself red and use await on your red function, or I resign myself to put everything after the sleep in a .then()
> I'm sure this advice might be useful to some people but it's probably the opposite of useful for many others

This is probably true of any advice.
Most large organizations are hugely bureucratic regardless of whether they are successful or not :-)

In any case the prompt for the thread is somebody mentioning their (subjective) view that the deep hiearachy they were operating under, made a "wrong call".

We'll never know if this true or not, but it points to the challenges for this type of organizational structure faces. Dynamics in remote layers floating somewhere "above your level" decide the fate of things. Aspects that may have little to do with any meritocracy, reasonableness, fairness etc. become the deciding factors...
The net effect of these "syntactic sugar" diatribes has been many lifetimes of wasted developer effort in migrating between programming languages and frameworks, and countless products/investment dollars fizzling into oblivion because the developers couldn't stop worrying about how pretty the code looks.
How many people bought it while knowing about the holocaust?
https://freetubeapp.io/

Old url is not working.
The tradeoff in Go as I understand it is that you can't know whether the runtime will opt for single threaded concurrency or parallelism? That seems like it could be a headache, but there will always be a headache somewhere in concurrent programming. Perhaps the Go headache is smaller than the C# one in this case.

Doing blocking IO together with UI code is pretty bad in general though. Disks are certainly not quick enough to have File.Delete(...) be blocking unless you know the disk isn't on a network server which is aboard a satellite leaving the solar system or whatever edge case you'll invariably run into.
Swords of Damocles
Coroutines via user-mode stack-switching worked just fine for decades. Async/await is really only needed on limited runtime environments like Javascript or WASM where stack switching isn't an option (and at the cost that the compiler needs to turn sequential code into a switch-case state machine under the hood, which then introduces all sorts of problems, from 'function coloring' to requiring special support in debuggers).
Shipping code to production without evidence anyone credible has reviewed it at a minimum is negligence.
What's new in Logic Pro for Mac 11.1