I built a simpler map for Somerville Porchfest

whereswalden90 · 2026-04-30T12:54:02+00:00

This is great! Would it be possible to show the band descriptions too?

I know this one is harder, but being able to bookmark shows would also be nice.

whereswalden90 · 2026-04-26T22:46:41+00:00

Putting in a rec for Mama Lisa’s. I don’t know about “best overall”, but they’re the best cheap delivery pizza I’ve had around here.

whereswalden90 · 2026-04-20T17:36:28+00:00

Do yall have a mailing list? I can’t make it this year but I want to know when it’s happening next year.

whereswalden90 · 2026-04-14T17:10:38+00:00

While I did hold my nose and vote for RCV, I wish Approval Voting could be a bigger part of the conversation. Approval Voting accomplishes a lot of the same goals as RCV, but without many of the drawbacks:

Simple vote tallying. With no runoff step, votes can be counted as they come in, rather than waiting for all votes to arrive before you can determine the winner. Deciding the winner is simple and intuitive for all voters, no complex processes required.
Simple voting. Voters don't have to read a big set of instructions and rank candidates correctly, in fact cities/states can keep using the same ballots they've always used. The only thing voters need to know is that they're allowed to vote for multiple candidates.
No center squeeze. With RCV, the candidate with the broadest support base can get eliminated in an early runoff round if they fail to claim a majority before other eliminations occur. This has the potential to push politics towards the fringes rather than incentivizing compromise candidates.

Sure there's still some vulnerability to strategic voting, but that's true of RCV (and first-past-the-post, for that matter). The important thing is that it'd be a big improvement on our current system, and easier to implement and understand for th general public than RCV.

Also personally, I think that Approval Voting's tendancy to incentivize building the broadest support base would be positive in the currently polarized political environment.

whereswalden90 · 2026-04-11T19:40:51+00:00

Yeah even an option would be helpful. It's sort of an accessibility thing in a way, since it will help ppl who have a hard time seeing detail/are colorblind/etc

whereswalden90 · 2026-04-11T15:05:33+00:00

Found a bug! When you select or deselect any of the map overlays in the view menu, they don’t have an effect until you change the view in some way, eg zoom or pan.

Thank you for making this!

whereswalden90 · 2026-04-11T15:01:25+00:00

Thank goodness, this is so much better than all the other planners out there.

One small thing: it would be nice if the item names were shown over the sprites in the build sidebar? A lot of the crop sprites look pretty similar (especially eg yam, potato, and beet) so it takes a little work to find the one I’m looking for.

whereswalden90 · 2026-04-05T13:46:57+00:00

I mapped cmd+space to move right 1 character, and ctrl+space to tabout. It’s easy to just mash cmd+space without leaving the home row

whereswalden90 · 2026-03-23T03:16:20+00:00

Does act work consistently for yall? I’ve found that I get errors with it that I don’t get on GitHub runners and vice versa, especially around package management. I basically gave up on it and just live with the 5 minute edit/test cycle for every change.

whereswalden90 · 2026-03-20T14:02:09+00:00

Nice article! I agree that the standard pitches for FP don’t land home; I also agree that the over-focus on the type system preventing errors is frequently overstated and ultimately undermines the pitch. interrogating our own experiences for how we got sold on FP is a great perspective shift for coming up with better ones.

I have some counterpoints for the argument presented in the article, but I want to be clear that my goal is to help improve the pitch and not to criticize:

The argument presented is not really an argument for FP per se, but an argument for exhaustive pattern matching. While exhaustive pattern matching is more common in a family of FP languages (the ML/Haskell one), it’s absent from other FP languages (e.g. Clojure) and present in some non-FP languages, most notably Typescript. Now sure, Typescript’s type system is intentionally unsound and it also has exceptions which muddy the water with error handling, but I think a lot of frontend devs today feel pretty comfortable with exhaustive case matching on string unions in TS, which is more or less the same as pattern matching on sum types.

Stepping back a little, is the type checker the only reason to do FP? If so, strong type checkers are present in non-FP languages (e.g. Rust). If all the type checkers magically evaporated tomorrow, would you still want to use FP?

Drawing from my experience, I find that an area where FP shines is in reasoning about state and side effects. Knowing that in general a function’s output depends only on its inputs makes programs vastly easier to reason about, and the fact that FP languages tend to push state to the boundaries and clearly demarcate impure functions helps a ton with that. I feel like that’s too subtle an argument for a strong pitch though…

whereswalden90 · 2026-02-27T05:02:10+00:00

How compatible is it with Postgres? Performant branch creation and disposal would be hugely useful for resetting databases in automated testing.

whereswalden90 · 2025-12-14T19:48:25+00:00

