telekid

This article describes almost exactly why I think gradual typing is actually a good thing. Type checkers shouldn't get in the way of your code compiling. Yes, the language has to be designed with this property from the beginning. Yes, you should always enforce complete checking in CI. But you should also be able to try half-baked ideas.

If you have never used QLab, I recommend downloading it and tinkering for a little while. It is probably the best-designed native macOS app that I’ve ever come across, finely tuned by a handful of developers for something like 15 years. It’s a great reminder of what apps _could_ feel like.

With great power comes great irresponsibility.

I don't have any idea what you're talking about, but I nevertheless found this very entertaining.

Which ones? And ignored (and potentially irreconcilable) or deferred?

That's a strange lisp...

A few other strategies for solving this problem include something along the lines of the Small Clojure Interpreter (1) and Defunctionalization (2, 3)

[1] https://github.com/borkdude/sci

[2] https://blog.sigplan.org/2019/12/30/defunctionalization-ever...

[3] https://www.cis.upenn.edu/~plclub/blog/2020-05-15-Defunction...

In general, you should be thinking about the delivery semantics of the systems calling your code. Many very useful callers offer "at least once" delivery guarantees, implying that your system should behave idempotently to their calls.

@borkdude’s sci actually seems like a nice contender for this as well.

Sad to hear of his passing - Glaser was prolific. I used to work fairly regularly with a company (Masque Sound) that provided audio equipment for Broadway shows. Milton arranged a beautiful illustration for their 75th anniversary. I still have a shirt with that drawing on it - it's a cherished possession.

This seems conceptually similar to differential dataflow.

https://github.com/timelydataflow/differential-dataflow/blob...

What about just `git reflog`? Then, you get to see recent branches _and_ you get additional context about what you were doing at the time.

Are you aware of http://www.hyperfiddle.net/?

I believe you're looking for dependent types: https://en.wikipedia.org/wiki/Dependent_type

If Postwoman doesn't tickle your fancy, I'd take a look at https://github.com/pashky/restclient.el. (I believe there's a vim equivalent, too.) You can save requests in a simple .http file, and check them into your codebase. Makes collaboration very simple.

Emacs now has great support for Language Server Protocol, which provides you with basically all of the code intelligence that powers VS Code.

I ran into this in the pre-webpack era where it was somewhat common to just concatenate JS together in a gulp build step. We imported code from two NPM modules, and each one was wrapped in an IFEE, but the first one didn't terminate with a semicolon. Not fun to debug.

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

This interface generalizes nicely to estimating any Fermi problem, not just business models. I love it!

Wait, really? That’s shocking to me - I would have assumed the entire link was encrypted E2E. Are there technical limitations that make this infeasible?

…really? "Nerd minstrel show?" Ah yes, we poor nerds, overcoming centuries of repressive awkwardness and desk jobs.

Yep, showed up in a First Order Logic course for me. IIRC, it was bundled with a book?

Edit - this one: https://web.stanford.edu/group/cslipublications/cslipublicat...

I've drafted this petition in response to the Equifax data breach. I feel that account access should be regulated in certain industries. This petition outlines why that is important and how legislators might go about doing that.

With that said, I am not a lawyer and I am not a security expert. As such, I would love feedback from people who are more familiar with the issue than I am. If you have something to add, please raise an issue or open a pull request.

Thanks! I'll be sure to look for these.

I decided to start teaching myself guitar about three years ago, at the age of 24. I had always wanted to learn to play an instrument, but before guitar, nothing ever really stuck.

When I picked up the guitar, I approached it from a different angle. The key for me was realizing that I could treat this like a 20 year project. I bought myself a guitar book[0] and started working through it page by page. I stopped worrying about whether I was good good or not – instead, I began to find great satisfaction in simply getting better.

Three years later, I've made a ton of progress. Practicing has become a kind of meditation for me; it helps clear my head, and keeps me from getting burnt out with work.

[0] William Leavitt's "A Modern Method for Guitar." This book is a pedagogical tour-de-force, though it helps to have a little bit of music theory under your belt if you are going to learn from it without an instructor.

I work for a company called untapt (https://www.untapt.com). We're building a Machine Learning-powered hiring platform that focuses on software engineers. We're very proud of what we've built – definitely worth checking out.

magit[0] solves many of the issues identified here. It's the first tool I've used that makes git feel like a paint brush rather than a camera.

[0] https://magit.vc/

HN has recently seen a surge in conversation about hiring best practices. The company that I work for (untapt) thought it would be helpful to create a document to help hiring managers improve their own hiring process.

We would love feedback from people on each side of the hiring table. What makes a hiring process successful in your eyes?

If there is broad interest, this document may turn into a more substantial GitBook.

Page best viewed with headphones.

I keep a pair of high-quality earplugs[0] on my keychain. They're completely invisible and always there when I need them. I find myself using them about once a week.

Nobody is going to protect your ears for you.

[0] http://www.earasers.net/

Holy hell this is well done. Congrats.