_never_k

I don't exactly understand how you're hurt by this, but fair enough.

Utilitarianism is a philosophical framework. It's not for me, but based on your comments you might be into it:

https://en.wikipedia.org/wiki/Utilitarianism

You keep complaining about indulging! What's wrong with indulging in something every once in while?

Your first bullet is an argument against this change as being suboptimal. That there's a more optimally utilitarian use of the resources, which I get. The thing I don't get about this argument is that nothing Github (or any of us except for some weirdos) does is optimally utilitarian. They have a cartoon mascot! They don't _need_ that. You're not upset that they pay someone to draw Octocat, why be upset about this?

Your second bullet is an argument against this change from the position that it's an unasked for burden. In general, I get that. In the specific context of software engineering, it's a little more surprising. Tools, APIs, interfaces, terminology, etc... are in constant flux. Software has to be actively maintained to be kept functional. Software engineers have to always be learning in order to keep current. A vendor changing something like this is par for the course, right? Why such an extreme reaction?

>Austerity? Monks in cells?

You're complaining about indulgence! You're saying that this change won't help people as much as something else. This is a fair criticism. Changing some technical term is probably not a optimally utilitarian use of resources.

However, while you may be trying to live an optimally utilitarian life, the rest of us aren't. I can only speak for myself of course, but evaluating all my life's actions on only that axis is too strict for me.

But, like I said, if you want to do that: props.

Github inherited it from git, which inherited it from bitkeeper, the DVCS that Linux originally used and the one that inspired git. Bitkeeper used a master/slave architecture that git dropped.

https://github.com/bitkeeper-scm/bitkeeper/blob/master/doc/H...

Serious question: you're not the only person in this thread who feels this, and I genuinely don't understand it.

Why is this so upsetting?

Props to you for committing to your austerity, but we're not all monks in cells.

The terminology of master/slave architecture is a direct reference to the working relationships between people on an antebellum plantation. Names should help you understand what things do, and those names do. We also have node that elect leaders, nodes that get fenced, nodes with parents and children, etc...

The terminology of our software architecture, and of our software in general, mirrors that of the real world relationships that they model, reference, or are inspired by. That's a good thing. It helps us understand these systems. It's also true that if this terminology references something we don't like in the real world, we're free to change it. After all, master/slave architecture isn't a perfect modeling of a plantation, it's substantially abstract from that. There are many other relationships in the real world which could be used to describe this architecture.

Terminology is effective when it's stable, so we should be conservative about changing it, but that doesn't mean we should never change it.

>I think for the political arena it would do us good to try to emulate the US House of Representatives where representatives are given equal time to address the floor.

This is a weird example. Representatives don't listen to each other. The speeches are for their constituents.

>Featured Comments are chosen by a team at NYT, presumably from ideologically diverse perspectives, and they choose comments that are insightful and rich in information without toxicity.

Agreed, the solution to the problems caused by getting rid of gatekeepers is to bring back gatekeepers. How do you do it with something like twitter though, where there were no gatekeepers to begin with?

>Once you start fact checking where does it end?

With all the facts being checked?

>I think one element of writing ASM by hand is the programmer subliminally changes the algorithm to be 'simpler' to write.

It's not subliminal. It's packing a backpack that someone else has to carry, vs packing a backpack that _you're_ going to carry.

I think of the BLAS algos as being very Fortran friendly, and the Fortran references never _out_perform the C implementations. (The asm implementations are of course the best.)

Be curious to know what you're thinking of here.

This is real, but also not new (as you can tell from the name check on Flash, Silverlight and IE). They used to be called "supercookies", but that term has come to mean something else in the last few years.

Before rust, I would incrementally evolve an incomplete design into a complete design (building a tree by building leaves, branches, and a trunk and then assembling them.) In rust, my early incremental versions would have lifetime issues that I used to not worry about until later. Now I start with a very small complete version that I make bigger (building a tree by increasing the size of a sapling.)

I do everything this way now (JS, python, etc...)

I live in the US and have a local US IP. A year or so ago, I made a site for a side project using vanilla HTML. No frameworks, no JS. Every word on the page was in English and could be found in an English dictionary.

When I first stood the site up and tested it, Chrome would always break in as soon as it loaded, with a popup to translate the site into _English_ from _Romanian_!

I was able to suppress this only by turning on every single language hint in META.

They work, but there's much more friction and many more gotchas than node. The requirements file for example, doesn't distinguish between direct and ancestor dependencies, it has to be explicitly passed to pip, you need to have created and activated your virtual environment correctly, many python libs have fragile, c based builds. Node and nvm just work.

This is the way I feel too. Python is both redundant and inconsistent at a basic level. The APIs for `map`, `filter` and `reduce`, the inversion between `split` and `join`, `sort` vs `sorted` -- it's all very weird. And these aren't advanced features.

When I hear people describe Python as simple and elegant, it feels like they're using a different language than the one I know.