skysight-inc/HackerNews huggingface dataset:
> "Smart programmers try to avoid complexity. So, they see the extra complexity in async/await and question why it is needed. This question is especially pertinent when considering that a reasonable alternative exists in OS threads."

Hm, yes, but is that complexity really avoided if it's in the language/runtime?

Sure, it's not in your code and it will probably have way more extensive testing and maybe also people that thought about the problem for months and you're just trying to implement Business feature #31514 and not reinventing the wheel, but as someone who has been bitten by specific implementations like the one in Quarkus (not a language, granted), I must say:

Complexity is there to stay (and occasionally bite you), even if it's hidden!
From forecasts on that page and other forecasts, it won't go far enough south to be visible.
Who killed the network switch? A Hubris Bug Story
Husband? Usually it is a wife who decides to stay at home and makes most decisions! Women control like 80% of purchasing power, most advertisement targets them!
It seems like there's a tension between making implementation details part of the API (so you can catch mistakes) and hiding detail (which improves reusability and makes changes easier).

For example, if every function is allowed to allocate memory whether it does or not, then changing the implementation of a function so that now it allocates memory is a simple, backward compatible change. If you have to declare that you allocate memory (for example, by adding a new argument, as in Zig), making the same change breaks compatibility, so now you have to change all the callers.

Depending on the circumstances, that might not be considered worth the trouble. It's a reason that Java's checked exceptions aren't popular. Often, reporting a new kind of error shouldn't be a compatibility break; they're all going to get caught and logged the same way anyway.

(An extreme case would be making performance guarantees part of the API, which, outside maybe real-time environments, nobody does. This means that a new version of a library could be much slower than before, maybe causing your servers to become overloaded, without any compiler warning. But performance depend so many factors that making guarantees is usually unfeasible.)

The proposed idea of having a compiler do certain context checks without declaring anything in the API means that there are invisible API constraints that are generated from the implementation. This is sort of like having type inference without the option of declaring a function's type explicitly.
I've heard that they stole it.
, so I approve of avoiding it.
Threads have a cost. Context switching between them at the kernel level has a cost. There are some workloads that gain performance by multiplexing requests on a thread. Java virtual threads, golang goroutines, and dotnet async/await (which is multi threaded like Rust+tokio) all moved this way for _performance_ reasons not for ergonomic or political ones.

It's also worth pointing out that async/await was not originally a JavaScript thing. It's in many languages now but was first introduced in C#. So by your logic Rust introduced it so it could be "jammed down the throats" of all the dotnet devs..
Reminds me of those listicle review sites where it's clear they never actually used the product but scraped reviews off amazon to write them.

I can see this product encouraging even more stuff like that.
I really have no idea how anyone could consider the books unimaginative. Dull and even cringeworthy I might be able to understand but still don't truly agree.

My only issue with the books is that the characters are pretty one dimensional which is something that does pop up in the series as well. (MINOR CHARACTER SPOILERS) Luo Ji simply doesn't care, Wade is a dick, Tianming is a loner, Da shi is a hero, etc.
Kinda surprised banks aren't more current with security, after all even NIST recognizes the problem with 2FA over SMS:
https://www.nist.gov/blogs/cybersecurity-insights/questionsa...
Related: I've written a thing that can automate extracting various resources (icons, cursors, bitmaps, sounds) from vintage Windowses: https://github.com/akx/res-extract

... originally because someone needed the Excel 95 icon as a Slack emoji, naturally.
I would damn this, if Async/Await wasn't a good enough (TM) solution for certain problems where Threads are NOT good enough.

Remember: there is a reason why Async/Await was created B E F O R E JavaScript was used for more than sprinkling a few fancy effects on some otherwise static webpages
Async wasn't invented after threads. It was primarily popularized in a system that has been designed such that it couldn't use threads (the web browser). Everything else is post-justifcation for why it's better. It isn't better.
I'm surprised this is not used more.

