g0wda

Yeah it is useful. However the problem arises when you share a notebook with someone and they just can’t get it to work either because you forgot to reorder cells or your output depended on some state from a cell you deleted thinking nothing depends on it. You need to restart the kernel and run the notebook all the way through to be sure. Pluto’s reactivity eliminates this issue altogether. It’s a readily reproducible artifact. The functionality you mention would be the default in Pluto btw. Something that reads a sensor will read it only when you run the cell and update all depenents.

Store fp16 vector blobs in sqlite. Load the vectors after filter queries into memory and do a matvec multiplication for similarity scores (this part will be fast if the library (e.g. numpy/torch) uses multithreading/blas/GPU). I will migrate this to the very based https://github.com/sqliteai/sqlite-vector when it starts to become a bottleneck. In my case the filters by other features (e.g. date, location) just subset a lot. All this is behind some interface that will allow me to switch out the backend.

Nice! I have my lastfm when I need a throw back. They still allow yearly views

oh nice! I didn't know that you can just make it use light dom.

  protected createRenderRoot() {
    return this;
  }

Something about Lit/web components that's not written clearly on the label is the hoops you have to jump through to style elements. If you're using tailwind in the whole app, you just want to pull it into your custom elements without much boilerplate. My main app compiles a single minified app.css, it felt not so modular to now include that in every single component. The alternative is create a subclass that injects tailwind into Lit components. It'd be perfect it just had a switch to inherit everything the page already has.

If you now have a function where you call this one with an integer literal, you will end up with a fully inlined integer answer!

Multiple-dispatch is the right abstraction for programming mathematics. It provides both the flexibility required to create scientific software in layers (science has a LOT more function overloading compared to any other field.), and the information required to compile to fast machine code.

Location: Boston Remote: Ok with it! Willing to relocate: yes, to anywhere reasonable Technologies: Analytical database design and implementation, Technical/Numerical computing, Julia, Python, Elixir, C, Lisp Resume: https://shashi.biz/resume.pdf Email: (in resume)

Summary: I've worked with the Julia community for 9 years as a professional and a student. Just finishing up my PhD at MIT now. Have been on a lot of varied projects so far, from web development to distributed computing, looking to do some exciting work in a place where I can use my skills, pick up new ones, and have some agency. (Not necessarily Julia, any decent technology will do.)

Incredible release!

Prof. Alan Edelman gave a nice lecture about this a couple of days ago https://www.youtube.com/watch?v=IuOXXQR7dAo

In Julia, there is one package manager and it gets things right. https://docs.julialang.org/en/v1/stdlib/Pkg/ It's super nice to have no fragmentation when it comes to packaging. In Pkg, package states are immutable, always reproducible, and quick. Julia packages that have binary dependencies usually build them all for every platform using the binary builder infrastructure (https://github.com/JuliaPackaging/Yggdrasil). It makes cross platform installation robust and testable, and suuuper quick. Pkg really is the rolls royce of package managers.

I like the reactive notebook concept. It does really help with bugs

Can you say more? An example, maybe?

The basic Dask-like functionality is in Dagger.jl, we have plans to move out the distributed array functionality out of it and keep just the scheduler in there.

I'm working on a set of functions to work with many DataFrames (or anything) in parallel and do it out of core if possible, it's basically like JuliaDB but with a FileTree abstraction rather than a table abstraction.

http://shashi.biz/FileTrees.jl/lazy-parallel/

Why not make one for yourself? ;)

julia> (∘)(f, g) = x -> f(g(x))

∘ (generic function with 1 method)

julia> (sum ∘ rand)(10)

3.397728240035534

Tip: type \circ<tab> to get ∘

The generic function is the basic unit of abstraction in Julia. And this is exactly what makes Julia a very powerful language.

If anyone is interested in reading more about Julia's design, I recommend Jeff Bezanson's thesis https://github.com/JeffBezanson/phdthesis/raw/master/main.pd...

Responsiveness is excellent when your Julia process is on the same machine as the browser - which in itself addresses a large set of use cases scientific computing audience has (such as presentations). When the Julia process is connected over the network, there is obviously a lag between updates. But it's no better or worse than an AJAX/WebSocket application. The intention is to use web components to encapsulate UI components and their behavior (including self-contained animations) and Julia to read from them and update their attributes. So one can switch to writing web components and using them in Escher if responsiveness is really a concern. With the programming model in Escher, it will be easy to hoist some computations to the browser once there is Julia to JavaScript compilation. However, I don't plan to write the transpiler (yet) ;).

FWIW, I work on Web-related stuff in Julia (like http://shashi.github.io/Escher.jl). I find Julia's type system more natural for general purpose modeling of data than, say, Python's classes. It's also really easy to enforce things like immutability or make stuff blazing fast if one needs to with little effort. Julia's multiple-dispatch is a great companion. On many occasions I've wondered if my code is even complete because it winds up being so small. Another thing to like is the hackability of any code. The standard-library is in Julia, you can look at any function's code from the REPL, and many more developer friendly features.

Jonathan Malmaud, Iain Dunning, Randy Zwitch, Mike Innes (OP) and many others write and maintain general purpose/web-related library code. I'm sure they will agree with some of what I said.

0.4 already ships with Go-like channels. http://docs.julialang.org/en/latest/manual/parallel-computin...

I love Julia. This is great news! :)

Yup. :)

Hello! I wrote Escher. Thanks!

Reactive.jl which Escher depends on for interaction was entirely inspired by Elm! I think the main difference between Elm is that Elm is currently a client-only compile-to-JS language. Escher, otoh runs on the server and compiles to Virtual DOM instead of JS. The Virtual DOM can include custom HTML elements, I use Polymer extensively, and have a few elements of my own for doing things like event capture, websocket communication, sampling events etc.

see https://groups.google.com/forum/#!topic/julia-users/UEaYPlBu... for a brief description of how it works.

Hey, I made this notebook. Thanks!

SICP talks about abstraction barriers, and I love the idea. It can guide great library design. When in doubt, I sometimes read this again: https://mitpress.mit.edu/sicp/full-text/sicp/book/node29.htm...

No it's not, in most of the world.

Very cool!

Well, not everything seems to show up for me on Chrome.

nbviewer seems to be down.

you can access it here: http://shashi.github.io/ijulia-notebooks/funcgeo/

If anyone is trying to run the code, you are gonna need my fixes to compose https://github.com/shashi/Compose.jl/tree/rotation_fix Will get it merged upstream and tag a new version soon.