skysight-inc/HackerNews huggingface dataset:
To quote myself from a comment on high speed trains the other day “[The French] build high speed lines for between 1/5th and 1/20th of the cost of the one the UK is building. Just to prempt the France is flat and land is cheap arguments. 1/5th is the cost of the section of line between Lyon and Marseille that crosses the Massif Central with 50 tunnels and bridges and plenty of earthworks. The cost of land acquisition is only £8bn of the £100bn+ cost of HS2.” So if we conclude this kind of cost difference is corruption, we clearly have a much bigger problem in Britain.
>fuck off with your clever code

Stupidly Simple Code is the best code, but it is also possibly the hardest to write from a programmer perspective.
And Ctrl + 9 will always take you to the last tab.
i think the word people are maybe looking for is oligopoly...
Could you or the parent commenter define "submarine" in this context? I searched and didn't find anything relevant.
Definitely your setup. Long uptimes for Emacs with no performance degradation are common. Mine are typically month+. Currently, M-x uptime on my desktop (Linux) shows 33 days; on my work machine (Windows, with Emacs in WSL) it's 5 days - but that's only because I wrote a lot of tricky Elisp code to optimize my work some, and I rebooted Emacs to check it will actually work when reloaded afresh. Normally, Emacs runs uninterrupted on that machine, until Windows forces me to reboot for updates.

Startup time with nativecomp? Typically around 5 seconds on Linux, 15 seconds on WSL. If I happened to update a lot of packages before restarting (as I sometimes do, I like to clean out runtime state when I do bulk updates), then on WSL the startup goes up to about 1-2 minutes - that is, Emacs is usable in about 30 seconds, but async native compilation keeps pinning most CPU cores, so I just let it work in peace for that extra minute.
GPL isn't "do whatever you want". It's "do whatever you want, as long as you let future users do whatever they want". That's what makes it such a good licence for the community.
qemu on its own is indeed faster to iterate and learn with.

In production you probably want the host-vm and vm-vm confinement provided by svirt https://libvirt.org/drvqemu.html#driver-security-architectur...
Indeed, there're edge cases. Still, how many people using linked lists on the stack?
This isn't accurate.

There is a citizenship test, and as I understand it some level of English proficiency is required. The residency requirement is four years, at least one as a permanent resident. Permanent residency, depending on the stream, has its own skill, employment, and English proficiency requirements.

As for how 'actual Australians' feel, this is a complex issue with questions on a lot of axes. People's opinions are going to be varied and nuanced.
It’s not the epic stupidity that bothers me - it’s the fact that it’s self evident - that’s what really bothers me.

It’s blindingly obvious this is a really bad idea.

What is so great about putting waste in surfaces that is driving this foolish rush to environmental disaster?

When something obviously stupid is happening and you just can’t see why, sniff to smell who’s money is behind it.

Actually the epic stupidity does bother me.
Five side-hustles that will make you an extra 35p a year
Tcp is my preferred option.
Experience reports are also common as scientific papers. [1]

[1] https://sigdoc.acm.org/conference/2017/guidelines-experience...
> Besides, I thought it was established a few months into the pandemic that fomites are not a likely route of transmission for coronavirus.

The virus has been shown to last for three days on bank notes (see below), though how easy it is to catch from the notes isn’t mentioned.
If my job involved touching bank notes from NY public transport last year, I’d sure as hell have been nervous, as small chances presumably add up. Those machines appear to move fast too, so maybe airborne spread could be possible?

https://www.nature.com/articles/d41586-021-00251-4
There is work ongoing to write a sailfishos/plasma mobile signal client in rust+qt: https://gitlab.com/whisperfish/whisperfish
> Finally, dynamic loading isn't even the right surface for messing with the behavior of existing binaries.

Then what is? Dropping a custom library next to a binary tends to be way easier than modifying the binary.
MeetKevin: Running for Governor of California
Proof of stake is even more of a Ponzi, with the rich in a given cryptocurrency getting even richer with time.

