skysight-inc/HackerNews huggingface dataset:
Ah interesting. I think it's close enough as to make no difference, but I see what you're saying.
Oops, my bad. I didn’t know they weren’t related. Sorry
Go almost certainly would not have been as successful Without googles brand. But also, without its funding. Google has poured tens of millions of dollars in to go. all of the good qualities of go are due to its incredible funding, whether that’s tooling or the fact that three or four extremely experienced engineers were given years of time to design and implement it.
The fine[1] article.

1. Originally from RTFM -> RTFA -> TFA, so feel free to use your own substitution for F, but in this case it's a fine article.
You can shoot yourself in the foot with null pointers.
The section titled “Isn’t there a paper trail? Why is malware a risk?” explains a bit about this. The printout is read by QR code so it’s possible to list the correct selections but modify the QR code that gets read. It also addresses the percentage of voters who verify and how thoroughly (it’s not many).

“If an attacker changes only the QR code, voters have no way to detect the change by looking at their ballots, since voters can’t read the QR code. The change might be detected in a manual recount or a risk-limiting audit (RLA) based on a review of the printed text, but that is unlikely given Georgia’s weak audit requirements, which have recently been further diluted.”

Also it’s a poor decision by Georgia to not install security updates until after next election, but that’s the state’s position currently. I watched some of the Georgia congressional hearings regarding election security, audits, and safe guards after the 2020 election and it seems like their board of election was a total shit show. It seems like paper ballots and counting could prevent all of the problems or alleged problems they experienced in the last two major elections.
Weekly Code Confessions Digest #2: News, and Resources from Last Week
The US needs them in Chicago, Detroit, New Orleans, Philly and LA.
I believe so - most (all?) string functions have an mb_ equivalent, for working on multibyte strings.

Regular PHP strings are actually pretty great, since you can treat them like byte arrays. Fun fact: PHPs streaming API has an “in-memory” option and it’s… just a string under the hood.

Just don’t forget to use multibyte functions when you’re handling things like user input.
Underage Enlistment in the United States and the Confederacy
I remember bookmarking this site years ago, nice to see it here. The about page says it was founded in 2005.

https://cloudappreciationsociety.org/about-us/
Any project, whether it's a "rewrite" or not, can succumb to scope creep and poor project management.
We also just didn't have any good ways of driving such high PPI displays until recently without having to resort to janky hacks like dual cable setups (and the lines down the middle that those tend to have).

A lot of laptops still don't support HDMI 2.1, and DP 2.0/2.1 only just came out (and I don't know if any displays are using it yet). There's also the bullshit the HDMI forum pulled where they relabeled HDMI 2.0 as HDMI 2.1 (years after HDMI 2.1 was out and established as "the one that can do 4k120hz no chroma subsampling" (a lot of implementations were around 40Gbps instead of the full 48Gbps because it was cheaper, and they didn't need the full 48Gbps for 4k120hz 10bit)), despite them having hugely different specs.

Displayport 2.0/2.1 is also a clusterfuck because they decided that it would max out at either 40Gbps or 80Gbps depending on the implementation (DP40 and DP80), and companies don't generally tell you what their implementation actually supports.

Macbook Pros only got HDMI 2.1 this year, iirc base and airs still don't have it. Intel iGPUs only do HDMI 2.0 and DP 1.4, AMD's Zen4 laptops can do HDMI 2.1 and DP 2.1 (idk what bandwidth). For dGPUs, AMD's 6000 series is HDMI 2.1+DP 1.4 (but there are issues with DSC), while 7000 series is HDMI 2.1 and DP 2.1 (DP80). Intel Arc dGPUs are DP 2.0 (DP40) and HDMI 2.1. Nvidia's 30 and 40 series are HDMI 2.1 and only DP 1.4.

edit: Also, people don't realize just how fucking huge an 8k framebuffer is, and you need multiple for a swapchain. Even for just basic 8bit colour you're looking at ~133MB per framebuffer.
You track them, obviously. Then it's mutually assured privacy destruction.
I think there is actually a pretty common consensus that returns diminish at ~220 ppi, i.e. what Apple calls "Retina."
I don't have a good guide. I had to just start getting my hands dirty and piece it together.

