# Ibid.

During my interview with Gene Kim on for Functional Geekery, Episode 128, Gene talked about how he had a problem he was asking different people for how they would solve it nicely with a functional approach, to see how to improve his Clojure solution to be more idiomatic.

His problem was on “rewriting” Ibid. entries in citation references, to get the authors names instead of the Ibid. value, as Ibid. is a shorthand that stands for “the authors listed in the entry before this”.

As he was describing this problem, I was picturing the general pseudo-code with a pattern match in my head. To be fair, this has come from a number of years of getting used to thinking in a functional style as well as thinking in a pattern matching style.

The following Erlang code is a close representation to the pseudo-code that was in my head.

-module(ibid).

-export([ibid/1]).

ibid(Authors) ->
ibid(Authors, []).

ibid([], UpdatedAuthors) ->
{ok, lists:reverse(UpdatedAuthors)};
ibid(["Ibid." | _], []) ->
{error, "No Previous Author for 'Ibid.' citation"};
ibid(["Ibid." | T], UpdatedAuthors=[H | _]) ->
ibid(T, [H | UpdatedAuthors]);
ibid([H | T], UpdatedAuthors) ->
ibid(T, [H | UpdatedAuthors]).


Running this in the Erlang shell using erl results in the following

> ibid:ibid(["Mike Nygard", "Gene Kim", "Ibid.", "Ibid.", "Nicole Forsgren", "Ibid.", "Jez Humble", "Gene Kim", "Ibid."]).
{ok,["Mike Nygard","Gene Kim","Gene Kim","Gene Kim",
"Nicole Forsgren","Nicole Forsgren","Jez Humble","Gene Kim",
"Gene Kim"]}
> ibid:ibid(["Ibid."]).
{error,"No Previous Author for 'Ibid.' citation"}


Throughout the editing of the podcast, I continued to think about his problem, and how I would approach it in Clojure without built-in pattern matching, and came up with the following using a cond instead of a pure pattern matching solution:

(defn
update_ibids
([authors] (update_ibids authors []))
([[citation_author & rest_authors :as original_authors] [last_author & _ :as new_authors]]
(let [ibid? (fn [author] (= "Ibid." author))]
(cond
(empty? original_authors) (reverse new_authors)
(and (ibid? citation_author) (not last_author))
(throw (Exception. "Found Ibid. with no previous author"))
:else (recur
rest_authors
(cons
(if (ibid? citation_author)
last_author
citation_author)
new_authors))))))



And if we run this in the Clojure REPL we get the following:

user=> (def references ["Gene Kim", "Jez Humble", "Ibid.", "Gene Kim", "Ibid.", "Ibid.", "Nicole Forsgren", "Micheal Nygard", "Ibid."])

user=> (update_ibids [])
()
user=> (update_ibids ["Ibid."])
Execution error at user/update-ibids (REPL:8).
Found Ibid. with no previous author
user=> (update_ibids references)
("Gene Kim" "Jez Humble" "Jez Humble" "Gene Kim" "Gene Kim" "Gene Kim" "Nicole Forsgren" "Micheal Nygard" "Micheal Nygard")


That solution didn’t sit well with me (and if there is a more idiomatic way to write it I would love some of your solutions as well), and because of that, I wanted to see what could be done using the core.match library, which moves towards the psuedo-code I was picturing.

(ns ibid
(:require [clojure.core.match :refer [match]]))

(defn
update_ibids
([authors] (update_ibids authors []))
([orig updated]
(match [orig updated]
[[] new_authors] (reverse new_authors)
[["Ibid." & _] []] (throw (Exception. "Found Ibid. with no previous author"))
[["Ibid." & r] ([last_author & _] :seq) :as new_authors] (recur r (cons last_author new_authors))
[[author & r] new_authors] (recur r (cons author new_authors)) )))


And if you are trying this yourself, don’t forget to add to your deps.edn file:

{:deps
{org.clojure/core.match {:mvn/version "0.3.0"}}


After the first couple of itches were scratched, Gene shared on Twitter Stephen Mcgill’s solution and his solution inspired by Stephen’s.

And then, just for fun (or “just for defun” if you prefer the pun intended version), I did a version in LFE (Lisp Flavored Erlang) due to it being a Lisp with built in pattern matching from being on the Erlang runtime.

(defmodule ibid
(export (ibid 1)))

(defun ibid [authors]
(ibid authors '[]))

(defun ibid
([[] updated]
(tuple 'ok (: lists reverse updated)))
(((cons "Ibid." _) '[])
(tuple 'error "No Previous Author for 'Ibid.' citation"))
([(cons "Ibid." authors) (= (cons h _) updated)]
(ibid authors (cons h updated)))
([(cons h rest) updated]
(ibid rest (cons h updated))))


Which if we call it in LFE’s REPL gives us the following:

lfe> (: ibid ibid '["Mike Nygard" "Gene Kim" "Ibid." "Ibid." "Nicole Forsgren" "Ibid." "Jez Humble" "Gene Kim" "Ibid."])
#(ok
("Mike Nygard"
"Gene Kim"
"Gene Kim"
"Gene Kim"
"Nicole Forsgren"
"Nicole Forsgren"
"Jez Humble"
"Gene Kim"
"Gene Kim"))
lfe> (: ibid ibid '["Ibid."])
#(error "No Previous Author for 'Ibid.' citation")


If you have different solutions shoot them my way as I would love to see them, and if there looks to be interest, and some responses, I can create a catalog of different solutions similar to what Eric Normand does on his weekly challenges with his PurelyFunctional.tv Newsletter.

# Ruby Tuesday – Proc#call

Today’s Ruby Tuesday is Proc#call.

Procs are blocks of code that are bound to local variables, and as such, we need a way to be able to invoke them at a later time. Enter Proc#call.

Proc#call takes a list of arguments which are then used as the arguments to the Proc that call is being invoked on.

Proc.new {|x| x * x }.call 9
# => 81
Kernel.proc{|x| x * x }.call 11
# => 121
lambda {|x| x * x }.call 7
# => 49
->(x){x * x}.call 5
# => 25
->(x){x * x}.call 5
# => 25


If Proc#call is invoked with extra arguments, it will either discard the extra arguments, or raise an error if it was created as a lambda.

Proc.new {|x| x * x }.call 9, 3
# => 81
Kernel.proc{|x| x * x }.call 11, 15
# => 121
lambda {|x| x * x }.call 7, 13
# ArgumentError: wrong number of arguments (2 for 1)
# from (pry):94:in block in __pry__'
->(x){x * x}.call 5, 3
# ArgumentError: wrong number of arguments (2 for 1)
# from (pry):93:in block in __pry__'


Proc#call also has some other syntactic sugar providing alias for calling the method. You can use [], .(), or even the method Proc#yield as variations of Proc#call.

Proc.new {|x| x * x }[9]
=> 81
Proc.new {|x| x * x }.(9)
=> 81
Proc.new {|x| x * x }.yield 9
=> 81


As an extra bonus, there is also the method Method#call that can be used when you have an named method and you have a Method object for it. This call method behaves in the manner of lambda in that it expects the correct number of arguments to be passed to it.

def square(x)
x * x
end

method(:square).call 2
# => 4
method(:square).call 2, 4
# ArgumentError: wrong number of arguments (2 for 1)
# from (pry):78:in square'


–Proctor

# LaTeX in WordPress

Writing up my post Project Euler in Clojure – Problem 15 I wanted to represent the formulation for combinations in a nice manner. As I previously had found the [sourecode] tags, I figured it was worth a shot at doing some searching to see if WordPress.com supported any forumla formatting plug ins out of the box.

I have known of LaTeX for formulas but as I use a wordpress.com site, I knew it only ships with a limited number of plug ins, so I did a search about mathematical formula formatting in WordPress.com. Through the blog post Math for the Masses, I discovered that WordPress.com does indeed support LaTeX.

In my previous post mentioned above, I had the following formula for combinations:

$\frac{n}{\big((n-k)!*k!\big)}$

So to break that down and outline how I display that lets give the WordPress markup I used to get that:

$\frac{n}{\big((n-k)!*k!\big)}&s=3$


So to start with we have $latex which begins our LaTex statement, and if you notice we have a $ that signifies the end of the expression. The example on for the LaTeX in LaTeX is coded:

$LaTeX$


Which results in the following:

$LaTeX$

The next part in the LaTex statement begins the expression, which is the fraction part of the expression where

\frac{numerator}{denominator}


giving:

$\frac{numerator}{denominator}$

The parenthesis are done using big( and big). The last part of the expression is parameters to update the size of the display in WordPress. The WordPress support page for LaTeX discusses the different parameters available for the LaTeX. The parameter s is the parameter to specify the size of the LaTeX, of which I set as 3 which is the numeric representation of LARGE`.

The posts mentioned above contained links to other resources for LaTeX. The two additional ones I used were: a LaTeX wiki on The Student Room and The Not So Short Introduction to LATEX 2ε.

# Welcome

Hello and welcome. I have recently realized that I should start chronicling my journey to becoming a better software developer and honing my skills and my craft. Sometime around the first quarter of 2009, I began to realize that my career growth had started to slow, and that if I was not vigilant, my career would stagnate.

Since that time, I have been reading software development books as well as blogs, and trying to understand, absorb and apply that knowledge to writing better code, making better software, and making the software better. I was also fortunate to have come across a user group in the area that somehow manages to get software development luminaries, such as Martin Fowler, Dave Thomas (PragDave), Kent Beck, and others, in the software development field to come out and speak to them for free, and have since started to attend those. I have also just come back from the Software Craftsmanship North America 2010 conference and CodeRetreat, and as a result have plenty of ideas and half-formed thoughts in my head which need to be captured.

As such, is finally time to stop wondering if I have anything worth saying, and time to just start journaling, even if no-one else will ever come across this blog; for even just trying to record those thoughts will clarify them. With that, here is looking forward to being able to document, and reflect, on my journey of continuous improvement as a software developer.