#midje

In the discussion How to handle refactoring with TDD and mocking/stubbing, Timothy Baldridge writes:

I don't recommend Midje at all. Many of the framework's mocking facilities (such as providing) are abominations. You shouldn't go around mucking with functions and re-deffing them on the fly. It may look cute, but I've lost countless hours to bugs and unexpected behavior related to Midje. IMO, stay clear of that. The pattern I do recommend is to break your system up into components. Each component should be testable by mocking its dependencies and then testing only that component. In a final test, stitch together all your components and run system tests against all components at once. If you do what Ashton suggests and use temporary databases, this will work quite well. This way you get the detailed errors of unit tests when things fail inside a component, as well as contractual tests between components. I highly recommend Stuart Sierra's Component Library for all of this: https://github.com/stuartsierra/component It forces you to define the dependencies of each component, and so mocking or stubbing out a component is almost trivial.

Your mileage, experience and needs may differ, but it is worth listening to Tim's opinion as he is a visible figure in the Clojure world and a Cognitect employee. Personally I like Midje but I absolutely agree that mocking is mostly an anti-pattern. Splitting code in components and testing those as units (instead of individual functions) while stubbing/mocking their dependencies makes good sense. (Though sometimes I really like to test individual functions - even if I discard the tests afterwards.)

Sean Corfield, another Clojure giant :-), agrees:

I agree with Timothy here: we have about 6kloc test code (for a production code base of about 24kloc) and only have 25 with-redefs to stub just 8 functions in our Expectations code. In addition we use Expectations’ side-effects to mock just one function in four tests. Whenever we find ourselves needing to stub or mock in tests, we usually try to refactor the code so it’s easier to test fully without that.

Welcome to another issue of Clojure weekly, my small routine blog contribution to the Clojure sphere! These are just a few links, normally 4/5 urls, pointing at articles, documentation, screencasts, podcasts or anything else that attracts my attention. I add a small comment so you can decide if you want to look at the whole thing or not. That’s it, enjoy!

ohpauleez/clojure-leap You know that where a Java SDK is provided there is also a Clojure library waiting to be built. If you want to impress your friends look no further: the Leap Motion Controller is a 3D motion detector device that attach to your USB port: https://www.leapmotion.com. This tiny library is a first attempt at managing the thing from Clojure. This project it's a work in progress and a fun way to learn some Clojure.

Developing Patches - Clojure Community - Clojure Development Ever wondered how to contribute to Clojure? That is an instructive way to learn the language and help the community around it. Joining the dev-mailing list is certainly the first step and it requires some time for the agreement that you need to sign and send to Rich (cool, really, Rich is receiving requests from worldwide aspiring clojure committers directly at his desk). The next step is really grab any of the bugs and requests in http://dev.clojure.org/jira/browse/CLJ and have a look around to see how bugs are discussed in Jira and sometimes on the mailing list. After that, you're good to go and this is a very well detailed guide on how to contribute to Clojure.

Manning: Big Data Big Data is the new book that Nathan Marz and James Warren are writing to describe an architectural approach to Big Data called Lambda Architecture. It consists of three main layer: a batch layer, a serving layer and a speed layer. The basic principle behind the lambda architecture view of data is that information is immutable (hence the lambda name). Similar to Datomic, changes to data are recorded as logs. The serving layer is constantly updated from data coming from the batch layer and it also contains a first aggregation of data plus indexing that makes querying faster. Since the serving layer is not up to date by definition, the speed layer is there to fill that gap. The speed layer can be truncated every time new views are materialized in the serving layer. This architecture should solve the problem of having query = function(all-data) no matter how big all-data is going to be. The reason behind f(data) is possible is that immutability allow for horizontal scaling.

What's new in midje 1.6 · marick/Midje Wiki In the latest alpha3 of the coming 1.6 Midje release, several changes have been made to make Midje compatible with standard continuos integration requirements to show output of test suites as part of the CI report. There are also a few other improvements in midje customisation for colors, autotest scope and more.

