I think the single most useful tool for novice learners of subjects, especially subjects with a very wide, very deep, well considered body of knowledge; is to get comfortable with imperfect abstractions. Just get comfortable saying to yourself "so there is this thing called x; and I don't really get it, but it seems to do y. Dunno how it does.".

When you first start learning a new body of knowledge; there are a lot of these. And they slowly get replaced with more and more precise abstractions as you start to map the contours of the knowledge-space.

When I was first learning computers. There were tons of those. If I'm honest, there still are. "CPUs have these things called registers; that are like tiny scratch pads for numbers."; "BGP is some protocol that big expensive switches use to route traffic to other big, expensive switches", and so on.

But the really cool thing, the thing that always baffles novices when they see some one more experianced seem to have a psychic intuitive sense; they might seem to "just know" how a thing they have never seen before works.

What'ss happening there, is as you explore more of a knowledge-space, and start to internalize more; you will start to have more points of reference to make better metaphors when you are building these abstractions. The abstractions start out more accurate from the jump. You have to do less work to resolve the fuzzy picture into one that's sharp enough to work with.

's server is now backed by akka-http rather than Jetty. Getting out of the jetty API mix and match dependency hell is welcome. I'm torn on akka-http's directive-based routing scheme. On the one hand, it is **really** slick how composable routes directives are. On the other hand, it tries to be a little too clever with the typesystem, making error messages a pain to debug. It also doesn't help that there's not a clear pointer to the `extract` directives.

Been fiddling around with akka-http for and it really strikes me how much of the Scala ecosystem is enamored of Scala's "build a DSL inside the language" capabilities. Scala has DSLs for everything... from reactive programming, to request routing, to build tools. Unfortunately, these DSLs have a tendency to leak implementation details through e.g., error messages, or crazy contortions needed to work around a DSL construct that Scala can't implement.

Finally tracked down a persnickety (and very bad) bug in (github.com/VizierDB/vizier-sca). In general, I love working with reactive frameworks, but when the abstraction breaks, it breaks hard. With the possible exception of Airstream (which I sadly learned of too late), reactive frameworks have no concept of collections with fine-grained deltas (insert, delete, update), nor any way for the user to declaratively provide finer-grained deltas for specific reactive types.

Along with..... the more behaviorally-accurate Sapsucker variant! 😁

Show thread

Thrilled to have my lightning talk on accepted at thedatathread.com/ Also, if in Philly, check out Nachiket's talk on bridging Jupyter and Vizier at TAPP (colocated with SIGMOD this year).

After about three weeks of optimizing startup times in and making minimal apparent progress, I just happened to rerun a giant 100-cell notebook I'm using for work data vis. Normally this is a terrifying experience, shutting down my ability to do anything for a good minute. Optimization payoff: By the time I realized what had happened, the notebook was done running.

Jupiter, Io and Europa a few hours ago. Three worlds in one shot.

Full Size: flic.kr/p/2nnsZDr

#NASA Juno Spacecraft
Altitude: 640205 km
Time: 2022-05-23

#Jupiter #Io #Europa #Perijove42 #Space
©NASA/JPL-Caltech/SwRI /MSSS/AndreaLuck

Never trust a Jupyter notebook - it's always plotting something!

@doomer_jesus
Paper really beats digital on everything for plein-air outside, imo:
✅ No battery issue.
✅ Super visibility.
✅ Real time high FPS gesture.
✅ Texture and no parralax.
✅ Mega cheap in comparison.
✅ Ecologically-friendlier.
✅ Lightweight in a backpack.
✅ No boot time or waiting time.
✅ Ends with a real art you can give (or sell).

But!
❌ Doesn't have Undo
❌ No Selections, Filters, versionning, etc...
❌ Doesn't have hundred thousands color available
❌ It doesn't run Doom

This is Mars! #NASA Curiosity Rover met "Blackcraig Butte" on its way up to Mount Sharp inside Gale Crater.

You should zoom on this 150MP super detailed photo via this link: easyzoom.com/image/321602

Sol: 3386 / Time: 13.02.2022
Full Size image: flic.kr/p/2n41EcP

#Mars #Curiosity #Space
©Nasa/JPL-Caltech/MSSS/AndreaLuck

I love when Mars shows off its clouds on the terminator!

#Mars #Space #HopeProbe
©UAESA/MBRSC/HopeMission/EXI/AndreaLuck

Show thread

Optimist: The glass is ½ full.
Pessimist: The glass is ½ empty.
Excel: The glass is January 2nd.

python.natto.dev/ looks like a nifty hack. The node-based workflow system is fairly common, but it has some nice ideas, making it easy to spin out new panes for subsets of data (e.g., try interacting with the dataframe view)

Show older
X marks the spot

The social network of the future: No ads, no corporate surveillance, ethical design, and decentralization! Own your data with Mastodon!