At least for miners in a PoW system, there’s a pressure for some liquidity by miners selling to cover the mining costs.
it certainly is...
And scammers love them.
It reminds me of an experiment where genius were assigned at random among schoolchildren and how it affected their results (only because teachers thought they geniuses). https://www.npr.org/sections/health-shots/2012/09/18/1611592...
Teachers' expectations can influence how students perform (2012)
If it wasn't for Microsoft, Linux on Nokia phones would have succeeded.

That seems wildly optimistic.

I owned an N900 and used an N9 for a while, and while I loved them for all their nerdy glory, they where not ready for prime time. Why do you think Nokia would have done better with Meego than they did with WP?
To be clear: I don’t think anyone who is interested in Linux on a phone wants to run Android.

It is Linux but not in any real way. It could just as easily be not-Linux.
Quantity and dosage also matter.
It’s certainly a worry, but at least other options do exist. And if you own a domain name, you can move your email hosting (including all your addresses) to the provider you like the most.

And it’s certainly a much better situation than other chat systems, where your identity is fundamentally tied to your account on that particular service. You can’t move to signal without moving everyone else to signal at the same time. I only need one email provider and one email app. But for messaging, everyone ends up needing signal, and WhatsApp, and Facebook to talk to each other. Imagine if you needed half a dozen email apps and accounts for each one to use email. “Oh, you’re emailing a company who uses Microsoft? Better open the Microsoft email program and remember your Microsoft login”.

No thanks!
I only use it in the rain to look up maps and see directions or to quickly see a message and you are right that the distortions from the rain can make it hard to see, though I haven't had the issue of a slippery phone.

Maybe I am just paranoid, but I would like to know my phone doesn't die on me when it is exposed to rain.
> So far, the only programming language I know of that supports this type of crazy data transformations is JAI,

As far as I know JAI is indeed the only language that explicitly lets you switch between AoS and SoA with one bit, but the APL family of languages - (APL, J, K, Shakti, and a couple more) has basically - for 60 years no - taken the "data oriented" SoA approach for storage, and provides the language support that makes it as easy to use as the "object oriented approach" AoS. (For some definition of "as easy as" - the languages themselves are generally not considered easy to use, but within the language, treating things in either way is straightforward, at most a "flip" away, but usually not even that is needed).

Additionally, Nim macros (and I suspect Rust and D as well) allow this to be a library-level thing as well. Lisp does too, of course -- but Nim/Rust/D are much closer to the Algol family-and-friends list given in the article.
Are people actually doing science with Python or are they talking about doing science?

There's so much buggy low quality stuff in that space that I'd write a serious application in C or C++ from scratch.

It would be a custom application, sure, but not everything needs to be general.

Also, I find Lisp much more natural for mathematical reasoning.
Pretty much this^

Why should the fact that the conversation is held with a phone change things?

The arguments only holds if you forbid all recording.

Reductio ad absudum.
Orphic Cosmogony
Highlights:

- No income tax for earners below $250k and flat tax of 5-7% above

- Reduce housing bureaucracy and empower licensed engineers to certify building permits

- Solve traffic issues by building tunnels instead of new roads above ground

- Merge high school & community colleges into “Future schools” with teachers earning ~$120k

- Eliminate homelessness with assisted enrolment in housing and “future schools”

- “Partner” with big companies to find what they need to run their businesses more efficiently

- Gun safety: expand access to legally owned guns to reduce number of unknown gun ownership (training required)

- Climate change: create a carbon tax

- Close the DMV and allow DMV certified private companies to administer driving tests and training

- Create virtual IDs to replace plastic IDs

- Eliminate speeding police enforcement and replace it with speeding cameras

- Create Handyperson license and others through future schools

- All state services to accept crypto currency

- Reform welfare benefits to incentivise future school enrolment

- Increase community policing via supervised community service by non-violent criminals

- Law: increase small claims from $10k to $100k

- Legalize and tax, online and in-person gambling