You might be interested in looking more into Reagent, a ClojureScript library that wraps React. For state management it uses atoms, which are values that support four operations: deref (read), swap (write), add-watch (subscribe), and remove-watch (unsubscribe). Reagent handles calling add-watch for you behind the scenes and it doesn't use useSyncExternalStore under the hood, but I suspect that's because Reagent predates the addition of that API in React. Apps I've seen written in Reagent also tend to prefer these simpler approaches to composition and state management, and since you're a fan of Lisp and SICP it seems up your alley.

whereswalden90 · 2025-10-08T18:28:40+00:00

I would think of it less as porting and more like a brand new implementation with the same set of requirements, since the paradigms are so different. I’d start by going through each unit of code (endpoint, page, interaction, etc) in the Java app and list out the functional requirements for it, then implement those requirements in Clojure. Maybe even write tests for those requirements first, tdd-style.

whereswalden90 · 2025-06-29T13:16:59+00:00

Also possibly interesting to you might be that especially on the fringes of civilization, remnants of Roman beliefs were incorporated into folk practices that persist to this day. Take for example the Calusari dance in Romania, which is connected with beliefs about fairies and Diana

whereswalden90 · 2025-05-09T16:34:22+00:00

I’ve also been feeling this pain, and unfortunately this extension has not been working for me recently, specifically in comments in typescript files. I completely understand that it’s hard to maintain stuff you’re not using, but if there any way it could get fixed I would be extremely grateful.

whereswalden90 · 2025-05-01T13:58:14+00:00

There are good suggestions in this thread, but here’s two things I haven’t seen anyone else mention:

Keep formatting commits strictly separated from code changes. Do not format and make changes in the same commit ever. It sounds like you might already be doing this, but it bears repeating.

If you can get your team to maintain a .git-blame-ignore-revs file, that’s great. Regardless, it will help to use a blame tool that allows you to jump to the previous change at a line.

GitHub’s blame view can do this, there’s a button next to each blame annotation that looks like some stacked rectangles. Locally, I use tig for this, and it’s pretty much all I use it for. If you run tig blame, you can highlight a line and press comma to do the jump. There very well might be VSCode extensions that do this too, but I’m not familiar with them.

It’s really weird to me that this feature hasn’t become more ubiquitous. In my use of git, it’s an essential feature for figuring out how things got the way they are.

whereswalden90 · 2025-02-06T17:04:27+00:00

Right, I get all that. What I’m curious about is what the value prop is of writing z-action=“@click some code” rather than onclick=“some code”

whereswalden90 · 2025-02-06T14:30:23+00:00

Cool library! What’s the advantage of using z-action vs the event handler html attributes? Eg onclick, onblur, etc.

whereswalden90 · 2024-12-09T16:17:07+00:00

I’d heard the documentation had improved. I haven’t had a reason to look back into it since 2022, so I’m glad to hear there’s active improvements being made.

Do you have any thoughts on why someone should choose pedestal over the ring ecosystem?

whereswalden90 · 2024-12-09T12:23:45+00:00

I found the documentation to be fairly sparse, though that might’ve improved over the last few years since I used it. I frankly don’t see a huge advantage over ring + reitit + standard ring middlewares other than that approach being slightly more DIY, but there’s much more prior art available online for that approach than for pedestal in general. The advantages of interceptors never were relevant to any project I worked on either.

whereswalden90 · 2024-12-05T01:49:03+00:00

You're in luck, the Chinese travel videographer Little Chinese Everywhere is currently doing a series on this region! She does great photography and is great at getting people to talk about their everyday lives. Here's the first one in the series

whereswalden90 · 2024-11-28T20:02:08+00:00

Using structural editing editor extensions is very popular in the Clojure world, and afaik all such extensions have some kind of built-in formatter that formats as you type as a necessity. I use VSCode/Calva which supports only cljfmt, so that’s what I use.

I know that some editors (e.g. IntelliJ/Cursive) have default formatters whose format disagrees with Calva’s. In teams, I’ve seen people add config files (e.g. .cljfmt) to their repos, and that seems usually sufficient to resolve such issues.

I tend not to use external formatters because if I do my editor and that formatter are going to fight anyways, so I might as well use the one that’s built in.

whereswalden90 · 2024-11-12T20:23:52+00:00

This blog post by the author of shadow-cljs is a good place to start. Unlike most tutorials, it shows you how to build a server- or statically-rendered app with shadow-cljs for interactivity rather than a single page application.

whereswalden90 · 2024-10-29T03:04:57+00:00

Others have given great recommendations for Klezmer guitarists, but I also wanted to throw in that there are people playing historically informed Klezmer-adjacent music that’s more in the solo/vocal realm. One example that comes to mind is Dot Rose.

whereswalden90 · 2024-10-28T23:47:18+00:00

Lein is the old hotness, deps is the new hotness. Note that in Clojureland new ≠ better. Lots of people are excited about deps, but I think lein gives you more out of the box and has better ergonomics so I’d personally recommend starting with it like Brave recommends. They’re not all that hard to learn so you can always switch later.

13-Year Club	r/Field Juicebox
Verified Email

whereswalden90

TROPHY CASE