jkachmar

I think knowledge of the concepts is very useful, but precise recall of the algorithmic implementations is absolutely useless.

It’s very different for someone to have a solid grasp of, say, cache-aware programming techniques, algorithms and data structures that are necessary for low-latency architectural work, etc.

...but I’m aware of very few positions (if any???) that require the ability to arbitrarily synthesize that information on the spot.

EDIT: Originally meant to lead with the fact that I broadly agree with what you’re saying, I just wanted to clarify my original objection.

Bullshit.

It has been my personal experience, and the experience of many people I’ve spoken with, that this kind of trivia is learned in order to get a job and then forgotten immediately afterwards because it’s useless.

Anecdotal example: a former colleague is an incredibly talented systems programmer and has had to study leetcode garbage for the last few months in order to feel qualified to interview for a position with a team that he had previously been on at an older employer.

As another commenter said elsewhere, these types of questions are used because they’re legal proxies for “IQ tests”, and because they filter for people who are willing to sacrifice much of their personal time for the sake of the company.

If you’re not already familiar with it, you may find the GRIN (Graph Reduction Intermediate Notation) compiler project interesting: https://github.com/grin-compiler/grin

I’m gonna be honest this is difficult to parse.

I’ve lived here for nearly 5 years now, and it sounds like you’re kind of describing Manhattan in the winter nearly any year. I’ll likely do most of the things I’d do anyway, except I’ll be wearing a mask for most of them.

I dunno, I guess I just enjoy my neighborhood and I’m putting a significant portion of my income into savings while still living here so why would I move?

No rent increase + 1 month free (July) + a discount on one month’s rent (August).

Amortized over the full 12 month term, it effectively knocks a few hundred dollars per month off of a (very small) one bedroom apartment (with an in-unit washer/dryer!) in lower Manhattan.

I think that even comparing NY/NJ to CA right now makes me slightly more confident that the NY Metro Area will handle a potential future resurgence better.

I was out at some of the protests a few weeks ago, and the fact that NYC hasn’t seen a measurable uptick in cases after that and the reopening is promising IMO.

I stayed in my apartment but negotiated a concession from my landlord to lower the effective annual rent.

I’m 29 and living in downtown Manhattan at the moment. I decided to re-sign for my lease, which would have ended this month, after negotiating some concessions from my landlord.

Everyone’s got different priorities, but I enjoy living here and I’ve budgeted to account for my rent even if my job situation changes drastically.

Lockdown was unpleasant-but-tolerable through the worst of it (end of March -> end of April), and at this point I’ve got a good system for dealing with another one.

Generally though, I’m concerned that other states and municipalities aren’t going to deal with a resurgence as well as the NYC metro area might. My family lives in New Jersey, so I’d be comfortable going out there if I felt that I had to, but I’d absolutely prefer paying to stay in NYC over returning to family living in most of the other US states.

A WAI `Application` is defined as the following type alias:

  type Application =
    Request ->
    (Response -> IO ResponseReceived) ->
    IO ResponseReceived

...which is to say that WAI applications are “just” functions that accept an incoming request and a callback that turns that request into a response object (which may emit side effects), and which return a respond object (which may emit side effects).

This leads to a very nice definition for middleware as the following type alias:

  type Middleware =
    Application ->
    Application

...which says that any WAI middleware is just a function that turns one application into another.

This means that WAI applications have a nice and easy to understand top-level interface, and that complex chains of WAI middleware can be built up by chaining smaller middlewares together.

The potential benefit here (over other language frameworks) is that the “grammar” being used to describe applications and middleware is the same “grammar” that’s used in most other Haskell applications (i.e. function composition). Ideally, this should make it more easily understandable to a Haskell practitioner who might not be intimately familiar with the framework at first glance.

I like Haskell, I write Haskell at my day job (and did so at my previous day job), and I help maintain some of the community build infrastructure so I’m familiar with a large-ish graph of the Haskell ecosystem and how things fit together.[0]

I don’t really think Haskell is _meaningfully_ superior than other languages at the things that OP is talking about.

Refactoring Haskell _in the small_[1] is much nicer than many other languages, I don’t disagree on that point. Despite this, Haskell applications are _just as susceptible_ to the failures of software architecture that bind components of software together as other languages are.

In some cases I would even suggest that combining two Haskell applications can be _more_ fraught than in other languages, as the language community doesn’t have much in the way of agreed-upon design patterns that provide common idioms that can be used to enmesh them cleanly.

[0] I’m mostly belaboring these points to establish that I’m not talking out of my ass, and that I’ve at least got some practical experience to back up my points.

[1] This is to say when one refractors individual functions collections of interlocking abstraction

> Types are for compilers, not people [...]

This strikes me as a similar sentiment to “Requirements are for managers, not engineers”