- Lower cannabis age from 21 to 18 and remove some restrictions on cannabis purchases & sales

- Create transition bond to raise money to fund transition that people can invest in
There is a Nim library inspired by this blog post that simulates array-of-structs with struct-of-arrays (implemented through macros):

https://github.com/liquidev/datarray
Imagine the fun when you give gas and the display shows that your subscription can only reach 100km/h, if you want to go faster, please subscribe to the PRO subscription :)

This is/was inevitable. I really think that we will be able to buy a car whose basic features can be locked/unlocked on subscription, and I am not talking about fancy features, but basic ones like speed, types of brakes, etc. It might not be a bad idea to reduce the price of a car considering you produce only one type and customize it at "runtime". And BTW, it's somehow already the case. I bought a Ford with 100 HP and the seller told me that with "some external help" I can get up to 125HP because the engine is the same as the one for the 125HP model. I was like "what the hell?". Of course the downside is that if you get into a bad accident and the insurance finds out, you're on your own. But that's another story.

A pay as you go model would also be fun. The more you press the pedals the more you pay:)
This could be anecdotal but several of my distant family and their friends in India have tested positive for COVID even after full inoculation. I wouldn't be surprised if it's true.
As a non-observant jewish person that used to live in Israel - I agree.

It's a total nightmare.
You wouldn't want to use an event loop to wait for a mutex as it doesn't really make much sense. It does make sense to use an event loop to wait for empty/non empty events (which on a normal queue you would implement with a cond var).

You have two options: you can use an eventfd to implement the queue full/empty event, or provide a generic notification interface (i.e. a callback). Any non event loop users wiuld simply have the callback signal a futex, but it allows for more complex use case: obviously you can wakeup the event loop from the callback, but you could resume a coroutine, send an async signal or whatever makes sense for the application.
There's only one solution: Get rid of Argentina.
I don't think I'd inherently read all the conflicting reports from people as obviously mis-attributed noise. I don't think there's strong enough reason to expect everybody to response similarly to the same diets.

Not only does everybody have unique genetics, environments, and histories, but how sure are we that all the people saying they do keto, for example, are doing the same thing?

It's a giant complex mess, even if you assume humans are prefect and infallible observers and attributers of cause to effect. Which, as you pointed out, they absolutely are not. At all.

So not only do you not have the expectation that individuals will respond similarly, the difficulties in ascertaining what any individual is actually doing, you also have to deal with misattributed experiences, and the ability for our brain to play tricks on us.

And that's even assuming everybody is acting in good faith. Which they almost certainly are not, considering money can be involved.

I've yet to come up with any decent way of approaching these topics. There are so many confounding factors I don't even know where to begin.

Turning yourself into an endless experiment and figuring out ways to blind yourself and measure results (which is yet another rabbit hole...) is honestly starting to look like the most viable way to get to some kind of 'truth' for this stuff, at least for you, now. Though even at this extreme, time is limited.

Otherwise... I guess you just do what you feel like and do something different if you feel bad. If you feel good doing whatever you're doing, maybe that just has to be good enough. Because I don't know how to actually get any deeper than that in any reasonable way.
Show HN: Programmable Raspberry Pi based smart camera
Not just that, there is an awesome project to scrape webpages that do not feature RSS:
https://github.com/RSS-Bridge/rss-bridge

You can replace most of your social media feeds. I'm compiling a list of URLs you can use to replace existing services with RSS:
https://gist.github.com/thefranke/63853a6f8c499dc97bc17838f6...
I have a pinephone; it is not good enough. Very unstable; everything (apps/wm) just keep crashing randomly; I send in crash reports. And I try the latest images every month.

But yes, I think it would work. I would be happy with a phone that can run Linux desktop software with HDMI. It would need to be powerful enough (which the pinephone is very much not at all), not eat so much battery when the USB dock is plugged in with HDMI and, most importantly as you say, be stable as Linux. The pinephone feels very far removed from any of this.

