One of the perverse side effects of code that’s “the simplest thing that could possibly work” is that it can appear much easier to create than it actually was. I refer to this as Athena Code because it can appear as if the code sprung full-grown and ready to go from the head of the developer that created it. In my experience as a developer this almost never happens and it can give developers the false impression that they should be able to spit out simple solutions on their first try.
A Specific Example
Recently I had a need to generate a list of all dates between a given start date and an end date in Elixir. This is the code that I actually ended up with:
defp generate_all_valid_dates_in_range(start_date, end_date) when start_date <= end_date do (:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(end_date)) |> Enum.map (&:calendar.gregorian_days_to_date/1)
end
#And here's how it would work.
#iex(4)> generate_all_valid_dates_in_range({2012,1,1},{2012,2,1})
#[{2012, 1, 1}, {2012, 1, 2}, {2012, 1, 3}, {2012, 1, 4}, {2012, 1, 5},
# {2012, 1, 6}, {2012, 1, 7}, {2012, 1, 8}, {2012, 1, 9}, {2012, 1, 10},
# {2012, 1, 11}, {2012, 1, 12}, {2012, 1, 13}, {2012, 1, 14}, {2012, 1, 15},
# {2012, 1, 16}, {2012, 1, 17}, {2012, 1, 18}, {2012, 1, 19}, {2012, 1, 20},
# {2012, 1, 21}, {2012, 1, 22}, {2012, 1, 23}, {2012, 1, 24}, {2012, 1, 25},
# {2012, 1, 26}, {2012, 1, 27}, {2012, 1, 28}, {2012, 1, 29}, {2012, 1, 30},
# {2012, 1, 31}, {2012, 2, 1}]
I have deliberately omitted comments so the simplicity of the code is, hopefully, a bit more apparent. For those that don’t read Elixir, basically I take the start and end date and I convert them to Gregorian dates. I then create a range from the two Gregorian dates and pass the range as the first argument to the Enum.map function which follows. As those of you familiar with functional programming will guess, the map takes each element in the list and performs the specified function (in this case the Erlang stdlib calendar module gregorian days to date function) on it, creating a new list with the result. {yyyy,mm,dd} is how one specifies a date literal in both Erlang and Elixir.
By the way, many thanks to the folks on the Elixir Lang Talk mailing list for helping me to simplify my first pass at this code.
Now some may argue that that code above while simple is not particularly robust. What happens if someone passes a bad date? Well, that’s the Erlang way–fail fast. If someone passes a bad date, the code will crash as soon as it’s executed. And it wouldn’t be hard to add a couple of lines of code to validate good inputs and it wouldn’t detract from the basic simplicity of the code.
Try Number 4
The point I’m trying to make is while that code seems obvious (I hope) it’s far from the first code I came up with to solve my problem. It was actually try number 4. I won’t share the code from tries 1 through 3 mainly because like any developer I want people to think I’m brilliant so I don’t want to keep failed experiments around. But in general terms this is what I tried:
First try:
Add one day to the first date
Is the resulting date equal to the end date?
Yes -> Stop
No -> Add the result to the output list and loop to the top.
There was nothing particularly wrong with this approach–the code was just a lot more complicated than that sounds.
Second try:
Use a comprehension to try to generate the list
Got nowhere with this approach at all. Totally failed idea.
Third try:
Modify the comprehension from try 2.
Again, total failure.
Fourth try:
Actually looked like this:
def generate_all_valid_dates_in_range(start_date, end_date) when start_date <= end_date do
(:calendar.date_to_gregorian_days(start_date) .. :calendar.date_to_gregorian_days(end_date))
|> Enum.to_list
|> Enum.map (&(:calendar.gregorian_days_to_date(&1)))
end
As I say, my fellow developers on the Elixir Talk mailing list helped me to make my code even simpler yet by pointing out that the Enum.to_list was redundant and that I could directly invoke the :calendar.gregorian_days_to_date function without having to wrap it in a lambda.
My point is this: it’s almost never easy to create “the simplest thing that could possibly work”. Simplicity is extremely hard to create. Almost never will your first pass be the best answer. Don’t beat yourself up if you can’t manage “Athena Code”; almost no one can. And don’t look at someone else’s code which is a monument to simplicity and think that that’s the way it looked when they first wrote it. Our job as software engineers can be hard enough without putting unrealistic expectations on ourselves.
Onor.io 