How good is the community repo?
Still production means sending my data to a hosted cloud black box? I can’t host this myself?
Clojure? VSCode? Neovim?
Bats do not have the cranial size of humans; that's kind of the point. They may have a loosely comparable cranium to body mass proportion, but allometric mass scaling matters with respect to physiological adaptation, quite a lot[0].

[0] https://www.phys.ufl.edu/courses/phy3221/spring10/HaldaneRig...
Rust async/await is as bad as C++ coroutines. They lack one of the most important language counterparts: async drop/destructor.
Game engines are a terrible business, so I don't know. I'm surprised investors were interested, TBH, as interesting a project as it is.

The fundamental problem with game engines is that the bulk of the users are tiny to small indies, who will complain endlessly about any fee whatsoever and even if it's the best tool ever would never pay more than a couple hundred per year. You'll be lucky to get even a few hundred to pay that. On the other end, BigCo game companies, if they'd ever by some miracle greenlight the use of your product rather than using their own shitty internal engines or Unity/UE, are so few in number that even if you can sign one or two you've got a tiny total addressable market.

Probably a fine business, if it works, for a solo bootstrapped engineer, but beyond that it gets very difficult. I'd love to be proven wrong because it'd be fantastic to see more competition in the space (Unity and Unreal both frankly suck balls, largely because they each essentially monopolize their niches and have no incentive to compete).
Because you want to avoid context switching cost. In fact, async/await/promise/future/Task is also closely related to fiber as opposed to thread at least in Windows, but fiber is provided from an OS level while async/promise/future/Task is provided by the language itself. You can switch to a different fiber without doing a context switch, just like how you use a state machine to switch to different job using async/promise/future/Task
And downthread from there, that guy's claim of "literally licensed from Info-Zip" is debunked. https://news.ycombinator.com/item?id=39812860
For simple poking at ports I think netcat is more common today. Especially for simple debugging and doing requests by hand.
They're really moving. I watched one go from Cape York to a similar latitude as Tasmania - about 4000km - in around 23 seconds. So about 600,000km/hr; around 20x faster than ISS (28,000km/hr). I have no idea why that speed was chosen, or if other speeds would work, just found it interesting.
Imagine if you covered the surface of the earth in 30,000 cars spread out evenly (including the ocean). They would be very difficult to find visually without them reflecting light and the space used is inconsequential.
Yes, agreed. The same is often true of other promises.
async can be scarier for locks since a block of code might depend on having exclusive access, and since there wasn't an await, it got it. Once you add an await in the middle, the code breaks. Threading at least makes you codify what actually needs exclusive access.

async also signs you up for managing your own thread scheduling. If you have a lot of IO and short CPU-bound code, this can be OK. If you have (or occasionally have) CPU-bound code, you'll find yourself playing scheduler.
Study: scientists prefer metrics which create an illusion that every time-consuming process is gradual and predictable
> page layouts using css-grid, container queries, light-dom web components

Tailwind doesn't "miss out" on any of these css features.

https://tailwindcss.com/docs/grid-template-columns

https://tailwindcss.com/blog/tailwindcss-v3-2

"Light-DOM web components" aren't a CSS feature... and they certainly aren't one that tailwind prevents you from using.
Absolutely nuts that we allow them to do any business where it isn’t reciprocated - social networks/ internet companies
That's the main gripe imo: Missing features that are not optional for certain problems where the solution would otherwise make perfect sense.

I get the pragmatism to "better ship something that is 80% finished now, than wait for it to be 100% finished in some years", but with Rust's async/await it was released in 2018 and the more time passes, the more it looks like some sharp edges are here to stay.
Insightful! Watch it with timestamps!
Results look like a map for Spindizzy (my favorite 8bit game).
I tend to agree, but an important note is that I've never seen an async/await system that didn't ALSO interact with OS threads. Async await is not an alternative to OS threads but rather an additional layer.
Bitmovin (YC S15) Is Hiring a Senior SW Engineer C/C++ in Berlin
The default visualization speed is 16x real time.
I disagree this is actually a good question.

Also I would have been a type 1 person, mostly becasue I would have assumed there's some clever trick to it, since we're in an interview.
I’m pretty certain Microsoft wouldn’t have dropped it in Win98. In fact I wouldn’t be surprised if that file is still shipped.

