michael 📈 👨‍💻
LightNews LightNews
banner
mikedecr.computer
michael 📈 👨‍💻
@mikedecr.computer
270 followers 290 following 400 posts
Low-latency quant finance R&D.
Former political scientist, sometimes bike rider.
Long form mikedecr.computer
Posts Replies Media Videos
mikedecr.computer
every inconvenience is an opportunity for evil
Python code: import polars as pl class Columns: def __getattr__(self, name) -> pl.Expr: if name.startswith("_"): raise AttributeError(name) return pl.col(name) def __getitem__(self, name) -> pl.Expr: return pl.col(name) c = Columns() df = pl.DataFrame({"foo": [1, 2, 3], "bar": [4, 5, 6]}) df.with_columns(baz=c.foo + c.bar) # shape: (3, 3) # ┌─────┬─────┬─────┐ # │ foo ┆ bar ┆ baz │ # │ --- ┆ --- ┆ --- │ # │ i64 ┆ i64 ┆ i64 │ # ╞═════╪═════╪═════╡ # │ 1 ┆ 4 ┆ 5 │ # │ 2 ┆ 5 ┆ 7 │ # │ 3 ┆ 6 ┆ 9 │ # └─────┴─────┴─────┘
August 21, 2026 at 2:12 PM
mikedecr.computer
I like language exercises like these, so I implemented some of these functions in Hy, which is a Lisp that generates Python.

We like functions right? Would we still like functions if they were **evil**?

mikedecr.computer/blog/r-hy/
hy code and output: (import toolz [first second]) (require hyrule [->]) (defn which [lst] (-> lst (enumerate) ((curry filter (compose bool second))) ((curry map first)) (list))) (which [False False True False True]) [2, 4] bugs bunny guns meme: forgive me lord but it's time to go back to the old me
June 1, 2026 at 3:00 AM
mikedecr.computer
scope in Python *is* possible but for your sanity you should ask no more questions
Python console input and output: >>> with Bind(1) as x: ... print(x) ... 1 >>> x Traceback (most recent call last): File "<python-input-12>", line 1, in <module> x NameError: name 'x' is not defined
May 20, 2026 at 1:14 AM
mikedecr.computer
I love the conceptual model of ggplot but believe that implementing the exact syntax feel in python is not desirable or important. The "adding" of the plot components... how much will you suffer for this? I write this helper fn all the time
python code snip: from pick_your_ggplot_emulation_pkg import * def fnplot(data, *args): return sum(args, start=ggplot(data)) fnplot( data, aes(x="x", y="y"), geom_point(), geom_line() ) # vs... ( ggplot(data) + aes(x="x", y="y") + geom_point() + geom_line() ) # or... ggplot(data) + \ aes(x="x", y="y") + \ geom_point() + \ geom_line()
April 29, 2026 at 2:10 AM
mikedecr.computer
I don't normally do really oop-y solutions to advent of code problems but it helped clean up the main fns a lot here

