skysight-inc/HackerNews huggingface dataset:
I think it's worth understanding why you need Arc and RwLock here.

If the compiler fails to type check because a future is not Send, it means that the future's context holds onto some state that is not safe to be sent to a different thread. For example, holding a reference to something on the stack across an await point. If it fails because something is not Sync, it means the future's context holds onto some state that is potentially accessed concurrently from multiple threads.

If you write your async code such that it does not have these concurrency bugs then you don't have a problem. Arc is a convenient way to make something that is Send and RwLock is a convenient way to make something Sync. You can also fix your code by not introducing concurrency bugs.

This isn't perfect though because the errors are often cryptic. You can have a function that is fine in one context completely break when called in another with "future is not send". And good luck identifying where the bug is and how to fix it.

As for constructing a future directly, sure you can do that. But keep in mind Rust futures aren't promises that just wrap some .then callback. They are types that implement the Future trait which has a method .poll that takes self by Pin and a Waker object to prevent the underlying data from being moved and invalidating references as well as wake other pending futures. If that sounds complex, it is, because async in Rust is actually super complicated and the syntactic sugar does a massive amount of work.
> dads aren’t around because they aren’t actually needed

They're incarcerated [1].

[1] https://nij.ojp.gov/media/image/19511
I don't think there was any dialog at all. IIRC.

At first, people weren't worried about security. It was just a bunch of us nerds on there. You interacted with real people that didn't seem like they were trying to swindle you. The world still used paper checks for anything big, and credit/debit cards were there, but not like today. It wasn't that uncommon to write a check and ask the shop owner to cash it next week, at least in my poor household.

There wasn't "online banking" or "online identities" to steal, so it didn't seem all that important. The worst thing that would happen is you would lose access to a chat handle.
You might be interested in this piece of news: Taliban leader praises Elon Musk and Twitter over Threads for 'freedom of speech' [0]

[0]: https://www.wionews.com/south-asia/taliban-leader-praises-el...
This might be a good chance to discuss a theory I have.

It seems that recently, a lot of attention is spent on making the world more inclusive. However, this inclusivity does not seem to span the spectrum of intelligence.

Overall, I assume that smarter people are being favored a lot, with better job opportunities, higher chances at finding a funny life partner, and receiving more freedom of choice overall.

(Luckily, if you are really smart you may notice an abundance of negative things, and make your own life miserable, so there appears to be some cut-off point.)

Would it be a good idea to make society more inclusive for the less fortunate, intelligence wise? How would we go on about this?

I for one would like more government interference, so that everyone profits equally. But perhaps this is not the best solution?
https://www.bbc.co.uk/news/uk-politics-36616028

https://en.wikipedia.org/wiki/Results_of_the_2016_United_Kin...

Percent of votes [b]

City Remain Leave

Edinburgh 74.4% 25.6%

Brighton & Hove 68.6% 31.4%

Glasgow 66.6% 33.4%

Bristol 61.7% 38.3%

Aberdeen 61.1% 38.9%

Manchester 60.4% 39.6%

Cardiff 60.0% 40.0%

greater Belfast 59.9% 40.1%

Greater London 59.9% 40.1%

Liverpool 58.2% 41.8%

York 58.0% 42.0%

Leicester 51.1% 48.9%

Newcastle upon Tyne 50.7% 49.3%

Leeds 50.3% 49.7%

--------------------------

Birmingham 49.6% 50.4%

Nottingham 49.2% 50.8%

Sheffield 49.0% 51.0%

Swansea 48.5% 51.5%

Southampton 46.2% 53.8%

Bradford 45.8% 54.2%

Coventry 44.4% 55.6%

Salford 43.2% 56.8%

Derby 42.8% 57.2%

Portsmouth 41.9% 58.1%

Plymouth 40.1% 59.9%

Sunderland 38.7% 61.3%

Wolverhampton 37.4% 62.6%

Wakefield 33.6% 66.4%

