"it will be hard to implement in chromium so let's just. dont." my siblings in christ you wrote the code

https://github.com/whatwg/fetch/issues/1254 chromium is why we can't have nice things

gatsby hardcodes dependency on eslint 7.27 for some internal stuff > Creating an empty .eslintrc file at the root of your project will mostly disable ESLint for your site. The empty file will disable the built-in eslint-loader because Gatsby assumes once you have an ESLint file you are in charge of linting. **However, the required ESLint rules for Fast Refresh (no-anonymous-exports-page-templates & limited-exports-page-templates) will still be activated and shown in the terminal output.** which means i can't upgrade to eslint 9 as it would break the internally used eslint because of breaking incompatibilities in eslint gatsby fucking sucks ass biome it is then

@[email protected] figma designs they provided are dogshit and any automated tool would generate garbage that would take me even longer to clean up and polish

god i hate writing markup for landings (the task as a part of that job interview) its so bad im basically procrastinating and not doing *anything* useful while i could be doing my own projects (which i would feel bad about as i should be doing that task) >_<

@[email protected] generator functions are slow af

money would solve literally all my problems smh

@[email protected] we had them for a while, we get native .map/.filter/.reduce on iterators now. https://github.com/tc39/proposal-iterator-helpers it got to stage 4 a few days ago and is already available in many runtimes and even some browsers

new es2024 iterators are cool and all until you are implementing a `Map`-compatible map :neocat_woozy:

im sorry to whoever might be affected but i think ill stop adding alt text, this is absolutely draining and is one of the reasons i stopped posting tbh

(and by "a bunch" i mean like 100+ applications total over 3-4 iterations of the resume) $[blur please hire me 🥺 https://s3.tei.su/Resume.pdf]

applied for a bunch of jobs, and the only ones who didn't reject me straight away are some crypto guys who use fucking gatsby guess im staying at my corpojob on a slave wage :neocat_facepalm:

i forgot i have fedi

@[email protected] nah im dead serious https://www.bilibili.com/video/BV1hE421P7vS for example

chinese club mixtapes are peak music

bun has an awesome wasm runtime ngl

@[email protected] wruff :3

@[email protected] fake

people on the internet are so cool and smart damn $[blur and here i am a literally brainless puppy :c]

@[email protected] it's s3 compatible but they also have a web ui to upload and manage files

@[email protected] not a joke, it's actually really nice when you need to just indefinitely store some files via a publicly accessible and memorable url

cloudflare r2 is the best free file hosting

tho i think it would kinda make sense to have 2 versions of the resume – one linkedin-pilled filled with buzzwords targeted at hr-s, and another one with real content targeted at people who would actually read it and not just stuff it into an llm 🙄

born to / forced to

fun javascript trick when an anonymous `class` is put in an object, its name is inferred from the field name :neocat_googly_shocked:

audhd is buying a dishwasher and procrastinating calling a plumber for a week already

techbros realizing that serverless sucks for most applications will never not be funny to me https://news.ycombinator.com/item?id=41416845

lol people actually upload suno.ai generated music to spotify :neocat_googly_woozy:

@[email protected] ehh, "smart" proxies can suck ass, http tunnels (and any kind of tunnel really) have exactly one job of forwarding traffic, and CONNECT does precisely that. proxy not having any flexibility is actually preferred imo (tho in case of http a bad proxy can still modify stuff, but at that point just dont use http lol)

it also saves only like 50 bytes, who cares lol

i see that curl does avoid using `CONNECT` unless needed but if im implementing a general-purpose tcp proxy layer, it seems like just ignoring anything except `CONNECT` is the way to go, esp considering that 99.9% servers should still support `CONNECT` (for https at least) bc otherwise i'd have to sniff the content before establishing the connection :neocat_googly_woozy:

is there a single reason not to use `CONNECT` when using http proxies? even if i indeed proxy plain http traffic, not doing that seems too much of an abstraction leak lol wikipedia mentions that > Since all traffic is encapsulated inside normal GET and POST requests and responses, this approach works through most proxies and firewalls but like, it's still not a "normal" GET/POST, normal http requests don't start with a protocol :/

`neverthrow` and similar libraries are cool and all but there are a few major issues with monadic errors in javascript that make those libraries nothing more than a toy. ive seen people on twitter shilling them some time ago, but javascript is just not ready for that - no syntax sugar for unwrapping (like `?` in rust) (side note: neverthrow provides a `safeTry` that uses generators magic to do something similar, but that's a lot of runtime overhead lol) - generally no single way to build the error info objects. you *can* use a simple ts enum, but you'll miss on having extra info in the errors (and also ts enums suck). you *can* use a discriminated union, but that's syntactically awkward to type. you *can* use simple strings, but like why would you do that at this point - no zero-cost closures. its cool that those libraries provide those fancy `.andThen` and `.orElse` but what's the point if they are expensive as fuck? every `.andThen` is capturing fucking everything, which gets really expensive really soon if you start using results across your codebase. that's also the reason i tend to avoid map/filter/reduce and then/catch - closures are stupid expensive. like at this point why do you even do monadic errors if you are negating *any* performance benefits it gives? - awkward async support neverthrow provides `ResultAsync` type which is basically a wrapper over `Promise<Result<...>>`, but like what's the point if `async` functions always implicitly wrap everything into a normal `Promise` (and not using async functions is dumb because see above) all in all i just hope that eventually js will get native Result type, and typescript will get proper rust-like enums, and until then i guess i'll just keep writing ```ts function safeDoThing(): | { ok: true, thing: Thing } | { ok: false, err: Error } function doThing() { ... wraps the above one ... } ``` in places where errors are often and `throw`-ing be a performance bottleneck

javascript is not a serious language

matrix sucks so much omg

can spotify please stop resetting my password for "suspicious activity" (logging in from a new device)

though actually no, nothing compares to "replace tsconfig.json and package.json files across the entire monorepo just to force tsc to build commonjs" lol

i wanted to move off of my cursed crutches on top of tsc just to end up having to write even more cursed crutches on top of tsc on top of vite :neocat_googly_woozy:

@[email protected] `// @ts-ignore` go brr

i wanted to use `vite-plugin-dts` with `rollupTypes`, but it turned it is not as smart as rollup is and can't figure out how to extract commonly used types in separate chunks when there are multiple entrypoints. which results in duplicate declarations. which would be fine if i didn't ever use `unique symbol` or private fields (as they are typed nominally in typescript) and it seems that my only options are either manually strip out any private fields from the resulting d.ts, or don't rollup types at all and just kinda deal with the 8712839 d.ts files in the tarball. (and don't even get me started on the esm/cjs interop which forces me to copy d.ts files into d.cts because otherwise tsc complains) god i hate this so much, jsr might actually be a blessing

i hate having to build d.ts files