matthewtoast

Plato Design | Product Engineer | Full Time | NYC / Remote (USA)

We're building iOS apps for second language acquisition. If you're a full-stack product engineer who wants to use AI and classic NLP to crack the problem of second language acquisition for adults, let's talk! This is an early stage startup inventing new kinds of tools, so comfort with trial and error, and the occasional pivot, is essential. If you join us you'll spend 90% of your time writing code and report directly to the CTO. As for our tech stack, we build mostly in SwiftUI and TypeScript. We can offer competitive salary, full benefits, and flexible hours. If interested, email mtrost@platodesigninc.com and tell us about (A) why language learning interests you and (B) cool things you've built.

Thanks, I really appreciate the feedback.

Aesthetic | Senior Full-Stack Software Engineer | REMOTE | NYC

Aesthetic (https://www.aesthetic.com/) is building tools for NFT creators and communities.

About us: We are a team of serial entrepreneurs (previous exit to Pinterest) with deep backgrounds in blockchain, machine learning, generative art, and design. We are backed by top investors, including Y Combinator, OrangeDAO, Soma Capital, Paul Graham, SV Angel, A. Capital, and Liquid2.

Responsibilities: - Build, test, deploy, and maintain our web3-integrated application (https://app.aesthetic.com/) - Own frontend-to-backend development, including QA, and bug-fixing of major features - Participate in product development, recommending features and contributing to vision

Job listing/apply here: https://jobs.ashbyhq.com/aesthetic/335f5c64-c991-4a18-a696-b...

Contact: Matthew - mtrost@aesthetic.com

If we're leaving out the sonic weapons from this hypothetical 6-hour Lynch's Dune, would we keep or throw out the heart plugs?

But if you just do the trial you don't know if you actually got the vaccine or placebo.

As we would with any drug, we'd start with a small group and scale it to more as it was determined to be safe.

I don't know. We should follow whatever procedures we follow when testing any potential new treatment.

Yes, and the practitioners boosting the drug combo have also said that in order to be effective, it should be administered early, similar to Tamiflu.

This is great. Any plans to add other genres (sci fi, espionage, mystery...)?

I do. William Langewiesche is probably the best writer on aviation - if you want really deep and detailed analysis.

Beware, this code is licensed under the GPL.

I wonder if we might achieve better* results in some systems if we added in these biases on purpose. (I.e. treated them like features, not bugs or even emergent patterns.)

Whether owned by family or raised as a member of a small herd is immaterial to where the majority of these cattle end up as adults: loaded on transport trucks to concentrated feed lots where they await processing by the factory slaughter system. Maybe the first 1/2 of their life is great, even idyllic, but that's not much of a comfort.

I'll admit phrased that last part ("types of people") very badly, so let me clarify. First, I should say that I'm very keen to believe that most of these workers are (as you say) professionals. It sounds like, in your direct experience, they are, which is great. But here's the issue:

This work is dangerous (dealing with deadly equipment and huge stressed animals), dirty (in the Mike Rowe sense), and low-paying (at or near minimum wage, per Google). So the gist of what I'm saying is, in that type of high-pressure, low-ethical-incentive situation, it's simply inevitable that:

1. Mistakes get made. 2. Corners get cut. 3. Equipment fails. 4. A worker stops caring (or didn't care to begin with).

Even if we imagine that literally all workers in these jobs are infallible, professional, and compassionate, we still have to deal with equipment working non-optimally (see the link about the bolt guns above; they ain't perfect). This means that some nonzero % of cattle processed suffer during slaughter. Even if we're charitable and say that that number must be small, like 1%, that's still a hell of a lot of cattle suffering.

In addition, you can easily find first-person accounts from slaughterhouse workers who describe exactly this imperfect system in vivid detail, where some animals end up dismembered while still "sensate". (And this is totally skipping over all of the ethical issues with confinement and slaughter in the first place!) So, to sum up:

We know logically that we make cattle suffer at scale.

We know empirically that we make cattle suffer at scale.

I would really, really like to be wrong about this.

Of course — all food has good and bad qualities, the question here is really: Is it unhealthier than a beef burger? With all other qualities being equal or better?

For example: Coconut oil may have the highest % of saturated fat, but that data point isn't relevant unless we know how much they put in each impossible burger, and compare that to the amount of fat in ground beef. I.e. despite that percentage, _per burger_ a beef burger might still give you more saturated fat.

The same goes for the concern about heme.

My understanding is that the vast majority of cattle (80%?) in the United States is raised in factory farms; the vast majority the meat Americans available to purchase grocery store, served in restaurants, and processed for fast food, is sourced from those same farms.

And my understanding is that the conditions would be horrific by almost any standard: the animals are kept confined, in extremely cramped and nasty conditions, often unable to move or turn around, all day and every day, seldom or never permitted to roam. (I'm ignoring the whole antibiotics overuse question.)

When they're ready for slaughter, they're crammed into trucks and transported for hundreds of miles, in all weather, standing in their own feces. Exhausted, terrified, and freezing or overheated after transport, many are shocked with electric prods or beaten to force them back out of the trucks. Then they are hit with bolt guns to "stun" them, after which their throats are slit.

The lucky cows are unconscious before they are sawed apart, but you can bet that the types of workers who do these dirty, low-paying jobs, hundreds of times per day, as quickly as possible, without clogging up the factory line, aren't always trained well enough nor concerned whether they cause suffering.

> The dogs pawed at the bowl for a few seconds and then gave up, gazing up at their owners as if asking for help. The cats, on the other hand, rarely looked at their owners; they just kept trying to get the food.

This surprises me because my cat often seems to ask me for help. For example, if I leave a door closed (most cat owners will tell you that a cat cannot abide a closed door!), he'll spend a minute or two trying to open it himself - pawing under the door, clawing at the crack in the door frame, and nudging it with his head. When he concludes can't get in, he'll meow at the door, or in my direction. Then he'll walk nearer to where I am and meow again, while looking right at me. This seems pretty clear "I can't do this, so you help me" behavior. He also meows at me if I forget to scoop his litter box.

I wonder if the cat-dog difference in the case of this experiment is that cats are solitary hunters, whereas dogs are pack hunters. Trying to get food out of some kind of puzzle box doesn't sound like a general intelligence/social task as much as a hunting-type task. A cat asking for help hunting would be like a human asking for help chewing their food. It would never even cross your mind to ask for help doing this innately personal task of chewing the food you're about to swallow. I'm of the opinion that we underestimate just how social or intelligent cats are, so I'm pushing back on the idea that that experiment proves anything obvious. It is interesting, though!

> most people see it as going backwards or retreating and struggle to get over this psychologically

If you return a chess piece to a previous position, it's possible that doing so loses you a tempo. Even if, strictly speaking, the game/board doesn't care about the direction you move, saying it's "just" another position isn't quite accurate, since turns matter, and using up a turn to walk back a piece may give your opponent a +1 turn advantage?

The article subhead ("animals are no less emotional than we are") is a bit misleading. (The headline likely wasn't written by the author.) This essay is not so much about whether animals operate on more or less of emotional basis than us; but the degree to which animals have subjective experiences to begin with. I.e., when a cat or monkey or bat feels sad, is there someone in there feeling that sadness?

Because non-human animals exhibit demonstrably less higher intelligence than us, we tend to assume also that their subjective experience is somehow less sharp or detailed or consequential than ours. Consider the way that virtually our entire civilization treats animals as disposable goods. We confine them in horrendous conditions, we slaughter them for food in brutal ways, we force them to do hard labor, and we even hurt and scare them for petty entertainment. Many people seem to assume that because animals don't cry or smile or frown or grimace like we do, they must not be feeling the emotions we associate with those faces.

If we all could believe that non-human animals could experience emotions such as fear, loneliness, loss, terror, shame, embarrassment, and joy just as richly and profoundly as we do -- and the article suggests that they do, indeed -- then what might we have to change about the way we regard and interact with them? I believe this is the question the article wants us to consider.

Fair point! Short answer: Even though our UI is totally platform-agnostic, we have a lot going on under the hood with platform-specific considerations. Examples include our Sketch integration (which, like Sketch, will have to be Mac-exclusive), ensuring our CLI works with the various ways our users can install Node/npm/yarn and Git, and supporting various firewall/antivirus configs in conjunction with our live design features. Like we said, multi-platform support is coming soon — focusing on Mac just helped us ship sooner.

Haiku Core is what our Mac app uses to render the stage. (Our app is built in Electron.) Here's the GitHub link if you're interested: https://github.com/HaikuTeam/core

> The system starts off with a neural network that knows nothing about the game of Go. It then plays games against itself

I might have missed this, but: Where are the actual rules of Go encoded? Mustn't there be some enumeration of what constitutes "capturing," how the win condition of the game is calculated, correct?

I've gotta throw in a counterpoint about Leviathan Wakes. The Expanse is my favorite new space opera series; it's pure entertainment that makes for great summer poolside reading. If they publish 100 of them, I will read them.

That said, Leviathan Wakes is perhaps the weakest in the series. The noir/detective plot feels like a crutch. The authors borrowed some tropes before they found their voice. If you need literary prose - or prefer your sci-fi philosophical - then these maybe aren't for you.

But if you like damn good fun, and like plot-driven novels that hinge on the stubbornness of physics and economics, give The Expanse a chance.

Cool! This is a great, clear tutorial.

I strongly recommend this activity to almost any programmer. No matter what, you'll end up with a deeper appreciation for great system design. You realize how almost every design decision boils down to a compromise between convenience and flexibility. For better or worse, you'll also get new respect for the cruel reasoning behind more arcane, but also more flexible APIs. Red pill blue pill kind of thing.

And, just to share: Last year I took a crack at creating a JavaScript-interpreted Lisp and this is the result - https://github.com/matthewtoast/runiq - I haven't added anything since then but I might pick it up again, as it was a helluva lot of fun and also quite mind-expanding.

I like this insight, but it doesn't overcome the argument for a first cause because you'd still need to explain where those fundamental truths came from.

Nice work! I've been looking for something like this.

I hope to see more tools in this vein emerge from the JavaScript ecosystem - tools that aren't afraid to make some well-reasoned assumptions for the sake of a more minimal interface. (It seems like every tool nowadays wants you to put another dotfile or garbage.json at the root of your project.)

Imagine you invited me over to your home for dinner, and you offered me a glass of tap water. And I said, "No thank you, I don't drink tap water."

Would you have any questions for me? Would you feel strange about drinking the tap water yourself now? Would you wonder why I chose to say "I don't drink tap water" instead of just "No thank you"?

The "other kind of fatigue" mentioned is that we have an overabundance of tools/interest in making ourselves more prolific, but a scarcity of tools/interest in improving our code's quality. We chase immediate productivity at the expense of longer-term survival (and happiness).

I agree with this sentiment, but the problem is barely tractable even at a small company working in a closed codebase.

The thing about those disregarded edge cases, which OP uses to exemplify the quality problem, is that there's always an opposite edge! Your fix might be a bug for someone else. There was one particular beautiful, high-quality, generalized, and case-covering npm module, but those very facts about it made it unworkable in one past project of mine, which had strict requirements around footprint size.

It's funny we use the word "ecosystem" to talk about this stuff. An interesting parallel is r/K-selection in ecology, where your species either favors nurturing a small few offspring, or churning out a big swarm and hoping that a few survive. Elephants vs. lemmings.

I would at least be careful using Redux to push realtime animation state changes. Returning a fresh application state every 16.6 milliseconds means a lot of object allocations, which means garbage collection, which means UI freezes turning your smooth animation design into an unpleasant experience.

There may be a general solution for this out there, or at least an approach that makes it workable for some cases, but I haven't come across it yet. And of course it really depends on how demanding your performance needs are. You might be able to get away with using Redux for animations despite the above.

It would be great to see something like Redux that gives you debugging precision all the way down to the animation frame, but which avoids the garbage problem.

I agree that big, deep stuff like architecture and abstractions can be daunting, but I wouldn't be quick to dismiss style and formatting as mere nitpicks. Code clutter can have an outsize effect downwind of those who create it.

A codebase is like a home. We all have to live in it. Architecture and abstractions are like the furniture and appliances. Code formatting and syntax are the nicknacks, paper bills, decorations, cat toys, board games etc.

Does the toaster really belong on top of that highly flammable mattress? This is a big, deep question about the overall functioning of the home. But throw a pile of ratty blankets on top, put some boxes of moldy half-eaten pizza around the floor, and maybe wind that kite string over the doorknob and around the teetering bookcase. Can you still see the toaster? How do you plan to get in there to move it to a proper place?

Small issues can block, conceal, misrepresent, and make big issues even more dangerous. Which why I say: fix all the small things first and stop new clutter from appearing (lint your code), then talk about rearranging the furniture.

Code clutter is much more consequential than it gets credit for. Poor formatting, inconsistent whitespace, snips of unused code, and misleading filenames are speedbumps (or worse, spike strips!) that a developer is going to hit every time they sit down to code.

And unlike bad abstractions -- which you can "learn" about and mentally model -- the friction of clutter is a constant damping to your productivity.

Building features in a cluttered codebase is like being asked to install plumbing in a hoarder's basement.

Understanding a cluttered codebase is like reading an advanced math textbook by candlelight that was written with broken typewriters by a group of modernist poets.

De-cluttering is the first thing you should do, and you should stick to it above all else. Before you add tooling, before you refactor, before you abstract and framework-ize, get rid of the clutter. That means format your code, and use a linter whose rules are based on widely adopted community conventions.