skysight-inc/HackerNews huggingface dataset:
I started thinking about this a few months ago when I voted by email as an overseas voter. Essentially, our state has an online-to-offline process to convert digital votes to a PDF that can be emailed or faxed, then printed and processed like any other vote.

We could immediately open this system up to every American with a small number of technical & legal changes.

Most of my thoughts about a more complex system are probably not unique, but thinking about this generated a few details that may be interesting.

The obvious final conclusion (for me) was that we could digitize our entire system in a few election cycles, without throwing out the entire system and starting over.

Just 1. Set minimum requirements federally for voter registration systems, 2. Create digital tools for creating and tabulating votes (form to PDF software, public ledgers), & 3. Allow everyone to cast a digital vote which can be converted to a normal paper ballot.

Then, at some point in time, you reverse the system, and make your digital ledger your source of truth, instead of your paper ballot counts.
Looking for art? Here is a list of UI designs built with flutter
I was quietly thinking that as well these past few days. You see, my last submission on HN hit front page and was on the matter of consensus protocols. After that either my awarness on the topic increased or the frequency of postings about it did.
If you want an easier to use web framework, might I recommend Rocket https://rocket.rs/k
Well for one, 538 gave Trump 10% at the lowest, which is quite a bit better than 4% by CU. Also, putting Florida aside, everything else so far has been well within the error margin, even if the overall mean is 3-4 points shifted towards Trump. I'm not an expert, but that's the whole point of confidence intervals. Polls will never be accurate, but it's about using the right uncertainty, and also mixing uncertainties properly.

EDIT: Let's look at a few of the tipping point results from 538 [1]

Florida: 50.9/48.4 -> 47.8/51.2 (2.8 diff) [99% reporting]

Arizona: 50.7/48.1 -> 50.7/47.9 (0.1 diff) [86% reporting]

Texas: 48.8/50.3 -> 46.4/52.2 (1.9 diff) [85% reporting]

Georgia: 50.1/49.2 -> 49.1/49.7 (0.7 diff) [98% reporting]

Minnesota: 53.7/44.6 -> 52.6/45.4 (0.9 diff) [99% reporting]

It's also worth noting that a lot of these are still at 85-95 percent reporting, so it's not over, but yes I don't see anything that's very off, even Florida that was so off was only 3 points off. I do consider 3 points to be well within the toss-up category.

[1] https://projects.fivethirtyeight.com/2020-election-forecast/

EDIT2: I think the main thing that surprised people is how in some places, mail-in votes came first, whereas in some other places, mail-in votes are coming much later. This really skews the early data but as things settle, everything is coming much closer to the predictions. But this is something 538 and others have been warning about since May or earlier.
> What if a double-click is blocked by default

I agree this would be a more sensible behavior for form submission, but given that ship has long since sailed: https://xkcd.com/1172/
Yes, I suspect most pollsters are Democrats, and are not aware of how they come across to Republicans.

So they think they have a representative sample, but they really don't.