Thanks for the trip down memory lane too. It’s been years since I’ve last thought about moricons.dll. Possibly even decades.

For those who haven’t heard of it: https://retrocomputing.stackexchange.com/questions/6705/what...

Edit: looks like it is still available https://en.m.wikipedia.org/wiki/Moricons.dll
spacex is hiring...

https://www.spacex.com/careers/jobs?discipline=engineering+-...
A very simple example “list the Presidents in the order they were born”.

It gets the order wrong unless you tell it to “use Python”

https://chat.openai.com/share/4a673ea0-67d3-4256-b57d-dc1cf8...
The team proposes a new economic Experiment, please review and let us know your thoughts on this. Currently testing with random test products.
But can you access your google account if you lose your phone? That account belongs to google, not to you.
I’m sold, just bought a license - we just deployed our first multi cluster application and constantly switching contexts has started to drive me up the wall. Thanks!
Yeah, on paper there is in reality there isn't.
Show HN: Budget Kanban – Visually manage finances in Kanban boards
Hi HN!

Budgeting can often feel overwhelming, especially when just starting out. That's why I'm thrilled to share what I'm working on for the past month, Budget Kanban, a visual tool to easily manage project finances using Kanban boards.

With Budget Kanban, you gain:
1. Real-time visibility into each project's financial status: Keep track of your finances effortlessly, knowing exactly where each project stands financially.
2. Stress relief from having an organized and easily understandable financial overview: Say goodbye to financial chaos and hello to clarity and peace of mind.
3. Reduction of time spent on manual data entry and corrections: Streamline your workflow and spend less time on tedious tasks, allowing you to focus on what truly matters.
4. Enhanced ability to identify and rectify budget issues swiftly: Spot potential issues early on and take proactive measures to address them, preventing headaches down the road.
5. Increased accuracy in budget allocation and monitoring: Make informed decisions with confidence, ensuring your resources are allocated efficiently and effectively.

I'd love for you to give Budget Kanban a try and share your thoughts .

Have a fantastic day!
- Just
I suppose this beats LeetCode and take-home, if this is a replacement. But this might just devolve into free work under pressure.

Also, previous discussion: https://news.ycombinator.com/item?id=31065143
Good on you for exercising, but this is really sad. We don’t live on Mars. I hope your city / district can find a way to create pleasant outdoor spaces.
Nothing. I just wrote it because it seemed amusing.
I’ve had a gm car with onstar- can who can I contact to see if my data was shared. And can I join to class action?
Not only Turkey, it is quite common across all Mediterrean countries.
Vector Database (fully-managed) Benchmark
Nice. It'd be cool to filter by version. Also visualizations like this https://www.youtube.com/watch?v=rddTXl_7Wr8 are useful for getting the status of how far along each shell is to completion.
Curious: Why does SpaceX say it’ll work on the Great Lakes, but not on the ocean? Don’t the satellites cover the whole planet? Are they somehow hibernating when traversing the ocean or…

Ah. I think I know the answer. They can only serve internet as long as the satellite can see the client and a ground station at the same time. Hence the Great Lakes will work, but the Pacific won’t. Right?
Thanks for checking it out. I am targeting non tech people so my guess is that the words related to blockchain scare away people so I’m trying to run an an test with no mentions about blockchain (on homepage)