About the Data Set - Common Crawl - Confluence Bookmarking this although not strictly clojure related. Clojure is often used to solve big data problems, a business that requires scripting capabilities, raw performance power and a good set of supporting library (I'm thinking at all the s3, EMR, hadoop wrappers out there, plus Cascalog and Storm). Well, if you happen to have a spare 81TB on your laptop drive you can play around with the common crawl dataset, the raw data you can obtain when you request 6 billions web pages, http headers included. The archive is already split into multiple S3 files based on the date of crawling, so it might be a better idea to use and ec2 instance or EMR for your processing. Just saying...

Welcome to another issue of Clojure weekly, my small routine blog contribution to the Clojure sphere! These are just a few links, normally 4/5 urls, pointing at articles, documentation, screencasts, podcasts or anything else that attracts my attention. I add a small comment so you can decide if you want to look at the whole thing or not. That’s it, enjoy!

pedestal/app-tutorial · GitHub Quick one to share the news that a comprehensive Pedestal tutorial is now available. The tutorial is very welcome, having tried myself to play with Pedestal and found the documentation lacking a true getting started section. Looking forward to try a little more of Pedestal app writing in my copious spare time.

Checkers · marick/Midje Wiki There are several useful checkers in Midje. I have use several of them, but never noticed "anything" or "irrelevant" which are totally useful when the specification of parameters is too noisy or not relevant while writing a fact. Metaconstants have a similar goal, but if they are checked in some "provided" function, they need somehow to come from the fact itself.

Clojure, core.async and the Lisp advantage core.async is a new library available on top of Clojure that was recently announced by Rich Hickey (as well as other core contributors). It takes inspiration from the Go language native support for CSP style concurrency, an old but goodie concurrency pattern. What Go "goroutines" and core.asynch allows is Concurrent Sequential Parallelism, where threads based on a thread pool can be orchestrated to provide a sort of "optimistic" approach to manage time consuming calls (often external services). This post by Leonardo Borges summarises this well: a central function coordinating three external service calls is allowed to return after a custom timeout, with partial or full results. The hope is of course that 90% of cases are returning full results allowing good perfromances while you can always retry again for the remaining 10%.

What is the :: used for in clojure? It is possible for code that you don't usually own to provide or require hash maps whose keys have a special meaning. Take for example the abused {:id "some"} key. It is very likely that if I'm a library provider and I use :id for an hash map that the final user needs to manipulate then there could be some sort of clash with a custom-applicative :id key. The double :: lets you specify a namespace for that key, for example ::myna/id so final users of that hash needs to know that namespace if they really want to override my ":id" key.

Hello weekly user! After a couple of weeks of vacation, Clojure weekly is back! Here you can find a few Clojure related links pointing at articles, documentation, screencasts, podcasts or anything else that attracts my attention. I add a small comment so you can decide if you want to look at the whole thing or not. That’s it, enjoy!

cascalog/midje-cascalog at develop · nathanmarz/cascalog Midje Cascalog used to be a standalone project on GitHub that now has been deprecated and incorporated into the main Cascalog project. This is already by definition a success! Cascalog is fun to use and probably for this reason it's easy to create complicated queries that become pretty soon difficult to maintain. Consider also that Cascalog errors tend to be difficult to troubleshoot. One strategy is to build complexity incrementally and extract functions with a specific small scope. Midje cascalog helps exactly with that, but with the added bonus of covering each specific piece of behaviour with some tests, incrementally confirming assumptions about the result of subqueries.

Riemann - Dashboards Riemann is a monitoring and event processing framework. The main idea is to handle any sort of application event (logging, performances, exception and so on). Riemann is similar to New Relic although is definitely not that feature complete, multi-platform and cross-language like New Relic is. After all Riemann is a Clojure product with a Clojure DSL so it has a very specific narrow focus. The link is pointing at the out-of-the-box dashboard which comes with Reimann that is probably good for a lot of possible installations.

Skills Matter : In The Brain of Uncle Bob (Robert C. Martin) Fascinating retrrospective of Uncle Bob taalking about the pillars of objectt orientation: encapsulation, inheritance and polymorphism. Uncle Bob claims at the end is that OOP is mostly about enabling easy polymorphism than anything else. he recognizes that concepts like encapsulation or inheritance are possbile in the C language and something like polymorphism aleady existed in assembly language as a technique to avoid expensive release of boards containing a sequential program in a series of 32K eproms. But easiness of polymorphism has a tremendous impact: it enables dependency inversion, one of the most popular techniques to dirrect dependencies in a single direction, which, ultimately, enables maintenability of software. he didn't talk about functional programming in this context so the following arre my thouthgs. encapsulation in FP has a simpler meaning, it means manly cohesion of related function that is achieved with namespaces (clojure) and functors (ML and close derivatives like Scala). Ijnheritance in FP is also possible in terms of relations between namespaces (not involving types). Polymorphism is also heavily present ijn Clojure: multimetods and protoclols are the enabling techniques. Polymorphism in FP has the same result, it can be used to invert pendencies and increase maintenability. That is maybe why FP is an equially powerful paradigm for modern programming.

Welcome to another issue of Clojure weekly, my small routine blog contribution to the Clojure sphere! These are just a few links, normally 4/5 urls, pointing at articles, documentation, screencasts, podcasts or anything else that attracts my attention. I add a small comment so you can decide if you want to look at the whole thing or not. That’s it, enjoy!

Pedestal Documentation - Build web apps in Clojure Potentially the biggest news this week, Relevancers released Pedestal, a brand new web application framework in Clojure. I skimmed through the documentation but couldn't try out, will definitely do the next webapp with it. On the surface it remembered me of Compojure or the now gone Noir. It also sounds it is an integrated environment instead, where what used to be the custom made "ring stack" is now a default choice. Can't say more for now, it is well documented and support on github and google groups. Give it a go if you can, I'm looking forward to it.

Separating code from tests: What is the vision? - Midje I was reasoning about later stages of development, when sources are already in their own files but at the same time I need to add more features. Since I'm not in the test file anymore, I thought I had to abandon my beloved top-down style, the midje "provided" keyword and the powerful "unfinished" block. Fear no more! This quick reply by Brian just tells you how to use unfinished in the source file and also gives you some reasons why you might even leave it after check-in.

tpope/vim-fireplace · GitHub Dear Clojure vim users (I'm not sure, but I have the impression there are just few of us), it seems that the glorious VimClojure life came to an end. VimClojure will be living in several different forms that are converging again to give you the best of the interactive Clojure experience in vim. Fireplace is a nREPL that replace the hg-server nailgun system of VimClojure. Along with it, the static part of VimClojure still lives in https://github.com/guns/vim-clojure-static project. Instructions are provided, I still have to migrate myself (my vim-clojure setup works great at the moment, not sure why I should migrate). If you're starting today with vim and Clojure wait no more and follow the instruction listed on the github project page.

ClojureDocs - clojure.core/every-pred every-pred is a powerful filter-chaining tool. Say you have a collection of stuff and you want to alter elements based on a set of filters: number? even? or more complicated ones. (filter even? (filter number? '(1 2 3 :a :b))) holds up to a point if you don't have too many filters. But what if you have a long list of filters? (filter (apply every-pred [number? even?]) '(1 2 3 :a :b)) fixes the problem for an arbitrary long list of predicates.

Not Lisp again... I enjoyed this reading about somebody who was there when MIT started teaching the Computer Science course in 1983. Lisp was resurrecting again in the form of Scheme and that course was taught until the last year. Not to mention that a book was extracted from that same course, the SICP. The examples in the book are some extracts from SICP up to chapter 1.3 where higher order functions are introduced.