nivertech
language families, not ethnicities
/ə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 jumpUNIX 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
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 will 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 ;)
—-
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.
https://www.danshapiro.com/blog/2026/01/the-five-levels-from...
January 23, 2026
72 comments
https://news.ycombinator.com/item?id=46739117
There are several other similar posts/videos. Steve Yegge also talks about it.
00 -> 0.0
01 -> 1.0
10 -> Inf
11 -> NaN
00 -> 0.0
01 -> 1.0
10 -> Inf
11 -> -InfThe number of alternative public and semi-public companies went up exponentially (Reg CF/Reg A, crypto ICOs).
After reaching some thresholds a Reg A company can become public and even trade on OTC markets.
There is only unofficial build:
Claude Desktop for Debian-based Linux distributions
https://en.wikipedia.org/wiki/ISAM
https://en.wikipedia.org/wiki/Record_Management_Services
They were more like BerkeleyDB and lacked Query Planner.
I think Oracle internally using something similar, i.e. a native filesystem optimized for an RDBMS.