David Sherret
LightNews LightNews
dsherret.bsky.social
David Sherret
@dsherret.bsky.social
1.3K followers 72 following 90 posts
Software developer at Deno. Also working on ts-morph, dprint, and more (https://github.com/dsherret)
Posts Replies Media Videos
Reposted by David Sherret
eurorust.eu
In his talk at #EuroRust25, @kettmeir.dev shared how the @deno.land project improved error handling by migrating from the anyhow crate to using thiserror and concrete error types – watch it on YouTube now! 🦀

👉 youtu.be/f6eofqicw_s

#RustLang #RustConference #EuroRust
From Any to This - Leo Kettmeir | EuroRust 2025
YouTube video by EuroRust
youtu.be
November 6, 2025 at 11:23 AM
dsherret.bsky.social
Wrote a library this weekend for modifying JSONC files david.deno.dev/posts/jsonc-...
First-class JSONC manipulation in JavaScript
Manipulating JSONC in JavaScript using a CST via jsonc-morph
david.deno.dev
October 12, 2025 at 11:30 PM
Reposted by David Sherret
lcas.dev
Stuck in an elevator with @snek.dev, @littledivy.com, @bartlomieju.bsky.social, @magurotuna.bsky.social, @dsherret.bsky.social, @kettmeir.dev, and Nathan
August 7, 2025 at 6:58 PM
Reposted by David Sherret
squiggleconf.com
🌟 Speaker Spotlight: David Sherret

@dsherret.bsky.social will walk us through the JSR package registry: why it exists, how it improves on previous approaches such as HTTPS specifiers, and the design decisions behind its module resolution.

Schedule, speakers & more info: squiggleconf.com
Poster for SquiggleConf 2025, September 18-19 Boston JSR: Designing Package Registry Module Resolution David Sherret, Deno Developer; creator of ts-morph, dprint-ts-ast-viewer
July 18, 2025 at 12:00 PM
Reposted by David Sherret
deno.land
Importing bytes and texts:
✅ adds to your module graph
✅ type checking
✅ works with deno bundle and deno compile

deno.com/blog/v2.4#im...
July 3, 2025 at 4:49 PM
dsherret.bsky.social
Type checking text and bytes imports is now working.
Example code snippet that type checks text and bytes imports.
June 25, 2025 at 5:56 PM
dsherret.bsky.social
Should have importing files as text and bytes ready for Deno 2.4 -- will be unstable because it hasn't been standardized.
Importing a file as text and bytes with an import attribute.
June 20, 2025 at 8:23 PM
dsherret.bsky.social
This is now published to JSR as a rolldown plugin: jsr.io/@deno/rolldo...
dsherret.bsky.social David Sherret @dsherret.bsky.social · May 31
Got bundling JSR/Deno code with Rolldown working.

This is using Rolldown's and Deno's crates respecting Deno's lockfile, config discovery, and resolution. Finally Deno's crates have been refactored enough for this to be feasible (~500 LOC). I'll update with more details later.
Terminal output showing a JSR specifier being bundled to a single file then executed. > ../rolldown/target/debug/rolldown_deno.exe jsr:@david/dax@0.43 Bundle jsr:@david/dax@0.43 Writing: dax.bundle.js Writing: dax.bundle.js.map > deno Deno 2.3.5 exit using ctrl+d, ctrl+c, or close() REPL is running with all permissions allowed. To specify permissions, run `deno repl` with allow flags. > import $ from "./dax.bundle.js" undefined > await $`echo 'Hello there!' && echo 'This is from a bundled copy.'` Hello there! This is from a bundled copy. CommandResult { code: 0 }
June 4, 2025 at 9:34 PM
dsherret.bsky.social
Got bundling JSR/Deno code with Rolldown working.

This is using Rolldown's and Deno's crates respecting Deno's lockfile, config discovery, and resolution. Finally Deno's crates have been refactored enough for this to be feasible (~500 LOC). I'll update with more details later.
Terminal output showing a JSR specifier being bundled to a single file then executed. > ../rolldown/target/debug/rolldown_deno.exe jsr:@david/dax@0.43 Bundle jsr:@david/dax@0.43 Writing: dax.bundle.js Writing: dax.bundle.js.map > deno Deno 2.3.5 exit using ctrl+d, ctrl+c, or close() REPL is running with all permissions allowed. To specify permissions, run `deno repl` with allow flags. > import $ from "./dax.bundle.js" undefined > await $`echo 'Hello there!' && echo 'This is from a bundled copy.'` Hello there! This is from a bundled copy. CommandResult { code: 0 }
May 31, 2025 at 2:19 AM
dsherret.bsky.social
I've come across so many bugs caused by using wildcard matches in Rust. Even though it can be verbose, I think it's better to avoid them in most cases so that adding a new enum variant causes compiler errors, forcing you to re-evaluate each match.
March 27, 2025 at 9:50 PM
dsherret.bsky.social
It was getting difficult to debug Deno's npm resolution so I wrote a tool to help visualize each step it makes.
March 20, 2025 at 7:35 PM
Reposted by David Sherret
markrussinovich.bsky.social
My closing keynote from Rust Nation UK last week is now online: "Microsoft is Getting Rusty: A Review of Successes and Challenges"
Microsoft is Getting Rusty: A Review of Successes and Challenges - Mark Russinovich
YouTube video by Rust Nation UK
www.youtube.com
February 26, 2025 at 10:18 PM
dsherret.bsky.social
Neat to see software I used to work on and features I helped implement in Severance.
Neurosurgical planning software seen in the show Severance.
February 25, 2025 at 1:37 AM
Reposted by David Sherret
marvinh.dev
Lint plugins are now available 🎉
February 19, 2025 at 4:18 PM
dsherret.bsky.social
Beware: npm doesn't show non-npm dependencies in the dependencies tab. Check out this package—npm lists it as having zero dependencies, but if you look at the package.json, it definitely has dependencies.
The @dsherret/outside-npm package having zero dependencies. The package.json showing two dependencies.
February 7, 2025 at 9:58 PM
dsherret.bsky.social
Did some work on the url Rust crate the past two days and got it parsing a 400 character URL more than twice as fast (still have a few PRs not merged).
Mean: 1903ns to 841ns
February 7, 2025 at 9:34 PM
dsherret.bsky.social
I feel like making node resolution "just work" leaves the JS ecosystem in a worse place.
Bun checking the __esModule property to inform the behaviour of a default import. Bun errors, but Node and Deno don't.
February 5, 2025 at 1:28 AM
Reposted by David Sherret
deno.land
@jsr.io is now openly governed — meet its board members and check out its governance charter 👇

deno.com/blog/jsr-ope...
Introducing the JSR open governance board
JSR, a modern open source JavaScript registry, is meant for the greater JavaScript and TypeScript community. We're thrilled to announce its own independent governing body.
deno.com
February 3, 2025 at 6:18 PM
dsherret.bsky.social
TypeScript <5.7 on left, TypeScript 5.7 on right. Glad this seems to work lol. Anyone have a better solution for dealing with Uint8Array being generic now?
buffer property on Uint8Array going to ArrayBufferLike in TS 5.6 ```ts type IsAny<T> = 0 extends (1 & T) ? true : false; // @ts-ignore uint8array is not generic in TS < 5.7 type NewUint8Array<T> = Uint8Array<T>; type IsOld = IsAny<NewUint8Array<ArrayBuffer>>; type Uint8Array2<T> = IsOld extends true ? Uint8Array : NewUint8Array<T>; function test(): Uint8Array2<ArrayBuffer> { return new Uint8Array([]); } const buffer = test().buffer; ``` buffer property on Uint8Array being ArrayBuffer in TS 5.7
January 28, 2025 at 5:34 PM
dsherret.bsky.social
Worked on this slowly over 5 months, but Deno's config discovery and module resolution logic has been extracted out of the CLI and into a re-usable crate (not yet published). Also a few days ago this setup code was hundreds of lines, but now it's only a few.
```rs use std::rc::Rc; use deno_resolver::factory::ResolverFactory; use deno_resolver::factory::WorkspaceFactory; use sys_traits::impls::RealSys; let sys = RealSys; let cwd = sys.env_current_dir()?; let workspace_factory = Rc::new(WorkspaceFactory::new(sys, cwd, Default::default())); let resolver_factory = ResolverFactory::new(workspace_factory.clone(), Default::default()); let deno_resolver = resolver_factory.deno_resolver().await?; ```
January 24, 2025 at 2:13 AM
dsherret.bsky.social
Wasmbuild is getting simpler thanks to Wasm imports.
Shows a diff of code that was previously complex, but now just requires a single import.
January 8, 2025 at 12:20 AM
dsherret.bsky.social
Recently I've started using a different approach to pre-allocating strings in Rust.
Maintainable string and bytes pre-allocation in Rust
How to stop manually calculating capacity by using a single source of truth.
david.deno.dev
December 30, 2024 at 12:10 AM
dsherret.bsky.social
After many years, we finally have control of the deno package on npm. Thank you, GitHub!

Now to get it all wired up and distributing the Deno executable...
December 12, 2024 at 5:08 PM
Reposted by David Sherret
just-be.dev
So in @deno.land 2.1 you can directly import WASM. That's pretty cool... but they also automatically generate typescript types for the WASM. Pretty wild... here's how they do it: github.com/denoland/den.... Uses this crate: github.com/denoland/was....

@dsherret.bsky.social, you do good work.
github.com
December 7, 2024 at 3:53 AM
dsherret.bsky.social
It's been a few months so let's bring this up again with an example of what other languages do—unawaited async function call detection is standard in other languages, but missing in TypeScript. So many bugs could be prevented if this were built-in and didn't require separate tooling.
```csharp async Task Example() { SomeAsyncFunction(); // warns, good await Task.FromResult(1); } async Task ExampleFixed() { await SomeAsyncFunction(); await Task.FromResult(1); } async Task ExampleSuppressedWarning() { _ = SomeAsyncFunction(); await Task.FromResult(1); } async Task SomeAsyncFunction() { // ... await Task.CompletedTask; } ``` ```rust async fn example() { some_async_function(); // warns, good } async fn example_fixed() { some_async_function().await; } async fn some_async_function() { std::future::ready(1).await; } ``` ```ts export async function example() { someAsyncFunction(); // please warn/error here await Promise.resolve(); } export async function exampleSuppressed() { void someAsyncFunction(); // proposed suppression await Promise.resolve(); } export async function exampleOkFloatable() { okToBeFloatable(); // ok because api was defined as floatable await Promise.resolve(); } export async function someAsyncFunction() { // ... await Promise.resolve(); } // This does not exist atm, but I think there should be a way for APIs // to define themselves as floatable given the prevalence of promises // in return types not expected to be awaited in the JS ecosystem export async function okToBeFloatable(): Floatable<Promise<void>> { // .. await Promise.resolve(); } ```
November 29, 2024 at 6:39 PM