Pinned oot

“Fischer Black thought that 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 = 🔥

Pinned oot

“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”

Pinned oot

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!)

Pinned oot

Ideas I frequently invoke:

- Philip Guo on silent technical privilege pgbovine.net/tech-privilege.ht

- Bryn Hammond on silenced history amgalant.com/

- Duncan Watts on cumulative advantage, or, MusicLab, in the top ten scientific experiments ever nytimes.com/2007/04/15/magazin

- AnimeFeminist for their critiques and season guides animefeminist.com/

(Don't link to this toot, it'll be edited+deleted, but it'll be pinned to my profile on Octodon.social.)

If you do with Browserify/Rollup/Webpack, use instead, is good: snowpack.dev

Introduced me to Preact and Servor and life is good.

Thanks to gamewright.com/product/Dragonw, plus a paper with the probability for each move (fasiha.github.io/dragonwood-tm), 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? ?

‘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 is.’ animefeminist.com/keep-your-ha

’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.

That's fine!

kids go!

May the best modeler and data digger and nonlinear regressor win!

I will probably set up a website or some service that can accept your VaR levels and calculate your VaR breaks. talks about risk management students calculating VaRs daily for an entire semester (gist.github.com/fasiha/b78ab1f) and it'd be nice to have a centralized place to organize it.

But I've not at all pushed , 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 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 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.)

After working through some more with (after & ), and reading both

1- reddit.com/r/rust/comments/abm OCaml🥊Rust &

2- discuss.ocaml.org/t/advantages Rust🥊OCaml,

I'm very gingerly going to make a claim:

Rust is imperative programming that's SO well done, with such clarity into

- copy-vs-reference,
- borrow-vs-move,
- mutable-vs-immutable,

and with such a well-designed stdlib & API, that it may make functional programming unnecessary.

May Zeus ⚡️⚡️ me 💀 now.

And of course in 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 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, 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 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!

(github.com/fasiha/advent-of-co)

The big lesson so far has been, things that I thought would annoy me might not be so bad:

- the leading language, , 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.

SO educational!

I wanted to make the function in generic, but gave up in disgust when I saw I couldn't use traits with arithmetic symbols. So 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.

So Rust is the first implementation that I'm happy with. (The first implementation in I compiled to JS, so only one number type 😇!)

I have done Day 1's (adventofcode.com/2019) in .

Hoooiiiii 😅!

I fell in love with Rust few years ago working through 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! github.com/fasiha/advent-of-co

"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?"

chadaustin.me/2019/11/two-year

If is this bad… 😱!

proposal (to the EcmaScript standards group that adds new features to ) to add records (primitive versions of objects) and tuples (primitive versions of arrays):

github.com/tc39/proposal-recor

and JVM is spoiling me, allowing tuples as keys in maps/sets, which JS can't do…

is still in the lead for language to replace since it compiles to JS & has that static-typing juice 💖, but… still can't put objects/arrays in maps/sets in frontend JS 😭!

For my people, songs are 🔥:

Op: chelmico’s Easy Breezy open.spotify.com/track/5Zjge6y

End: Kami-sama, I have noticed’s 名前のない青 (namae no nai ao, roughly meaning, umm, something like “nameless blue”?) open.spotify.com/track/0xSKobz

(With fixed link)

Another cool daily data feed to practice calculating (per 's books on risk management): DuckDuckGo publishes daily the number of queries it got going back to 2010:

duckduckgo.com/traffic

and looking at Dev Console's Network tab, I see an XHR to the raw CSV file!

duckduckgo.com/traffic_data/di

Hopefully it's updated daily?, it doesn't have 22Jan yet, likely there's some latency in calculating daily numbers, will update.

Coworker's only exposure to Lisp was a stupid college course & was nonplussed when I mentioned I loved & —couldn't fathom how parentheses were compatible with big webapps.

Looking at the code now… github.com/fasiha/unlock-mvp-r 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.

Show more
Octodon

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