
(#Bio)Informatics & WebDev @labsergen @uga_langebio | #Fitness Trainer | Marathon x4 | Cocinero , Opinions and views my own.
Guanajuato, México
Joined June 2017
- Tweets1.3K
- Following2.6K
- Followers325
- Likes4K
Linux 7.4 Features Very Exciting With Radeon HDMI 2.1 By Default, AMD PerfOpt, Apple M4
So many darn exciting changes expected for the Linux 7.4 kernel. Should be a wonderful end-of-year holiday gift for its stable release.
phoronix.com/news/Linux-7.4-…
Jacob Israel retweeted
An electron in a hydrogen atom has a characteristic speed of about 2,190 km/s in its ground state, roughly 0.73% the speed of light.
Niels Bohr’s 1913 model treated the electron as moving around the proton in a fixed orbit. Modern quantum mechanics tells a different story: an electron’s orbital describes where it is likely to be found, not a definite path through space.
The surprising part is that we can calculate its speed without being able to trace its journey like a tiny planet.
Jacob Israel retweeted
remove-ai-watermarks v0.46.0 — Remove visible and invisible AI watermarks from images and video, and AI provenance metadata from images, video, and audio... ktp.sh/PWesSDbnVK
Jacob Israel retweeted
Continuous batching in LLMs, explained visually:
(a popular LLM interview question; bookmark this)
In traditional ML inference, a batch is a matrix.
Every input is padded to the same length, one forward pass runs, and every row finishes at the same moment.
LLM decoding does not work that way.
One forward pass produces one token per sequence, so a request needs as many passes as it has output tokens, and nobody knows that count until the model emits a stop token.
Under static batching, membership is fixed when the batch starts.
A request that finishes in 30 tokens holds its slot until the slowest request in the same batch finishes at 400.
The GPU keeps paying the full weight read for a batch that is mostly empty.
Loading model weights out of HBM costs the same whether four slots are producing tokens or one.
Continuous batching moves the decision boundary.
Instead of scheduling once per batch, the scheduler runs a single forward pass, gets control back, and decides again.
A finished request leaves at the next iteration boundary, and a queued request takes its slot right there. No slot stays reserved for work that is already done.
Anyscale benchmarked both OPT-13B on a single A100.
With uniform generation lengths, the two policies came out about level (as expected), and as output length variance rose, static batching fell to around 81 tokens per second while vLLM reached 23x the throughput of naive Hugging Face serving.
Variance drives the entire gap.
Production traffic mixes 30-token replies with 400-token ones, which is exactly the condition static batching handles worst.
None of this alters the model.
vLLM, SGLang, TGI, and TensorRT-LLM all run it by default, and NVIDIA implements the same mechanism under the name in-flight batching.
The animation below depicts the continuous batching process. I took inspiration from Sreedath Panat's post on a recent post to create it.
To dive deeper into continuous batching specifically, I wrote a full breakdown of the scheduler underneath it.
It covers what happens between two forward passes, how tokens get handed out against a fixed budget, why the scheduler needs no separate path for prefill and decode, and what preemption costs you when the KV cache fills up mid-generation.
Read it below.
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: before you rewrite a legacy codebase, map it with 16 reverse-engineers at once and never let the big model touch the old code.
578 files, 16 services, mapped in 4 minutes. Opus alone was 6% through and already sitting on 34.2k of context.
You just launch Claude Code like this:
claude --model opus --rea-swarm 16 legacy/
here's the split:
→ Opus 5.5 splits 578 files into 16 services, one per agent
→ 16 REA agents reverse-engineer a service each, in their own context
→ every agent returns a summary, never the code it read
→ Opus 5.5 merges 16 summaries into one system-map.md
the part everyone gets wrong: they let the expensive model read the repo.
alone, Opus would have to read 578 files, 412k of context, and it drowns long before it understands the thing.
here it reads 16 summaries. 8.6k of context total, and it still ends up with the full map: services, rules, edge cases, conflicts.
the agents did the reading, Opus did the understanding. the raw code never left the swarm.
Opus splits. REA reads. Opus merges.
JEV engineering is the same move one layer down: the forks that need no thinker (which file next, which tool, retry or stop) go to JEV in milliseconds, and the big model only sees the ones that actually split
the full tree:
> Opus 5.5 runs the main session and splits the repo into services
> 16 REA agents reverse-engineer one service each, in parallel
> every agent reads its own files and returns only a summary
> raw code never enters the main context
> Opus 5.5 merges 16 summaries into one system map with rules and conflicts
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Opus 5.5 and split any legacy repo into services before reading anything.
2. Spawn one REA agent per service, each with its own context, all in parallel.
3. Every agent returns a structured summary only. Raw file contents never enter the main session.
4. Merge the summaries into a single system map listing endpoints, rules, edge cases and conflicts between services.
5. Add one rule to CLAUDE.md: no rewrite starts until the map exists and every conflict is resolved.
6. Route fast deterministic forks (file order, tool choice, retries) through JEV. Show me every change as a diff first. No edits until I say go."
↳ code.claude.com/docs/en/mode…
save it, you'll use this on the first legacy repo you touch.
Jacob Israel retweeted
Excaliflow just got multi-canvas tabs and auto-save.
You asked for it on X, so I shipped it.
Added this with Gemini 4 Argon in Antigravity in one session.
It's 100% open-source: github.com/Shubhamsaboo/awes…
This is NOW 100% open-source.
Built with Gemini 4 Argon in Antigravity (plus gemini 4 argon is now available for pro users).
GitHub Repo: github.com/Shubhamsaboo/awes…
Jacob Israel retweeted
Looking to test TCP and UDP ports on Linux?
This guide shows you 5 practical ways to check whether ports are open, closed, or reachable using `nc`, `nmap`, `ss`, and built-in Bash commands.
Learn how to test remote ports, check listening ports, scan TCP and UDP services, and troubleshoot network connectivity directly from the Linux terminal.
📖 Read here: tecmint.com/test-open-ports-…
👉 Follow @tecmint for daily #Linux, #LinuxTips, #Networking, #TCP, #UDP, #Nmap, #Netcat, #SysAdmin, and #TechTips
Jacob Israel retweeted
How to Take a Website Screenshot with Python
Vendor-authored Site-Shot tutorial: Python SDK, CSV batch captures, and a local HTML index. Requires a paid Site-Shot API plan.
site-shot.com/blog/take-webs…
Jacob Israel retweeted
Ya curamos al árbol al que le cortaron la corteza para matarlo en @BJAlcaldia . Le pusimos tierra humeda con sustrato, fibra de coco y lo envolvimos con yute. Gracias vecinos de @VillaDeCortesBJ! 🌳También tenemos la evidencia en video de los culpables! 👹 Supercivicos.com
“La 4T, su modelo de redistribución del ingreso, privilegia los programas sociales, el dar el dinero en efectivo y ha dejado a un lado la provisión de servicios públicos tan importantes como es la educación y la salud”: @leozuckermann en #TercerGrado | Mira el análisis en nmas.com.mx/en-vivo/?canal=n… y escúchalo en todas las plataformas de audio. #Podcast
Jacob Israel retweeted
kuva v0.6.0 is out!
New:
Genome browser layout: stacked tracks on one shared axis, so coverage, variants, amplicons and genes line up column-for-column.
-Typeset math in labels (typst)
-NA handling on the CLI
-15 new colour palettes.
Full release notes:
github.com/Psy-Fer/kuva/rele…
Jacob Israel retweeted
Quick Linux tip:
When you need to create several directories at once, you don’t have to do it one by one.
The mkdir command supports brace expansion, letting you create multiple nested directories in a single go.
$ mkdir -p ~/scripts/{site-01,site-02}/{backup,monitoring,network}
This instantly creates folders for two sites, each with its own backup, monitoring, and network directories.
A neat way to save time and keep your directory structure organized.
Jacob Israel retweeted
LLM = Smart, but works only with what it was trained on. Its knowledge is fixed after training, and when it lacks relevant information, it may generate plausible-sounding but incorrect answers (“hallucinations”).
RAG = Smart + can “look things up” in real time. It retrieves specific, relevant information from an external source and combines it with the LLM’s reasoning to give more accurate, up-to-date answers. Still, if retrieval is poor or ignored, hallucinations can happen.
Agent = Smart + can “decide what to do next” to reach a goal. It reasons through problems, chooses and uses the right tools (like web search or APIs), and can optionally maintain memory of its steps. This enables it to handle complex tasks that require multiple actions.
----
Follow @techNmak
Jacob Israel retweeted
Learn Linux before Learning Cloud
Learn Linux before Learning Docker
Learn Linux before Learning Kubernetes
Learn Linux before Learning Terraform
Learn Linux before Learning Git
Learn Linux before Learning Computer Network
Learn Linux before Learning programming
Jacob Israel retweeted
GIT Cheat Sheet
Follow @techNmak
Jacob Israel retweeted
HTTP 2 vs HTTP 3 — What's the Difference?
• 1996 → HTTP 1
• 1997 → HTTP 1.1
• 2015 → HTTP 2
• 2022 → HTTP 3
But what’s the difference? Starting at the foundation:
🔹 𝗛𝗧𝗧𝗣 𝟭.𝟭:
✓ 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 — Reuses connections instead of opening new ones
✓ 𝗖𝗵𝘂𝗻𝗸𝗲𝗱 𝘁𝗿𝗮𝗻𝘀𝗳𝗲𝗿𝘀 — Sends data in parts instead of waiting for the full response
✓ 𝗜𝗺𝗽𝗿𝗼𝘃𝗲𝗱 𝗰𝗮𝗰𝗵𝗶𝗻𝗴 — Introduced headers for better caching and connection management
🅇 𝗦𝗲𝗾𝘂𝗲𝗻𝘁𝗶𝗮𝗹 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 — Requests block each other (HoL blocking at the request level)
🅇 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗻𝗲𝗲𝗱𝗲𝗱 — Browsers used multiple TCP connections for speed
It introduced core features still used today.
🔹 𝗛𝗧𝗧𝗣 𝟮:
✓ 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲𝘅𝗶𝗻𝗴 — Multiple requests in a single TCP connection
✓ 𝗛𝗲𝗮𝗱𝗲𝗿 𝗰𝗼𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 (𝗛𝗣𝗔𝗖𝗞) — Reduces metadata size
✓ 𝗦𝘁𝗿𝗲𝗮𝗺 𝗽𝗿𝗶𝗼𝗿𝗶𝘁𝗶𝘇𝗮𝘁𝗶𝗼𝗻 — Ensures critical resources load first
🅇 𝗛𝗲𝗮𝗱-𝗼𝗳-𝗹𝗶𝗻𝗲 (𝗛𝗼𝗟) 𝗯𝗹𝗼𝗰𝗸𝗶𝗻𝗴 — A lost packet blocks all streams
While HTTP 2 optimized TCP, it remained constrained by TCP’s head-of-line blocking.
🔹 𝗛𝗧𝗧𝗣 𝟯:
✓ 𝗕𝘂𝗶𝗹𝘁 𝗼𝗻 𝗤𝗨𝗜𝗖 (𝗨𝗗𝗣) — No more TCP bottlenecks
✓ 𝗜𝗻𝗱𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝘁 𝘀𝘁𝗿𝗲𝗮𝗺𝘀 — Packet loss in one stream doesn’t affect others
✓ 𝗙𝗮𝘀𝘁𝗲𝗿 𝗵𝗮𝗻𝗱𝘀𝗵𝗮𝗸𝗲𝘀 — Combines transport + encryption setup in one step
✓ 𝗠𝗮𝗻𝗱𝗮𝘁𝗼𝗿𝘆 𝗲𝗻𝗰𝗿𝘆𝗽𝘁𝗶𝗼𝗻 (𝗧𝗟𝗦 𝟭.𝟯) — Security by default
✓ 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻 𝗺𝗶𝗴𝗿𝗮𝘁𝗶𝗼𝗻 — Seamless across network changes
𝗜𝗻 𝗮 𝗻𝘂𝘁𝘀𝗵𝗲𝗹𝗹: HTTP 2 optimized TCP, but HTTP 3 rewrites the game with QUIC, making it faster, more reliable, and encrypted by default.
💬 Which fact surprised you? 💭
--
Thanks to our partner Augment Code who keeps our content free to the community.
𝗗𝗶𝗱 𝘆𝗼𝘂 𝗵𝗲𝗮𝗿 about Augment Code releasing Auggie CLI to GA?
Check it out: lucode.co/augment-code-cli-z…



