Kingston upon Hull 32.4% 67.6%

Stoke-on-Trent 30.6% 69.4%
Fira Code (or rather its nerd font) has been my goto for a few years, its just really nice.
In the sense that if I worked for a big company, I have reasons to not look into Llama as a using it for work would have obstacles.
>did they not enforce the Twitter buy offer against Elon

They did, I wouldn't be surprised if it was the same judge, lol.

The lesson here is that DE's Court of Chancery doesn't fool around.
I think we can safely say that about most of Europe and Asia too. Don't know about other parts of the world but I don't think there's any significant part where trust in institutions is significantly rising.

For a lot of objective metrics the institutions are doing better than ever in history. Life expectancy, human rights, reduction of extreme poverty, etc. Sure you can find some higher peaks in the post WWII decades but the trend on a larger time scale is for improvement.

So what's going on? I don't think there's an single and easy answer and I think anybody presenting one is misguided if not intentionally misleading. To me it looks like a cultural problem. What sort exactly I could not say. But I see some signs: individualism, skepticism about institutional missions, people having an ever harder time swallowing hierarchies, cynicism about taking part in society, an increasing sense of doom, pop culture is very anti establishment and other things like that.

All of the above also form a sort of self fulfilling prophecy. If there's no trust in institutions the only people that are going to join them will tend to do so with cynical self interest in mind. Which damages the institutions image further and so on.
Amazon has had very strong competition that they mostly beat. Meta has faced strong competition which they beat through scaling out acquisitions. Apple has gone from nothing to the world's richest company. Microsoft was a joke and now it's not. Google I agree with you on.
Show HN: Hash functions from C++ running in WebAssembly
> chatgpt will easily create complete autohotkey scrtips

I’ve used it to do this very thing and while it was helpful, it really struggled with sticking to either v1 or v2 of the language. It felt like playing whack-a-mole. I would tell it some line was incorrect syntax for v2 and it would apologize, fix that line and break something else.

The bones of the script were good, but I had to do quite a bit of editing.

I don’t feel all that negative about it though because I understand that it will only get better.
> ICs have had to deal with slim pickings at senior level promos for a long time

A lot of people don't have what it takes to reach higher levels as SWE. Technical skills alone can be a blocker. On the other hand, it seems easier for managers to assume new responsibilities. I could definitely see my direct manager assume the role of his manager for instance.

Personally, I know I can't be an E7 at that stage of my career. My teammates at that level are fast thinkers, extremely well organized, technically exceptional and so on. In comparison, my skip manager is just a guy with good communication skills, enough technical knowledge to understand what the teams do, and smart enough to understand the rules of the game.
2014 CEO compensation vs shareholder return [1]

[1] http://si.wsj.net/public/resources/images/OG-AE821_ExecPa_NS...
Nah, if I were to go back in time I'd just push them to clean it up a bit before launch.

In the end, JS has been a net good for the industry. I don't work in it, but it's turned into something decent over the years though the frameworks around it are insane. But it took 15 years to get to this place and become a "grown up" tool, imho partially because of some odd choices early on.

Scoping: Especially initially, the scoping rules were really wonky.

OO: I am actually a fan of prototype inheritance (Self & LambdaMOO FTW) but the form implemented in JS was confusing for most people and they never understood it, esp given Java was ascendant at the time with its very strict and boring class-based model. I think some clarity was needed here. Lack of standardization around how to do objects, inheritance, encapsulation led to a total bizarre mixture of approaches and misunderstandings.

Essentially I just think having it passed over by some more sober minded language designer types who had research background in e.g. Scheme, Lisp, Self, etc. would have been good.

Going all in on JS instead of wasting time with the ill-fated Java applet stuff would have been good for the industry. It's what the industry ended up doing eventually anyways, but it took until the 2000s before this really clicked for people and they finally gave up on the various half-baked dynamic plugin solutions (Flash, ActiveX, Java applets, etc).

