Obligatory 2015 Marijuana update

The minimal evidence we have of marijuana usage harms keeps withering away under more careful study, but the very real harms of police enforcement go on. I’ve really stopped paying attention to this stuff because it never ends; one month of stories look like any other. I just pop in once in awhile to see the latest abuses. Yep, young women cavity searched on the side of the roadkids shot; tons of no-knock drug raids putting everyone in unnecessary danger

America’s criminal justice system is so brutal and resistant to reform that the only way to reduce harm is to lessen people’s contact with it: move regulation strategies away from criminal law. Thankfully, state referendums to get cops out of the pot business are all over and even nation candidates are being forced to take the issue seriously.

To think how much harm could’ve been avoided if the country hadn’t wrapped up marijuana with the war on crack in the 80s. Hard drugs truly were devastating some communities then and now, but the “smell of marijuana” gave the police practically unlimited power and financial resources to forcibly invade and ruin the lives of people, particularly in neighborhoods unlikely to afford decent lawyers. Very few upper class families receive the Cheye Calvo experience, but lots of the little people still do.

Plugin-based Systems (and Events)

Modern application design is solved! OK, well we at least have a set of camps with their own principles, tools, and paradigms leading us toward the light. One might be “build some components, wire them up with references to each other, and let them talk to each other.” We love/hate static typing, but it allows tools to reason about really large programs.

All that is great, but I feel like plugin system design is in the wild west. To be clear, I mean dropping a new directory of code in place, performing some ritual, and the system behaving radically differently. Of course, we’re getting better at this as apps learn from each other, but I feel like our principles and tools aren’t particularly well matched to this goal of plugins being able to cooperate on a deep level to build up a system.

Allowing plugins to provide APIs introduces a big set of challenges. Just a few:

  • How do we conditionally use API’s if they’re available?
  • How can a plugin decorate/filter the API’s output?
  • How can a plugin replace the API with its own?
  • If two plugins want to replace the API, which “wins”?
  • How can a plugin remove part of the behavior/API of another plugin?
  • How much can plugins detect about each other?

Most robust plugin systems solve these with event systems and some mechanism of ordering plugins to solve disputes (all unique).

A big problem is that events are almost always run-time linking based on strings. Hence it’s very difficult for tools and humans to reason about which listeners will be called, in what order, and what data will flow to each listener and be returned to the dispatching party. Ideally IDEs could sense all this stuff, and help wire up new listeners and events. Instead, devs on a plugin-heavy system must do string searching on event names or at best use some reporting tool built into the event system.

Symfony’s typed event objects and Ruby’s symbols probably help here. Drupal has a strong convention both in code and docs that helps, and is popular enough for toolmakers to focus on it. Middleware systems as in Express (node) and Stack (PHP) offer a formal way to compose applications, which is pretty exciting, but I’m not sure they solve any of the above problems of plugins tightly collaborating on processes.

What’s the future look like here, and what’s the way toward it? Standardizing on a single event system seems unlikely, but what are the best and most powerful ones out there? What language features would make this easier? Can someone stop me from diving deep into Event-driven programming literature?

Events and Dependency Injection

The Laravel podcast folks mentioned a backlash about firing events in controllers, and I would guess those arguments were based on the notion that events can be used as a sneaky way of using global dependencies. Depending on the design of the event system, the party firing the event can access resources returned by event listeners, and this pattern can be abused like a service locator.

If you allow events to return resources and to be called within a component, you don’t really know a component’s real dependencies without reading the source code. Not at all does this imply you shouldn’t do it, but just that there are trade-offs anytime you reach out for undeclared dependencies at runtime.

What might give the best of both worlds is a way of injecting a dispatcher limited to a single event. E.g. make a class that triggers a particular event and depend on that. This would be best baked into the language similar to generics, so reflection could determine the event(s) needed without a bunch of boilerplate single-event objects.

Pass all the Breakpoints

When modifying a system without adequate tests, I found it helps to include debugger breakpoints in my manual testing checklist:

For each change I make, I add a breakpoint after the modified line, and won’t remove it until the interpreter has passed through it exercising the logic to my satisfaction. Before committing the changes I can pull up the list of breakpoints to make sure I’ve hit them all.

This is probably most valuable when I’ve made a lot of changes at once, or if temporary delusion is making me think I don’t need to test everything.

Caveat 1: I suppose, if there’s any parallel operations, you should also test everything with the breakpoints gone, lest the code relies on losing a race condition.

Caveat 2: In no way is this a substitute for automated tests!

Freedom by vote

I’m already seeing folks in my Twitter feed assuring themselves that Ireland’s recent marriage equality referendum could never be repealed. The danger of freedom-by-majority is that public opinion is fickle, and a shift in voter turnout can have a huge effect. No doubt large numbers of Californians against Prop 8 assured themselves that it could never pass and didn’t come out to vote.

So, for Irish freedom-lovers, pat yourselves on the back, but consider the repeal efforts a serious threat.

Update: In this case it’s unlikely the demographical and cultural shift to acceptance will swing back, and it looks like this could not be repealed by simple vote. In fact, putting it to a popular vote might’ve been a wise move even if it would’ve been non-binding; it got people talking and gave the public an anonymous way to voice their support.

Comedy Bang Bang podcast primer

For those only familiar with the TV show, the podcast eps are much longer, unscripted, at times not at all SFW, and frequently funnier than the show. I tried to pick densely funny episodes, but my favorites have more Andy Daly characters.