ZFS has

- redundancy

- striping

- compression

- encryption

- mountpoints

- volumes

- quotas

- snapshots

- send/recv backups

- disk error detection (ECC protects memory only)

All built in with consistent well-documented tooling. No futzing around with lvm mdadm fsck luks fuse fstab etc.

> one designated "origin" remote

Git is not limited to a single remote. The default remote is called "origin" but there's nothing particularly special about it.

To be more precise, git clone adds the origin cloned from as a remote named "origin", unless you override this with a configuration setting or the -o option.

The default is no remotes at all.

But git gives you nothing to handle more complicated topologies, all remotes you interact with have to result in a linear history with everything on all other remotes… unless you feel like doing a manual merge every time you update your social media feed. Making that work automagically needs another layer on top of git, none of which seems documented here.

Humans have feelings, hopes, and dreams. Humans are a subset of the universe. Therefore, the universe has feelings, hopes, and dreams.

Now that the universe has manifested we conscious agents of its matter, how dare we squander this gift? Just because it didn't come with an instruction manual? We will find our own purpose.

Does the universe enjoy having feelings, hopes, and dreams? This kind of thinking is anthropocentric and doesn't generalize to any scale. Consider cancer cells thinking that their goal (growth) is good for the organism, because, after all, they are part of it.

As a tiny representative of the universe, yes I do enjoy having feelings, hopes, and dreams. If nihilists find this to be meaningless, perhaps we simply disagree about which of us is the cancer.

It it is an interesting conversation to me even if it moves into a philosophical realm, where I have little to no experience. Why would we think of ourselves as the representatives of the universe, whereas we are closer to resembling atoms at the scales involved ( and even that seems to embellish our relative size ). Does having feelings, hopes and dreams bestows the status of an envoy? Nihilists do not see things as meaningless, which may carry negative connotations ( 'the cancer part' ). Rather, things are devoid of meaning. Nihilists recognize that meaning is not inherent, but rather ascribed by the person experiencing the feeling.

I will admit that I chuckled at the cancer comparison. How does the universe consider, which cells are 'good'?

If you show a skyscraper to an ant, should he abandon his queen because their little hill is too insignificant to matter? Or should he jump back in and build the best damn nest in the city? I just don't think relative scale is really important - even a galaxy-striding star-snacking titan would grapple with the same problem of meaning.

> Nihilists recognize that meaning is not inherent, but rather ascribed by the person experiencing the feeling.

That sounds reasonable, so here's an attempt at a synthesis. The universe is huge and mostly empty, but here we have a tiny patch full of life and self-ascribed meaning. Does the universe prefer life? The part that's alive certainly does! So don't let it fall to ashes just to appease the void. I think that's the best answer a mere mortal can give.

    grep -o $pattern $filename | wc -l

But yours has better error handling!

That's a fine idea, but this would not be an open source (https://opensource.org/osd) license.

> 5. No Discrimination Against Persons or Groups

> The license must not discriminate against any person or group of persons.

> 6. No Discrimination Against Fields of Endeavor

> The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.

Depends on what you call open source. In my view, it's open source if the source code is open for viewing by anyone. That doesn't say anything about the cost of using the code in a commercial situation. Anyway, you could start a new movement and call it "fair source", where programmers are properly compensated for code used by large companies who make millions using it.

>if the source code is open for viewing by anyone

That would be _source-available_. Open source is well understood to also enable modification and redistribution - see Wikipedia's[0] or Merriam-Webster's[1] entry on open source.

Also, open source says nothing about using the code in a commercial situation to begin with. The most popular open source licenses (MIT, Apache, GPL, ...) don't distinguish commercial and noncommercial usage.

I agree that the situation with large companies is not easy. Either you pick a stricter license like GPL, and risk your software being left unpopular, or pick one that enables popularity more, like MIT, but then risk being taken advantage of by the lack of restrictions. I think it's a tough call.

[0] https://en.wikipedia.org/wiki/Open_source

[1] https://www.merriam-webster.com/dictionary/open-source

How about an open core under something like GPL and a set of extensions under something like MongoDB's SSPL (server side public license)?

> var myValue = DoSomethingAsync().ConfigureAwait(false).Result;

Came out a decade ago and we still don't know how to use it safely.

This example doesn't compile because there is no Result on ConfiguredTaskAwaitable. Regardless, ConfigureAwait(false) does absolutely nothing here because this Task is not being awaited.

If you're going to block this thread, you must push the work to another thread or it's going to deadlock when the implementation tries to resume a continuation (unless the implementation is 100% perfect and the SynchronizationContext smiles upon you).

var result = Task.Run(() => CalculateAsync()).GetAwaiter().GetResult();

This avoids the deadlock but can lead to other nasty things like thread pool starvation. The only true solution is to go async all the way - https://blog.stephencleary.com/2012/07/dont-block-on-async-c...

> Regardless, ConfigureAwait(false) does absolutely nothing here because this Task is not being awaited.

It does help if there is a SynchronisationContext active, like in legacy ASP.NET

No, really. ConfigureAwait configures the await. If you don't await - if you block by calling .Result - it does nothing

That seems like a poor design in apt. Does any other package manager allow such a thing? I know Arch's pacman has no autoremove - you have to gather a list of unneeded packages then remove them as a separate step. And Gentoo's emerge builds a dependency tree rooted in the @world package set, so if kde-plasma/plasma-meta is there it will never be removed by an automatic depclean.

Nominally-typed interfaces are still clumsy in some circumstances. For example, if I consume a library with

    namespace ThirdParty {
      public sealed class Foo { public void Do() { } }
    }

and I want to hide it behind

    namespace MyCode {
      interface IFoo { void Do(); }
    }

the compiler does not accept ThirdParty.Foo as an implementation of MyCode.IFoo so I must define a wrapper

    namespace MyCode {
      sealed class ThirdPartyFooAdapter : IFoo {
        public ThirdPartyFooAdapter(ThirdParty.Foo instance) {
          _instance = instance;
        }
        readonly ThirdParty.Foo _instance;

        public void Do() => _instance.Do();
      }
    }

which only gets more tedious as the number of methods and implementations grows.

While I agree, I feel that third-party library consumption is a bit of an edge case (i.e. the majority of your interface implementations won't be wrappers around third-party stuff).

Whenever I do work closely with a third-party library, the wrapping pays for itself quite quickly because it never takes long for you to find a 'quirkiness' or unsuitability in how the library implements something and you end up with code resembling this:

   public void Do() {
     _instance.SpecialOptionForTheBehaviourYouRequire = true;

     try
     {
       _instance.Do();
     }
     catch
     {
       // Workaround for bug that has not been fixed in ThirdParty Library yet. Remove when fixed!
       _instance.ResetBrokenStateCausedByBug();
       _instance.Do();
     }
   }

The vscode source does have telemetry enabled by default, which is why vscodium exists to patch it out.

Oh come on now - don't pretend that comment was some neutral statement of fact. It was a clear implication of moral failure in your opponent's argument. And it's not really persuasive to then double down on a false dilemma (is my out-group evil, or just stupid?).