mjaniczek

Thanks for the "Ski-bi dibby dib yo da dub dub" earworm

I wonder what the modus operandi of preset makers is. Like, the "Boards of Casio" patch data here is amazing, usable, playable. But the official patch banks of many synths, VSTs etc. are quite unusable. Maybe they're aiming to show the breadth of what sounds you can get out of it, rather than provide good defaults?

I like the idea of a fast Spotify player, but I can't get over my doubts of LLM code quality when the audio playback stutters even with the 200ms output buffer setting (on macOS).

AI blindness is making my reviews of others' PRs harder and harder.

Having reusable functions and pipelines compiling to SQL sounds amazing. (EDIT: and sum types!) Will want to try this out on some side project later.

Although for my Elm + backend needs I feel like I still prefer Lamdera: https://dashboard.lamdera.app/ - WebSocket communication and being able to push new data to clients immediately instead of juggling HTTP endpoints and the client having to pull/refresh. `sendToBackend`, `sendToFrontend`, `broadcast` are a great primitive.

Congratulations to Hillel for finishing the book!

Thank you for another check on my bingo card.

Oh cool, I have to try these fonts on my amber CRT getting commands from an Elm webapp ([demo](https://youtu.be/M9Q5tFPtGaA?t=121), [code](https://github.com/Janiczek/crt-esp32-elm/tree/main/vdom/)) - there's not a lot of real estate in a 400x240 NTSC resolution. But the scanlined rendering has so much charm!

EDIT: realized a better demo for this discussion would be the photos I took of all the tiny bitmap fonts I had converted to the C array style at the time. Thread has more but here are my favorites: https://bsky.app/profile/janiczek.cz/post/3mh25atboz224

The choice to use Count was made before I joined the company; IIRC they migrated to it from Tableau.

We wanted to migrate (to Streamlit, back then) to have the SQL not live locked in a tool, but inside our git repository; to be able to run tests on the logic etc. But the spaghetti mess was felt too, even if it wasn't the main reason to switch.

(But then, 1) some team changes happened that pushed us towards Metabase, and 2) we found that Streamlit managed by Snowflake is quite costly, compute-time wise. (The compute server that starts when you open a Streamlit report, stays live for tens of minutes, which was unexpected to us.)

----

Export to DBT sounds great. Count has "export to SQL" which walks the graph of the cell dependencies and collects them into a CTE. I can imagine there being a way to export into a ZIP of SQL+YML files, with one SQL file per cell.

Look at count.co for a Figma-like approach to databases.

We were using it at work (transitioning to Metabase); it's great for exploring and debugging and prototyping but it ends up too much of a tangled spaghetti mess for anything long-term. Would not recommend for user-/other-company-departments-facing reports or dashboards.

I'm optimizing performance of PBT generation and shrinking in [elm-test](https://github.com/elm-explorations/test/compare/master...ja...) - on its own PBT-heavy test suite I got it down from 1336ms to 891ms by using JS TypedArrays.

I'm also experimenting with coverage-guided PBT input generation in the same library, AFL-style -- right now elm-test only has random input generation.

It seems like the ASCII/Unicode mode doesn't work all that well: https://agents.craft.do/mermaid#sample-6

It's entirely happy paths right now; it would be best to allow the test runner to also test for failures (check expected stderr and return code), then we could write those missing tests.

I think you can find a test somewhere in there with a commented code saying "FAWK can't do this yet, but yadda yadda yadda".

I have only had some previous experience with Project Euler, which I liked for the loop of "try to bruteforce it -> doesn't work -> analyze the problem, exploit patterns, take shortcuts". (I hit a skill ceiling after 166 problems solved.)

Advent of Code has this mass hysteria feel about it (in a good sense), probably fueled by the scarcity principle / looking forward to it as December comes closer. In my programming circles, a bunch of people share frustration and joy over the problems, compete in private leaderboards; there are people streaming these problems, YouTubers speedrunning them or solving them in crazy languages like Excel or Factorio... it's a community thing, I think.

If I wanted to start doing something like LeetCode, it feels like I'd be alone in there, though that's likely false and there probably are Discords and forums dedicated to it. But somehow it doesn't have the same appeal as AoC.

Yes, I'll only have an answer to this later, as I use it, and there's a real chances my changes to the language won't mix well with the original AWK. (Or is your comment more about AWK sucking for programs larger than 30 LOC? I think that's a given already.)

