It's pencils down, people. Writing code by hand is no longer an economically viable skill for most programmers at most companies. But the future of making software has never been brighter. Don't you dare black pill this beautiful moment! youtu.be/vDjW_dRyKXY?si=6Fsfβ¦
π§π’π ππΊππ°π΅π΅ retweeted
Bend 2 is here!
It is a new programming language that blocks AI mistakes via *proof checking* - the same technique big AI labs used to solve open math problems, like Navier-Stokes.
It is also very fast, and runs on GPUs.
Watch the video. Link in the comments.
RELEASE DAY
After almost 10 years of hard work, tireless research, and a dive deep into the kernels of computer science, I finally realized a dream: running a high-level language on GPUs. And I'm giving it to the world!
Bend compiles modern programming features, including:
- Lambdas with full closure support
- Unrestricted recursion and loops
- Fast object allocations of all kinds
- Folds, ADTs, continuations and much more
To HVM2, a new runtime capable of spreading that workload across 1000's of cores, in a thread-safe, low-overhead fashion. As a result, we finally have a true high-level language that runs natively on GPUs!
Here's a quick demo:
π§π’π ππΊππ°π΅π΅ retweeted
You can now use Claude Code with OpenRouter π
Code with over 320 LLMs, including 39 free ones!
π§π’π ππΊππ°π΅π΅ retweeted
I describe the module I need, completely ignoring that there's a UI involved, and let the LLM barf something out in 2 minutes that's better than I would build in 2 days
Then plug it into the setup scope, call methods in event handlers, and this.update() when needed
π§π’π ππΊππ°π΅π΅ retweeted
In response to the good @SubtleGradient, who recently asked [paraphrasing] will Effect-TS avoid RxJSβs βflash-in-the-panβ fate in the JS ecosystem?
RxJS was an early solution to the challenges of async and reactivity. Gradually, aspects of this problem were solved by simpler, more imperative apis: React, hooks, react-query, async/await, etc.
The Reactive Streaming paradigm has failed to really take off in any languageβe.g., a few years back, Apple released its very own first class reactive streaming API called Combine, which was deprecated within a year, supplanted by a much simpler, more imperative API. It also doesnβt help that RxJS is inspired by Javaβs Reactive Extensions, and thus its API surface area is circumscribed by existing, non-great Rx conventions.
For whatever reason, however theoretically elegant, modeling everything as a reactive stream appears to suck (as objectively judged by the market). This inherent suckiness, combined with competition from more modern alternatives, has driven people away from RxJs.
Now, with Effect, there isnβt anything in JavaScript that solves these same problems, let alone more simply. If you want resource safety, retries, log spans / annotations, typed errors, composable dependency injection, interruptibility, and all the other benefits derived from Effectβs programs-as-values design, youβll either have to use Effect or roll your own much shittier ad hoc version, once per codebase.
Promise isnβt really an alternative to Effect, as it merely provides barebones async support and none of the aforementioned capabilities. Once youβre reaching for AbortController, youβre doomed. The only true alternative is total acquiescence to a diminished quality of life: you wonβt know all the ways your program might fail; parallel computations wonβt be interrupted; retrying will be ad hoc and verbose; logging shmlogging; telemetry shmelemetry.
The one convincing argument contra-Effect is that you just donβt need or want to solve these problems. In many apps, this might be fine, if you can tolerate a certain amount of pain and turmoil. Clearly, this approach works and can scale, it is indeed the approach of most companies. The question is: can it scale as fast, as far, and with as small of a team of developers? Iβd reckon the difference is measured in orders of magnitude.
In my experience, once you do get on board with Effect, understand what it offers, and acclimate to its syntactic idiosyncrasies, you could not possibly fathom going back.
I imagine it would be like having an 18th-century doctor struck with a prophetic vision about Germ Theory before returning to his 18th-century operating room. He might then feel, justifiably so, that he was doing great harm to the people he was supposed to be helping.
π§π’π ππΊππ°π΅π΅ retweeted
Replying to @Baconbrix
maybe expo could use ts-plugin-sort-import-suggestions to downrank the generic rarely-used View props? nothing worse than a component with like one special prop that get buried by a billion generic ones
github.com/tidalhq/ts-pluginβ¦
π§π’π ππΊππ°π΅π΅ retweeted
Do yourself a favor and set this in your pnpm config
π¨ Major active supply chain attack just hit npm.
Popular package @βctrl/tinycolor was trojanized β and it didnβt stop there. Over 40 packages were silently modified to steal secrets from dev machines & CI pipelines.
Our team at Socket caught it. Full report coming soon. Stay safe out there.
π§π’π ππΊππ°π΅π΅ retweeted
Replying to @mattpocockuk
Yes! I call this pull oriented development.
Start at the end (or the entry point) where the rubber hits the road, (or where the steering wheel meets the hands), and use an imaginary ideal api to build it very clean and simple.
Then implement that api later in the same way
π§π’π ππΊππ°π΅π΅ retweeted
...and weβre back.
The new Evolu is here.
Itβs not true that local-first software doesnβt scale.
The real local-first, not offline-first, does.
Traditional client-server doesnβt.
Read our blog post: Scaling Local-First Software
π§π’π ππΊππ°π΅π΅ retweeted
@rive_app is built entirely in Flutter. It's the most commercial example we can cite.
π§π’π ππΊππ°π΅π΅ retweeted
Few things better than working on a new project that youβre excited about.
π§π’π ππΊππ°π΅π΅ retweeted
Replying to @thorstenball
Powerful workflow!
I keep saying this: Debugger is for when things go wrong, printf is for understanding how things behave. They are friends, the debugger and printf.
π§π’π ππΊππ°π΅π΅ retweeted
Hello word! Lynx is a family of open-source technologies empowering developers to use their existing web skills to create truly native UIs for both mobile and web from a single codebase, featuring performance at scale and velocity. visit lynxjs.org/
π§π’π ππΊππ°π΅π΅ retweeted
What is tinygrad?
tinygrad is a formalist project. It attempts to capture the full gamut of software 2.0 in a non leaky abstraction. The methods on Tensor class create a directed graph of immutable RISC UOps defining what the computation is.
Tensor is a frontend, in addition we have an ONNX frontend and a PyTorch frontend. Whether you code in tinygrad, torch, or import ONNX models, it all boils down to the same very simple UOp graph, which you can see with VIZ=1
This graph contains nothing like matmul or conv, it's just movement ops, elementwise ops, and reduction ops. Seriously, try VIZ=1.
Below that, there's a scheduler which breaks that graph up into kernels. Then we do more graph transforms on each kernel subgraph until we have code which can run on an accelerator. See the kernels with DEBUG=2.
Then we have runtimes capable of running that code. For AMD, our runtime goes all the way to the physical hardware; we are mmaping the PCIe bus and peeking and poking it. It's all in Python, but it is fast because once you have the graph compiled, you are running the same graph over and over; just ringing a doorbell.
The hope is that, similar to Linux and LLVM, we will prevent a major source of rent seeking in our AI future. By clearly and simply specifying the job, being able to precisely spec what is bought and sold, you can have a fair marketplace for compute.
By the end of the year, we should be similar in speed on NVIDIA to the existing torch CUDA backend, except without CUDA. We will also have a test cloud up where you can run jobs from any of the three frontends.
You don't want to rent a GPU per hour on a machine, you want to rent a couple FLOPS in a lambda function. That's what the OpenAI API is. Now offer it decoupled from the specific model.
π§π’π ππΊππ°π΅π΅ retweeted
π @Tan_Stack Start w/ React 19 achieved internally. Will be the new default asap. Had to do a ton of work with @schanuelmiller around streaming order and hydration, but it works really well.
Promise streaming is cool, but wanna feel like a wizard? Return a readable stream in your Router loader, your app renders and hydrates, then watch the chunks continue to get injected over SSR and incrementally update your React component on the client.
Quite the emotional rollercoaster we've been on, @tannerlinsley!
π§π’π ππΊππ°π΅π΅ retweeted
Replying to @SubtleGradient @evoluhq
The new Evolu (backward compatible) will be everything I ever wanted MooTools to be; I accidentally made a βJS libraryβ ππ« β¨
π§π’π ππΊππ°π΅π΅ retweeted
This short article of mine from 2007 illustrates in depth the mechanics of regex backtracking: blog.stevenlevithan.com/archβ¦



























