chestervonwinch

Needs to prefix the tab's title with a blinking "(1)" or "*" when the chat pops up. And have that paired with a loud chat notification sound. Edit: also should mention that this is both sad and awesome.

> pattern 4: fun illustrations on dry explanations

Or an arbitrary unsplash landscape photo with a tenuously related caption. Why do people do this? Is it to stretch the content, or just a fad? Surely there's a different way to break up long text than adding visual noise.

> meaning errors will accrue over time

This is not universally true. Error behavior is a function of the particular problem, the algorithm used to approximate its solution, and the properties of input data. A large subtopic of numerical analysis is concerned with this kind of stuff. See [1] or [2] to get a flavor.

[1]: https://en.wikipedia.org/wiki/Numerical_stability

[2]: https://en.wikipedia.org/wiki/Lax_equivalence_theorem

Probably has to do with our brains preferring instant gratification over long term payoffs.

This sounds related: http://aosabook.org/en/index.html

> I accidentally abandoned...

It sounds like you made a conscious and intentional decision. How does one drop their preconceived judgements by accident?

I enjoy LinkedIn for keeping up with old colleagues. But -- and I hate to be too sour on people who are earnestly excited about sharing their career progress -- everyone seems to announce every minor career move on LinkedIn in posts that read like a Grammy acceptance speech.

What you describe as the "Finnish way" seems like it would translate better to a distributed company. I've been working remotely for over a year now, and I've found that those serendipitous conversations by the coffee-machine "French way" breaks just don't happen remotely.

Thanks, that's helpful. If I was just starting out, would it be better then to start with a broader programming language theory text, rather than going straight for type theory?

What is a good an introductory text (or other resource) for learning? What's the relationship between programming language theory and type theory? Is type theory a special topic, or would it be considered a core topic in programming language theory (e.g., like integration in calculus)?

I'm not understanding what you mean. The latter portion of your comment seems to disagree with the former.

> Most of the time I can moderate my response, sometimes not. But I think getting better at this comes with practise, and without inviting those kinds of conversations, I'll never get better.

The intent of some mindfulness and meditation exercises is to become more attuned to one's lower-level physical responses as a grounding point for being able to more readily identify one's higher-level emotional responses.

In the moment, it might be difficult to recognize and moderate the higher-level reaction without first becoming adept at recognizing the lower ones (e.g., sweaty palms or tense muscles).

Just to be clear, you're saying "uname -s == Linux" => "/proc exists" right? Not trying to be pedantic; just having a TIL moment.

Have you considered the WASM build of Qt?

https://www.qt.io/qt-examples-for-webassembly

Aha! This makes sense. So basically, on native, there's lessened ability to leverage browser extension ecosystems to block ads and tracker scripts?

I do not think this is a dark pattern. I don't see any exploitation or misrepresentation.

I think we should be careful to distinguish between exploitation / malicious intent vs. airing of grievances of about UI/UX feature completeness.

Can you explain why this is a dark pattern? How does slack benefit from you using the native app vs. the web app?

Not OP, but I've been using a Durgod Taurus K320 TKL for two years as my primary work keyboard with no problems. I like it quite a bit.

There are some cashew-based queso dips that are pretty darn tasty. Although, it's a bit easier for vegan to compete in that context since "real" queso dips are the whey stuff not cheese, per se.

Edit: to be clear, I'm commenting as a tangent to the ground nut suggestion. I'm not suggesting anyone put queso on pizza, unless that sounds good to you :)

> PlantUML is great but suffers from having ... ugly default style ...

I quite enjoy the C4 diagram stylings: https://github.com/plantuml-stdlib/C4-PlantUML

> Why would someone (especially someone non-technical) spend the time to learn and write what's essentially code to make a diagram when the alternative is drag and drop?

An advantage, depending on context, is that it brings the diagrams closer to the code that they're modeling, making it possible to version control them and include the diagram generation in documentation build automation.

> Do you people really like such music?

I like it, but I use it moreso for when I want to tune out noises in my surroundings with something other than say, "bird noises" or "distance thunderstorm".

I'm somewhat familiar with McCabe style complexity measures[1], but I'm curious if there's a metric that measures a code base's ease with which it can be refactored or extended. Has anyone heard of such a thing?

[1]: https://en.wikipedia.org/wiki/Cyclomatic_complexity

> And inability to easily quantify it, opens up door for corruption.

Yes, and since it's not readily quantifiable, any notion of something analogous to a payoff schedule is not possible. This makes it difficult to make a concrete and specific case for doing code cleanup or debt paydown often just before it's absolutely necessary.

Was the sleep issue not resolved by a BIOS update?

Tangentially, I want to mention that the archlinux wiki is a terrific catalog of machines and their known quirks (and sometimes, fixes for the quirks!).

Any dimensionality reduction method (DL-based or otherwise) can be viewed as a form of compression. But, the end goal in data dimensionality reduction is usually quite different than with data compression.

Either way, this is much different than model compression/distillation, which is compression of the parametrized functional mapping itself. As a silly example, imagine you fit a 100-degree polynomial to noisy linear data using some proper regularization. You would find that can distill/compress your 100-degree polynomial model into a 1-degree model with comparable accuracy.

Have you read any computer vision textbooks? Szeliski's book for example is quite popular and sort-of free:

https://szeliski.org/Book/

I bet it's constantly crowded since no one can figure out how to exit.

Right, spending all your effort on the one true design gets you in architect astronaut territory. Similarly for existing systems, conjuring up the grand rewrite in the sky (as Robert Martin calls it, I think?) is equally poor. Instead, recognize that design is important but will constantly evolve. Tests give the ability to incrementally redesign quickly and confidently.

In Python land, we use a library called marshmallow for mapping domain object attributes to JSON fields. In most cases, these mappings are a direct reflection of the associated domain objects, so the result is a bit verbose but still works nicely because you can easily version them as your model definition evolves over time.

I was under the impression that having an interface between models and JSON serialization was commonplace, given the popularity of marshmallow library in Python. Is this not the case in other languages and ecosystems?