gioele

No silver option?

> Excellent technical history, but it misses what made Olivetti incomparable: Adriano's human-centric philosophy that business and human culture were inseparable. > > The article mentions worker housing and urban planning in passing, then moves on. But that was the strategy. Ivrea wasn't welfare—it was integrated design. Factory, housing, schools, public spaces all operating under one coherent philosophy: machines and lives should both be beautiful and functional. > > [...] > > That's why Olivetti succeeded where technically equivalent competitors didn't. They engineered for humans, not just machines.

Two decades ago I randomly found myself in a tiny lecture room with a Very Important Manager from a Very Big European Bank. She started her talk stating "In the '80s, the Italian politics had to choose between the economic model of the Olivetti's family and that of the Agnelli's family. They choose Agnelli's. That was a mistake." Followed by a long string of expletives.

For context and for contrast, the Agnelli family was the owner of FIAT, then the biggest private employers in Italy. They were strongly anti-unions. They even bought the most important newspaper in Turin (the headquartiers of FIAT) to suppress reports of workers initiatives and strikes.

> The whole patch quilting thing is awful. Just keep the patches as commits.

I'd say that `quilt` the utility is pretty much abandoned at this point. The name `quilt` remains in the format name, but otherwise is not relevant.

Nowadays people that maintain patches do it via `gbp-pq` (the "patch queue" subcommand of the badly named `git-buildpackage` software). `gbp-pq switch` reads the patches stored in `debian/patches/`, creates an ephemeral branch on top of the HEAD, and replays them there. Any change done to this branch (new commits, removed comments, amended commits) are transformed by `gbp-pq export` into a valid set of patches that replaces `debian/patches/`.

This mechanism introduces two extra commands (one to "enter" and one to "exit" the patch-applied view) but it allows Debian to easily maintain a mergeable Git repo with floating patches on top of the upstream sources. That's impossible to do with plain Git and needs extra tools or special workflows even outside of Debian.

Kudos on releasing Yandori!

We have been (low-keep) working on something similar (more from an academic point of view) for the past few years:

This is the introductory article (open access): "Comparison of news commonality and churn in international news outlets with TARO" https://dl.acm.org/doi/abs/10.1145/3603163.3609062

(Allow me a moment of pride for the student leading this project: the paper won the Ted Nelson Award at ACM Hypertext 2023.)

We need to drive down the cost of dealing with nuclear waste. Possibly to zero, because that is a cost that will have to be paid basically forever.

Between 1961 and 2023 «5,600 TWh of electricity were generated from nuclear energy in Germany». [1]

Every year Germany spends (and will have to spend until the end of time) at least 2 billion Euros just to keep the existing nuclear waste safe [2] (more than half of the yearly budget of the ministry of the environment and about 0.5% of the yearly government budget). That's a drag. Think about it: it's all unproductive money, that does not produce any new energy, and stopping these payments will cause irreparable damage to the environment. Forever.

[1] https://kernd.de/en/nuclear-energy-in-germany/ [2] https://www.bundesumweltministerium.de/ministerium/struktur/...

There is work going on at freedesktop to standardize drop-in config files:

«basedir: support separate (vendor/local) trees and masking for config files» https://gitlab.freedesktop.org/xdg/xdg-specs/-/merge_request...

«basedir: support drop-ins for configuration paths» https://gitlab.freedesktop.org/xdg/xdg-specs/-/merge_request...

MailmanLists is a valid service run by competent people: https://www.mailmanlists.net/

They provide plain good ol' GNU Mailman lists. You can bring your own domain or subdomain. They also have a good handle on privacy issues (GDPR requests and so on).

Related to this topic (spouse with Alzheimer), there is a touching story by Alice Munro: "The Bear Came Over the Mountain", the closing story of the book "Hateship, Friendship, Courtship, Loveship, Marriage".

Just a remark: the person whose fingerprints have been reconstructed and that was the defense minister of Germany at time of the stunt (Ursula von der Leyen), is now the president of the European Commission (~= head of the EU government).

> The only thing that Japanese dont get ( and they somehow still dont ) is Software.

cough Ruby cough

In far fewer words: https://heeris.id.au/trinkets/ProgrammerInterrupted.png

> If there was such small incentives I would've immediately subscribed $5/m to following project: Nodejs, Postgres, Node-Pg, [...]

Who would receive that money? Only the core developers? Anybody with "commit access"? In which share? Will it detract voluntary contributions? How should other companies working on the same code-base be treated? Are they allowed to contribute at all? Do they get some shares of the funds?

All these questions (and many others) that have been discussed in the Debian project for a long time and nobody has yet found an answer that is acceptable to everybody.

Some sources:

* "Debian + Dunc-Tank.org = dissent" (2006) https://lwn.net/Articles/201488/

* "Paying (some) Debian developers" (2019) https://lwn.net/Articles/790954/

* "DPL: Debian project has plenty of money but not enough developers" (2020) https://www.theregister.com/2020/09/10/debian_project_addres...

> it's very common - risc-v also has a 2-instruction compressed subset > > Note: "jalr zero, 1b" can also be written as "j 1b", "jalr zero, 0(ra)" can be written as "ret"

`j` and `ret` are so-called "pseudo instructions" [1], not compressed instructions.

Pseudo instructions are just shortcuts used in assembly language to pretend that some common operations really "exist" without the need to type (or display) the corresponding more complex (but actually existing) instructions. `nop` is a common pseudo instruction. RISC-V has no real `nop` instruction, but, instead, the "do nothing instruction" is canonically encoded as `addi x0, x0, 0`. The programmer can write a more understandable `nop`, and the assembler will write instead the binary code equivalent to `addi x0, x0, 0`.

The compressed instruction set (a.k.a "extension C"), instead, is a subset of the full [2] instruction set, in which a restricted combinations of operands are possible. The assembly (human readable) code of the compressed instruction set looks similar to that of the full instruction set (including pseudo instructions), but they are encoded as completely different binary sequences.

[1] https://github.com/riscv/riscv-asm-manual/blob/master/riscv-...

[2] https://riscv.org/wp-content/uploads/2019/06/riscv-spec.pdf#...

> While we're at it, can we stop replacing physical knobs and buttons by dumb touch sensitive buttons ? I feel like a cave man when I have to repeatedly press "+" on my induction hob and hear the stupid beep it makes x times.

Most induction systems can be controlled by ovens that have physical knobs. For example the AEG EU327MDE [1]. The hob-oven interface is more or less standardized. For unfathomable reasons such combined "induction hobs + compatible oven with physical controls" are not sold in all markets worldwide.

[1] https://www.euronics.de/haus-und-haushalt/kochen-und-backen/...

> I don't know how they're encoded on their database.

All hentaigana are available in Unicode 10. They can be found in the Unicode block 1B000–1B12F (Kana Supplement + Kana Extended-A).

For example, U+1B004 𛀄 HENTAIGANA LETTER A-3

The technical term for this kind of markup is "stand-off markup" or "stand-off annotation".

There is wealth of research done on stand-off markup since the SGML times, with a renaissance in 2005-2010.

Historically, the main drawback (as highlighted by other comments) is that stand-off needs a way to refer to the content, i.e. a pointing mechanism. Pointers in a pointing mechanism can be either a) hard to write but easy to maintain or b) simple to write but prone to breaking after a change (and thus requiring support from authoring tools). Nobody has found a viable ergonomic balance yet.

That is just a coincidence (decimal ending in "5"), plus the fact that `.to_d` does some cleanup preprocessing.

Counterexample:

  BigDecimal("1.5999999999999996") == 1.5999999999999996.to_d
  => false

The most ergonomic way to initialize decimal numbers is IMO

  "123.45".to_d

(Note the quotes around the number. `.to_d` is being called on a string.)

BigDecimal's only lossless API is through strings. It would be nice to have native support for decimals at the parser level:

  0d123.45 => BigDecimal("123.45")

I also appreciate using `git whoami` to check the current identity settings:

    $ git whoami 
    GIT_COMMITTER_IDENT=Mel Smith <[email protected]>
    GIT_AUTHOR_IDENT=Mel Smith <[email protected]>

`whoami` can be implemented via a simple alias:

    git config --global alias.whoami = "! git var -l | grep '^GIT_.*_IDENT'"

> Without IdenTrust, Let’s Encrypt may have never happened and we are grateful to them for their partnership.

What I have never understood is why IdenTrust accepted to cross-sign Let’s Encrypt's root certificate.

With that move, IdenTrust basically broke the CA cartel and helped driving the price of basic certificates to zero. How did they, as a for-profit organization, justify "doing the right thing" when that meant disrupting their own market?

Anyway, kudos to IdenTrust.

CCAN (C Code Archive Network) http://ccodearchive.net/ follows a similar philosophy. CCAN contains various small, self contained snippet of C code are meant to be be downloaded in a local directory ("vendored") and used directly or with small modifications.

The most straightforward way to use CCAN is to

1) `git clone` it in a subdir;

2) create a `config.h`;

3) include whatever `lib.h` you want in your project.

Updating these micro dependencies means doing `git pull`.

All libraries come with tests and a somewhat standardized API design.

What is missing (compared to your aims) is a declarative way to lock a dependency to a specific version.