Interesting Talk: "The Value of Values"

I've just watched this wonderful talk by Rich Hickey:

• The Value of Values

Interesting Talk: "The Curious Clojurist"

I've just watched this talk by Neal Ford introducing Clojure:

• The Curious Clojurist

It's a really great introduction to Clojure.

Interesting Talk: "Functional Programming You Already Know"

Today I watched this interesting talk by Kevlin Henney:

• Functional Programming You Already Know

Interesting Interview: "Stuart Halloway on Clojure and Functional Programming"

Today I watched this great interview with Stuart Halloway:

• Stuart Halloway on Clojure and Functional Programming

It's a great way to get an overview of where Clojure can be helpful for you.

Bizarre factorial in Clojure

I'm reading Brian Marick's Functional Programming for the Object-Oriented Programmer book.

This is my solution for an exercise from the first chapter, Just Enough Clojure in which I had to write a "bizarre version of factorial that uses neither iteration nor recursion":

	(defn bizarre-factorial [n]
	(apply * (range 1 (+ n 1))))

view raw bizarre-factorial-ints.clj hosted with ❤ by GitHub

Tested at the REPL it seems to work fine:

	user=> (bizarre-factorial 1)
	1
	user=> (bizarre-factorial 2)
	2
	user=> (bizarre-factorial 3)
	6
	user=> (bizarre-factorial 4)
	24
	user=> (bizarre-factorial 5)
	120
	user=> (bizarre-factorial 6)
	720
	user=> (bizarre-factorial 7)
	5040
	user=> (bizarre-factorial 10)
	3628800

view raw bizarre-fact-repl-1.sh hosted with ❤ by GitHub

However, there are problems for big enough results because they don't fit into integers:

	user=> (bizarre-factorial 40)
	ArithmeticException integer overflow
	clojure.lang.Numbers.throwIntOverflow (Numbers.java:1388)

view raw bizarre-fact-repl5.sh hosted with ❤ by GitHub

This can be easily solved using arbitrary precision integers.
You just need to append an N after any number in the calculation, since it's "contagious" to the rest of the calculation:

	(defn bizarre-factorial [n]
	(apply * (range 1N (+ n 1))))

view raw bizarre-factorial-bigints.clj hosted with ❤ by GitHub

Now it works:

	user=> (bizarre-factorial 40)
	815915283247897734345611269596115894272000000000N
	user=> (bizarre-factorial 100)
	93326215443944152681699238856266700490715968264381621468592963895
	21759999322991560894146397615651828625369792082722375825118521091
	6864000000000000000000000000N

view raw bizarre-fact-repl2.sh hosted with ❤ by GitHub

That's ok but how does bizarre-factorial works?

Let's first examine range function:

	user=> (doc range)
	-------------------------
	clojure.core/range
	([] [end] [start end] [start end step])
	Returns a lazy seq of nums from start (inclusive) to end
	(exclusive), by step, where start defaults to 0, step to 1,
	and end to infinity.
	nil

view raw bizarre-fact-repl3.sh hosted with ❤ by GitHub

So, for example, to get the first 10 positive arbitrary precision integers we'd write:

	user=> (range 1N 11)
	(1N 2N 3N 4N 5N 6N 7N 8N 9N 10N)

view raw bizarre-fact-repl4.sh hosted with ❤ by GitHub

We might refactor bizarre-factorial using let to create a helper function, positive-ints-until, to make this more explicit:

	(defn bizarre-factorial [n]
	(let [positive-ints-until (fn [n] (range 1N (+ n 1)))]
	(apply * (positive-ints-until n))))

view raw bizarre-factorial-with-helper.clj hosted with ❤ by GitHub

Let's see now how apply works:

	user=> (doc apply)
	-------------------------
	clojure.core/apply
	([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args])
	Applies fn f to the argument list formed by prepending
	intervening arguments to args.
	nil

view raw bizarre-fact-repl5.sh hosted with ❤ by GitHub

So in the case of bizarre-factorial the apply function is applying the * function to a list of numbers returned by the positive-ints-until helper function.

That's how bizarre-factorial works.

Finally we can use partial to give a better name to the partial application of apply and *:

	(defn bizarre-factorial [n]
	(let [positive-ints-until (fn [n] (range 1N (+ n 1)))
	multiply (partial apply *)]
	(multiply (positive-ints-until n))))

view raw bizarre-fact-with-partial.clj hosted with ❤ by GitHub

This version of bizarre-factorial is much more readable.

Interesting Debate: "Kickstart Academy Podcast - with Sandi Metz "

Last night I watched this great conversation with Sandi Metz about object oriented design, writing maintainable software and more:

• Kickstart Academy Podcast - with Sandi Metz

I really recommend it.

