csjh

In-browser data analysis is a great place to use Wasm. Javascript is great, but larger datasets really benefit from SIMD + tighter memory control/controlled memory layouts.

Some interesting data-related Wasm projects:

- DuckDB Wasm | https://github.com/duckdb/duckdb-wasm

- Row Zero | https://news.ycombinator.com/item?id=39551064

- PGLite | https://github.com/electric-sql/pglite

I like that you have a vscode extension already - I'm making a similar language project, and you really don't notice how much you miss even basic syntax highlighting until it's gone

I'm not sure where you're getting O(logn) from here. If it couldn't work that way when a container can grow and shrink, then arrays wouldn't be able to have both amortized O(1) push and pop as they do in most relevant implementations.

As long as the expensive O(n) resize operation happens at some frequency relative to the size of the container rather than every constant size difference (i.e. capacity doubles when length == capacity and halves when length == capacity/2) then it will amortize out to O(1).

There's a proof available in section 2.1.2 of this textbook: https://opendatastructures.org/ods-java/2_1_ArrayStack_Fast_...

I wonder if this is what the "gpt2-chatbot" that was going around earlier this month was

Agreed on DuckDB, fantastic for working with most major data formats

Decreasing capacity wouldn't affect the theoretical complexity of algorithms using it - same concept as increasing capacity during push still being amortized O(1)

How do you mean? Svelte 4 and 5 don't use any node-specific APIs for SSR

Cloudflare workers use them for portability/v8 isolate compatibility/speed/isolation, Figma uses for the main editor, a bunch of Web3 stuff uses them for ???

OOB indexing from the Javascript side would return undefined, but OOB indexing on the engine side (lines 5/7/9 of JSArray::fizzbuzz()) is the same as OOB indexing a pointer

Is sponsorship available for Canadian applicants?

I'm glad that proposal was withdrawn; it would've been by far, in my opinion, the worst implementation of operator overloading, in any (mainstream) language

That too, but WebGPU isn’t very well supported yet

Why not using a faster language that compiles to WebAssembly?

How do you mean? CPython uses karatsuba's for large numbers which should be asymptotically fast

https://github.com/python/cpython/blob/d864b0094f9875c5613cb...

Many divide and conquer algorithms are expressed in the form O(n^logb(a)) because of the master theorem https://en.m.wikipedia.org/wiki/Master_theorem_(analysis_of_...

Why?

Is the number crunching running fully locally via WASM? Or is it more of a websocket pushing commands thru to the backend type setup? I'm guessing the latter because of how fast the S3 import was but the former would be super interesting as well. Great demo!

A GC language would be more fit to use Wasm-GC

Mass adoption in what way? What benefit does the average CRUD web app gain from using some form of WebAssembly?

What is the point of `algorithms::bubbleSort`?

2-9% isn't changing any language hierarchies

What other private company languages are there? Swift is the best example I can think of, which matches Mojo's situation down to the head of the project.

Isn’t factoring out C based libraries ignoring a large part of the Python ecosystem?

webgpu is only available on chromium atm

I wouldn't be so sure, Java was definitely in mind while the GC proposal was being worked on. Maybe not as much with the goroutine/Java concurrency stuff, but not sure.

The subject of the parent comment was about AOT WASM compilers - definitely languages using WASM GC right now, and (hopefully) more to come

In Javascript yes, in Wasm no: https://webassembly.org/roadmap/

Support is still mediocre (mainly because of safari)

I'd imagine the majority won't support GC, at least not for some time

Neural network