HN user
This is great. I’ve been thinking to set up an HF radio rig to talk to friends and strangers that are real people. Maybe the LLMs flood the internet with enough trash and we go back to more voice comms
Thanks! I made this change.
As a side project I'm working on a multitrack audio play along website. If you are learning bass you can mute the bass track.
I used to play along to Jamey Aebersold CDs back in the day, and now on YouTube there are many Play Along videos... but I thought it would be fun to make one where you have more control.
Here's the demo, feel free to upload a track if you have one handy! https://jamz.stereosteve.com/
The source code is here: https://github.com/stereosteve/playalong
It uses this wave surfer multitrack example, which is a pretty nice vanilla JS project: https://wavesurfer.xyz/examples/?multitrack.js
Now that the basics are working... hopefully I'll actually spend some time actually making some practice tracks!
Why does Picard always have to specify temperature preference for his Earl Gray tea? Shouldn’t the super smart AI have learned his preference by now?
Just a few days ago I started working on a similar project, but one where you can upload via a UI.
After talking to some artists + musician friends, it was clear that a SSG was going to be a non-starter for most of them.
Currently it just supports simple track upload + playback, but plan is to add Artists, Albums + RSS feed.
Code: https://github.com/stereosteve/SHYM Demo: https://tunez.stereosteve.workers.dev/
There is no auth and everything you upload will be deleted in the coming days. But feel free to upload some tracks!
Another good library for this is Graphile Worker.
Uses both listen notify and advisory locks so it is using all the right features. And you can enqueue a job from sql and plpgsql triggers. Nice!
Worker is in Node js.
I don’t disagree. RSS has most of these features and was pretty popular 15 years ago.
My point is that key pairs and signed posts is a good primitive if things are to be re homed and retransmitted.
I think nostr is better in this regard:
- The "account" primitive is just a key pair, but you can layer more auth requirements on top of that.
- All messages are always signed by your key pair end to end.
- Server admin can't read your DMs or edit your messages. The worst they can do is see public posts or delete events.
- You can move your messages between servers with via piped CLI commands.
echo '["REQ", "my_mirror_request_id", {"pubkey": "mynpubkey"}]' | websocat -n wss://source | jq -c '[.[0,2]]' -M | websocat wss://destination
Maybe nostr is not "the thing" but it's better than the mastodon paradigm.
Agreed. I am experimenting with using go-jet instead and it’s going real good so far.
This is a cool explanation!
I wrote a Euclidean rhythms plugin for Logic Pro X scripter:
code: https://github.com/stereosteve/ScriptDiddy
demo: https://www.youtube.com/watch?v=cInvIxaeYZ4
of course I copy pasted the actual implementation from here: https://github.com/Lokua/euclidean-sequence/blob/master/inde...
It's pretty fun to use with AUs and VSTs
The interleaving of modern day ads really kills the fun here. And everywhere I suppose.
I just started working on a project with this use case in mind.
So far just a "browse" experience somewhat like GitHub, but uglier.
Soon want to add ability to commit, similar to GitHub desktop, but without electron.
Very WIP atm but hoping to work on it some this week.
While not sqlite… duckdb is inspired by the design of sqlite
The Audio Signal Processing for Machine Learning [1] youtube playlist is a pretty excellent course on sound processing for ML. In particular, the MFCC video. [2]
[1] https://www.youtube.com/watch?v=iCwMQJnKk2c&list=PL-wATfeyAM...
Similar question: how does it compare to using ClickHouse with http interface (which supports a number of output formats including Arrow and ArrowStream).
It does take a few more commands to start a ClickHouse server, create table and load data in... a friendly loader program could probably get pretty close to Roapi interface.
Both Roapi and Datafusion look very cool! Excited to learn about them.
Running a git server is a bit more challenging than running a traditional stateless web app because git is all filesystem centric. If you use NFS, pages that require many git operations can be very slow. Or if the storage servers have a low-level API some page loads might require many round trips and increased latency or long queues can make things bad.
Gitlab went thru a similar journey from NFS to a high level git api called gitaly:
https://about.gitlab.com/blog/2018/09/12/the-road-to-gitaly-...
https://gitlab.com/gitlab-org/gitaly
There are some other projects like this one that seek to address the problem:
https://github.com/takezoe/gitmesh
Git is already good and synchronizing between peers, but it's not low latency, so does require an extra management layer to make sure everything is correct.
Yeah the company I work for (https://www.copia.io/) is doing similar things for Programmable Logic Controllers, which historically have binary project files.
Also a means to an end given the current sad reality. But most vendors are slowly moving towards better VCS support.
Ahh this is my bad. For some reason I assumed the blocks were part of the storage scheme, but I see they only are used to compute hash, and that the whole file is added to zip. Sorry for the misunderstanding!
Oh I'm not talking about disks... this is based on how SnowFS (the library for this project) splits up big files into chunks:
https://github.com/Snowtrack/SnowFS/blob/main/src/common.ts#...
The intent is a simple form of delta encoding, the hope is that many chunks will be common between two versions.
Yeah this is cool analysis!
Looking at Fossil's delta code it uses 16 byte blocks and a sliding window when finding deltas:
https://fossil-scm.org/home/file?ci=trunk&name=src/delta.c&l...
the problem happens with any fixed window spacing regardless of the block size.
If you create a block every Xmb... inserting a single byte at the beginning of the file will change every subsequent block.
From a quick read of the SnowFS source code, it looks like it splits large files into 100Mb blocks and builds up a zip of blocks over time. A version of a file is an ordered list of hashes for the blocks in that version.
I like the simplicity of this! But is it at all problematic if something changes early in the file and all the subsequent blocks boundaries shift causing many new blocks to be created?
rsync uses a sliding window to handle this situation. The implementation would be more complicated, but have you considered using librsync internally?
Can relate. After some searching I found:
https://github.com/Teamwork/visual-dom-diff
Which is quite good and fast. Encodes HTML tags as Unicode chars, calls diff-match-path and uses diff to build a final visual output.
Based on this it sounds like the GUI is custom and that they don’t really use an existing framework.
https://www.reddit.com/r/Bitwig/comments/4c2zoh/what_program...
This is excellent.
I was recently reviewing Lucene concepts and found this video really good: https://www.youtube.com/watch?v=T5RmMNDR5XI
Also this site has a series of Lucene articles that are pretty nice. The one on Term Vectors in particular: http://makble.com/what-is-term-vector-in-lucene
Based on some quick research it seems like Lucene is already using a sorted skip data structure for the posting list, so I wonder why they had to do a custom implementation? Perhaps it has to do with their custom Document ID scheme and how they want to preserve order in the Posting List being different from the default behavior. It also sounds like searchers are searching on indexes as they're being written, and there is some custom coordination around visibility, which might require diverging from Lucene default behavior.
Either way, pretty impressive!
CMU database group videos recently had the duckdb lead on
In the reference there's no mention of SQL Window functions. Is it possible to do multiple moving averages over different time spans?
If not, are there plans to add support in the future?
Umbra DB was recently posted on HN and has the ability to avoid LLVM for simpler queries, in addition to novel buffer management and index approaches:
Look forward to hearing more about it in the future.
ClickHouse is easy to run on local machine and has great performance.
This project has similar goals to the MLIR project:
https://github.com/tensorflow/mlir
https://www.youtube.com/watch?v=qzljG6DKgic
Exciting times for the future of parallel computing!