Learned Optimism @learnedoptimism - Tumblr Blog

Dependency Injection on the small

I've been, very slowly, going thru Sandi Metz' wonderful Practical Object-Oriented Design In Ruby. In Chapter 3, which deals mainly in managing dependencies, one of the suggested ways to loosen coupling between entities is to inject the dependency.

This got me thinking about my usual playground for programming ideas, my eternally-in-development Halibut library. In it there are two classes that are very much entangled, in a very similar way to the book's examples: Halibut::Core::Resource and Halibut::Core::Link.

You can see this coupling here,

Halibut::Core::Resource

def add_link(relation, href, opts={}) @links.add relation, Link.new(href, opts) end

which method is further called from other places.

def initialize(href=nil, properties={}, links={}, embedded={}) … add_link('self', href) if href end def add_namespace(name, href) add_link 'curie', href, templated: true, name: name end

On top of the several connascence of name sprinkled through the Halibut::Core::Resource class each time I send a message to Halibut::Core::Link, and this includes #new, we also have connascence of position and probably some other types of dependency.

What this essentially means is that any time Halibut::Core::Link changes, especially the initializer method, we are probably breaking Halibut::Core::Resource. This might not be a big deal, since it's such a small library and you can even argue that such breakage is actually desired, since all these pieces are meant to work together.

On the other hand Resource already depends on Link, and I'm not doing the user that much of a favor by shoving "implementation details" further down the road. The user already has to know that a link has a href, and possibly options, and which type of options it supports, so I might as well make it explicit and make the user inject the dependency directly.

Having added Halibut::Builder to the library, I'm actually more confident in making this change. The builder pattern allows a straight-forward (I hope) way to build a resource, making use of the much popular DSL pattern.

You can see the diff after applying this change right on GitHub

#halibut #dependency injection #poodr

•18+ Adults Only

Watch Anya Live on Cam

Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.

✓ Live Streaming✓ Interactive Chat✓ Private Shows✓ HD Quality✓ Free Actions

Free to watch • No registration required • HD streaming

Internal dependencies (aka require/autoload)

In trying to find ways to think about my source code and to communicate intent I'm experiment with yet another aspect: require/autoload. In [halibut][halibut] I'm [autoloading Builder][builder] and also [both the JSON and the XML Adapters][adapters] because that is what you will probably will be using, — especially the JSON variant, popular among rubyists, — and I don't think putting burden of requiring them on the user necessary. I also [autoload Resource][resource] to provide "raw" access to the object, in case the user wants to manually handle it. I will probably abstract Resource into a Halibut::Document class. In the other bits of the source I try to be explicit about dependencies, requiring any code that the file internally depends on. This has a twofold benefit: you can more easily map dependencies, and it might just help isolate tests. Or at least you won't have require dependencies in your test setup. [halibut]: https://github.com/locks/halibut [builder]: https://github.com/locks/halibut/blob/master/lib/halibut.rb#L5 [adapters]: https://github.com/locks/halibut/blob/master/lib/halibut.rb#L11-12 [resource]: https://github.com/locks/halibut/blob/master/lib/halibut.rb#L17

#intent #rubygem

Exposing your library

In developing my [halibut rubygem][halibut] to deal with the [HAL][hal] hypermedia format, I decided to try a little experiment. I am making use of public/protected/private to expose as little interface as possible, while still trying to maintain a certain degree of flexibility in the use of the gem. I have a couple of reasons to try this out. First of all, the less interface there is, the easier it should be to use the gem since I reduce the mental space it occupies in the user's mind. I am also forced to think harder about the design, in order to ensure that the library is actually, you know, useful. I'm going to err on the side of exaggeration, as you can probably see if you check the source code. Talk about sweeping under the rug. [halibut]: https://rubygems.org/gems/halibut [hal]: http://stateless.co/hal_specification.html

#minimalism #interface #api #rubygem #intent

My code's nether regions

A long time ago I believed there was no point in using the public/protected/private keywords on Ruby. I came into this belief after, IIRC, a discussion started on the subject from some of zenspider's source code. You see, in Ruby it's possibly to effortlessly access any of the methods on an object, so why bother hiding anything at all, right? What I've since realized is that it's not so much about limiting other's access to those parts of the code, as it is about communicating intent. Just like semver aims to embue meaning into the version number, so does the use of public/protected/private. By marking regions of my code as private I'm informing the possible users of that code that if they depend on it, they will feel pain in the future as that region of code is likely to change under their feet. My brain has been quite crowded lately. This is one of the things crowding it.

#intent #api #minimalism

Trending Blogs

Last Seen Blogs

Learned Optimism