Appreciate it
Oh, so it is, (I see now 'live' is available by clicking on that option (top right). Thanks for the correction.
In October I wrote a blogpost on this subject: https://hlfshell.ai/posts/llms-and-robotics-papers-2023/

..and plan to do an updated version soon for much of what's been released since. I've also done work related to LLM and robotics integration, also on that site.

Happy to chat about it.
> A scientific theory of consciousness must be able to explain ... how consciousness is causally efficacious ...

A strong claim, that.
This is why self-diagnosis isn't an actual standard, but also your statement is that of ignorance. ADHD can be seen more of a chronic condition, people do forget minor details once in a while, but when you start to have that happen almost daily, even after a few minutes or hours, that is more akin to ADHD. Another analogy is, everyone has to urinate, but when you have to urinate every 5 mins, that is a problem, that is ADHD. ADHD affect the ability to perform executive functions first, which is it's main trait, it also come with it's own set of other problems like memory, so writing off ADHD as a trend, is reductive, imo. It's not something actual sufferers label themselves to feel special, it's more like society labels them to call them lazy or "special".
> You have three hours. Go!

Cool challenge, but isn't it a bit of a red flag? I don't expect you to ask me to get familiar with a codebase, test, and implement a feature in 3 hours. Ever. It's also oddly specific, if you know what I mean...
Getting reminded of late 90s & early 2000s design choices, the glassy feel of Bluecurve icon themes of Redhat Linux looked way ahead of their competition [1] Most people didn't have access to Classic Macs OS 8.5~9, which probably had beautiful icon sets too (Aqua?). As a highschooler, this looked so futuristic & colorful as compared to 2000/XP desktop themes & icons.

EDIT: Adding as postscript: Is there anything similar which would come close to Bluecurve today? TIA if there is anything in reader's minds.

1. https://upload.wikimedia.org/wikipedia/commons/7/71/GNOME_2....

2. https://upload.wikimedia.org/wikipedia/commons/b/b8/Fedora-y...
Asynchronous code has race conditions and synchronization issues too.

I pray for all the code written by people who think they didn’t need to learn about synchronization because they wrote asynchronous code.

And unfortunately I’ve come across and had to fix asynchronous code with race conditions.

You cannot escape learning about synchronization. Writing race-condition-free code is not hard.

What is actually hard is writing fast lock-free routines, but that’s more a parallelism problem that affects both threaded and asynchronous code. And most people will never need to reach that level of code optimization for their work.
> Hypothetical async Drop could help here (though you would have to rely on async drop guards extensively instead of processing "cancellation errors"), but adding it to Rust is far from easy and AFAIK there are certain fundamental issues with it.

Wouldn't fiber cancellation be equivalent and have equivalent implementation difficulties? You say you just send a signal to the task, but in practice picking up and running the task to trigger its cancellation error handling is going to look the same as running a future's async drop, isn't it?
I'm not sure, if there's no gotchas in this question I feel like it'd be mostly copy and paste from the addition or subtraction command?

Doesn't necessarily mean that it's a good question of course.
FWIW there are 2 trillion galaxies in the universe

So says Wikipedia
Sorry, but it is not clear to me. Lezer obviously works in the real world, as codemirror is quite widespread (integrated in chrome dev tools for example).

And since I use codemirror anyway, it might make sense to also use lezer, unless there are downsides I am not aware of.
As someone that was big into threading back in the 2000, with the experience gathered through times, I think with modern hardware resources we are better off with OS IPC, as it offers much better safety guarantees, specially in C like languages.
I'd recommend reposting someone else's articles if you insist upon reposting.
Remember when they followed up with Visual Studio 2012?
I've seen this and am amazed, also obviously grateful for the job, nevertheless I dream (I don't demand, this is just a dream) of a way better library including also all the icons from all the prominent apps and libraries of all the Windows eras since Windows 3.x. I mean also MS Office and Visual Studio to say the least. Ideally every single one should be accompanied with upscaled versions up to 512x512px.

This all probably is very questionable from the legal point of view but I have courage to hope nobody is going to care busting us as long as we only use these in small personal projects just a handful of people sees.

I even hope there will one day be a Dall-E-like neural network which would take a prompt and produce icons in Windows 3.x/98 style in any resolution you might need (i.e. up to whatever it takes to make a big icon on a Retina display).

Long live vapourwave! :-)
Opera sees big jump in EU users on iOS, Android after DMA update
Nobody mistakes ice for something sudden emergent though, it's obvious to naked eye that it gradually appears
Right, the travel-time metric is not compatible with a Euclidean R² metric. You can imagine three subway stations in a triangle loop, such that it's a shorter trip to do a full loop on the subway then to walk to a point in the interior.

