james-mcelwain

I don't think OP is referring to meaning in an existential or epistemological sense, but rather discussing workaholism as a "practical" avoidant behavior for those who put off dealing with some kind of dysfunction or trauma.

Good. Drones are incredibly annoying and have already ruined many things like a pleasant day in the park. I don't want to live in a future with huge drone fleets buzzing around every time I step outside.

Are you seriously arguing against event loops as a category? Blocking in non-blocking code is going to be an issue whether the language is C or JavaScript (duh).

I'd expect the tooling will improve over time. This obviously isn't an immediate solution for running Clojure in situations where cold starts matter, but in general I think many of the improvements coming to the JVM in the next few years will pay dividends for Clojure.

> Clojure’s slow startup time on the JVM makes it unfeasible for serverless functions

GraalVM could totally change this.

> I don’t know how non binary people would feel about this and would like to hear more from them.

That it reeks of biological essentialism and is exclusionary by its nature.

Taxation isn't bondage.

I'm not sure about other container solutions, but Docker isn't a black box at all. It's fully introspectable -- I often dump a container's file system to see what's actually included.

Besides referential integrity, foreign keys may improve the query plan (depending on vendor).

But either way, I can't imagine any reasons why you wouldn't want constraints to ensure you database is in a consistent state. There can always be bugs in you application code, manual db updates, etc.

They are similar to Kotlin's sealed classes, except there's no concept in Kotlin of an object "consuming" itself, which is necessary for maintaining safety in the API.

For example, in Kotlin, if a method on state A returns state B, there's no way to invalidate all existing references to state A. Normally this invariant would be enforced on the caller's side, or perhaps by throwing an IllegalStateException if state A is called after producing state B.

In actual Rust APIs, opening a file returns a result, which needs to be handled or unwrapped in order to operate on the file.

All resources in Rust are implicitly like your Python with example -- when they go out of scope and destructors run, the file will be closed.

You're acting as if we can't do anything about power of Facebook. It's absurd to to conflate making Facebook take editorial control of their platform with making it the state censor of an authoritarian country.

Regulating and/or breaking up Facebook is hardly "demanding they become the final arbiter of truth." The goal here is reducing Mark Zuckerberg to the point where his personal judgement is irrelevant.

I'm only familiar with the US. If I had to speculate, it's probably better in countries with better bike infrastructure. I know personally I only break traffic laws when I feel it's subjectively safer for me as a cyclist to do so. There is a legal push in some places for the [Idaho stop](https://en.wikipedia.org/wiki/Idaho_stop), which seeks to make this behavior legal in the name of safety.

It's not an interesting point because this topic has already been studied. Cyclists break traffic laws at roughly the same rates as motorists.

Right, I'd be sympathetic to this liability argument if they weren't extracting profits and neglecting maintenance. Obviously the fire issue is bigger than a single utility, but their actions here leave them little public good will.

Here's how it works in Rust. You can imagine this working in Java with reified generics: https://gist.github.com/rust-play/214adf5bd15b18ec2d5c63d97f....

I believe they mean static methods as part of the interface signature, e.g. to define constructor/factory methods.

AFAIK there are issues with how Java handles dynamic dispatch that prevent this.

Unfortunately, making policy isn't a matter of epistemology. If we prevented ourselves from making any kind of decisions due to uncertainty about our empirical claims, we would be stuck in a kind of ethical paralysis that would prevent any kind of coordinated policy.

To argue that inherent complexity means we should remain in a state of inaction is in itself a form of denialism. The fact that it is difficult to make predictions about chaotic systems does not mean that the null hypothesis is automatically true.

I'm not saying it's not marginal, but if you spend time around audiophiles, they make lots of claims that aren't just "marginal" but simply not based in reality. I would not spend $2000 on a keyboard, but I believe people who do are doing it largely based on aesthetics, not the kind of imaginary science that audiophiles do.

Differences in headphones are real. Spending 20k on a custom tube amp is not.

I wouldn't really consider nice headphones to be a prime example of audiophile gear, tbh.

Yes, this is what I'm saying. I'm not suggesting that the margins of quality are worth a 5x price point (it's not), but it's not quite the same as some of the voodoo beliefs among audiophiles that a 20k tube amp makes an appreciable difference.

As a disclosure, I own expensive audiophile gear, but, again, for the aesthetics primarily. I would be much happier with audiophiles if they just said they like the aesthetics.

The key difference being audiophiles often fail A/B tests comparing audio quality. You would definitely notice how nice an expensive mechanical keyboard feels. Whether you think that is worth luxury pricing is another story, but the quality is at least more immediately appreciable.

This is how it's commonly done in Clojure, and not a problem in my experience. You can define the keys that are relevant:

    (defn foo [{:keys [bar baz]}]
      ;; do something...
      )

    (foo {:bar 1 :baz 2})

This isn't as good as a type signature, but makes it easy to know what the dependencies to a function are.

Kotlin.

  x ?: y 

is shorthand for

  x != null ? x : y

Or my preferred (gross) version:

    void async function main() {
       // code
    }()

Despite other deficiencies, JavaScript devs are generally pretty good at writing async code, for the simple reason that you get burned suuuper quickly if you try to mutate state outside of an async context when doing things like adding click handlers. This is something most front-end devs learn pretty quickly since it's such a fundamental part of writing JavaScript.

5% is not typical. The highest strength vape juice sold in most places is around 24mg/mL or 2.4%. Most "old-school" vape users smoke something more like 12mg.

> What if your result set doesn't really match any of your models? Pick one arbitrarily.

I don't want to sound like the ORM defender, but I'm not sure I understand.

This sounds like a deficiency of Ruby and the ActiveRecord record model. In Java, for example, you'd just write a new POJO for your query, which isn't exactly difficult. There are no "smart methods" or whatever.

It is a valid criticism that this can proliferate data classes, but that depends on the application.

What net neutrality? Net neutrality was repealed over a year ago.