Functional C# Application Composition, Part 2: Delegates

In my previous post on the Stateless Single-Responsibility Object (SSRO) approach to C# application composition I reviewed the concept and its shortcomings. To recap: You end up with a ton of classes splitting up semi-related logic across multiple files. This is necessary to conform to the classname == filename convention. In order to mock, you […]

Functional C# Application Composition, Part 1: Shortcomings of Single-Responsibility Objects

Functional code is easier to test than code with state or side effects. However, most developers spend the majority of their time in traditional, imperative languages. There’s plenty of value in those imperative languages, but these days when I use one, I also try to bring in applicable functional concepts. In this post I will […]

Automation Road Blocks: Altering the Behavior of an ASP.NET Server for Tests

Any realistic application is hard to test. Often much of the complexity is unavoidable, but sometimes things are harder than they need to be.

Automating Artifact Generation on Capybara(-Webkit) Failures with Autopsy

System tests are a crucial piece of testing any application. I’m a big believer in isolated unit tests as well, but if I had to pick just one kind of test to use, it would be system tests. There is no substitute for actually exercising the full code base from top to bottom. That said, […]

“Progressive F# Tutorials” |> Reflections

I recently attended the Progressive F# Tutorials event in DUMBO, New York. It was a really great experience, and I think much of that is due to the way it was both a conference and more than a conference. Specifically, many of the talks featured hands-on tutorials, which provided a great opportunity to learn and […]

Six Ways Developing Software Is Like Being a Parent

Four months ago I became a father. My daughter’s birth changed my life in a million ways. Most of these are good (there’s nothing in this world that compares to your child’s smile), but it has also meant less sleep and especially less spare time. I’ve learned a host of new skills that are pretty […]

Funkify and Pattern-Proc: Messing with Ruby for Fun (but probably not profit)

Partial application is awesome. I love it. Same goes for functions as first-class citizens. I wish these were features in every language. I’m working in Ruby right now, and every time I use map() or reduce(), I find myself wishing I had them. class MyClass def negate(x) -1 * x end def add(x, y) […]

Testing Web Apps Developed via Vagrant Using Capybara

As a software consultancy, we often perform additional or maintenance development on a previous project. It’s great to be able to maintain positive customer relationships and provide good value to them, but I admit I often dread returning to an old project. The main reason for my fear and trembling is trying to get the […]

Functional(ish) C# & MVVM: Single-Responsibility and Code-as-Data

I’ve spent the last year working in C# and WPF. Over a few blog posts, I have alluded to a particular pattern of structuring code, referring to it as “stateless single responsibility” objects or “stateless SRP” objects. For the purposes of this post I will call the pattern “stateless single responsibility principle” (SSRP) objects. I’d […]

Ninject Tips: Some Binding Magic & Kernel Cleanup

I’ve been happily using the Ninject Dependency injection library on my C# project for over a year. In order to keep my project even reasonably organized, I quickly started using Modules to group together my dependencies. For the most part in my project, my Modules correlate to the first layer of namespaces beneath the project […]

Atomic Spin

Atomic Object’s blog on everything we find fascinating.

By: Will Pleasant-Ryan

Author: Will Pleasant-Ryan