The inputs shouldn’t be “random”, but the idea is that you should provide an input distribution that’s roughly representative of your expected distribution of real-world values (+ some perturbation to find edge cases).

As for frameworks in the languages you listed...

Ruby and Python: https://github.com/HypothesisWorks/hypothesis

Elixir and Erlang: https://github.com/proper-testing/proper

Node and JS: https://jsverify.github.io/

As for real world use-cases, imagine you’re writing a program that accepts timestamps as input and has to implement branching, requirements-defined business logic based off of them. When you’re writing your unit tests you can use the requirements to select timestamps that are “known good” and “known bad”, but it’s hard to explore this state space on your own.

Same thing goes for handling unexpected inputs to certain functions. You probably don’t want to check _every_ type of input for _every_ dynamic function, but it might make sense to make sure that certain “entry points” to your program fail in the expected manner when they get poorly typed input.

This is in constant tension with the point that GP is making though.

If you’re not _very_ careful with your software architecture, you can inextricably tie your frontend and backend applications together. Depending on the size of your product, or why the growth plans are for that particular frontend/backend app end up being, this might not be a problem.

If it becomes one, though, then every bad technical design decision made in that `common` set of modules or packages ends up hurting you as it gets unspooled from (at least) two components that likely have very different architectural idioms.

Having followed the PostgREST project for years, it’s been wild to see the recent explosion of similar sorts of projects (as you describe); I’d very much believed this was a “solved problem”.

I always find this comparison a little... silly? I dunno, there’s probably a better word, but I can’t think of one right now.

Nix focuses on reproducible build declarations and development environments, while Docker focuses on self-contained, distributable sandboxes for code execution.

You can certainly try to use Docker to manage development environments or reproducibly build software, but that’s a secondary concern of the system. You’re probably right that these sorts of posts tend to have a “Nix hammer in search of a nail” feel, but the inevitable comparison to Docker always feels cheap to me I guess.

Steve Klabnik and Sean Griffin were both early adopters of Rust (and are now fairly visible members of the community), and I believe that helped sow the seeds of the language in parts of the Ruby community [0].

I think Rust managed to also cultivate a community that was very much like Ruby’s [1], which brought people over.

[0] cf. Klabnik’s “Rust for Rubyists”

[1] mostly being very “people-oriented” in terms of inclusivity and documentation, as well as putting effort into ensuring that the language and its tooling provide a lot of “developer happiness”

Ha, TIL!

I’m not too familiar with the Long March family but that does make sense.

More random engine nerdery:

- It’s really exciting to see all of the development going into full-flow combustion metholox engines these days; BE-4 and Raptor have been incredible projects to follow.

- The Rocketdyne F-1 is still the most impressive rocket engine to me, although the RS-25 is a very close second. Watching videos of the Apollo launches and seeing those things in action is absolutely awe-inspiring.

Regarding hypergols, I love the fact that you are absolutely correct that they’re mostly relegated to places where you _need_ autoignition these days, but then you look at the Proton rocket family...

https://en.wikipedia.org/wiki/Proton_(rocket_family)

He rarely, if ever, is. It’s his biggest flaw, IMO: in spite of the fact that he’s extremely smart and very articulate, he quickly escalated his rhetoric and takes extreme positions based on his gut.

Along the lines of what others have said elsewhere in this thread:

No one reasonable is criticizing Musk for being a visionary CEO, someone who is interested in taking risks that overcome historically difficult challenges.

They're criticizing him going completely off the handle; calling someone a pedophile on Twitter when they disagree with him, talking completely out of his ass about "taking the company private", or trying to play armchair epidemiologist when he _clearly_ has a vested interest in a potentially risky avenue of behavior.

I'm very happy to see the things that SpaceX has achieved [0] and I'm also happy that Tesla has done such a good job popularizing EVs [1], but I'm blown the fuck away whenever I see people responding to _entirely justified_ criticisms of Elon's character by pointing out what he's accomplished and how lofty the rest of his goals are.

Do we just not have standards for people in Musk's position? Do folks really think it's reasonable for someone to comport themselves the way he _routinely_ does?

[0] Although let's be honest, the company treats its employees pretty damn badly.

[1] Accurately representing the self-driving capabilities of their vehicles, on the other hand, leaves quite a bit to be desired.

So this was something that a former boss/colleague and I kinda worked on for a few months at a prior company to help architects collaborate on global development standards.

There was a base set of standards which evolved over time, and regions whose standards would extend that base in different ways.

We actually got to the point where a small team of architects would write these standards in Markdown, use GitHub Desktop to manage their branching/PR-ing/reviewing workflows, and then tag releases. Then Jenkins would pick up the tag and process the Markdown with Pandoc to produce DOCX and PDF documents that adhered to our corporate style guide.

