michael 📈 👨‍💻

editing the clip: "hard rule: no statistics... it isn't worth it"

my worry is that this is good armor against slop only to the extent that people have collective energy to join hands and hate it together, which is a shaky foundation

the work is never done, matt

One bewildering piece of condescending Apple UI is that, while you *can* attach files to iMessage, you can't do it with the obvious UI element that should do it.

If you're audacious enough to realize that your computer has these things called "files" there's drag-and-drop or the menu bar?

really excited for my gf's new iphone to arrive so I can finally rid our lives of lightning cables forever

as a blog post @ mikedecr.computer/blog/map-as-...

curious to try omarchy but i would need to buy a computer

this has been a very nice trick so far actually. it's way easier to set prior expectations when the scale is like, multiples of the mean vs. the number of nanoseconds between things

does it help in another way besides the prior for the mean e.g. better sampling or something? assuming you are doing a log link then it sounds like you can get the same algebra by centering the intercept on log of the mean right?

anything helps me absorb little intuitions, thanks

anybody got a good pragmatic blog post or paper on modern techniques for fitting gamma likelihood models? bayesian is ok / preferred actually

Are you guys street or vert

built a great model at work. beautiful really. has everything you think you need or want in it. sucks though. doesn't work at all

Open Social — overreacted The protocol is the API.

i wrote about atproto and why it matters

this is the kind of stimulating content you can expect by following me at mikedecr dot computer

screenshot of python code: # this is the classical definition of map def map(fn, xs: list): if len(xs) == 0: return [] else: return [fn(xs[0]), *map(fn, xs[1:])] # but you can implement as a reduce from functools import reduce def map(fn, xs: list): return reduce(_as_binary_op(fn), xs, list()) # casting func into a binary operation def _as_binary_op(fn): def binary_op(accum: list, x): accum.append(fn(x)) return accum return binary_op map(str.upper, ["a", "b", "c"]) # ['A', 'B', 'C']

weird idea: map in terms of reduce

I really like riding a bike but sometimes it would be great if it could have four wheels so I could lug more stuff, an engine so I wouldn't have to pedal it all by myself myself, climate control because sometimes the weather is bad, and safety features to protect me in an accident

mhm yeah I mean, watch a youtube video of people in amsterdam. it's pretty slow. can't safely go much faster

Look, I ride a bike and I want better bike infrastructure, but this is magical thinking. If every car disappeared there would be way more bikes, way more bikers who don't ride as fast as you want to go, so way more bike traffic

text in the R console: R > by_sex = \(x) group_by(x, sex, .add = TRUE) R > mean_mass = \(x) summarize(x, mass = mean(body_mass_g)) R > penguins |> by_sex() |> mean_mass() # A tibble: 3 × 2 sex mass <fct> <dbl> 1 female 3862. 2 male 4546. 3 NA NA

will anybody ever want this? idk. a cheaper / better way might be to just define the fns with lambdas

Screenshot from the text of the blog post: More abstractly, what I want is more separation of functions from data in the R pipeline style. In some situation, I want to pass data `x` to functions `f`, `g`, and `h`. But instead of writing this: ```{r} #| eval: false x |> f(...) |> g(...) |> h(...) ``` I want to write something like this: ```{r} #| eval: false # first argument omitted from each of these expressions pipeline = compose(f(...), g(...), h(...)) # supply data to the ultimate function call x |> pipeline() ``` `pipeline` is a function that captures unevaluated function calls on `f`, `g`, and `h` with their first arguments omitted. Then I pass data `x` such that the data pass through the first argument of each function in the chain. Why do I want this? Because it should be easier to build a pipeline of expressions that can be re-used on different datasets. I am thinking specically of examples like this: ```{r} #| eval: false # I could evaluate this function as-is x |> pipeline() # and I could also drop in extra steps j and k x |> j() |> pipeline() x |> k() |> pipeline() ```

I re-published this post about "lazy" pipeline functions: mikedecr.computer/blog/lazy-dp...

Basically, exploring how to make pipeline-style R code more re-usable and composable by abusing partial function application

The trick to laundry is never stop. Don’t lose your momentum

I can see my hairline doing things that I do not regard as familiar

Screenshot of R code that reads: library(dplyr) library(palmerpenguins) # how a normal pipeline looks mass_stats <- penguins |> group_by(species, island) |> summarize( mean_body_mass = mean(body_mass_g, na.rm = TRUE), sd_body_mass = sd(body_mass_g, na.rm = TRUE), ) |> print() # using lazy pipe # create a function by composing partial expressions with %=>% operator compute_mass_stats = group_by(species, island, .add = TRUE) %=>% summarize( mean_body_mass = mean(body_mass_g, na.rm = TRUE), sd_body_mass = sd(body_mass_g, na.rm = TRUE) ) # then pass data compute_mass_stats(penguins)

Screenshot of R code that reads: # by using .add = TRUE we can prepend extra groupings to our pipeline # so we can re-use code more efficiency when we need to slice data more ways by_sex = group_by(sex, .add = TRUE) |> as_partial() penguins |> by_sex() |> compute_mass_stats()

I wrote a "lazy pipe" operator %=>% that lets you build function compositions from partial function expressions in a linear way.

Instead of passing data up front, you define pipeline steps without reference to the data. You get reusable + composable pipeline steps w/out as much function boilerplate

you really think someone would do that? go on linkedin and tell lies!?!?

I think this whole thread is good but this especially 🔔🔔🔔.
Genuinely good ideas will attract even people you dislike. It's a sign of success. If you link every single issue to these character dramas that most people never think about, you won't know how to recognize good ideas, only tribes

Chicago, Baby! - by Feather Flores (Hardcover) Read reviews and buy Chicago, Baby! - by Feather Flores (Hardcover) at Target. Choose from contactless Same Day Delivery, Drive Up and more.

i got this book for some friends and their kid now announces things from the book when they go out in the city

www.target.com/p/chicago-ba...

the constant Calabrian chili-fication of gentrified Italian food is getting totally out of hand and must be stopped

slide from a presentation that reads "Syntax don't solve your problems"

good slide from this talk: www.youtube.com/watch?v=EGLo...

I admit I may be misunderstanding something major about the CRAN model. It's my understanding that you can still install an "archived" pkg from CRAN if requested. is there a way to ensure that the rest of your deps work with that version? and if so is it easy for the user to declare those wishes?