My strategies:

- keep the documentation open

- install nixos in a vm

- search github for "configuration.nix" to find fully worked examples for nixos. I just cloned anything that looked useful[1] and would grep through it

- read the source code for nixpkgs

- search google and search https://discourse.nixos.org/ when you have an idea of what you want to do to find other people discussing it

It took me a couple days to have a very basic system running and a month to port most of my setup into nix (running some containers, overriding system packages, defining my own packages, running unmodified binaries using nix-ld).

I still use non-nix containers for a few services that I don't want to port over (but if I had known nix when I started I definitely would've used it).

Every step of the way was a huge struggle but the tools I have learned stay useful so I hope it is worthwhile investment. Still sometimes the extra nix friction is really frustrating but I can't help but think Nix or something like it is inevitably the future of software.

[1]: here is my random current list with some good and some bad...
https://cgit.euer.krebsco.de/stockholm/ https://github.com/9ary/dotfiles.git https://github.com/baitinq/nixos-config https://github.com/barrucadu/nixfiles.git https://github.com/catern/dotfiles.git https://github.com/contrun/infra.git https://github.com/disassembler/network.git https://github.com/juliosueiras/rasp-nix/ https://github.com/KFearsoff/NixOS-config.git https://github.com/lopsided98/nixos-config https://github.com/Mic92/dotfiles.git https://github.com/moul/nixpkgs.git https://github.com/musnix/musnix https://github.com/myme/dotfiles https://github.com/nix-community/emacs-overlay https://github.com/nix-community/home-manager.git https://github.com/NixOS/nixos-org-configurations.git https://github.com/reckenrode/nixos-configs https://github.com/skogsbrus/os https://github.com/Xe/nixos-configs.git https://github.com/Xe/site.git https://git.immae.eu/perso/Immae/Config/Nix.git https://gitlab.com/pgronkievitz/nixos-configurations.git https://gitlab.com/rprospero/dotfiles.git
Well now thanks to these guys the powers that be have a crystal clear development road map for locking in the next elections. Ever notice how nobody ever actually cares about patching security vulns in voting machines? It's always lip service and inconsequential paid studies forever and ever.
Reddit restored the last 6 months of my comments after I deleted them
Three thousand years of river channel engineering in the Nile Valley
You can find a gun to shoot yourself in the foot in any language.
Recently watched the Ken Burns documentary about the US National Parks - really great. As in this example, it's remarkable how much private money (John D. Rockefeller for instance) was donated to divert these beautiful places to the public.
5k (5120x2880 resolution) on 27" monitor makes difference for text. It looks crisp clear on 200 PPI, much better compared to 4k.

I still use HP Z27q bought in 2016. I wonder why the industry has so few offers for 27" 5120p monitors.
I think a lot of people are simply anxious and have trouble making long-term commitments, and conflate that feeling with this abstract idea of readiness. No one is "ready" to do something for the first time including child-rearing.
I think desktops need at least >200.
TPDb alleges Python HTML parser a violation of TOS
Are you saying naps lead to staying up later? I haven’t notice that to be the case. Naps don’t seem to affect my normal sleep schedule much.
I might have used incorrect terminology but what I meant in my previous comment is that it should be obvious when the right hand side is evaluated.

If a function has type declaration `f :: A -> B -> C` you would expect that its body only gets evaluated when two arguments are actually supplied. So evaluating the function itself using `seq` doesn't do anything. Nor does partial application of a single argument.

To be absolutely clear, the expressions `seq f (putStrLn "hello")` and `seq (f undefined) (putStrLn "hello")` should both not evaluate anything and cause the string hello to be printed rather than raising an exception.

However you can make it otherwise. That breaks the user's intuition about evaluation. Most of the time it's not a problem at all; I just personally don't like it and prefer to be more explicit.