IIRC there were a few reasons why it never got widespread adoption. One thing that sticks is that even after we taught people how to use git and they ran with it while pushing out updates, without the daily reinforcement (e.g. like what software workflows require) the knowledge just didn't seem to stick.

The whole thing was really slick; in retrospect I wish we would have given a small talk about it and open sourced the workflow as an example. If nothing else, it reinforced my belief that with _just a little more polish_ force-multiplying dev tools could save people in other industries a lot of time/effort.

> Markets would love to build more housing. But they're prevented from doing so by the regulatory state. Markets would love to build nuclear power plants, but they're prevented from doing so by the regulatory state.

I don’t like it when people anthropomorphize concepts like economic markets, but I _especially_ don’t like it when they do this to make it seem like the anthropomorphization should be a sympathetic character to the reader.

Like one of the GPs said, above: the market is something that responds to incentives.

Regulation and bureaucracy shape those incentives, sometimes in the ways that you’re describing, but the market is just as “happy” to capitalize on bad housing regulation as it is to capitalize on a lack of any housing regulation at all.

The problem of constructing just the right amount of regulatory apparatus is very difficult, though.

I don’t see how “political correctness” is a factor in this analysis.

It sounds like socioeconomic status is correlated with race in America [0], there’s a strong correlation between one’s socioeconomic status and one’s ability to enforce self-isolation and social distancing [1], and there’s a clear causal relationship between self-isolation and social distancing and one’s likelihood of contracting COVID19.

So it doesn’t seem too hard to see how NYU doesn’t believe race to have a causal relationship with disease severity without resorting to claims that “political correctness” is influencing their analysis.

[0] Hard to object to this, given the institutional racism present in the country.

[1] Many essential jobs (sanitation, public transit, supermarket, food prep, warehouse worker, etc.) are not well paid and don’t offer the flexibility to preventatively take paid sick leave and/or work from home.

You can work around this in the event that your commercial software provides a consistent interface for the license key stuff; e.g. via the CLI, a key file (ideally plain text) on-disk, or some scriptable interface.

Then you can store this info in separate key management software (e.g. Unix pass for your local machine) at which point bootstrapping your system could be done relatively automatically.

EDIT: I should add that this is my view of how things should work in the-world-as-it-ought-to-be, which isn’t necessarily the same as the-world-that-we-live-in.

In practice you can actually get extremely close to having Nix manage your whole macOS system with the exception of actual OS-level updates (and particular tools like Xcode, I suppose).

John Wiegley’s system configuration [0] is an example of this, although it is extremely ambitious and definitely not a good place to start for anyone who has used Nix before.

One of the interesting things that Wiegley does for further reproducibility is to have Nix manage and install DMG-based Applications [1] in addition to CLI apps, services, and other system-level things.

[0] https://github.com/jwiegley/nix-config

[1] https://github.com/jwiegley/nix-config/blob/bbad310daa1106f6...

Informing others and providing an explanation for why people should be discouraged from using a malicious tool is not virtue signaling.

Trying to discourage people from disseminating this information under the auspices of “virtue signaling” is unhelpful.

Some people build technology, some people research and critique it.

Would you tell researchers who demonstrate critical vulnerabilities in technology that they should build something better instead of just talking about it?

You are commenting on an article that is nearly as apolitical as I can imagine one being to say that politicization of this topic makes it impossible to have a debate rooted in science.

Isn’t this precisely an injection of politicization into a summary of scientific work?

> This group is currently living outside of the system.

I think that the point that I’m trying to make (as are others in this thread) is that there are many more people who are “living outside the system” when we consider “the system” to be those who can get treatment and afford to distance themselves from others (i.e. stay home from work or work remote).

Expressing concern about the problem that undocumented immigrants pose is such a massively premature thing to do that I find it impossible to read the original comment in good faith.

> 10M people are unable to participate in a productive treatment or cure.

Many more than 10M people are going to be unable or unwilling to participate in treatment or inoculation due to the structure of the American healthcare system.

Raising the concern about undocumented immigrants inhibiting our recovery effort is naïvely misinformed at best and a dogwhistle for encouraging discriminatory behavior at worst.

> We’re in uncharted territory here [...]

Small point of disagreement on this one. There may not be a 1:1 correspondence between what’s happening now and any exact historical event, but I would have hoped that traditionally Western nations would have studied countries affected by SARS (et al.) and learned from their successes/failures.

The author’s rhetoric is likely the cause of the downvotes, in particular focusing explicitly on “undocumented immigrants” when there seems to be no evidence that this group of people presents any greater (or lesser) risk than other groups that share their socioeconomic or demographic status.

To contrast with your interpretation, I found the author’s comment to be unnecessarily divisive.

Consider, for example, that Asian people are being harassed and assaulted in response to how aspects of this pandemic have been framed.

Now consider the response that the author’s comment might incite towards demographics associated with undocumented immigrants, in light of this, given that there is no reason to believe the premise.