The previous blog post gave us our first aspect to look for in a problem, meaningful structure in our valid input blob. Let’s look at some concrete examples. The important thing about a metric space is that you are able to create some sort of distance function. However, this isn’t the only thing that we are […]
Problem Analysis: Blob Structure
The previous blog was just an introduction to the problem analysis technique that I want to talk about. And to review, the definition of problem that I’m going with is: Aspects of a situation that makes understanding its behavior difficult. This blog entry is going to talk about the first aspect of a situation that […]
Problem Analysis: Introduction
Before we can measure how difficult a code base is for software engineers to work with, we have to also have a method to measure how difficult problems are for people to work with. This gets a little bit difficult because the idea of a “problem” can get very philosophical and we want something a […]
Objective Code Quality Blog Series
I’m proposing a method for tracking how difficult it is for software engineers to work with code. Preexisting methods such as code smells, cyclomatic complexity, best practices, test coverage, etc seem to work okay for a course grained approach for determining how difficult a code base may be to work with, but I don’t feel […]
The Future is Optional
Matt Swanson made a post[1] on his blog concerning the Optional type[2]. I think it’s pretty good; go ahead and read it. The gist is that the Optional type allows a programer to communicate the intent behind a parameter in a function. A function utilizing an optionally typed parameter is telling any consumers of that […]
Recursive Breadth-first Traversal
One of my coworkers [1] brought to my attention an interesting problem. What’s the best way to run a breadth-first traversal on a tree data structure using recursion? He already had an initial algorithm working correctly, but it had some unfortunate characteristics that made it less than ideal. I haven’t dealt directly with the plethora […]
Monadic Complexity Resolutions
Matt Sheehe wrote a great blog post [1] where he brought up a fantastic idea. Instead of making code more complex than it has to be, send a message to an administrator. This solution belongs in a real special class of solutions that are invaluable to not just software engineers but problem solvers in general. […]
Lambda Calculus
So I wrote a lengthy blog post about functional programming [1] and in it I have a segment where I praise lambda calculus as the best thing ever [2], link a couple of books, and leave you to your own devices. One of the nice things about lambda calculus (elaborated upon below) is that it […]
Functional Programming
What is FP? Unfortunately, Functional Programming (FP) isn’t really a single thing. It’s a bunch of different programming constructs that get put together for traditional, convenience, implementational, or mathematical reasons. Some elements of FP, like higher order and anonymous functions, have slowly become ubiquitous, which tends to confuse the dialog. I’ll try to keep this […]