This often occurs in cases where the above hypothetical function `f` requires an intermediate value that's expensive to compute but only relies on the first of its two arguments. Then do you evaluate that expensive intermediate with a partial application of a single argument, or do you not? Neither is satisfactory and so this problem is best avoided.

In your trivial example `reverse . sort` the compiler will inline the dot operator and make it `\x -> reverse (sort x)` and I have no issue there.
> Each 775-ton flywheel can spin up to 225 rpm and store 3.75 GJ,[47] roughly the same amount of kinetic energy as a train weighing 5,000 tons traveling at 140 kilometres per hour (87 mph). Each flywheel uses 8.8 MW to spin up and can generate 400 MW (briefly)

Does that mean that the 775 ton flywheels could come to a complete stop in less than 13 seconds if fully used up?
It does feel like mostly google backing (other aspects are important as well). Imagine if google would be behind ie. Crystal - you'd see it everywhere.
Because 4k (and even 1080p) is good enough for most people?
> Besides that, you can't get HTTPS for these domains (without the mess of a custom CA and even then you'll run into CT issues)

Of course you can, you just cant use HTTP validation for it. Use DNS validation and it works fine.
> In my 25 years of writing shell scripts, they've nearly always been for automation on a specific OS where portability is not a concern.

I've written hundreds of scripts for Busybox for Windows (https://github.com/rmyorston/busybox-w32), Linux bash and macOS zsh. POSIX compatibility means a lot.

WRT the specific concerns of arguments: if you are doing something complicated, use Python. ChatGPT writes it better anyway.

In my experience, more complex scripting is reinventing Gradle, Ansible, Terraform, YAML & similar.
I don’t know about that. Charter commercial airline flights have worse safety records than other airlines. Often those involve pilots who are close to the business end of things and make poor choices because of it, even if it presents them some personal risk.
Pretty sure I saw this in the Apple store.
The Federated App Problem has already been solved a couple of times using replicated gossip networks of signed messages. Sometimes they use append-only logs, other times they use only relays, and the implementations are all highly creative and experimental.

The trouble with decentralized federation social media servers is the weight of the network falls upon whoever volunteered to host the program at the domain name in the first place, and sometimes the weight is too much to handle.

The solution is, as we all already know, self-authenticating messages that do not rely on any one server. Do we want to call this Scuttlebot? Do we want to call this Nostr? Does Bluesky even qualify? Well, I'm sure we'll figure it out eventually with enough minds trained upon the problem.
Nah, i have recently seen some dude mirroring Usenet posts in his gopherhole... granted, its not posting, but still..
As a kid, our Sony trinitron also ended up having burn-in due to leaving it on with a fixed NES game screen. Fun cycle.
Demo != coding
Nepal introduced limits on the number of permits it will issue recently, because there’s more people who want to climb Everest than it can safely accomodate each year.
Thurgau says, „GTFO.“
I don't know if they're popular at my work but they're certainly popular in my car.
Show HN: I made a landing page am I doing this right?
Full write-up explainer blogpost here: https://dayvonjersen.com/blog/announcing-dj.exchange

Maybe I should have linked that instead of the landing page???

What do you think I'm new to this :)
> In Go, you are always forced by the language to return a value of type "A or B, including both or neither." The consumer isn't any more in control, it just has to guess whether "both or neither" are possible return types.

it does not have to guess

convention dictates either one or the other

is convention enough? is it roughly the same as compiler-enforced rules? you're free to say "no" but it is not like a guarantee
Makes sense to me; I like to listen to a podcast while falling asleep. I bet you could also find nice background noise YouTubes, rain and whatnot.
Because there is active search and rescue happening, a much lower tech solution is to use dye. But even that presumes a canister on the outside that can be activated from the inside and which will survive the depths of the dive. In retrospect perhaps something that does that automatically if not disarmed after a certain amount of time.
Carmack is on twitter.
I found it really funny, it actually made me laugh out loud. It seemed very deliberate to me, though, so that's why.

Edit:

To clarify, I think DHH would probably laugh at this as well, which is why I feel it's not so much laughing at anyone as it is laughing with them.
Running a printer off a 2000W gas-powered generator, it always gives me a little chuckle to hit print and hear the engine rev.
I would guess that returns diminish a lot earlier, and just stop to matter entirely at around 220.
> you can't get HTTPS for these domains

What are you talking about? Certificate insurance and DNS A/AAAA records are entirely decoupled. Use the ACME dns-01 challenge to get a cert for domains resolving to anything, including 127.0.0.1 or ::1. Alternatively you can even use http-01 or other challenges to get a wildcard cert, with subdomains pointing to localhost. I use Lets Encrypt certs for localhost and LAN every day.

Edit: a little more precision.
Wouldn't you want a portrait mode monitor for your PDFs? I read them on a 24" UHD portrait mode display. It is so nice to have the PDF page fill the display so I don't have to scroll within each page.

Of course this doesn't solve the problem of reading them in bed! Or would it?

At least in the LazyBoy you could have a portrait mode monitor on an Ergotron arm and that would work pretty nicely?

I wrote about this in more detail here:

https://news.ycombinator.com/item?id=36179132
There's lots of research about bi-phasic sleep. It may not be so bad to get 6 hours at night and another 90 minutes during the day. That's 5 REM cycles.
I agree 4k is enough for TVs, but not for computer displays. 27"@4k still looks pretty bad on a desktop display. For desktop display, 220 ppi (27"@5k or 32"@6k) is perfect.
That's true, but those "alias records" are created as a sub-resource of the DNS Zone parent resource.

In Windows Server Active Directory integrated DNS zones, the records are registered and maintained by the computers themselves. So if a server is assigned 10.1.2.3 as its IP address, it'll register itself in DNS without someone having to go into the DNS Server and add an alias record for it.

Similarly, certificates shouldn't be "under" a Key Vault, they should be linked to the DNS record.

It should all work like DHCP + ACME as seen in Let's Encrypt. Within a single cloud, there's no need to emulate the traditional system boundaries.

E.g.: If I create a virtual machine with DNS name "foo.bar.com" and a public IP address of "1.2.3.4" it should register itself into that zone, and then un-register itself if the VM is deleted. It should also get a matching certificate (for free!) without any TXT records or manual steps.

Weirdly, some things already work this way, inconsistently. Azure Front Door automatically issues certificates. App Service auto-registers itself in DNS, mostly. Virtual Machines can register themselves for Private DNS Zones, but won't get certificates... unless they're AD domain joined and have an Enterprise PKI available.

It's such a mess.
Bill Hammond, the Engineer Guy on youtube, has a video on the design and engineering of the aluminum can with a brief clip of someone standing on a can (around the 7-8 minute mark).

https://m.youtube.com/watch?v=hUhisi2FBuw
Go's error handling is a horrible mess:

1. It's easy to ignore returned errors without any compiler warnings. You have to rely on third party tools such as golangci-lint to report missing error handling.

2. Errors don't carry stack traces with them, you have to rely on third party libraries or custom errors to get that functionality and you will only get it for your own code, not in other libraries you are using.

3. It's unclear who should add context to error messages is it the caller or callee? Usually it gets skipped, leading to useless error messages.

