justhelpingout

Almost no one chooses that their child should have a disability. Epsilons were created for their plasticity.

If we were creating them, then _Brave New World_ would be very applicable. But helping someone who has come to be through no intention of others accomplish good things in their life is good.

`let lifetime = max(...components_lifetime)` is like `let size = to_greeklish(base10(hard_drive_capacity))`. Some people don't care, but the people who do care are not going to thank you when they optimize on the basis of the appearance of a promise with an actual performance that is opposed to its appearance.

Oliver Twist's England, surely, where children are pressed into service in dangerous factories that can severe limbs and kill, for mere pennies a day?

Otherwise, we definitely agree. We are fallen creatures and will drive earth to hell, regardless of which car we decide to drive there in. Only external help can save us from ourselves.

Morals and ethics are either relative or absolute. If they are relative then they are not based on "what a thing is" (it's essence, to use an Aristotelean term) but on "how useful it is to me" or some other relative criteria). If, on the other hand, "what you ought to do with this thing" is based on "what is this thing and what is it intended to be", then there must exist some `intender` who is the reason for this thing's form / end being what that form / end is.

Socialism without morality leads to Stalinism. Socialism with morality requires strict (e. g. sworn) obedience to a higher authority (see the monasteries of Catholicism which are strictly speaking socialist).

A system of ethics and moral rules that is evolved over time with no relation to how things are in themselves is simply so much legacy code, to be replaced by the stronger man at a time convenient to him.

If, on the other hand, moral rules and ethics are due to the natures of things then there must be someone who intended things to exist in the manner they are intended to exist. That being must be a person because of the principle of sufficient cause (since we exist). Faith is the response to communication from this person. It does not require abandoning of reason, but simply picks up where reason cannot ascend to because of its lack of perspective.

The problem here is that the diff is not source, but "compiled" code. We ultimately come back to "Reflections on Trusting Trust" [1]

  [1]: https://www.win.tue.nl/~aeb/linux/hh/thompson/trust.html

Article says "YES!"

> This new runtime allows you to take advantage of Python's vibrant ecosystem of open-source libraries and frameworks. While the Python 2 runtime only allowed the use of specific versions of whitelisted libraries, Python 3 supports arbitrary third-party libraries, including those that rely on C code and native extensions. Just add Django 2.0, NumPy, scikit-learn or your library of choice to a requirements.txt file. App Engine will install these libraries in the cloud when you deploy your app.

Find a solid proof-of-work system for sharing signed data in this manner and you will change the world. Especially if you can re-combine the shared model with the local model.

> It seems much more simple to assume some system must simply exist without necessity of creation.

You are spot on. This system must exist in-itself. That is, it must be so simple that its existence cannot be separated from its nature (to use Aristotelean terms). In other words, I AM WHO AM.

See also _The Metaphysics of democracy_: https://www.firstthings.com/article/2018/02/the-metaphysics-...

In fact it is:

    sqlite3 .tup/db 'select name from node where type=4' | xargs echo rm -f

  [1]: https://github.com/gittup/tup/issues/120#issuecomment-64832104

http://www.newadvent.org/cathen/ and http://www.newadvent.org/summa/index.html

but the former is more like INFO while the latter is more like `man builtins` (that is, it assumes you already know a lot about the system)

You can certainly do this - you just need something to contain the enum since an enum is a nominal subtype of `number` already, so TypeScript unifies `number & anyEnum` to `number`.

The best tagging mechanism these days is `Nominal<T>` (which has no emit) or `As<T>` (which has a minimal amount of emit):

    interface Nominal<T> {
      'nominal type tag': T
    }

    class As<T> {
      private tag: T
    }

Both are used in the same manner:

    const enum SomeTag { }
    type Something = number & As<SomeTag>
    // or
    type Something = number & Nominal<SomeTag>

You can even avoid the boilerplate of `const enum` if you make the `T` of `As` or `Nominal` `T extends string`:

    type Something = number & As<'some:unique:string:tag'>

In both cases, the values are not unified, so:

    type Something = number & As<'kind1'>
    type SomethingElse = number & As<'kind2'>
    var x: Something = 123 as Something;
    var y: SomethingElse = 456 as SomethingElse;
    x = y;  // Type 'SomethingElse' is not assignable to type 'Something'.