Jott

I wrote one article on Medium. I ended up writing my own little version using open source markdown rendering to see how hard it would be to roll my own, https://jott.live From what I found, there is a lot of stuff Medium does well that is hard to recreate by one's self. Super simple features, like - rich text editing that isn't ugly - caching what you're currently working on - tracking views and who has viewed your article aren't easy to build and generally aren't worth it unless you write many many articles. Although I don't like the aggressive account on-boarding and payment models for reading articles, Medium certainly makes life easy for writing articles.

It can be converted, and can be fairly fast, see Tensorflow.js or https://jott.live/markdown/m1_webgpu_perf. However the any “web” standard will always be a subset of what the hardware can truly provide because it has to support ALL GPU vendors. For example leveraging Nvidia Tensor Cores or Apple’s neural accelerator is not possible. For ML training and inference this means that any webGPU implementation is at least ~3x slower (likely much more) vs an optimized CUDA implementation.

I'll be benchmarking the WONNX GEMM in the near future - would be curious to see how far a GEMM on WebGPU can be taken. Bram wrote some interesting exploration here: https://jott.live/markdown/webgpu_safari

In my opinion performance optimization should be taught from the ground up, rather than with lists of "performance rules." I found learning this stuff that a solid mental model of the compute resources available (registers, cache) and the paranoia of a compiler (correctness) often made it easier to write fast code. With a good mental model, rather than memorizing rules, one can just walk through the code and re-derive them from first principles. I also find visualization to be extremely important in this domain: https://jott.live/html/mm_impl_anim

I used OpenBLAS on my cheap last-generation AMD Ryzen 7 4700U laptop like so: git clone https://github.com/xianyi/OpenBLAS && cd OpenBLAS && make PREFIX=/opt/openblas install && curl https://jott.live/code/blas_test.cc | sed -n "/<code>/,/code>/p" | tail -n +2 | head -n -1 > blas_test.cpp inspect blas_test.cpp file, and then... g++ -I/opt/openblas/include/ blas_test.cc -lopenblas -std=c++11 -O3 -L/opt/openblas/lib/ -o blas_test && ./blas_test 512 512 512 100 100 and got a peak of about 192 gflops, averaging closer to 180. So yeah, the M1 is > 6x faster in this simple single-precision matrix test.

I found the site's architecture quite interesting: It uses inline JS to transform the Markdown in HTML. view-source:https://jott.live/markdown/elementary_blockchain Ideally it would be as a Service Worker that pulls pages and transforms them into HTML, so you could serve your Markdown directly, without a separate build step.

Cool deal. Suggest adding a note on the homepage for how to access notes you save under `https://jott.live/note/<your-note-name>` I saw it on the Github readme

Here's one source on Python very obviously not matching Node.js's perf on a simple microbenchmark: https://jott.live/markdown/nodejs_vs_python_ CPython really is inherently less performant than V8. CPython, until very recently, didn't have a JIT at all. It compiles scripts to bytecode, then runs the bytecode in a giant case statement. It doesn't have a tracing profiler-guided optimizer or an exotic garbage collector. CPython is way, way simpler than V8, but it's consequently slower. It's just the consequence of Google putting centuries of developer-years into an engine. You can't just claim Python is fast because Python's C libraries are fast. Those libraries are fast despite Python. Torch is extremely fast, but it's fast from C and Lua too. There's valid reasons to want to compute in your programming language. Python is, ironically, probably popular because its slow speed encouraged users to write blazing fast C libraries rather than even try writing native Python, vs. settling for middling performance as in Java or .NET. I shouldn't have to get out my hammer and tongs when NumPy doesn't implement the operator I need. Why can't Python be fast like Julia?