Shoop

Part of this has to do with the fact that it is not possible (without tricks) to have multiple different typeclass implementations for one type in Haskell (I believe Rust also has this restriction). This language restriction has the tendency to seep into people's way of thinking about monads (and other typeclasses). However, it is not fundamental that a typeclass (or other ad-hoc polymorphism) system has this restriction.

That being said, the language design problem of how to support multiple different typeclass implementations for one type is actually trickier than you'd think. For example, it's easy to fall into the diamond problem if you don't have instance canonicity. If you're interested in how this problem can be solved in practice, check out this lovely paper about Modular Implicits in OCaml [1]. The paper is quite accessible if you have some FP background.

[1] https://arxiv.org/pdf/1512.01895.pdf

I think this partially answers your question: One thing people try to do to "fix" the incompleteness is to just add the Godel sentence as an axiom of the mathematical system. However, each time you do this, you can create yet another new Godel sentence for the new system with the new axiom. Since it's a diagonalization argument, no amount of adding of new axioms can permanently "fix" the system and make it complete -- there will always be new Godel sentence that is true but not provable.

This git repo is quite out of date. The best place to look for updates is the smlnj website: https://www.smlnj.org/

Really cool idea! I could definitely see myself using this service when I graduate and have more time.

Out of curiosity, what is player retention like in campaigns? Have you guys considered adding any incentives to keep players coming to the sessions? When I last played DnD, we would always have a ton of fun during the sessions, but it was difficult to keep everyone coming back regularly.

I vouched for your comment but it looks like you may be shadow banned. Just an FYI -- you might want to email the mods, they're quite nice people.

Arch Linux Trusted User https://wiki.archlinux.org/index.php/Trusted_Users

HN copied reddit.

> "[Graham] wanted to make Hacker News a place to recreate the way Reddit felt in the good old days, when most of its community was made up of hackers." [0]

[0] https://techcrunch.com/2013/05/18/the-evolution-of-hacker-ne...

@dang: Could we get a title change to "How Renormalization Saved Particle Physics"?

Related fiction: "Universal Love, Said The Cactus Person" [0]

[0] https://slatestarcodex.com/2015/04/21/universal-love-said-th...

Do you have a link to Linus’s post? Would be much appreciated.

@dang: Could we get a title change?

Maybe "Carl Bergstrom on data manipulation, fake news, and the importance of using science as a lie detector"

Maybe "Once you deploy, you aren’t testing code anymore, you’re testing systems"? Trying to lift something out of the article instead of writing a new title.

"Note the consistent user interface and error reportage. Ed is generous enough to flag errors, yet prudent enough not to overwhelm the novice with verbosity." - Ed, man! !man ed [0]

[0] https://www.gnu.org/fun/jokes/ed-msg.en.html

I'm pretty sure the applications he discussed weren't for a PM role. Check out the first footnote which talks about that experience separately:

> [1] I actually did also apply to 3 product manager positions. None of them panned out. Made it to an interview stage at one company, and I thought it went quite well. Apparently, it didn’t go well enough. I’m glad. I’m happy where I wound up.

Previous discussion: https://news.ycombinator.com/item?id=8238133

Really incredible work and it's been very fun to follow along. The streams where Andrew did the last part of this work can be seen here: [1], [2].

I am really happy that someone is making the effort to steadily simplify systems programming rather than make it more complicated. Linux goes to such incredible lengths to be bug-for-bug backwards compatible, but then the complexities of all of our layers of libcs, shared libraries, libsystemd, dbus, etc cause unnecessary pain and breakage at every level. Furthermore, cross-compiling C code across different architectures on Linux is far harder than it needs to be. I have a feeling that there wouldn't be as much interest in the steady stream of sandboxes and virtual machines (JVM, NaCl, PNaCl, flatpak, docker, WebAssembly) if we could just simplify the layers and layers of cruft and abstractions in compiler toolchains, libc implementations, and shared libraries. Practically every laptop and server processor use the exact same amd64 architecture, but we have squandered this opportunity by adding leaky abstractions at so many levels. I can't wait until installing a program on linux is as simple as downloading a static executable and just running it and I hope zig brings this future.

[1] https://www.youtube.com/watch?v=2u2lEJv7Ukw [2] https://www.youtube.com/watch?v=5S2YArCx6vU

What’s the ruling on using threadreaderapp? Would a good submission post the original twitter source and link threadreaderapp in a comment?

Do you have a link handy? I couldn't find it with a quick google.

The thing you are referring to with open and closed files is called typestate. Check out its implementation in the Plaid programming language: http://www.cs.cmu.edu/~aldrich/papers/onward2009-state.pdf

This is because hash tables resize when they are filled with too many elements. Assuming a suitably good hash function, this gives O(1) lookup w.h.p. and insertion stays O(1) amortized. The mathematics of hash collision probabilities is factored into the resizing thresholds.

Many standard library implementations of hash tables (such as rust's) also include special hash functions which are salted with random values to prevent DoS attacks which create large numbers of hash collisions.

Cool one liner! Here's some other languages:

Python: 2 * sum([x for x in range(1, 13)])

Haskell: 2 * sum [1..12]

Even if you never want to write any Perl code, I definitely recommend checking out some of the features of Raku. As someone who is interested in language design but never has (or likely will) use Perl for a project, I still found reading about Raku's feature set super interesting. Here's a whimsical slide deck that introduces a lot of the most interesting features: [0]. Even if you find yourself shaking your head at all the craziness, you at least have to admire Raku's success at fulfilling its goals of being a post-modern language optimized for fun (-Ofun).

[0] http://tpm2016.zoffix.com/#/

Does 1,100 microservices mean 1,100 distinct programs or 1,100 running instances of dozens or hundreds of distinct programs?

> We run about 1,100 microservices written in Go

Asking as a university student: is this a common number of microservices to have running in production? It looks like monzo has about 1,351 total employees [0]. If all of them were software engineers, this would be a little less than one microservice per engineer. How do you handle code reuse and reliability among thousands of microservices? It seems like the number of possible failure states would be unthinkable.

[0] https://en.wikipedia.org/wiki/Monzo_(bank)

Here's a threadreaderapp version https://threadreaderapp.com/thread/1034492056968736768.html

Looks like you've got a small typo on your about page:

> Even though there is an AI behind this website, recommendations should like they are hand-picked and hand-written.

Missing the word "feel"

Here's a great article covering why some dictionaries are great and why some are just boring. It also goes into a more detailed discussion of John McPhee (mentioned in OP) and what dictionary he uses.

"You're probably using the wrong dictionary" - http://jsomers.net/blog/dictionary

Based on what my friend (who is running a small psychology study) told me, non harmful deception is allowed so long as you explain the deception in the debriefing of your experiment. This is in the US.

Just an FYI, the poster is female.

Discussion for part 1: https://news.ycombinator.com/item?id=20375702