james-mcelwain

> Rust has affine types (can be used no more than once), but not linear types (must be used exactly once)

Obviously it's not part of the type system itself, but doesn't the must_use attr get pretty close?

No, TypeScript is compile time only. There's no runtime type info.

Anecdotally, proc macros just aren't that common. Almost every Haskell tutorial I read introduces language extensions, and it seems like many users have a set of extensions that they always enable by default. I don't think proc macros are really comparable in that sense, although maybe they will be in the future?

These statistics don't include all the discriminatory interactions with the police that don't end in death. Being killed by the police is only one way that racialized policing can have a disparate effect on policed populations.

Hope you have good margin rates, you could be waiting a long time. A lot of these are steaming piles of shit if you think about fundamentals but the market doesn't care about fundamentals.

Just look at the price action on any big tech stock and pretend you're a tech investor looking for a big exit. People are pouring money into equities, particularly tech.

There's no alternative to equities. These prices could continue to go up for years, even if the bottom totally falls out.

Ignoring the importance of the bottom 1/3rd for consumer spending.

Lots of tools built on top of Docker do imbue special meaning in latest, however.

First of all, "Basic economics/psychology informs" does not constitute empirical proof that UHC leads to decreased "innovation" (which is a weasel word in itself).

Second, even if we granted the premise that UHC leads to less healthcare innovation, this doesn't mean that there's "infinite harm" in to people in the future. Unless you're claiming you have a crystal ball, there is absolute 0 epistemic basis on which to make this claim. For all we know, not having UHC leads to nuclear war and we all die. Or, having UHC leads to the singularity. Etc.

Third, even if we grant that there's an innovation advantage to for-profit medicine AND we grant that you can predict the future, that still doesn't mean that there's "infinite harm", precisely because "harm" is comparative. I would argue that we've picked most of the low-hanging fruit of human medicine and that the marginal utility produced by new treatments is far outweighed by the human suffering of our for-profit system.

The solution to "stop the punching" isn't to demand oppressed people not be upset. The solution is to stop punching down. We stop racism by reversing the material effects of racism, not by spreading an imaginary "color blind" ideology. The last thing we should be doing right now is pretending that race doesn't matter.

Do you have any evidence any sub was banned for the opposite equivalent of "Democraps" or whatever? This feels like a strawman without evidence that people were banned selectively.

Punching up vs punching down is a super important distinction to make in these kinds of policies.

> If the ultimate commercial relationship is between you and the hotel or airline when you book through Expedia, then it's just as fair to say that the ultimate commercial relationship is between the passenger and Uber/Lyft driver.

When I book a flight through Expedia I enter a contract of carriage with the airline, not Expedia. This is a contractural matter, not just an abstract concept of "commercial relationship."

I seriously doubt there are many lawyers willing to sue Amazon on contingency unless it's the most slam dunk of cases.

For what it's worth, Java has hit code reloading, even though it doesn't work perfectly all the time.

> Go also espouses "frameworks bad, libraries good" but the biggest difference is that they actually have a strong robust ecosystem of solid libraries while pretty much every Lisp claims to have production-ready libraries but expect you to cobble together the entire kitchen sink from scratch.

I mean, Java is pretty much the biggest ecosystem there is and it's trivial to use Java libs from Clojure, so I'm not sure this is a fair comparison.

The Go ecosystem seems pretty weak outside of the standard library. I'm not an expert, but I was trying to fix something the other week and was shocked by how few packages there were to solve my problem. The main one (which is a dep of things like k8s) is currently unmaintained.

I'm not super familiar -- what editor integrations does create-react-app provide? It seems like it's just a project template like Luminus for Clojure.

Tooling is definitely important, so I don't want to downplay friction here, just curious about what other ecosystems do better.

I'd love to use a light-weight Clojure hosted on Go, etc., but also wonder whether performance improvements to the JVM will solve many of these issues without requiring a full rewrite.

Many of the issues Clojure has with the JVM are shared by regular Java apps, so I think there is motivation to improve many of these areas over time, even if it takes a bit.

What tooling has given you problems? I think that some tooling assumes familiarity with the Java ecosystem (which is a problem for many things in Clojure land), but otherwise it seems pretty solid to me.

Even though Ansible is declarative in spirit, in practice I feel like a lot of playbooks just read like imperative code.

> the average person doesn't understand that types exist in dynamically-typed languages

Again, this is needlessly uncharitable as to what people mean when they talk about type systems, which is obviously about the capabilities of defining new types for program analysis, not that the runtime has an internal conception of types.

> Could you explain what descriptive and expressive power is missing here?

Sure! Looking at this, I have no idea what the size of side_length is, whether it's possible for it to be negative, or whether it's possible it to be null.

Of course, unless you're writing purely square based software, most domains are more complex than this. But I still think it's pretty helpful to know the properties of the parameters being passed to build your square are!

I'm not making a claim about all languages, I'm talking about languages that support any kind of extensible type validation, whether statically or at runtime.

When people refer to "typing", it is almost certainly reasonable to assume they are referring to static typing, as implemented by most languages. I don't think this should be confusing.

Specs/contracts are cool but ultimately don't afford the same kind of descriptive and expressive power that a static type system does.

> static types in most languages[2] don't reduce this burden much: there isn't an alternative to thorough testing.

However, there definitely is a burden about how much testing you have to write. I generally don't want to have to test every branch of my program to make sure a string doesn't slip through where an int should be or that variables are initialized and not null, etc.

There are also operational concerns here. Dropping columns may require rebuilding indices, which can have a high cost that isn't worth paying for just to keep the schema clean.

Sure, I probably phrased that poorly -- it's not a unique advantage, but benefit of having URLs be the only way to link to dependencies versus a centralized, dominant package manager.

Not a tie, 60 votes.

I'm not sure this is referencing the js api, which will be based around promises like node. I believe this is referencing the rust implementation, which is built on top of tokio and rust's async/await.

One advantage of urls is that you can link to a specific git sha, tag, or branch for a dependency, e.g. on github.

I'd highly recommend mirroring packages anyway. Obviously this isn't always necessary for small projects, but if you're building a product, the laws of the universe basically mandate that centralized package management will screw you over, usually at the worst possible time.