Personally, I don't really care about the size of the phone; I gladly give up weight for more battery life (I will have to carry a battery anyway otherwise so why not inside the phone). I guess I would rather the (6.5inch) phone have an eInk display but plug into a screen for a full Linux desktop. But sure, there is no real money in that for phone makers as only people like me would buy them. With Android they are next to useless for me though, which is annoying as there are nice Android (eInk) phones out there if they would run Linux.
A major distinction of humans is that we are a cultural species. We have evolved to pass down large amounts of knowledge to the next generation.

Being good at communication (and motivated to use it for teaching) kind of follows from this. We are not game-changing smart at figuring out new tools. But we are excellent at copying innovations from others, remembering them and fine-tuning them over generations.

On this I highly recommend Joseph Henrich's book: "The Secret of Our Success: How Culture Is Driving Human Evolution, Domesticating Our Species, and Making Us Smarter".
> Are people actually doing science with Python or are they talking about doing science?

People are actually doing it. And a lot of it too. Both in terms of data science (as a broad term that can mean a bunch of different things) and in terms of computation for specific scientific fields like physics or biology.
> If you imagine a game that has characters, relationships, items, spells, and so on, it's often not that easy to model as encapsulated objects. Does each character have a list of other characters that they have a relationship with? What happens when you want to change the relationship, or a character casts a spell that temporarily changes the relationship? Can easily end up a mess, because it's not obvious where such things should live in >an OO model.

It's not really that hard. You just have one RelationshipManager that every Character have access to via simple public methods. OO is not so bad, especially when you forget about inheritance and use composition.
I use ConEmu on windows with PuTTY, PowerShell and CMD attach3ed as consoles to have exactly this. In fact the ConEmu setting is called "Quake mode" ~ drop down. I do all my work from my replacable windows box, and code exclusively in vim ssh'ing into whatever VPS.

So I can be viewing the website in a browser on windows, then Ctrl+~ to get my shell/vim screen, type some code, the server restarts and I can reload. Fast feedback loop. I love it!
Because we know how something can be abused until there is another way to abuse it. It's an endless way to abuse it, where a PM with an even more cynical goal will introduce an even more disgusting way to monetize a product. Finally, it's to save money on production costs and make even more money. All this thanks to software scalability, pluggability, etc etc. All you need is finally the idea, and if you have a crazy idea backed up by a graph that shows you can make 20% of profit more, that's it, done.

Eventually people get used to it. That's the main selling point, always. We are commoditizing literally everything, it's happening under our nose and we just let it happen. Until finally alternatives come and we need to pay double to have something we used to have 20 years ago (conceptually speaking, not technically) for a normal/cheaper price.

Can we boycot this? Yes, by buying products whose pricing model is old and outdated. And that's typically not the shiny one...
Show HN: An easy to use interactive star map
> You can't have both programs on your system

That's incidental and not by principle, isn't it? You should be able to have a multiple versions of a library installed, and the dynamic linker would pick the appropriate version.

Heck you could even have multiple versions in the same process (if you depend on A and B, and B uses an older version of A internally). Unfortunately I think the current dynamic linker on Linux has a shared namespace for symbols.

I also disagree that it is not useful to be able to update libraries separately. The example that I like to give is a PyGtk app written against an earlier Gtk2. Without modifications, it ran against the very last Gtk2, but now supporting: Newest themes, draggable menubars, better IME, window size grippers, and all kinds of other improvements to Gtk.

In the days of ActiveX (and I realize this is a bad example because in reality you often had breakage), you could update a control and suddenly your app would have new functionality (like being able to read newer file format versions or more options to sort your grids and so on).
>If one program on your system depends on a quirk of libfoobar-1.0.3, and another program on your system depends on a quirk of libfoobar-1.0.4, you're fucked.

Why? You can have both e.g. /lib/libfoobar-1.0.4.so /lib/libfoobar-1.0.3.so