The "Java" in the name was/is a problem and led to a decade of stupidity. I understand how it happened, but it shouldn't of.
Not to be mistaken for Glycol, god of wine adulteration, that had a large and influential cult within the Italian republic in the late 20th century.
>Unlimited migration from Schengen

The Schengen area had nothing to do with who could or couldn't migrate to the UK when the UK was in the EU.
They're not green threads. Futures are stackless coroutines.
Interop compliance should be a thing. Enterprise customers are missing the plot here. Please ask your software vendors to support interoperability. Example - Outlook should support/declare standard interfaces for video calling meeting links from other products. I see the need for a body for enterprise integration standards. Please help me such a body if there already is one.

I look specifically for something of the likes for Enterprise Integration Act of 2002 for software vendors.
>What’s “fair” is generally what is accepted by the parties involved. Even if you complain about the compensation, if you’re working at a particular rate, you have implicitly agreed to that rate rather than seeking a higher compensating position.

Both implicit and explicit agreement can be problematic, depending on the conditions under which you give them.
Yeah, the problem is certainly real. I remember working with a much smaller python monorepo some years ago (probably 100x fewer python modules but the beginnings of multiple client-specific variants that depended upon a swathe of core libraries) and we were already starting to see places it would be valuable to declare constraints banning certain types of imports that broke our desired module architecture and enforce those constraints during CI without needing humans to notice the violations during code review.
I also found the intro to be of very high quality, I wonder if they overfitted on that?
It's really not that rare. For sure there are companies (big and small) which have a quite paranoid lockdown environment, but there are just as many which understand that local admin access is quite important for developer productivity and if you have the appropriate network architecture it's no less secure.
This isn't debate club or a courtroom, there aren't rules on how we can share how something sounds to us in an informal setting like this. If you want a nice discussion consider being a bit more polite, less confrontational and assuming good faith.
The "so .. what do we do here?" phenomenon is real. People keep forgetting the social part of social media. It's the same brain that reduces everything to "content". What's actually in the content, what it means, and who it appeals to, matters.

The four questions:

- who's using the platform
- what are they using it for
- who's NOT allowed
- what purposes are NOT allowed

The platform itself makes affordances as to what kind of thing is easier to do, and the vanguard of users (usually including the founders and their friends) determines the starting conditions, but then it tends to evolve from there.

Finally, an under-appreciated condition: what are the PVP rules? Twitter allows a fairly high degree of inter-poster hostility which participants are expected to deal with themselves via block/mute. Bluesky, crazily, launched without this feature, and had to retrofit it with the odd choice to make blocks public.
Then it should be easy to find companies with different management practices that did just as well. We can talk hypotheticals all day and get nowhere.
I've recently got into WebAssembly and it's a lot of fun. Theoretically this could be extended to other hashes like SHA1, etc, but--really--why would you when you already have crypto.subtle ? Still, I love WebAssembly because it lets you run whatever you write wherever you write it, on the web. Perfect! :)
> Also, IMO it's relatively easy to use Send-bounded future in non-Send(i.o.w. single-threaded) runtime environment, but it's almost impossible to do opposite. Ecosystem users can freely use single threaded async runtime, but ecosystem providers should not.

We have Send and non-Send primitives in Rust for a reason. You could use Arc/Mutex/AtomicUsize/... everywhere on a single thread, but you should use Rc/RefCell/Cell<usize>/... instead whenever possible since those are just cheaper. The problem is that in the ecosystem we are building the prevailing assumption is that anything async must also be Send, which means we end up using Send primitives even in non-Send contexts, which is always a waste.

> If you want every users to only use single threaded runtime, it's a major loss for the Rust ecosystem.

Running single threaded executors does not prohibit you from using threads, it just depends on how you want to do that. You can:

1. Have a single async executor running a threadpool that requires _everything_ to be Send.
2. Have a single threadpool, each thread running its own async executor, in which case only stuff that crosses thread boundaries needs to be Send.

