/ən ˌɛs.kjuːˈɛl ˈkwɪri/
  vs
  /ə ˈsiːkwəl ˈkwɪri/

  “a San Francisco startup” /ə ˌsæn frənˈsɪskoʊ ˈstɑɹtˌʌp/
  vs
  “an SF startup” /ən ˌɛsˈɛf ˈstɑɹtˌʌp/

A. you reduce impedance mismatch, but making the new language using similar concepts and mechanisms

--

You're right, this table is just a coincidence, probably derived from the standard math notation, and used in many PLs like FORTRAN and Python ;)

  PDP-11        C
  
  INC R         ++i
  DEC R         --i
  ADD src, dst  dst += src
  SUB src, dst  dst -= src

  (R)+          *p++
  -(R)          *--p
  X(R)          p[x]
  @(R)+         **pp++
  @X(R)         *p[x]

  BR label      goto label  ; near jump
  JMP label     goto label  ; far jump

UNIX for PDP-7 in Assm -> UNIX for PDP-11 in Assm -> UNIX for PDP-11 in C

https://news.ycombinator.com/item?id=42644851

and

https://news.ycombinator.com/item?id=43245166

this can't be true, If that hardware can run Django and Phoenix, it for sure can handle orders of magnitudes more concurrent clients than 50 even before you start tuning the OS and the runtime.

> Playwright headless Chromium

maybe you mean you're unable to generate more than 50 concurrent clients using Playwright+Chromium - but that's the wrong tool for loadtesting.

Loadtest should run from a different machine or cluster of machines/VMs. You can generate up to ~ 64K outgoing connections per IP address / alias. With 17 IP addresses/aliases you can generate up to C1M.

That's for a single node.

Then try multiple nodes / cluster - C1M, C2M, C10M, etc.

Also, all concurrent clients should send periodic pings / keepalives and do something useful (e.g. some CPU work, not just being idle).

Then you'll have to change your conclusion from:

> The data answers my original question: yes, Django LiveView holds up against Phoenix LiveView. In day-to-day operations they are practically equal.

to

> The data answers my original question: yes, under *toy* load Django LiveView holds up against Phoenix LiveView. For *toy* operations they are practically equal.

Django LiveView vs Phoenix LiveView: a real benchmark

https://en.andros.dev/blog/80134668/django-liveview-vs-phoen...

Hard to take this seriously without the loadtest with the the large number of concurrent users.

For a number of users concurrently reading a long-tail blog post - you will get good results even using DotCom era HTTP polling.

---

See:

Django LiveView vs Phoenix LiveView: a real benchmark

https://en.andros.dev/blog/80134668/django-liveview-vs-phoen...

The dichotomy is generic vs custom/bespoke:

- generic (CRUD / REST / RDBMS+SQL+ACID Tx / Tx Scripts / 2PC / BPMN / Admin UIs) - also SmartUIs/Fat Clients (VB, Delphi, SPAs, etc.)

vs

- custom (DDD / CQRS/ES / Sagas / Process Managers / Durable Executions / TBUI)

Also, learning data engineering and BI helps one better model the real world than generic methods. It's somewhat similar to CQRS/ES, but with much more prior art

- stamp every initial request / domain event with the UUID (idempotency key)

- use client-side IDs instead of using server-generated ones with RETURNING

- use PUT instead of POST

- use UPSERTs

- etc.

IMO, you migh as well use CQRS/ES which is a natural evolution of this idea of modeling the physical reality rather than trying to reduce it to CRUD/L

Here, we can draw an analogy between natural hedging and financial hedging (derivatives). Natural hedging requires planning, preparation, and hard work, and even that doesn't cover every scenario, but it's cheap. With derivatives, you pay someone else to take care of it. The other party may not even understand the underlying asset, but they have quant models (a technical solution)

RE: the question about the first mentions of idempotency keys, IMO cryptographic nonces (numbers used only once) are somewhat related. Idempotency keys are used to facilitate message replay, while nonces are used to prevent replay. But the basic idea is similar

But this naive actuarial model with a 100% deductible is obviously far less sophisticated than modern insurance ;)

—-

1. https://en.wikipedia.org/wiki/Hapi_(Nile_god)

2. https://en.wikipedia.org/wiki/Bastet

One of the most interesting was the thieves' union

Suppose someone stole yr carpet at night, and in the morning you'd go to the office of the head of the thieves' union, pay 25% of the carpet's value, and get it back. Much better than modern insurance!

1. how far behind the West it was, and

2. that there were no other secrets

Rapira was more like SETL + Python. It was a dynamic interpreted PL with a rich set of compound data types, such as sets, records (associative arrays), and so on. Compared to the contemporary BASIC, it was ADVANCED

Like Logo, Robik was used to teach programming to kindergarthen-age children, while Rapira was aimed at high school students

---

1. https://en.wikipedia.org/wiki/Robic / https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%B1%D0%B8%D0%BA

2. https://en.wikipedia.org/wiki/Rapira / https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%BF%D0%B8%D1%80...

You get lines like “no priors” or “embracing exponentials” that sound smart but mostly signal status

Same move as N Taleb and “convexity.” A real idea turned into a generic intellectual flex

But the main question is: does this FP2 have any real applications? Maybe it could be useful when only one operand is FP2? Especially for vectorized math.