Usually you would have /lib/libfoobar-1.so -> /lib/libfoobar-1.0.4.so, but it doesn't prevent you from linking the problematic program directly with libfoobar-1.0.3
> Somehow over the years I've found that the animals/cars analogies given in OO tutorials are one of the few places that fit well with the model.

Yes, and I've never actually needed to implement a cat or a cow in any project :)

The other thing for which OO works much better than plain data is GUIs - and I think it is not a coincidence that OO popularity exploded together with the the coming-of-age of GUIs.

The other canonical example of OO - "Shapes" - doesn't actually work well at all; It doesn't work better with "plain data", but it exposes the fallacies of trying to use OO inheritance to model the real world. Every square is a rectangle, so square should inherit from rectangle ... but, you can't stretch width and height independently in a square, so it's not really a rectangle, etc. etc.
Data-oriented programming is not hard by itself, rather as a consequence of how programming is done and what sort of flexibility you get in return.

The traditional (or should I call "inverse") approach is to define what the program should do and make it modular enough so that parts can be changed easily. For this to work well, functions are given a state snapshot to read/operator or change. Encapsulating this state into a struct/object allows functions operating on the same data to be extended easily, without having to think which functions do what, when and where they're called.

Thinking about locality though does force you to think not only about program structure, but overall program flow, which can be much, much harder to implement in a flexible fashion.

Struct-of-arrays or arrays-or-structs has little to do with it, although it's a common pattern seen when working with some kind of highly structured datasets.

Look at high-performance graphics pipelines to see how this affects the structure of the code. There's a lot of duplication which is required to handle data which is structured in a different way for efficiency, something which is not solved by just SOA/AOS swapping, but requires thinking of what data is used, what are the access patterns of the algorithm and how to pack the data so that locality is optimized. It's also harder to change as a consequence.
I made this simple interactive star map because I find that the existing programs, some of them very mighty, are a bit complicated to use. My star map contains the 300 brightest stars, the planets visible to the eye, the sun and the moon. The position data is automatically determined, the orientation is not. The star map is a progressive web app (PWA), so it works offline on a smartphone. I wrote this in my own programming language, which runs in the web browser using WASM.
Thanks, yes started reading through PCL last night, as it's online, and it's already cleared so much up for me. I'd never really thought about learning CL first until this thread, but now it feels like I've found the missing piece. And PCL is pitched exactly right, for me.
I sometimes find it hard to understand the GNOME's design rationale. When GNOME 40 moved the dock from the left side to the bottom of the screen, it created an ergonomic problem for mouse users, who now need two large mouse gestures to switch apps -- first to the upper left corner to reveal the dock, then all the way to the bottom. And in the issue thread[1], Gnome's designers seem to be carefully avoiding the obvious solution of a hot bottom edge, proposed by several commenters, which is how Mac OS has always handled an auto-hiding dock.

https://gitlab.gnome.org/Teams/Design/os-mockups/-/issues/68
We need legislation.
Good call! Will play around with this.
how old were you at the time? if you were in your late teens-20s your body might have been strong enough to sustain the pace.
Thanks for the feedback. Please see a step by step description below:

1. Log in

2. Upload a video (from your desktop or phone)

3. Watch as we create and add subtitles to your video

4. Edit & style the subtitles as you like

5. Export your newly subtitled video

We will be adding a description/demonstration soon. Did you get a chance to try the product?
Yeah, they're very much doing it.

Pandas is huge, libraries like Spacy, NetworkX, etc exist. It's a massive and good ecosystem. Python is the goto for scientific computing in most of the sciences for newer students I'd hazard a guess over the older R and Julia.

This will be blindingly obvious if you work in that area. Yes, you can do it in another language, but you're missing out on a lot of stuff that is just done and is state of the art and is fast because the speedy parts aren't in Python. The complaints about parens for lisp are superficial, but it's my experience the same same goes for whitespace in Python. They just don't matter.
Ah ... here we are again.

http://www.paulgraham.com/reesoo.html

OO is not so bad because OO is not well defined.