The argument is that there are many scenarios where 2 is the optimal solution, both for performance and developer experience, but the ecosystem does not support it well.
Calling dupe on a post in favour of one with no discussion just wastes everyones time.
> And what do you propose?

That you get your terminology right, back up your claims with links that actually make sense and try to understand that the software world is complex and that incremental approaches make more sense than demanding unrealistic / uneconomical changes because they are not going to happen.

> To let only 1.5 good C programmers in the world write code like in 70s?

No, I did not propose that, you just did and clearly that's nonsense aka a strawman even if you didn't bother throwing it down.

C is here. It will be here decades from now. Rewriting everything is not going to happen, at least, not in the short term. C will likely still be here (and new C code will likely still be written) in 2100, and possibly long after that. This isn't ideal and it's not going to help that we can not make a clean break with the past even though we are trying.

The solution will come in many small pieces rather than as one silver bullet to cure it all and TFA announces two such small pieces and as such is a small step in a very, very long game. The adoption of Rust and other safer (not inherently safe but safer, there are still plenty of footguns left) may well in the longer run give us a chance to do away with the last of the heritage from the C era. But there is a fair chance that it won't happen and that Rust's rate of adoption will be too low to solve this problem timely.

The same goes for every other managed language, they are partial solutions at best. This isn't good news and it isn't optimal, but it is the reality as far as I can determine. If you're going to do a new greenfield development I hope that you will find yourself on a platform where you won't have to use C and that you have skills and resources at your disposal that will allow you to side-step those problems entirely. But that won't do anything for the untold LOC already out there in production and that utterly dwarfs any concern I have about future development, it's the mess we made in the past that we have to deal with and we have to try hard to avoid making new messes.

Think of it as fixing a large toxic waste spill.
The Australian game was codified first.
It is opt-in. If you're using Tokio then you can specify whether you want to use a single-threaded or multi-threaded runtime. Multi-threaded is "default" in the sense that if you just use `#[tokio::main]` then you get a multi-threaded runtime but you can also just do `#[tokio::main(flavor = "current_thread")]` to get a single threaded executor.

More to the point, even using a multi-threaded runtime won't spawn threads willy-nilly. It will default to using N worker threads (where N is the number of CPU cores available).
Infosec and similar communities migrated off twitter starting months ago.

Threads was not an option then, and isn't of much interest to these communities (as a platform to socialise upon) now.
Maybe short term, but long term I am really not that convinced any longer. Forcing the UI approach everywhere has a cost, these tools are terrible for operations. You can automate code testing, deployment and ops and have really good operations as a consequence. You will never be able to do that with spreadsheets or more horrible stuff like Power Apps. Just see how many millions of people are hired to manage all these UI clicky things offshore and how much mess it creates for business ops.
>Would employees be better off if their employer didn't exist?

Absolutely.
People are emotional and sometimes addressing an emotional concern helps. In this case, people who are exhausted by cryptocurrency culture would be more willing to read this write-up being assured that it's not cryptocurrency related.
Used NUC, optiplex or others from eBay. If you need just "a" server for home, look for one of those small PCs on the used market. They often appear at very low prices after some company refreshes their office desktops. Replace the storage with something decent and you've got a perfect server.
On the explainer page [1], the first use case example is to prevent ad fraud (and, presumably, ad blocking...):

> Some examples of scenarios where users depend on client trust include:

> Users like visiting websites that are expensive to create and maintain, but they often want or need to do it without paying directly. These websites fund themselves with ads, but the advertisers can only afford to pay for humans to see the ads, rather than robots. This creates a need for human users to prove to websites that they're human, sometimes through tasks like challenges or logins.

So it's essentially Google further entrenching its tentacles in web standards in the most invasive ways with no regards towards privacy and user control. It's a shame what the W3C has degenerated into.