github.com/mikedecr/aoc...
Screenshot of python code: @dataclass class CircuitNetwork: _circuits: list[Circuit] # idk if this is the best place for this method but oh well. def contains_link(self, a: Box, b: Box) -> bool: """True if a local circuit contains boxes A and B""" return any(a in circ and b in circ for circ in self._circuits) def attach(self, a: Circuit, b: Circuit) -> None: """Consolidates circuits A and B into a single circuit""" assert a != b, "Circuits must be distinct" assert a in self._circuits, f"Circuit {a=} is not in the network" assert b in self._circuits, f"Circuit {b=} is not in the network" self._circuits.remove(a) self._circuits.remove(b) self._circuits.append(a.union(b)) def get_circuit(self, pt: Box) -> Circuit: """Returns the circuit containing provided Box""" for circ in self._circuits: if pt in circ: return circ
January 19, 2026 at 7:57 PM
mikedecr.computer
I suppose this is also less clunky then popping an element only to maybe re-append it
def attach_interval(lst: list[Interval], new: Interval) -> list[Interval]: """Collapse interval `new` to the last element of `lst` if possible, otherwise append.""" if len(lst) == 0: lst.append(new) return lst if (collapsed := maybe_collapse_intervals(lst[-1], new)): lst[-1] = collapsed else: lst.append(new) return lst
January 10, 2026 at 3:24 AM
mikedecr.computer
de-structuring the tuples here creates a more pleasant reading experience
python code: def maybe_collapse_intervals(left: Interval, right: Interval) -> tuple[Interval, ...] | None: """Return collapsed interval if possible, or None""" a, b = left x, y = right if a <= x <= y <= b: # left contains right return (a, b) elif x <= a <= b <= y: # right contains left return (x, y) elif a <= x <= b <= y: # left straddles right lower bound return (a, y) elif x <= a <= y <= b: # left straddles right upper bound return (x, b) else: return
January 10, 2026 at 3:21 AM
mikedecr.computer
did I overly functionalize Day 5.2 or is this just the thing to do
Python code: @app.command() def day_5_2(test: Flag("--test") = False): data_path: Path = Data(5, test=test) intervals_lst: list[Interval] = [] with open(data_path, "r") as f: for line in f: if line == "\n": break interval: Interval = tuple(eval(chr) for chr in line.strip().split("-")) intervals_lst.append(interval) # with the intervals sorted, we can do this w/ reduce # fn: combine RIGHT w/ tail of LEFT or append RIGHT to LEFT intervals_lst.sort() collapsed_intervals: list[Interval] = reduce(attach_interval, intervals_lst, []) result: int = sum(1 + (right - left) for left, right in collapsed_intervals) print("solution:", result) def attach_interval(lst: list[Interval], new: Interval) -> list[Interval]: """Collapse interval `new` to the last element of `lst` if possible, otherwise append.""" if len(lst) == 0: lst.append(new) return lst end = lst.pop(-1) if (collapsed := maybe_collapse_intervals(end, new)): lst.append(collapsed) else: lst.append(end) lst.append(new) return lst def maybe_collapse_intervals(left: Interval, right: Interval) -> tuple[Interval, ...] | None: """Return collapsed interval if possible, or None""" if left[0] <= right[0] <= right[1] <= left[1]: # left contains right return left elif right[0] <= left[0] <= left[1] <= right[1]: # right contains left return right elif left[0] <= right[0] <= left[1] <= right[1]: # left straddles right lower bound return (left[0], right[1]) elif right[0] <= left[0] <= right[1] <= left[1]: # left straddles right upper bound return (right[0], left[1]) else: return terminal input and output: $ time uv run aoc day-5-2 solution: 357907198933892 uv run aoc day-5-2 0.08s user 0.02s system 94% cpu 0.110 total
January 10, 2026 at 3:16 AM
mikedecr.computer
weird idea: map in terms of reduce
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']
September 27, 2025 at 6:59 PM
mikedecr.computer
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
September 21, 2025 at 7:16 PM
mikedecr.computer
will anybody ever want this? idk. a cheaper / better way might be to just define the fns with lambdas
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
September 21, 2025 at 4:18 PM
mikedecr.computer
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
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() ```
September 21, 2025 at 4:01 PM
mikedecr.computer
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
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()
September 14, 2025 at 3:05 PM
mikedecr.computer
good slide from this talk: www.youtube.com/watch?v=EGLo...
slide from a presentation that reads "Syntax don't solve your problems"
September 1, 2025 at 7:45 PM
mikedecr.computer
i'm chewing on this

fly.io/blog/youre-a...
Screenshot of text from the linked blog post. The text reads: but the craft Do you like fine Japanese woodworking? All hand tools and sashimono joinery? Me too. Do it on your own time. † (I’m a piker compared to my woodworking friends) I have a basic wood shop in my basement †. I could get a lot of satisfaction from building a table. And, if that table is a workbench or a grill table, sure, I’ll build it. But if I need, like, a table? For people to sit at? In my office? I buy a fucking table. Professional software developers are in the business of solving practical problems for people with code. We are not, in our day jobs, artisans. Steve Jobs was wrong: we do not need to carve the unseen feet in the sculpture. Nobody cares if the logic board traces are pleasingly routed. If anything we build endures, it won’t be because the codebase was beautiful. Besides, that’s not really what happens. If you’re taking time carefully golfing functions down into graceful, fluent, minimal functional expressions, alarm bells should ring. You’re yak-shaving. The real work has depleted your focus. You’re not building: you’re self-soothing.
June 14, 2025 at 6:11 PM
mikedecr.computer
at a high level it's basically this
screen shot from the blog post. Text reads: I am being silly, but I have this irrational beef with Python. Python has a lot of trivial syntax sugar for operations that could simply be functions. I like functions because you can do things with functions: composing, mapping, reducing, currying. You can’t do much with syntax sugar. In Python, all the sugar is parsed away to C code before any operations are actually executed against your data. So the syntax sugar in Python is convenient, but programmatically it is kind of useless.
May 11, 2025 at 6:07 PM
mikedecr.computer
...which will let me figure out why the checking for legal moves is broken. The existing code lets you just bring a piece out of bounds to the left, then when the piece settles it is somehow chopped between left and right sides of the board
A gif showing a tetronimo piece going out of bounds to the left of the game board, and when the piece is sent to the bottom of the board, some of it appears on both sides of the board.
April 19, 2025 at 7:53 PM
mikedecr.computer
- I had to add a few missing pieces? Originally S and Z were somehow blended into one piece, so had to be separated. We had an L but not a J? O needed to be added entirely.
- I am now running main() using typer, which lets me easily pass CLI args. This is very convenient for activating "debug" mode
A Git diff showing the addition of `import typer; typer.run(main)` a git diff showing the addition of a debug argument to the main() function. The argument is used to pass a 0 fall speed to the TimeUpdate class if debug is True, else we pass a fall speed of 50.
April 19, 2025 at 7:53 PM
mikedecr.computer
The game display looks like this. I have already fixed a few things about it:

- colors were random which was confusing. I didn't expand it to full colors but did add some classics: I=blue, O=gray, T=yellow
- pieces were rotating counter-clockwise-only so that had to get fixed
a computer window showing a tetris-like game. pieces are red, green, blue, yellow, and red. Some pieces have already been played.
April 19, 2025 at 7:53 PM
mikedecr.computer
not my cat, not my balcony
March 29, 2025 at 12:03 AM
mikedecr.computer
if you can remap keys with either firmware or software I put the EQ here on key tap, and ctrl/cmd on key hold, so it’s on the thumb
Picture of a keyboard. The left GUI / Cmd key is circled
March 12, 2025 at 1:57 PM
mikedecr.computer
i let myself get nerd-sniped by this and I looked up the marginal rates and computed the weighted avg tax rate for some income blah blah
a plot of marginal and effective tax rate as income goes from $0 to $1mil. the effective tax rate is always below the marginal tax rate and is much smoother than the marginal rate
January 26, 2025 at 7:47 PM
mikedecr.computer
I want a way to search / interact with my archive of tweet data so I began a little project for parsing & presenting the data. extremely WIP, no designs are finalized, just kinda goofing around for starters

github.com/mikedecr/twe...
screenshot of a terminal command and output: uv run tmd parse --archive ../twitter-archive/twits -o tweets.json && head -20 tweets.json [ { "tweet": { "edit_info": { "initial": { "editTweetIds": [ "1855701514406309953" ], "editableUntil": "2024-11-10T20:58:12.000Z", "editsRemaining": "5", "isEditEligible": true } }, "retweeted": false, "source": "<a href=\"https://mobile.twitter.com\" rel=\"nofollow\">Twitter Web App</a>", "entities": { "hashtags": [], "symbols": [], "user_mentions": [], "urls": []
January 20, 2025 at 7:05 PM
mikedecr.computer
it’s Saturday
photo of apartment living room, v60 coffee making station on the counter in the foreground
January 18, 2025 at 4:46 PM
mikedecr.computer
I saw some people talking about "No syntactically significant whitespace Python" which was enticingly evil...

I am being too strict about it...function defs aren't even allowed, only lambdas, so the type hints are trying to make it interpretable but now it look messy.

Some of my worst filth yet!
""" No-Significant-Whitespace Python. Not even function defs! """ import itertools from pathlib import Path from typing import Any, List, Callable as Function parse_words: Function[str, List[str]] = lambda chars: \ [s for s in chars.split(" ") if s != ""] parse_int_sequence: Function[str, List[int]] = lambda chars: \ [int(word) for word in parse_words(chars)] diff_series: Function[List[int], List[int]] = lambda series: \ [a - b for a, b in itertools.pairwise(series)] all_same_sign: Function[List[int], bool] = lambda seq: \ all(x < 0 for x in seq) or all(x > 0 for x in seq) # haters weep that we find a use for this yet again... juxt: Function[List[Function], Function[Any, List[Any]]] = lambda fns: \ lambda *args, **kws: [fn(*args, **kws) for fn in fns] good_seq_checks: Function[List[int], List[bool]] = lambda seq: \ juxt([all_same_sign, lambda lst: all(1 <= abs(x) <= 3 for x in lst)])(diff_series(seq)) is_safe_sequence: Function[List[int], bool] = lambda seq: \ all(good_seq_checks(seq)) part_one: Function[Path, int] = lambda filepath: \ sum(is_safe_sequence(parse_int_sequence(seq)) for seq in open(filepath).read().splitlines()) if __name__ == "__main__": pt2_data = Path("data/2024/02") test_file = pt2_data / "test.txt" final_file = pt2_data / "final.txt" assert part_one(test_file) == 2 print(f"{part_one(final_file)=}")
December 3, 2024 at 4:48 AM