Haskell, 范畴论, λ, Distributed Systems, Formal Methods
Poland
Joined February 2009
- Tweets7.7K
- Following669
- Followers2.9K
- Likes6K
Paweł Szulc retweeted
2027 is going to be the year of Haskell
Turbo Haskell (public release announcement)
comonad.com/reader/2026/turb…
Paweł Szulc retweeted
The 1995 cult film "Hackers" was released 31 years ago today. HackersDay.com
#Hackers #HackersDay #HackersMovie #HackThePlanet
Paweł Szulc retweeted
Bro casually walks and explains 5 GPU performance optimization methods for LLMs.
one of the most simple and intuitive explanations for beginners.
Paweł Szulc retweeted
The honest part: multi-host is deliberately early. Testable, not finished. That is the point of shipping it: run it, break it, tell me.
Full story: flodl.dev/blog/then-the-cpu-…
Benchmark: flodl.dev/ddp-benchmark
#RustLang #DeepLearning
Paweł Szulc retweeted
This is an outstanding talk by Scott Meyers on hardware and CPU caches ..
YOUR CODE ISN'T SLOW BECAUSE OF YOUR ALGORITHM, IT'S SLOW BECAUSE OF A TINY CHUNK OF MEMORY YOU'VE NEVER ONCE THOUGHT ABOUT AND THIS MAN PROVES IT WITH TWO PROGRAMS THAT DO THE EXACT SAME WORK, WHERE ONE IS MASSIVELY FASTER
76 minutes from Scott Meyers -- the C++ authority whose "Effective C++" books a whole generation of engineers learned from.
-> His point: the CPU is not waiting on math. It's waiting on memory. And it's starving far more often than you think.
The cache is a scrap of ultra-fast memory near the core. Hit it and you fly. Miss it and the whole chip stalls, doing nothing, for what feels like forever.
He shows the same loop, same data, just walked in a different order. One layout stays in cache. The other keeps missing. The gap is not small -- it's brutal.
The kicker: your language, your fancy abstractions, none of it hides this. A "clean" data structure that scatters memory quietly wastes most of your machine.
And it's the AI era's hidden tax too. Everyone rents oceans of compute, then leaves most of it stalled on cache misses nobody profiles.
You thought fast code was about picking the right algorithm. This is the man showing it's really about how your data sits in memory.
Save this. You'll never lay out a struct the same way ↓
Paweł Szulc retweeted
Watch git diff while the code is changing! 🤯
👁️ livediff — A real-time diff viewer for the terminal
💯 Watch file changes live as generators, formatters, migrations & refactors modify your code
🦀 Written in Rust & built with @ratatui_rs
⭐ GitHub: github.com/SoCkEt7/Livediff
#rustlang #ratatui #tui #git #terminal #devtools #opensource
Paweł Szulc retweeted
It's interesting how AI is constantly providing false information and incorrect statements about my area of expertise. Fortunately, it's very useful and always right about topics I know very little about.
Paweł Szulc retweeted
Gödel's incompleteness theorem is one of those things that math popularisers always talk about as a hugely important result.
But according to @3blue1brown, it almost never comes up in practice. It's a weird pathology that nobody expects to matter for the big questions.
Paweł Szulc retweeted
Avi Wigderson is the only person in history to have won both a Turing Award (computer science) and Abel Prize (math). I interviewed him all about his field. We discussed:
• His intuition on a proof of P vs NP
• Why we use SAT solvers for most NP problems
• Zero knowledge proofs and their impact
• Quantum computation and implications
• Math and computer science's relationship
Where to watch:
• YouTube: youtu.be/5GUcvSAJcJw
• Spotify: open.spotify.com/episode/4JZ…
• Apple Podcasts: podcasts.apple.com/us/podcas…
• Transcript: developing.dev/p/turing-awar…
Thank you to this episode's sponsors for supporting my work:
• WorkOS: makes your app Enterprise Ready with easy to use APIs to add SSO, SCIM, RBAC, and more in just a few lines of code, check them out at workos.com/
Timestamps:
00:00 - Intro
01:08 - P vs NP
14:51 - What if you relaxed correctness
25:38 - Why NP complete problems are equivalent
30:33 - Space vs time complexity
43:06 - Why people use SAT solvers
45:53 - Randomness is a resource
55:48 - Randomness depends on computational power
01:21:20 - Zero knowledge proofs and their significance
01:38:30 - Quantum computation and why it matters
01:56:24 - Math vs computer science
02:08:16 - Major breakthroughs and his experience
02:12:31 - Advice for his younger self
02:14:48 - Outro
Paweł Szulc retweeted
Agent amnesia isn’t a feature - it’s an expensive habit.
@modiqoai just dropped the cure with rote: turning one-shot agent explorations into permanent, deterministic flows that every future agent can reuse instantly.
No more re-learning the same APIs. No hosted gateways. Just pure outcome maxxing.
This is how agentic systems actually scale. Thread 👇is required reading w/ ☕
Paweł Szulc retweeted
Anthropic is deeply incompetent at building software that works reliably.
Their users would be happier if they focused on the model and outsourced the tooling to engineers who go beyond 'vibe coding'.
Paweł Szulc retweeted
Sci-Hub is an evil website that pirated 85M+ research papers and made them freely available
And now they've added AI to their database to make Sci-Bot.
It answers your questions using latest, full-text articles.
But DO NOT use it. We should all try to make billion-dollar academic publishers richer.
I'm putting the link below so you know how to avoid it.
Paweł Szulc retweeted
Call For Pages is still open! We're calling all authors and artists who would like to be a part of Paged Out! Issue #9. Our email [email protected] is waiting!
Paweł Szulc retweeted
Write-up: flodl.dev/blog/huggingface
Tutorial: flodl.dev/guide/flodl-hf
Crate: crates.io/crates/flodl-hf
Repo: github.com/fab2s/floDl
Feedback and PRs welcome.
Paweł Szulc retweeted
🚨 BREAKING: Someone just built the exact tool Andrej Karpathy said someone should build.
48 hours after Karpathy posted his LLM Knowledge Bases workflow, this showed up on GitHub.
It's called Graphify. One command. Any folder. Full knowledge graph.
Point it at any folder. Run /graphify inside Claude Code. Walk away.
Here is what comes out the other side:
-> A navigable knowledge graph of everything in that folder
-> An Obsidian vault with backlinked articles
-> A wiki that starts at index. md and maps every concept cluster
-> Plain English Q&A over your entire codebase or research folder
You can ask it things like:
"What calls this function?"
"What connects these two concepts?"
"What are the most important nodes in this project?"
No vector database. No setup. No config files.
The token efficiency number is what got me:
71.5x fewer tokens per query compared to reading raw files.
That is not a small improvement. That is a completely different paradigm for how AI agents reason over large codebases.
What it supports:
-> Code in 13 programming languages
-> PDFs
-> Images via Claude Vision
-> Markdown files
Install in one line:
pip install graphify && graphify install
Then type /graphify in Claude Code and point it at anything.
Karpathy asked. Someone delivered in 48 hours.
That is the pace of 2026.
Open Source. Free.
Paweł Szulc retweeted
🚨 BREAKING: GPT 5.4 rates the Claude Code codebase 6.5/10 💀
"This is not junior spaghetti. This is staff-engineer spaghetti: performance-aware, feature-flagged, telemetry-instrumented, surgically optimized spaghetti" 😭
Paweł Szulc retweeted
Here's my current workflow summary for spec-first agentic development in Rust (example from ring-buffer repo [1]) ..
The order of evolution of artefacts both for new development and for updates is: spec.md → Quint spec → Rust code
• spec.md (source of truth) - define or update the invariant in English + math notation
• RingSPSC.qnt - translate the invariant into a machine-checkable Quint model, add tests, run 𝚚𝚞𝚒𝚗𝚝 𝚟𝚎𝚛𝚒𝚏𝚢 / 𝚚𝚞𝚒𝚗𝚝 𝚛𝚞𝚗 --𝚒𝚗𝚟𝚊𝚛𝚒𝚊𝚗𝚝 to validate the model
• Rust implementation - generate/update three artifacts downstream and then proceed for the rest of the implementation:
• 𝚒𝚗𝚟𝚊𝚛𝚒𝚊𝚗𝚝𝚜.𝚛𝚜 - 𝚍𝚎𝚋𝚞𝚐_𝚊𝚜𝚜𝚎𝚛𝚝! macros referencing spec IDs
• 𝚙𝚛𝚘𝚙𝚎𝚛𝚝𝚢_𝚝𝚎𝚜𝚝𝚜.𝚛𝚜 - proptest strategies exercising the invariant
• 𝚚𝚞𝚒𝚗𝚝_𝚖𝚋𝚝.𝚛𝚜 - model-based test driver replaying Quint traces against real code
Main components of Quint spec:
1. Constants
2. State Variables
3. Pure helper functions
4. Invariants
5. Actions (State Machine)
6. Temporal Properties
7. Embedded tests
For a complete sample for the ring-buffer implementation, refer to [3] - around 640 lines of clean unambiguous spec.
Why spec-first matters in agentic development:
• Catches design bugs cheaply - model checking explores the full state space in seconds. A wrong invariant or missing guard is found before writing any Rust
• Generates test oracles - the Quint spec produces ITF traces that drive MBT tests, so the spec is the test suite
• Constrains the LLM - when the agent generates Rust code, the spec IDs (INV-SEQ-01, etc.) anchor it to verified properties rather than hallucinated logic
• Feedback loop - if 𝚚𝚞𝚒𝚗𝚝 𝚟𝚎𝚛𝚒𝚏𝚢 fails after a spec change, you fix the model before touching Rust. If MBT tests fail, the spec and implementation are out of sync
So update the Quint spec first, verify it passes, then proceed to implementation. For details on the flow refer to [2].
[1] Github Repo: github.com/debasishg/ringmps…
[2] Detailed development pipeline: github.com/debasishg/ringmps…
[3] Sample Quint Spec: github.com/debasishg/ringmps…
Paweł Szulc retweeted
What happens when we take Andrej Karpathy’s legendary “The spelled-out intro to neural networks and backpropagation” — and rebuild it line by line in Rust? This is what @EncodePanda is showing us right now.
#rustikon #rustlang #rustprogramming #learnrust