[1] https://github.com/RupertBenWiser/Web-Environment-Integrity/...
I skimmed the paper and didn't see an answer to this: how much of the video did the AI actually generate? how much of it was touched up by humans and how much of it was actually drawn/animated solely by humans?
US Payroll
I think where I was confused is that the applets were already programmable and interactive, so I'm just not sure what throwing JS into the mix brings. But it could be that there's some functionality it gained (XHR, perhaps?) in the intervening period that it lacked at the time.
The magic behind the order screens of fast food restaurants
I don't really care about promotions. I care about my comp steadily increasing. In fact, I prefer getting a raise without being promoted.
"We" are never going to stop trying to use LLMs for math. They are obviously mimicking a smart person. What do you do with smart persons? You query them with bad and lazy questions (often without being too honest about that to yourself), and hope/expect helpful answers.

Because that is how it works. The limiting factor so far has been the smart persons time and patience. Now, no longer.

People moderating their LLMs usage is never happening, from here on out until the end of civilisation. Any LLM service that is designing for that is done. You need to make lazy questions efficient. People do not care about how complicated your sql query is and they will never care. People will not give up on energy, meat, cars, as long as they feel they are giving something up.

People will never think twice to not make your LLM think twice.

If it seems useful and convenient, people will use it. If it's not giving good answers to lazy questions out of the box, they will go to the thing that does.
An awful way to phrase "giving someone an opportunity".
The only sure thing for productivity is use the same keyboard everywhere preferably forever.

Even if the brain is a master at slow context switching (absorbing the office keyboard) it will lead to slower typing.
Real life isn't like a simplified story. No one's 100% good or evil, nor entirely perfect of imperfect. That's the third option, somewhere in the middle / "well, it's complicated".

Government is particularly bad as inherently if an exception to a rule is required for society to function well that's where it has to happen.

An active process to strive to be better and to fix problems, constant vigilance, is the best stance for a high quality organization. To strive for that (reasonable) perfection.
> People who have a higher level of understanding- people who can intelligently talk about the product

I agree with you here, those are valuable. But IME those are usually not the ones in positions of power.

I've met passionate developers that understand the issues of the product and not only the tech. Support folks that know exactly why and where the product falls short. Sales folks that deeply understand what the product doesn't offer and what it probably needs. The list goes on.

You said so yourself: these people are rare and even from a statistical point of view there will be way more people that understand the product down in the trenches compared to higher ups. Most of those at the top are hired because of previous prestige/success or more commonly: connections.

> People in the lower echelons usually don't understand what their product is for, how it works, who uses it or how it fits into their company's overall business strategy.

You've just described so many people at the top that I've seen first hand. VPs of X coming in, having zero understanding of the product (sometimes they never even used it) and making decisions that hurt everyone. Even the ones with previously successful products come in and it becomes apparent that success is not easily replicated. Survivorship bias is all too real. How many come in and try to copy/paste what worked in their previous company blindly only to fail upwards after the fact?

> I don't agree about the lower levels doing all the work.

If you want to see how right I am, all we have to do is examine the bus (or submarine?) scenario. If all managers vanished in a submarine today would the company stop? Now compare that to the same scenario with devs/support/infra/sales/etc. Yes, they do all the work.

One of the few issues the lack of management causes is regarding decision making. But not because folks are incapable of deciding, it's because they are powerless to do so. When they have that power, the company continues to move forward just fine - it might even thrive if you ask me.
My energy bill is up from 32 c per kWh pre-pandemic to 37 c per kWh now. Gasoline was 1.79 yesterday and was about 1.70 pre-pandemic.

Food prices have risen, but some more some less, but 50% seems too high. But maybe Germany is different.
How is Copilot's behavior changing over time?

And has anyone successfully used Copilot to do simple but tedious things like generate library bindings for various languages? I suspect that Copilot would be good at this kind of thing because it is a relatively simple task and there is a lot of training-code available.
I'll give the system a try in the next few days.