My personal discipline is to always phrase imperatives as trade-offs: * You should be tithing some of your time to understanding your computer. It's not enough to ask why others have not made it easier for you to understand your computer. * You should be willing to put up with klunkier interfaces in exchange for nicer implementation properties. (Eat your vegetables.) Sticking with text mode is an extreme form of this, hopefully I can break out of that in time. * You should be willing to take on some complexity in selecting forks of software to depend on, in exchange for a simpler computing stack once you've added them. * You should be willing to give up efficiency for safety. Memory leaks are ok if they avoid memory corruption. I think speaking in trade-offs is a major level-up in discourse over "why don't we have this yet?" Relevant is the Thiel question: "What important truth do very few people agree with you on?" Most answers turn out to be not very iconoclastic at all, because they aren't phrased as trade-offs. It's great that you want world peace. What do you think is worth giving up for it? So, what important but iconoclastic trade-off do you believe in? 🙂

This prompt also feels like a gentler version of the [your name] paradox thread from... the before times. In that my iconoclastic trade off is (of course) something like: you should accept that not all incidental complexity is avoidable, but what incidental complexity you have should be your choice. (Also — Interfaces vs Implementations, for anyone who missed it the first time around)

In fact, trade-off is also at the very core of the programming activity. It is good to know that as Future of Coding designer. You design tools with which people make trade-off all the time. Making and managing trade-off in programming is hard and intimidating. How the current state of programming actually helps programmers in that task? How to do it better?

That’s what I don’t understand: as programmers we make trade-offs all the time and we deeply understand the complexities involved in these trade-offs. But then when you listen to programmer conversations a lot of them are about how “it’s clearly better to do it a certain way”, as if that’s so easy to determine without having (and often not even attempting to learn about) any of the context.

my tradeoff is interactivity over abstraction. games are more fun (and faster) when you move your own avatar, not when you write a bot

Great answer, though I'm hopelessly addicted to bot-writing games: https://github.com/akkartik/brooks-ruby-warrior; https://2016.halite.io/user.html?userID=2460

Regarding "You should be willing to put up with klunkier interfaces in exchange for nicer implementation properties. (Eat your vegetables.) Sticking with text mode is an extreme form of this, hopefully I can break out of that in time." I once wondered why text editors weren't better designed, given that they're the software that programmers make for themselves. But the more I've studied other software packages, the more I've come to believe that text editors actually are the best software that's ever been made. To make this argument, I'd put software like Emacs, Vim, BBEdit, TextMate, VS Code up against things like Photoshop, Excel, After Effects, Ableton Live. In my book, the text editors always come out ahead. They're more flexible, they're faster, they're more powerful, in that features can be combined in freeform ways more gracefully. The basic building blocks of selecting and operating on data works more fluently than in any other software I've encountered. Most of them can also be extended in powerful ways. What do other people think? What software is better than text editors? (That's of comparable usefulness, I tend to want to narrow it to software that you actually make something with, e.g., because some utilities are so focused they practically vanish. But I'd still be curious what answers people have.)

Interesting. Just to clarify, though, I was alluding here to not using a graphics mode of the display.

I'm curious to hear if anyone disagrees that we'll always have trade-offs, there's no getting away from them.

We will always have tradeoffs but the winners and losers are not always the same person. I might be in a situation where "nicer implementation properties" genuinely don't benefit me. For example, I am basically insulated from the difficulties Intel engineers have in understanding their chip designs. If they have to take on enormous extra complexity to give me a minor performance improvement, then from the perspective of God it probably isn't worth it, but from the perspective of me, it is, because the cost in this trade to me is smaller than even a small benefit. In this sense a faster chip is always better, there's no tradeoff. In nand2tetris, the language you design, Jack, requires each line to either start with

set

or

do

. So instead of saying

obj.func()

you have to say

do obj.func()

, instead of

a = 123

you say

set a = 123

. The design tradeoff they made here is to make the implementation of the parser/compiler easier at the expense of an annoyance when using the language. In the context of the nand2tetris course this makes sense because the user of the language and the implementer of the compiler are both you, but if Jack was a real language this would be absurd. Finally, just because there will always be tradeoffs doesn't mean there aren't sometimes outright improvements. Leibniz's calculus notation is strictly better than Newton's, IMO.

For sure, the distinction between society at large and individual circumstances is important. I used the word 'tithing' above. Who should do the hard thing? She who can. There are many examples of strictly better things. To restate my question: does anyone expect a domain to ever decompose into a lattice of strictly better solutions?