I do. It pairs nicely with this quote from the article:
> “With Dyad 3.0, you can upload data and design documents and the system will design an entire aircraft for you,” Shah says
3,445 karma · joined May 17, 2009
yurivish@gmail.com
https://yuri.is
> “With Dyad 3.0, you can upload data and design documents and the system will design an entire aircraft for you,” Shah says
Yep, and it is unfortunate that this unrealistic expectation is explicitly encouraged by the creators of the language:
> It is actually the case in Julia that you can take generic algorithms that were written by one person and custom types that were written by other people and just use them together efficiently and effectively.
It seems worth reiterating that on a personal level I really like and appreciate the vast majority of the folks I’ve met in the Julia community. I’m glad I got to hang out with them and learn from them. But in my opinion setting expectations like this fosters bad science.
In Julia it's almost as if every function is an interface, with (usually quite terse) documentation as its only semantic constraint. For example, here is the full documentation for `+`: https://docs.julialang.org/en/v1/base/math/#Base.:+
I love Game Programming Patterns, by the way! Laughed out loud when I first saw the back cover.
I may refresh the post with more recent information at some point. In the meantime, those curious can find a short story of one newer correctness bug here: https://discourse.julialang.org/t/why-is-it-reliable-to-use-...
The person who eventually fixed the issue, mkitti, had to push through a lot of "institutional" friction to do so, and the eventual fix is the result of his determined efforts.
While his part of the story mostly played out in venues outside of the Discourse forum some of it is on display in this thread: https://discourse.julialang.org/t/csv-jl-findmax-and-argmax-...
Yes, you could try making one using Observable Plot (which is what I used for these): https://observablehq.com/plot/transforms/dodge
One of the slides in my presentation has the full prompt I used, in case that's useful. I ran it on chunks of the podcast transcript and then merged/deduplicated the results to get the data that's visualized here.
My secret agenda is to explore how the "information supply chain" can be tracked across the data-processing stack all the way from the original audio through transcription, the processing pipeline, and UI. I'm using language models for multi-stage summarization and want to be able to follow the provenance of summaries all the way back to the transcripts and original audio.
Another paper of his that I really like combines a few elegant ideas into a simple implementation of bitvector rank/select: https://users.dcc.uchile.cl/~gnavarro/ps/sea12.1.pdf
During this time I got really excited about succinct data structures and wrote a Rust library implementing many bitvector types and a wavelet matrix. [2]
My interest came from a data visualization perspective -- I was curious if space-efficient data structures could fundamentally improve the interactive exploration of large datasets on the client side. Happy to chat about that if anyone's curious.
[1] Paper: https://archive.yuri.is/pdfing/weighted_range_quantile_queri... though it's pretty hard to understand without some background context. I've been meaning to write a blog post explaining the core contribution, which is a simple tweak to one of Navarro's textbook data structures.
[2] The rust version is here: https://github.com/yurivish/made-of-bits/tree/main/rust-play... and an earlier pure-JS implementation is here: https://github.com/yurivish/made-of-bits/tree/main
I've just added a credit to you and your repository (see the second sentence).
I had put together this minimal example based on your repository together with a StackOverflow answer containing the build command (https://stackoverflow.com/questions/68476647/errors-with-com...).
Being just a single file with a simple build command it seemed like a minimal advancement on the state of the art, so I quickly decided to publish, and did not appropriately credit the original as I should have. I hope you can accept my apology – this was an honest mistake.
Which is another nice WASM-based browser SQLite user interface.
I'm currently working on my first-ever side project with user accounts, and now I'm wondering what I'm in for. :-)
When the number of the bins in the data is not an exact integer multiple of the number of bins in the histogram, adjacent data bins can get mapped to the same histogram bin, resulting in e.g. 2x the data volume in some rows/columns of the histogram.
When a bit of loss of fidelity is acceptable the two solutions I've used are to render the histogram at an exact factor of the number of data bins then set the canvas dimensions to the desired size (relying on the browser to downsample the resulting image), or to use `max` as the reduceOp and render the histogram directly at the intended size.
Imagine a point moving along the curve, depositing a constant amount of density/ink onto the canvas per unit of time. When the point is moving quickly it deposits less density, and when the point is moving slowly then it deposits more, since the density deposited per time unit is constant and the point traverses less space when it moves slowly.
You can think of each vertical strip of bins as representing a unit of time. The discrete approximation to arc-length normalization means, for each time series, making sure that it contributes a single unit of density per vertical strip: if a curve goes through one bin in that strip, then that bin has its density increased by 1. If it goes through 3 bins, then the density in each is increased by 1/3.
If you're interested in the technique behind the plot you can read more about how that works in this paper: https://arxiv.org/abs/1808.06019
(This is mentioned in the intro post for this library: https://observablehq.com/@twitter/density-plot-introduction?...)
Traditional graphics pipelines aren't built to handle more than 256 incremental levels of opacity since it's an 8-bit channel, and when you have a thousand time series you can no longer distinguish between levels of density. Conditional information (following a single line) becomes difficult as well since there are so many lines. Density plots solve the overdraw problem by accumulating density into an offscreen buffer before rendering, which allows the color scale to be tuned to the amount of overlap in the specific dataset. Interactive selection/hover techniques can be used to recover conditional information.
This example is part of a density plot library published earlier this week (https://observablehq.com/@twitter/density-plot-introduction?...) and one of the references there is to an opacity-based approach I've seen used for 2D point clouds, though I haven't seen an analogous demo for curves: https://observablehq.com/@rreusser/selecting-the-right-opaci...
Brooklyns: https://gist.github.com/yurivish/326f64c439176f6d55f8d5528f1...
You can find the full dataset here: https://data.cityofnewyork.us/Health/NYC-Dog-Licensing-Datas...
Some of the things I've thought about:
- Expanding the expressive range. The new app has a "silk eraser" and I have ideas for at least one new type of brush.
- Continuous undo (as if it's a movie), or at least more undo levels.
- Making a better Alchemy: http://al.chemy.org/
- Unifying the experience of the website (2013; JS/Canvas) and the new app (Swift/Metal)
- The website lets you share replays of your drawings that play back on the site. What's the best way to do something similar with the app?
- A gallery would be great but requires figuring out the previous two points to some extent. There's a lot of potential but it feels like a lot to navigate through.
Long-term I'd love Silk to be a Bret Victor-inspired environment for visually exploring computation: Compute with color and time, explore the system, make your own brushes. You can think of a brush as a function from input history to pixels on the canvas. I think there's a lot of potential here.
Some of the common things people ask for:
- More colors. The new app has more palettes, which is a start.
- More undo levels.
- High-resolution export. This will be coming to the app, potentially inside a bundle of "pro" features.
- Plugins for Photoshop and other professional design tools.
- Prints. I've experimented with prints before but found that the art doesn't come out nearly as well in print. My bar for quality here is this piece made by a talented designer friend (Anand Sharma) many years ago: http://bit.ly/1TDS2sz. Maybe the right answer here is something more ephemeral like greeting cards.
http://weavesilk.com is a side project of mine for many years. I put out a brand new version of the iOS app this month and am thinking about developing it further but find it very hard to decide what direction to go.
The website is popular, and people love Silk, but for different reasons: some find it relaxing and meditative, others like that it closes the gap between their artistic ability and taste.
It's been used as an inspirational sketching tool for artists (http://bit.ly/1Qlm1kA), to make album art, and has been on exhibit at the Children's Creativity Museum. Some teachers use it to teach kids about symmetry.
I've made something compelling but don't know what to do next, or how to figure it out.