Thankfully, if that's the case, then I've only lost a few hours """implementing""" the language, rather than days/weeks/more.

In my case, I can't share them anymore because "the conversation expired". I am not completely sure what the Cursor Agent rules for conversations expiring are. The PR getting closed? Branch deleted?

In any case, the first prompt was something like (from memory):

> I am imagining a language FAWK - Functional AWK - which would stay as close to the AWK syntax and feel as possible, but add several new features to aid with functional programming. Backwards compatibility is a non-goal. > > The features: > * first-class array literals, being able to return arrays from functions > * first-class functions and lambdas, being able to pass them as arguments and return them from functions > * lexical scope instead of dynamic scope (no spooky action at a distance, call-by-value, mutations of an argument array aren't visible in the caller scope) > * explicit global keyword (only in BEGIN) that makes variables visible and mutable in any scope without having to pass them around > > Please start by succintly summarizing this in the README.md file, alongside code examples.

The second prompt (for the actual implementation) was something like this, I believe:

> Please implement an interpreter for the language described in the README.md file in Python, to the point that the code examples all work (make a test runner that tests them against expected output).

I then spent a few iterations asking it to split a single file containing all code to multiple files (one per stage, so eg. lexer, parser, ...) before merging the PR and then doing more stuff manually (moving tests to their own folder etc.)

EDIT: ah, HN screws up formatting. I don't know how to enforce newlines. You'll have to split things by `>` yourself, sorry.

Yes :)

What is it with HN and the "oh, I thought {NAME} is the totally different tool {NAME}" comments? Is it some inside joke?

Hey all, I've just added a paragraph about this. Thanks for the feedback.

As much as I don't want LLMs shoved in every product I use, writing or tweaking SQL queries with knowledge of the database schema is one of the LLM uses that work well for me. I don't know if I could jump ship from Cursor/VSCore which gives me that + Vim mode.

Reminds me of Symphony CMS, which is XSLT based. Cool concept but not entirely practical in my experience.

Related: Rubber duck channels. https://wolfgangschuster.wordpress.com/2023/04/14/ducks/

I've now seen this across two companies, and it's great to have #rd-martinjaniczek where I can just talk about what I'm doing as I'm doing it, post error messages and later how I solved them (or let somebody else jump in and tell me how they solved it etc.), it helps Slack searchability and combats the remote loneliness, it's pretty great.

And reading other folks' RD channels, you realize how frickin' funny some people are.

For some reason the first 10 seconds of the video felt like satire. Only after it didn't continue with cookie banners and "Do you want to send anonymous usage?" dialogs I assumed it's being serious.

I'm usually building my slides in Figma (the original app), and I've learnt to run the PDF exported by it (hundreds of MB) through Adobe "Compress PDF" online utility that gets it to <10 MB. Would be great for the Figma-exported PDF to be small right away.

I'd love to see this sort of design history, but for old terminal/text-mode GUIs (TUIs?). I'm too young to have experienced it outside of the odd DOS cash desk at a grocery store. Does any book/website exist about these? VT220 library systems etc...

I'm an EU citizen who's on the organizer team of Elm Camp 2025, and I'm really on the fence whether to even risk the flight to US and attending, hearing these stories :(

An exploration into how the old VT220 terminals rendered font glyphs.

Follows advice from the classic two texts:

- VT220 Built-in Glyphs - https://vt100.net/dec/vt220/glyphs

- Raster CRT Typography (According to DEC) - https://www.masswerk.at/nowgobang/2019/dec-crt-typography

Source code at: https://github.com/Janiczek/vt220-font-emulation

Originally I wanted to use WebGL but then in the name of getting something on the screen chose to render with DOM divs. Efficiency gods forgive me.

Dove into this after getting an old monochrome amber CRT myself and being fascinated with the aesthetic. It’s definitely a vibe :)

Nah, Elm doesn't need the rec keyword and could be argued to be a ML descendant

How do you need HKTs for monads?