There's no way to continuously deform a map so that it represents travel times as distance in a plane.
As another data point, I’ve faced this question as well when interviewing with them.

Having said that, it’s a great alternative compared to Leetcode style questions, where you’re penalized for just asking about the problem or not having the right insight from the get go, or not using the interviewer’s preferred formulation of the solution (such as using two queues for a graph search problem instead of just one).
Warning: don't look if you ever want to contribute to Wine or ReactOS
I'd assume there's some kind of gotcha that makes naive solutions not scale. I may just be cynical, though.
> regular RISC platforms were riding an economy of scale

I've found a fascinating page [1].

[1] https://computer.fandom.com/wiki/Instructions_per_second#Tim...

ARM (1986) has 4 Dhrystone MIPS, and Motorola 68020 (1984, as CISC as you can get) has 4.84 Dhrystone MIPS.

RISC was not riding economy of scale then, it barely existed on the periphery of the mass computing, being utilized in very expensive workstations or cheap arcade game consoles. The first significant RISC chip that made any waves was Alpha AXP 21064, when banks worldwide started to buy these in bulks.

The fact that 68020 outperformed ARMv2 is what people from Syymbolics had at hand then, in 1986, writing that document.
I use my own 15 lines of Python code calling pyotp. At least for desktop means preferably CLI.
I think a fine-tune of SD or SDXL would be perfectly able to produce such images. I would also like to see this.
I tried WinGet out when it came out, but ended up sticking with scoop. What would you say are the advantages of WinGet over scoop?
> A common refrain is that threads can do everything that async/await can, but simpler.

> OS threads don’t require any changes to the programming model, which makes it very easy to express concurrency.

I think these claims need a bit of justification, or else why write the article?
> One of the simplest and most pernicious programming problems is the humble deadlock

> […]

> Unfortunately deadlocks are not always so easy to spot, especially as more layers of abstraction are added

> […]

> Compilers don’t even try to help here.

https://clang.llvm.org/docs/ThreadSafetyAnalysis.html:

“Clang Thread Safety Analysis is a C++ language extension which warns about potential race conditions in code. The analysis is completely static (i.e. compile-time); there is no run-time overhead. The analysis is still under active development, but it is mature enough to be deployed in an industrial setting. It is being developed by Google, in collaboration with CERT/SEI, and is used extensively in Google’s internal code base.

Thread safety analysis works very much like a type system for multi-threaded programs. In addition to declaring the type of data (e.g. int, float, etc.), the programmer can (optionally) declare how access to that data is controlled in a multi-threaded environment. For example, if foo is guarded by the mutex mu, then the analysis will issue a warning whenever a piece of code reads or writes to foo without first locking mu. Similarly, if there are particular routines that should only be called by the GUI thread, then the analysis will warn if other threads call those routines.

[…]

EXCLUDES is an attribute on functions or methods, which declares that the caller must not hold the given capabilities. This annotation is used to prevent deadlock.”

Googling “static deadlock detection” will uncover similar tools (often not as well integrated with the compiler)
If you want a more approachable model of context than effects, try "dynamic scope".

(and remember there are good reasons we try to do as much as possible with lexical instead)
https://archive.org/details/globotipo2016
Yeah once your app gets to be sufficiently complex you will find yourself needing mutexes after all. Async/await makes the easy parts of concurrency easy but the hard parts are still hard.
No gotchas in there. It's a realistic and straight forward problem that exercises your ability to navigate and modify a well-written C codebase.
Using NixOS for My Homelab
"We're sorry we got caught" in all its beauty. But I wish other companies, especially telcos, would be a little more bothered by this.
Starts at $5 a month with no free option or trial?

No thanks.
There are production systems handling PII (finance, healthcare etc), where logs are treated as radioactive and only people with trust, training and protective gears should be touching them. This is the case where these are legal/ compliance requirements.
Non-prod of those systems can have wide open access to logs, unless someone decides to import prod data for "testing" in non-prod.
While I agree access to logs may seem too restrictive, there are some very solid reasons for that... and then we have some cargo-cult and some lack of time/ understanding which causes too restrictive log access where it might not be required.