“Fischer Black thought that #markets got the right price within a factor of two about 90 per cent of the time… I knew Fischer pretty well, and he didn’t throw numbers like those around lightly; he thought long and hard about them, even though they sound like the kind of rough figures other people would come up with quickly. We argued quite a bit about them, and I pushed for ‘within a factor of two about half the time’.” —Aaron Brown
*Financial Risk Management for Dummies* chapter 4 = 🔥
“Taking less risk than is optimal is not safer; it just locks in a worse outcome. In competitive fields, doing less than the best often means failing completely. Taking more risk than is optimal also results in a worse outcome, and often leads to complete disaster.”
—Aaron Brown, “Red-Blooded Risk”
Friends, I'm a terribly incompetent social medialyte—I don't see many toots since I follow almost no one, don't check local or federated timelines, don't get follow/fave/boost notifications—just at some point I lost the taste for being plugged in.
But! I'm more than happy to read, learn, discuss, answer, and mentor:
or whatever 🤗!
(I'll pin this toot, so don't link to it!)
Ideas I frequently invoke:
- Philip Guo on silent technical privilege http://pgbovine.net/tech-privilege.htm
- Bryn Hammond on silenced history https://amgalant.com/
- Duncan Watts on cumulative advantage, or, MusicLab, in the top ten scientific experiments ever https://www.nytimes.com/2007/04/15/magazine/15wwlnidealab.t.html
- AnimeFeminist for their critiques and season guides https://www.animefeminist.com/
(Don't link to this toot, it'll be edited+deleted, but it'll be pinned to my profile on Octodon.social.)
Thanks to #Dragonwood #BoardGame https://gamewright.com/product/Dragonwood, plus a paper with the probability for each move (https://fasiha.github.io/dragonwood-tm-rolls), even my pre-schooler gained a solid grasp of good vs bad odds.
Thing is, the game makes it too easy to just wait for bad odds to improve (draw another card). Everyone mostly goes on good odds. Very rarely does anyone take a real chance.
I'd like to find a game that forces you to take longer odds, to teach what that feels like viscerally. Suggestions? #Poker?
‘I normally spend premiere season locked in our home office, mentally sorting shows into “things I’ll never watch again,” “things I’ll watch on my own,” and “things I’ll tell my wife about later.” Halfway through turning on the premiere for this series I paused the stream, ran down the stairs, and demanded that the rest of my family watch it with me right that second.
That’s the kind of show #Eizouken is.’ https://www.animefeminist.com/keep-your-hands-off-eizouken-episode-1/
#AnimeFeminist’s Vrai Kaiser gets it! Episode 4 drops tomorrow!
Yup, on 25Jan, the CSV file has updated to 23Jan, so probably ~2 days latency in updating.
#VaR kids go!
May the best modeler and data digger and nonlinear regressor win! #ValueAtRisk
I will probably set up a website or some service that can accept your VaR levels and calculate your VaR breaks. #AaronBrown talks about risk management students calculating VaRs daily for an entire semester (https://gist.github.com/fasiha/b78ab1f9e31e2c4a4f0a50b995d53a95) and it'd be nice to have a centralized place to organize it.
But I've not at all pushed #Rust, maybe you do need immutable data structures (with efficient copy-on-write) for a concurrent world, & polymorphic variants to write expressive APIs—I'll definitely look to falsify my gently-held hypothesis.
But I think a lot of languages need to update their view of "our pros vs cons"—both from fancy (most of the chapter headings of Real World #OCaml are in Rust) and the plain (Rust needs so little text beyond Python/JS to make copy/reference/borrow/move clear).
The immutable data structures (red-black trees backing even arrays), the map-reduces, the recursions—all the things we thought we needed to avoid shooting ourselves in the feet, maybe we don't actually need to write correct programs.
With #Rust we also get pattern matching, traits baked into the stdlib, ergonomic interfaces—all the creature comforts, extremely organized & polished.
(The fact that the resulting programs are about as fast as they can ever be is not interesting to me right now.)
I'm very gingerly going to make a claim:
Rust is imperative programming that's SO well done, with such clarity into
and with such a well-designed stdlib & API, that it may make functional programming unnecessary.
May Zeus ⚡️⚡️ me 💀 now.
And of course in #rust you can write your own traits and then provide implementations for built-in types, and vice versa, write your own custom types and have them implement built-in traits! And write new traits and new types! Which is really cool!
(Of course all the #Haskell people are like ‘what’s wrong with this weirdo’ 🤣 yes yes I’ll get to y’all soon.)
So as you can tell from this snippet, #Rust has a veritable Pokémon universe of traits like this, and each of its built-in types (from i8 to Vec to HashMap) have some eclectic subset of traits (so types would be Pokémon trainers?), and if you want to write type-generic functions, you have to specify which traits your code relies on—the compiler was helpfully guiding me to which traits I needed and a kind soul on Rust Discord channel helped me identify the details like parametrizing traits.
I needed and got so much help from #Rust Discord to write this:
fn mass_to_fuel<T>(mass: T) -> T where T: Div<Output = T> + Sub<Output = T> + From<i8> + Ord,
that I think I was literally moved to tears by the generosity of strangers to this rotten soul.
That line says, “this function will take any type T that supports division and subtraction (both of which will result in T), conversion from int8, and where T can be ordered” 😅! So it works for lots of number types!
The big lesson so far has been, things that I thought would annoy me might not be so bad:
- the leading language, #ReasonML–#OCaml, makes me use separate functions for lists vs arrays, and different symbols for adding ints vs floats, and I can probably get over that.
- JVM, despite not targeting JS, is surprisingly ergonomic!
Maybe Go's lack of generics is just fine too 😂?? Jk, revisiting that Clojure code reminds me I'm looking for something at least as smart as TypeScript.
I wanted to make the function in #Scala generic, but gave up in disgust when I saw I couldn't use traits with arithmetic symbols. So #Rust let me say "I promise type T implements division, so let me do `t / 3`" but in Scala, I'd have to do `Div.div(t, 3)` or something grotesque like that. So I left everything as `Int` in Scala.
I fell in love with Rust few years ago working through #Cryptopals challenges, but I wasn't competent enough to write Rust to compete with C++ at work, so I drifted away. Now with WebAssembly and at least one React/Elm alternative (Yew), Rust could be The One.
But, whew, that learning curve for templates & trait bounds hit me hard! Got tons of help on Discord though so I got there! https://github.com/fasiha/advent-of-code-2019-reasonml/blob/491361b46199224f6f7e7731c356da6331ceeed6/src/main.rs#L14-L19
"One thing I don’t understand is why these iteration speeds were tolerated. Is it because the company had a huge number of new graduates who didn’t know better? Maybe the average Dropbox engineer can handle context switches a lot better than I can? Perhaps the situation was better outside of core product engineering? Maybe Dropbox grew so fast that the situation regressed faster than people could fix it? All of the above?"
#Scala and JVM is spoiling me, allowing tuples as keys in maps/sets, which JS can't do…
Op: chelmico’s Easy Breezy https://open.spotify.com/track/5Zjge6yCThuBMdnJdOBp9A?si=93KhAZtSQUiSJNzEBgrtsA
End: Kami-sama, I have noticed’s 名前のない青 (namae no nai ao, roughly meaning, umm, something like “nameless blue”?) https://open.spotify.com/track/0xSKobz5d2E8oIkwTumwkZ?si=X8_8PyQPRIunkHGDpp-2Iw
(With fixed link)
and looking at Dev Console's Network tab, I see an XHR to the raw CSV file!
Hopefully it's updated daily?, it doesn't have 22Jan yet, likely there's some latency in calculating daily numbers, will update.
#Eizouken is absolutely perfect #anime watch it now (available on Crunchyroll) why is it so good, ah, #Sakuga will tell me https://blog.sakugabooru.com/2020/01/06/keep-your-hands-off-eizouken-01-production-notes/
Looking at the code now… https://github.com/fasiha/unlock-mvp-reframe/blob/master/src/cljs/mvp_reframe/handlers.cljs very messy, yes, yet very fun and cerebral.
But Clojure's committment to immutable data structures didn't help when the same data being written by a HTTP handler and rendered by a DOM view—I really needed types to ensure coherence.
Still. Great times.
Programmer in the big city 💎🌇. Tries to maintain privacy, and yet see how these toots flow.
The social network of the future: No ads, no corporate surveillance, ethical design, and decentralization! Own your data with Mastodon!