It can be explained simply by pollsters mainly living in large cities, and not really understanding rural Americans.
Refuse to buy a car with an internet connection that can't be permanently disabled. Do not do it.
WebAssembly doesn't grant any extra permissions into the inside of the browser sandbox. Audio and canvas HTML elements already exist and don't have any innate connection to WebAssembly. (If you ignore performance, WebAssembly could be entirely polyfilled into old browsers that didn't support it through a Javascript interpreter.)
> but that's the whole point of confidence intervals.

That would make sense if some parts of the country had errors one way, and others another way. i.e. random error.

But if every part of the country has an error, all in the same direction, then there's something larger going on.
Even with inlining and escape analysis to remove unnecessary boxing, unboxing, and heap allocations, most Java programs still do a lot of pointer chasing. All of that (often poor locality) memory traffic tends to hide the overhead of unnecessary register moves and even some unnecessary register spills.
The proposed solution (an HTML attribute to 'allow' double-click submissions of <form>s) is backwards from how the standard would be updated.

The proposal should instead be for an attribute that prevents double-clicks, because that way browsers that have not implemented it still behave correctly. Additionally, you don't "break userspace" for millions of forms online that no longer work as the developer intended.

However, I'm skeptical that we need to encode this at all into the standard, since setting the `disabled` attribute on the submission button after submission is pretty much test case #0 of any serious online form development.

Amusingly, things have gotten a lot better since 2015 when this was written. That blob of JQuery is now replaced with binding the `disabled` attribute to `isSubmitted` state on your React-based webform. An interesting glimpse into the web-that-used-to-be.
The processing time of applying in the store would be enormous there's a reason very few stores still use the price sticker gun to label items, it's time consuming when there's already a tag on each item.

Also in a number of places walmart and other stores literally just open a box provided by their sources and place it on shelves.
This was a really satisfying use of pyparsing
> I would argue 538 made a similar error[1], but unlike Gelman, Nate Silver is a less likely to admit their model was off, and consequently examine/discuss the underlying factors that lead to this issue.

Why do you say this? He did plenty of writing on what he, the site, and the whole industry got wrong in 2016 for Trump's win in both the primary[1] and general[2][3].

I really don't understand the hate Nate Silver gets from basically all sides.

[1] - https://fivethirtyeight.com/features/how-i-acted-like-a-pund...

[2] - https://fivethirtyeight.com/features/the-real-story-of-2016/

[3] - https://fivethirtyeight.com/tag/the-real-story-of-2016/
> ... we can’t be so happy about having issued that 96% win probability. Our model messed up.

As it stands now, that sounds pretty good, however we have to wait for the end of the count of course.

And in general, I am a fan of not overly editorializing mathematical output. Nate Silver made on his podcast today the point that the popular vote polls look quite good right now, because mail ballots in very blue states like NY are still be counted. However, I kinda enjoy how the forecasters are beating themselves up right now, even if I think that is probably somewhat premature right now.
Interpreting JSON is a good concrete example.
But I wonder if that hints at that sum-types are mostly good for writing interpreters (and compilers).

Another good example mentioned is nullable types. It seems null is so important that many programming languages have built-in support for it. So it seems null-types make null unnecessary. (?)

I can also see that sum-types are useful for modeling data. But are there any (relational or otherwise) databases which have support for sum-types?
> why does anything needs to be open source in the first place?

Not advocating FOSS approach for anything, and I'm not strictly speaking of GH in that context, but generally, malicious code loves being hidden into closed source software since it's the best effective way to keep it hard to control and correct.
When privacy, security, safety, accountability become important, the FOSS approach might solve a problems or two.
Of course the downside is that everyone can look at it, so building a billions worth business out of a fork + 10 line changes + renaming of a FOSS project cannot work without violating the license by keeping it closed.
I'll admit it. I voted for Trump.

Why?

Here's what happens when you live under real Democrat policies. Gunfights. Knife fights. Fist fights. Not far away. Right outside your front door. All crimes of opportunity. Meaning if they see you, you get it. Prison is safer. I'm here because they came after my family. 5H. Investigations. They are not fair. They are not your friend. Wealth soon will protect you as much as a prison commissary account will. And I'm the psycho, huh.

Concerning the article, let's recap what his political opposition did to win, mostly international corporations loyal to no one but themselves:

Corrupted the FBI

Partisan impeachment

Collaborated with Communists to unleash a biological attack

Committed hundreds of nationwide riots and arsons

Mail in bailout scam, and keep counting the vote

And wow. Big surprise. They juiced the polls to help with messaging. Must be life and death for them. Glad I can do the math.

No more smiling celebrity to hide behind anymore. Now they just have bullying. You break it you bought it.
Why not use something like Webrtc? You’ll be able to use a native decoder + seek to the nearest key frame.
I'd love to use this (and probably will try eventually) , but the try.typedefs.com[0] example is hard to penetrate.

; Booleans correspond to a sum of unit types.
(name Bool (+ 1 1))

I'm familiar with Lisp/S-Expressions, Haskell, ADTs and this still threw me for a loop, even with the generated Haskell code on the right. Why have you chosen terseness at the cost of approachability? Without looking at the intro page[1], I couldn't figure out how in the world this syntax created a boolean type. Here's my thought process:

- OK, we're making a name (I guess that's a type? why is it not called that?)

