Getting your team out of the ditch in 8 not-so-easy steps So you just became a team lead, or maybe you’ve been a team lead for a few years now, but things never really clicked as to how to lead other people. Here’s the bare minimum to having a functional Continue Reading
Writing functional code in Java
So, with the onslaught of java 8, I, like many, was happy to believe java was finally a functionally compliant language. This is only somewhat true. Unfortunately, breaking old habits die hard in a language that makes them easy. Why do we use mutable datatypes by default? Mutability is a Continue Reading
The five egos of developer meetings
We humans want to believe that all we do is make the world around us better. If we get lots of us in a room, something great will happen, right? Not exactly. Our egos are powerful things, and, without proper precautions, it can lead to a complete waste of time. Continue Reading
Logging context with Mapped Diagnostic Contexts
Since upgrading my log acquisition platform to be metadata-aware (it’s effectively syslog messages + log flume + “other stuff”), I’ve really started to take advantage of the message diagnostic context available with major logging frameworks for tracking a specific complex interaction. Below is an example of what I’m talking about: Continue Reading
JADE Setup for Beginners
Introduction Prerequisites This howto is written assuming that you have basic understanding of Java and that you are capable of downloading Maven and get it on your command line. You may also want to choose an IDE (Eclipse or Intellij are both good choices). For more information about what JADE Continue Reading
log4j2 + rsyslog for the client side of centralized logging
Introduction So right now, the absolute coolest setup is the ELK (Elasticsearch, Logstash, Kibana) stack, and as far as I can tell, that community is growing and doing very cool things. However, you may not feel like installing LogStash on all your servers, especially if they are constrained for memory Continue Reading
The science of top-down debugging
I’ve found that the biggest difference between effective debugging and ineffective debugging is the process used to root out a problem. Inexperienced people too often will hit their head against a wall without even knowing how to take the next step for solving a problem. Their problem is not following Continue Reading
The Bellman Equation
Back in college, I learned about a tool called the “Bellman Equation”. It’s very nice because it turns into a local calculation for each node, and you only need to know about your neighbors’ previous values. It’s parallelizable. (Do every node in parallel, sync, repeat, until convergence). The only gotcha Continue Reading
Tour de Heuristics: Joint Equilibrium Search (JESP)
The final stop on this heuristics tour, and the last stop for our overview of Cooperative Decision Making is Joint Equilibrium Search. This technique starts with some pre-set horizon T policies for each agent, and then cycles through each agent so that it may tweak its behaviors to maximize the Continue Reading
Tour de Heuristics: Memory-Bounded Dynamic Programming
Memory bounded dynamic programming is another technique offered in Cooperative Decision Making. This is the first sub-optimal heuristic that is brought up. It takes the same techniques as seen before with an exhaustive backup, but at each stage, only a specific number of trees remain at the end of these Continue Reading