iambvk

I did some research and just purchased Thinkpad X1 Nano Gen 9 last week. My Debian Linux setup was fairly easy.

I had to drop Macbooks because it's NVMe SSD is soldered and is not upgradable.

Thinkpad X1 Carbon is a decent choice, but they all seemed to be limited to 1920x1080 screen resolution for some reason -- which is a big-no for me.

Does it support NVME for storage? I only see MicroSD card.

What is the benefit?

This depends on the deployment model. I am curious, how does your release and deployment looks like?

Instead of Read-Modify-Write, I like to think of it as Read/Determine/Write cycle.

A note worthy point is that, Paxos actually expects proposers to drop their value and carry-forward someone-else's value to complete the consensus. This is typically not an intended behavior from client's point of view, but proposers role is to form the consensus, not push their value.

Read phase is basically understanding if there is any value that could've been chosen when F nodes are unavailable.

Determine phase is to choose to carry-forward any value (if-any) from the Read phase or use the new value from the client.

Write phase is to actually ask majority of the acceptors to save the value selected in the Determine phase.

I totally agree. Paxos is such a simple solution that it is so amazing.

I agree with `Get` returning `(T, bool)` I don't see why one would want to return an `error`.

It becomes painful to write in unit tests.

I really liked their `check` proposal. I hope they will bring it back to life.

Such assumptions break network request retries and/or relies on proposer-identity, etc.

Here is what the paper says:

Phase 1.

(a) A proposer selects a proposal number n and sends a prepare request with number n to a majority of acceptors.

(b) If an acceptor receives a prepare request with number n greater than that of any prepare request to which it has already responded, then it responds to the request with a promise not to accept any more proposals numbered less than n and with the highest-numbered proposal (if any) that it has accepted.

Important part of the statement is

  ...with a promise not to accept any more proposals numbered less than n...

So, Phase-1 promise is not on the proposer-identity, but on the proposal-number.

I do not want spend more time on this, so I will let you explore.

Algorithm is not tied to the proposer identity (uuid or fqdn or ip, etc.) The promise in Phase-1 response is not to the proposer, but to the proposal-number.

In your model, proposer cannot change his identity, between Phase-1 and Phase-2 which is not a constraint imposed by the algorithm.

Sure, imagine all nodes are crashed (due to poweroff) in the middle of two proposers A and B doing Phase2 with the same proposal-number, but different values. Remember, they can go to Phase2 cause their proposal-number is the largest ever seen when they are the first.

Proposer-A received Phase2 votes from nodes n_1,...n_f and Proposer-B received one vote from n_f+1 when power is off and other nodes n_f+2, n_f+3...n_2f+1 don't know anything about the Phase2.

Now, consider the case when power is back and only the first F+1 nodes came back online. System is expected to continue with F+1 live nodes.

Proposer-C now does Phase-1 with the same proposal-number. He is expected to pick the already voted value associated with the max proposal-number from the Phase-1 responses, but there are two different values and he can't determine what to pick.

The problem is on the recovery path.

Recovery path needs to identify if there was a chosen value only from F+1 nodes (out of 2*F+1 nodes total).

When two proposers with same proposal-number, but different values have partially executed the protocol before the crash, then you would end up with all F+1 nodes with same proposal number indicating successful consensus previously, but with divergent values.

On Paxos: The following already seems wrong. AFAIK the proposal number space must be divided across proposers. If all proposers use minNumber+1 replicas will diverge on the chosen value.

  protected override void Propose(Instance r)
  {
    proposalNumber = minNumber + 1;
    Broadcast(r, MessageType.Propose, proposalNumber);
  }

Transient is one of my favorite packages now.

I replaced all my custom keybindings into transient under just one C-j keybinding. Now I have a meaningful popup window with my custom keybindings, so I don't have to remember the less-frequently used bindings.

Also, transient has this one cool feature, where you can configure a timeout to delay the popup window, which is also nice.

I wrote a browser extension and command-line tool for password-store. See https://github.com/bvk/past

Having NFC or Bluetooth on the hardware makes me paranoid. Aren't their software stacks large enough to be a security risk?

IMO, their taxable "income" is typically very less.

If they are not actually backed by dollar numbers, but with volatile assets (like real estate, stock, metals, or bitcoin, etc.), their holdings are not correct.

I don't know.

If you (or someone) could tell me number of network-hops and Disk-IOs involved in performing an RPC using Kafka streams, I will definitely take a look at them.

How do you think Google does?

To me personally, it is not monolith vs microservice that bothers me, but statefull vs stateless services.

If a service can't assume local state, it creates unnecessary design overhead. For example, you cannot achieve exactly-once semantics between two services without local-state. If you replace local-state with message-queues, you just turned 1-network-1-disk op into 5-network-3-disk op and introduced loads of other problems.

> Lots of people use a queue with six disk writes and fifteen network hops where a single socket write() could have sufficed

This issue is so wide spread in the industry...it makes me sad.

Google domains page says $98 a year after early-access.

$98 a year? Are they serious? Do they think all developers live in the first world?

Begin Greencard processing and get I-140, after which, you can keep extending your H1b beyond 6 year limit.

It has as much impact on my workflows as Magit does. If you are an Emacs user on Linux, you should give it a try.

+1 for Ubuntu Mono. IMO it has just enough styling that rest all feel like, too dull or trying too smart or plainly inconsistent.

Sounds interesting cause I like to use Go everywhere. Do you have any example we could look at? Thanks.

Why-Not depends on which side you fall into. There are two sides: People with Debt and People collecting Payments.

People-Paying would love to start from zero.

People-Collecting would not want that.

If you think about it as two groups (theoretically): one group receives monthly, recurring payments from the other group.

In practice, individuals move from one group to another group and back, etc. based on life circumstances.

But here is a catch: Due to a bug or design, if an individual (or few individuals or families) could always stay in the receiving-group, he can live for free till end of time (or system halts/collapses.)

What will blow your mind is, are there such individuals or families in the system by design?