- "Bool" -- OK we're making the haskell Boolean type

- "(+ 1 1)" -- What? Bool is 2?

- (At this point I looked over to the right at the Haskell code, read it to discover that it's 0/1)

- Oh OK, '+' must be sum? but why would I sum 1 with itself? is it a 1 and 1? 1 must not be numeral...

At this point I went back and read the introduction and it was clear but please, don't point people to the try page without giving them a brief syntax intro. That, or change the syntax to actually be a bit more approachable -- why not `unit` instead of `1` or `sum` instead of `+`? At least the option would be nice..

I wonder if there's been consideration of leaving some space/ability for people to add custom implementations/overrides for some of the translations? Less so in the Haskell case since it just compiles to something byte-encodable, but I don't want booleans in my JSON to be represented by {"case0": "singleton"} and {"case1": "singleton"}. I know this breaks the purity and generality of the solution but if it's going to see real-world use I think this complaint will come up.

Also, there's the distinction when structure is included or not -- it looks like there is a discrepancy between haskell and jsonschema in that one is structure/schema included and the other is not, is that intended? Any client can read the JSON schema, but not any Haskell client can read the haskell code -- AFAICT boolean is just... 0/1 sitting in a byte stream, untagged. I guess this is another thing that goes against the generality and purity of the solution, but I sure would like to be able to have tooling that can tell me I'm dealing with Product type containing two bools... I tried it out:

; Booleans correspond to a sum of unit types.
(name Bool (+ 1 1))

(name BoolTuple (* Bool Bool))

The code that came out on the haskell side looks like this:

-- ... snip ....

encodeBoolTuple :: Serialiser BoolTuple
encodeBoolTuple x = case x of
(y,y0) -> mconcat [(encodeBool y),(encodeBool y0)]

decodeBoolTuple :: Deserialiser BoolTuple
decodeBoolTuple = do
x <- decodeBool
x0 <- decodeBool
return (x,x0)

So just... two 0/1s on the wire and that's it? Efficient yes, but I think it'd be nice to be able to tell I got handed a tuple with 2 elements (even if I don't necessarily know they're both booleans, though it'd be nice to know they were a well-known boolean type).

[0]: https://try.typedefs.com

[1]: https://typedefs.com/introduction/
Biden might still pick up GA, AZ, PA and NV. That would put him over 300 EV. I think it is too early to say just because some states broke the other way and it feels like something it might not be.

Popular vote margins will also change once the big blue states finish counting which might take a while.
I worry a lot about this but if this is the price of competing with the Google/Apple duopoly maybe it's worth it.
That’s cool — I’ve built something similar in the past: https://github.com/typed-wire/typed-wire
Why would a candidate engage in criticism of their own party, when that is the surest way for the candidate to get primaried? Our two-stage election system does not reward self-criticism. Consider how that might change if voters were allowed to vote in all parties' primaries, at the same time.
What they're probably thinking of is buying land, which you can lease or pay to have tended. Getting into this market is understandably more difficult; if it was easy free money everybody'd be doing it.
"please use the original title [...] don't editorialize"

https://news.ycombinator.com/newsguidelines.html
The number of states is irrelevant. An optimized tail call is achieved with, exactly, a single branch instruction.
Imagine a simple, digital, public ledger:

1. Each existing voter registration generates a unique, anonymous identifier. They probably already do, you just have to standardize it and create an API to verify it. Cryptographic verification solutions would improve this even more.

2. Create a simple, open source public ledger with an open API. Something where any software that knew enough of the voter registration details combined with that identifier could submit or update a ballot.

3. Give voters multiple systems for voting, to ensure everyone has access to a system that meets their needs. No reason to restrict who can create a system, just set federal minimums for each of this systems & let any tech company build a competing app.

4. A public / private key signature process could be used to ensure the validity of both a "local copy" of the vote stored on the user's device, and that the vote was cast, for future auditing. You could create APIs for validating a vote.

Once you get everyone a unique voter registration identifier, Voters could download the database and use simple tools to audit their vote as part of the final, public count. Any irregularities would be publishable and verifiable.

Independent groups could use samples of volunteers (who would essentially agree to publish their voter ID & local copy of their choices for that year) to further validate the integrity of the result.

You could even plant fake votes that cancelled each other out to facilitate an audit.

I'm sure there are details I'm getting wrong (like how to protect someone's identity in a world where all your voter registration details are able to be purchased in legal and illegal markets).

My only point is, anyone could start working on this kind of system as an open source project, validate it works, and start "patching" our existing voting processes with more accessible or more efficient digital replacements.
This is well thought out, especially the “Omissions” section that explains what’s not in scope. I wish they had defined a constraint for types that have a usable zero value that doesn’t immediately blow up (like maps and struct pointers).

> That may in turn lead to pressure to modify the language to add some mechanism for using an Iterator with the range clause.

Yes please, there’s so much grammar that just refuses to support any user-defined type.
Or I see this a lot from people who live in an apartment with no yard or balcony who really just want a small garden.
and 0 way to do a lot of things
The polls didn't mess up, the election did. Gerrymandering and vote suppression has been eating at the heart of American democracy for decades. Your survey of "likely voters" now needs to take into account the probability that a respondent will show up to a polling station to find broken voting machines, that their ID is no longer acceptable, or that their mail-in ballot will be "lost" in the postal system.
> i.e. random error.

Did they say that their confidence interval was confidence against random error? I don't think that's a requirement of a confidence interval, I think it's certainly valid to encode e.g. the chance of "shy Trump" respondents in a confidence interval.
The results of state elections aren't independent. The problems that cause most errors are going to exist in multiple states and cause the errors to be correlated.
cbt and mill are just obvious scala code
You’ve given up on data consistency entirely, which is a significant problem with micro-services in general.

Do you run DR tests? I bet $TEXAS you will have orphaned relationships as your data stores will be restored from different points in time.
I don't think it's expecyed the errors would be random: that the polling errors are correlated and not random is something that Nate Silver talks about at length as part of the key interpretation error that others made in 2016.
I think that's a great criterion to use when choosing a language
Isn't there a difference between sterilization, and genetic intervention, on potential unknowns?
I am not saying that the first one was entirely safe, but explicit gene editing seems to be much more risky than sterilizing.
Show HN: GUI apps in Node.js with smaller bineries
Couldn't agree more. If this election is shocking to you, you may want to forcibly try and exit your own bubble. Read media you don't frequent - I recommend Quillette and Reason for an alternative yet logical perspective. Stop eating what the mainstream media feeds you without any analysis. I had been telling my family and friends for months that Trump might pull this out, and they were shocked (once again). There is a huge world out there beyond Twitter and the NYT.
Noted. However we could remove the question entirely by limiting advertising/funding for propositions. I realize that's a short answer to probably a long question, but I'd like that experiment.
I like the look of that.

There's a few things I'd like to learn but I'm finding I have less and less time to invest in possible dead ends. I'd like to just throw money at the problem and book in time with someone to get me up to speed in things.
This allows Ring owners to opt-in to allowing a live feed to police. I’m pretty sure that works around that sort of issue.
No that says nothing about the polling just your model. 538 had an interesting page where picking a state would influence the model and change what other states where predicted to do. But I can’t seem to find it now.

Figuring out the dependencies between demographics is how you come up with a useful model rather than just simulating everything independently based on raw polls numbers. Aka Michigan and Wisconsin have a lot in common where Florida is influenced by wildly different racial, demographic, and economic factors.
> But when the vast majority of polls in Florida showed Biden in the lead, and then Biden lost there by a few percentage points, that’s a polling error.

What went wrong in Florida shows up clearly in the results for Miami-Dade county.

The Biden vote in that county was way down on the results acheived by Hillary Clinton and that then meant Florida was lost.

And in my opinion this shows exactly why polls can go wrong.

In the last days of campaigning Trump ran hard on the idea Biden was a communists, hell bent on turning America into the next Cuba.

That theme resonated strongly with the Cuban-American population of Florida.

I suspect in the early days of polling that Trump fear campaigning was just simmering away, having little effect.

But it really came to the boil on election day.
I'll try to explain why.

Your comment amounts to "Github's security team should be making sure the dependencies in their Gemfile don't have vulnerabilities". Which is an obvious and pointless statement, yes, of course github's security team should make sure github's code doesn't have vulnerabilities. That's the most important duty of their job.

The fact that the Gemfile has been leaked changes nothing about what the security team should be doing.

Your comment doesn't really contribute to discussion because it's not presenting novel information, and it's misleading because, per the reasons above, their security team's priorities goals/responsibilities/behaviors/etc aren't really impacted by this, and your comment sorta implies otherwise.
Wasm has a pretty simple execution model, wouldn’t be hard to write something that preprocesses wasm code during load, similar to what you can do with java classloaders.
Unpopular opinion: these things are big enough to be a decent snack. Pumpkin spice roast murder hornets, anyone?

* may contain stingers

edit re child comment: unpopular in the US and Canada, I guess... bugs are yummy and crunchy, y'all. Or... they're crunchy with little flavor so, pumpkin spice that shit
Looking from outside it's an horror show. No voter ID, no physical marks on person all ready voted. Most bizzare is the mail ballot how do you even trust those.
> More studies showing the same results means they aren't suffering from the replication crisis, even if the exact same study isn't being replicated.

Not specific to CBT, but as a general point, replication crises are behind the scenes. Publication bias means only positive results get published, even if it's only the occasional lucky studies (or ones with overt cheating or innocent bad statistics) which come out positive. Researchers know about it and grumble privately, because they wasted months or years of effort before figuring out it's largely false. But this knowledge isn't generally what goes into archival publications.
I was referring to birds that eat mosquitoes and other insects potentially getting something analogous to a food allergy.

Note that only female mosquitoes bite - blood is a necessary component for their eggs to form.
Correct, and it is at least important for the people to realize that.

When moderates and centrists can only be found way passed the downvote threshold for visibility, when the reality is that they are the only ones listening to the spectrum and can perceive what's going on, saying the least inflammatory things, but are perceived as a false negative by both parties because they don't sound like a party member.
Now maybe someone will actually make a "hack" with a UI that looks like this...

https://pbs.twimg.com/media/De17PIKXUAE27W6.jpg:large

...and show that making it work in any browser, even text-based ones (as far as possible), is not hard.
See this[0] for an example of just how bad GitHub's UI is at presenting impersonated commits.

[0] https://news.ycombinator.com/item?id=24977398
Show HN: Toy Haskell blockchain with variable hash functions for ASIC resistance
You can't fool HN though!
>> Some people think RIAA’s DMCA notice is not legally valid, arguing RIAA is not the copyright holder and there is no infringing material.

> DMCA takedowns do not need to be from the copyright holder themselves. They can be from ANY authorized agent of the copyright holder

I think it's clear that "RIAA is not the copyright holder" is shorthand for "no member of the RIAA is the copyright holder". Even if you don't accept that, you can easily deduce that no member of the RIAA is the copyright holder by looking at the immediately following claim, "there is no infringing material".

Given that there is no infringing material, it can't really matter whose agent the RIAA purports to be.