4. Errors are untyped. If you want to decide based on error types, you have to use errors.Is or errors.As, which, surprise, is roughly as expensive computationally as panic-recover. (Source: I did a performance tests on this with Go 1.18) Go might as well add a simpler way to create exceptions. (I wrote a prototype library to that effect a while ago: https://github.com/APItalist/lang )

5. Error messages are too terse and hard to read when using the recommended semantic of "message (cause(cause(cause)))". I'd rather see stack traces, that's much more useful.

6. Most loggers are globally scoped and cannot be injected into code, leading to an all-or-nothing approach. It is not uncommon that you have 3-4 logging libraries as dependencies, which you need to configure separately (if you even can). Also, good luck securing this mess.
long time windows user that switched to mac due to Apple Silicon dominance on the laptop experience.

This, 1000x this.

It's utterly bizarre that the window management paradigm is "let 'em all stack up and make it easy to spread 'em all out"

At first I thought I didn't get the paradigm. Now I get that I don't get the idea behind the paradigm.

Rectangle (pro version) fixes some of this and adds some really cool features. And because of the Apple app hegemony, it does work nearly OS level good. But why, oh why does this have to be 3rd party?

It's like some any UX pattern baked in since Lisa?
There's a difference between working an honest manual labor job and being a thief.
Traditions emerge from "other reasons". There is probably not enough excess buoyancy to open the hatch without flooding, so without external support you're dead anyway.
Are you saying that the primary issue is that for each federated service we need a separate account / instance for it as opposed to email which is just one email account? I don't disagree with that but it's the same situation for Reddit, YouTube, Twitter. I have to maintain separate accounts on those platforms too.
Yes, I meant self-checkout machines.

> The only reason it's not good is that it's not automated enough (if at all -- for me the self checkout machine is literally zero automation more than a regular cashier)

That's the point. But you are not the buyer of that automation, the store is. That automation displaced human cashiers and lowered the quality of service for customers, while generating better margins for the store (promptly eaten by competition). From your POV, i.e. customer's POV, it's not automated enough - but it's not going to be for quite a while, because there is no incentive to do it. The store doesn't stand to benefit much from additional automation, not enough to justify investment. Whether or not customers like it is irrelevant, as long as they're still coming in anyway.
>The discussion opened to say that Result is better than the pattern used in Go

You are trying to paint a false dichotomy between Rust's Result<T, error> and Go's (T, error). In reality the dichotomy is between sum types (which Result is a very simple case of) and languages without sum types, of which Go is one of a very small set. The key difference is that Result is available as an option in Rust/Haskell/Ocaml/etc, and I'm free to not use Result if it's not the right fit, where in Go the only option is to use a product type.

Result<A,B> and the ? operator are shortcuts for concisely handling the very common case of handling "A or B, but never both or neither." If your producer doesn't fit that, you're free to define your own sum type. In Go, you are simply unable to represent these and must cover all four cases (or eight, or sixteen, or thirty-two, etc, as the function grows in complexity).

Nothing I'm saying is specific to Rust either, despite your appealing to conspiracies, and Rust's ideas are not new, not by decades. Haskell, Ocaml, Java, C++, typescript, etc, (even C with a bit of squinting) all have basic sum types and can encode "A or B, but never both or neither" and "A or B or both, but never neither" in their type systems and control flow in a way that Go cannot. Rust didn't pioneer the idea of a basic sum types, Go is just uniquely (among popular statically types languages from the last 50 years) incapable of representing them.

>So, in other words: Dependent state puts the producer in control, while independent state puts the consumer in control and that there are pluses and minuses to each approach, with neither being better, just different tradeoffs...?

No, this is complete nonsense. In Go, if I never write "return nonNilFile, nonNilError", the consumer cannot magic that into existence. Your entire position about languages being consumer controlled vs producer controlled is entirely nonsense. Consumers cannot rewrite the code of the functions they call.
> It just highlights to me how the job of "programmer" can be many things, depending on your domain.

Agreed, though I'd argue different languages entreat different kinds of knowledge. That's why there's value in having experience in many.

> One could argue that a goal of programming is to build higher abstractions so you don't need to manipulate bits in order to express yourself.

Could be; though I'd argue just because those abstractions are there, it's still good to know how and why they work. That reveals some things about the language which I think influences the subtle choices you make every day.
I always learned you should either sleep 30 minutes or less, or 90 minutes or more, to prevent waking up in the middle of REM sleep and feeling more tired than when you started.
I don’t disagree with the idea that code-switchers introduce new vocabulary to the general public at all, in fact, the two terms describe a word or phrase at different phases of its journey to integration within a language. In other words, there exists a point in the history of the language or dialect, the use of word or phrase ceases to be code-switching and becomes widely accepted as imported vocabulary.

There is a distinction, however, that not all words that are used via code-switching are going to become part of common enough vernacular that it would become accepted within a language, and likewise, there may be cases where loanwords do not enter a language via speakers that code-switch it into their daily vocabulary.