Interesting Talk: "Agile Architecture and Design"

I've just seen this great talk by Neal Ford:

• Agile Architecture and Design

Interesting Talk: "Clojure for Java Programmers"

I've just watched these interesting talks by Rich Hickey:

• Clojure for Java Programmers Part 1
• Clojure for Java Programmers Part 2

Interesting Talk: "Dealing with Dynamically-Typed Legacy Code"

I've just watched this interesting talk by Michael Feathers:

• Dealing with Dynamically-Typed Legacy Code

Interesting Talk: "Making Little Classes out of Big Ones"

I've just watched this interesting talk by Avdi Grimm:

• Making Little Classes out of Big Ones

Interesting Talk: "Build a Bigger Brain: How Healthy Living Makes You Smarter"

I've just watched this interesting talk by Joe Kutner:

• Build a Bigger Brain: How Healthy Living Makes You Smarter

Interesting Talk: "Rules of Simple Design"

I've just watched this interesting talk by Corey Haines in which he comments some ideas from his last book:

• Rules of Simple Design

Craft Conference 2014

Last month @pclavijo and I went to the Craft Conference in Budapest.

It was my first international conference and it was a great experience.

This were my favorite talks in no particular order:

• Conway's Law and you: How to organize your organization for optimal development, Michael Feathers
• Polyglot Data, Greg Young
• Responsibly maximizing craftsmanship in software engineering, Theo Schlossnagle
• Acknowledging CAP at the Root - in the Domain Model, Eric Evans
• Find the right abstraction level for your tests, Gerard Meszaros
• Going reactive: event driven, scalable, resilient and responsive systems, Jonas Bonér
• Coaching teams through change, Rachel Davies
• Building on SOLID Foundations, Nat Pryce and Steve Freeman
• Jackstones: the journey to mastery, Dan North

This other one I couldn't go but @pclavijo said it was great, so it's in my talks queue:

• How I learned to stop worrying and love flexible scope, Gojko Adzic

Interesting Talk: "Test-Driven JavaScript Master Class"

I've just watched this great talk by James Shore:

• Test-Driven JavaScript Master Class

This class is a sample of what he teaches in his series of Let’s Code: Test-Driven JavaScript screencasts.

Interesting Talk: "Decoupling from Rails"

Great talk by Jim Weirich where he refactors a Rails application code to decouple it from the framework so that it follow the clean architecture:

• Decoupling from Rails

There's a lot of wisdom in this talk.

Values without practices

"All of this high-minded talk is well and good, but if there isn't some way to reduce it to practice, to reinforce it, to make the values a natural habit, then all we will have is yet another brave leap into the swamp of methodological good intentions."

Kent Beck, Extreme Programming Explained

Talks related to Sandi Metz's Practical Object-Oriented Design in Ruby book

These talks by Sandi Metz explain many of the ideas in her book Practical Object-Oriented Design in Ruby book:

• Less - The Path to Better Design
• Defining Object-Oriented Design
• Rules
• Magic Tricks of Testing

Interesting Talk: "Find the Right Abstraction Level for Your Tests"

Last month I attend this great talk by Gerard Meszaros at the Craft Conference in Budapest:

• Find the Right Abstraction Level for Your Tests

Interesting Talk: "The Architecture of Uncertainty"

I've just watched this great talk by Kevlin Henney:

• The Architecture of Uncertainty

This talk gives great insights in the relationships among uncertainty, design, learning and change.

Lately I've been reading and thinking a lot about this after reading Sandi Metz great book on OO design and several interesting discussions with @remosu.

Some intuitions are growing in my head but they are still quite fuzzy.

Interesting Talk: "AngularJS Fundamentals In 60-ish Minutes"

I've just watched this great talk by Dan Wahlin:

• AngularJS Fundamentals In 60-ish Minutes

Interesting Talk: "Given When Then" considered harmful"

I've just watched this great talk by Steve Freeman:

• "Given When Then" considered harmful

Interesting Talk: "Less - The Path to Better Design"

I've just watched this great talk by Sandi Metz:

• Less - The Path to Better Design

Kata: Revisiting Gilded Rose in Java

Yesterday Jaume Jornet and I were practicing together doing the Gilded Rose kata in C#.

At the end of the session, we left the code in a point where it was ready to substitute several conditionals with polymorphism. Then we discussed how we would do it without modifying the Item class (to avoid the goblin's rage).

We talked about wrapping Item in another object DegradableItem and then create several subtypes for it. Once having this design in place the Conjured items might be implemented using a decorator over DegradableItem.

When I got home I did the whole kata again in Java and coded these ideas we had talked about with some slight variations:

This is the resulting code commited step by step.

You can compare it with another version I did nearly a year ago.

Our lifes would be much easier without the goblins :)