Interesting Talk: "Acercándonos a la programación funcional a través de la arquitectura hexagonal"

I've just watched this wonderful talk by Juan Manuel Serrano and Javier Ferrer

• Acercándonos a la programación funcional a través de la arquitectura hexagonal

Interesting Talk: "TDD, Where Did It All Go Wrong"

I've just watched this wonderful talk by Ian Cooper

• TDD, Where Did It All Go Wrong

Interesting Talk: "Testable Architectures"

I've just watched this great talk by Aslak Hellesøy

• Testable Architectures

Interesting Podcast: "Hexagonal Rails with Matt Wynne and Kevin Rutherford"

I've just listened this great Ruby Rogues podcast with Matt Wynne and Kevin Rutherford:

• Hexagonal Rails with Matt Wynne and Kevin Rutherford

Interesting Talk: "Hexagonal Rails"

I've just watched this wonderful talk by Matt Wynne:

• Hexagonal Rails

Interesting Talk: "DDD applied"

I've just watched this great talk (in Spanish) by Sergi González and Eloi Poch:

• DDD applied

Interesting Talk: "Silex: An implementation detail"

I've just watched this great talk by Dave Marshall:

• Silex: An implementation detail

It's about DDD, BDD, Ports and Adapters and the Entity-Control-Boundary Pattern (EBC).

You can find the source code of the examples in this GitHub repository.

Interesting Talk: "Decoupling from ASP.NET, Hexagonal Architectures in .NET"

I've just watched this great talk by Ian Cooper:

• Decoupling from ASP.NET, Hexagonal Architectures in .NET

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.

Some resources about Object-Oriented Design, Testability and Legacy Code

These are some resources about Object Oriented Design, testability and legacy code that I collected for the developers at Tecnatom.

I hope that you'll find them useful.

OOP

• Embedded Object Oriented Design
• DIP in the wild
• Google The Clean Code talks

Testing and Testability

• Writing testable code
• Design for Testability Talk by Miško Hevery
• The Magic Tricks of Testing Talk by Sandi Metz
• Integration tests are scams Talk by J. B. Rainsberger (blog)

Ports and Adapters

• Ports and Adapters (hexagonal architecture)

Legacy Code

• An Agile Approach to a Legacy System
• Strangler Application Pattern
• Seventeen Secrets of the Great Legacy Makeover Masters Talk by Brian Foote

Birthday greetings refactoring kata at Barcelona Software Craftsmanship: step by step commits and screencasts

Last Monday I hosted an event for Barcelona Software Craftsmanship community.

We practiced refactoring and learned about ports and adapters using Matteo Vaccari's Birthday Greetings kata in refactoring mode. This is the initial code in Java that we tried to refactor.

I prepared several slides to introduce what we were going to do. I thought that we could just start refactoring for two hours right after this explanation, but, thanks to the suggestions of some attendees, we changed the plan and did two iterations (extracting the employees repository in the first one and extracting the greetings sender in the second one) with a retrospective in the middle.

This was a really good idea because it gave us the opportunity to debate about different approaches to this refactoring and about ports and adapters. Some very interesting points were raised during those conversations and we could exchange personal experiences and views about this architecture and refactoring. This kind of conversations are a very important part of practicing together and they enrich the kata experience.

I think I have a lot to improve as an event host. Next time I'll make explicit that attendees need to bring their laptop and I'll try to help more the beginners.

I had published a possible solution to the kata, but it was just the final solution not the intermediate steps. Some attendees said that they would like to see how this refactoring could be done in small steps. For that reason, I redid the kata again at home committing after every refactoring step and recording the process:

• Step by step kata commits
• Screencasts of most of the process: Extracting the employees repository and Extracting the greetings sender

Take this recordings with a grain of salt because I'm still working hard to improve my refactoring skills.

Well I hope this might be useful to someone.

Just to finish, I'd like to thank all the attendees for coming, I had a great time. I'll try to do it better the next time.

I'd also like to thank netmind for their support to our community giving us a place and the means to hold Barcelona Software Craftsmanship events. Having a regular place for our events makes everything much easier.

So far the events have had much more attendees than we had expected. In fact, this last Monday we nearly run out of space. If this trend continues, we'll probably need to ask for a bigger room to hold future events.

-----------------------------------------------------------------------------

PS: Christian Soronellas shared a version of the initial code in PHP.
Thank you very much Christian!

Interesting Talk: "The Framework as an implementation detail"

I've just watched this interesting talk by Konstantin Kudryashov and Marcello Duarte:

• The Framework as an implementation detail

They show how the framework (in this case Symfony) can become an implementation detail by using the hexagonal architecture.

Check also the example code they show at the end of the talk.

Interesting talk: "TDD, where did it all go wrong"

I've recently watched this interesting talk by Ian Cooper:

• TDD, where did it all go wrong

He talks about ways of avoiding common problems that arise when TDD is not practised well.

Interesting Talk: "Mi dominio es mío y no lo comparto..."

I've recently warched this gret talk by Javier Acero about DDD and architecture patterns:

• Mi dominio es mío y no lo comparto...

Kata: "Birthday Greetings"

@CoGaNic and I have done the Birthday Greetings kata.
This kata is a simple refactoring exercise by Matteo Vaccari that is meant to teach something about dependency inversion and dependency injection. You can download the kata initial code from here.

We refactored it to decouple the domain objects from the file system and email sending code using the ports and adapters architecture as the exercise suggested. You can see the refactoring result on GitHub.

We think there's still room for improvement in the adapters code, but we are satisfied with how we manage to eliminate the initial coupling between domain objects and the infrastructure classes used to read files and send emails. Now the domain objects don't know anything about them.

All in all, it's been a great exercise. We've thought about dependency inversion and dependency injection (this great article by Brett L. Suchert helped us a lot: DIP in the wild) and clarified many doubts we had about the ports and adapters architecture, also known as, hexagonal architecture.

PS: Some time ago I posted some useful links about the ports and adapters architecture.

----------------------------

Update:
I revisited the kata some time after this post, recorded a screencast to document the refactoring process and wrote a new post about it.
Check it here.

Interesting Talk: "Best practices for JavaScript RIAs"

I've just watched this interesting talk (in Spanish) by Carlos Blé:

• Best practices for JavaScript RIAs

The slides can be donwloaded here.

Interesting Interview: "Matt Wynne on BDD, Cucumber, Hexagonal Architecture"

I've just watched this interesting interview with Matt Wynne, the author of The Cucumber Book: Behaviour-Driven Development for Testers and Developers:

• Matt Wynne on BDD, Cucumber, Hexagonal Architecture

Resources for Growing Object-Oriented Software Guided by Tests (GOOS)

I've been reading Growing Object-Oriented Software Guided by Tests during August. It's a great book.

I've also started to read some of the articles mentioned in the book and to watch talks in which the authors talked about some of the topics treated in the book. These links are included in several posts in this blog.

When I found out that there was a reading club with people interested in the book, the path11 book club, I thought that I could help by collecting in a single post all the posts containing related resources that I've posted so far.

So here they go:

• Interesting Talk: "Better is Better" 
• Interesting Talk: "Fractal TDD: Using tests to drive system design"
• Ports and Adapters
• Interesting Talk: "Sustainable Test-Driven Development" 
• Interesting Talk: "Listening to test smells" 
• Interesting Talk: "Test-Driven Development of Asynchronous Systems"

I hope they will be useful.

Ports and Adapters

In Growing Object-Oriented Software, Guided By Tests its authors explain how they grow systems a slice of functionality at a time. As the code scales up, they need to structure the functionality so they can continue to understand and maintain it. They use two principal heuristics to guide this structuring:

1. Separation of concerns.
2. Higher level of abstraction.

They state that, when applied consistently, these two forces push the structure to something similar to Cockburn's "ports and adapters" architecture.

These are the links I'm reading to find out what this "ports and adapters" (or hexagonal) architecture is about:

• Original description by Alistair Cockburn
• Ports and Adapters architeture (C2 wiki)
• Hexagonal Architecture (C2 Wiki)
• Ports and Adapters in Garfixia Software Architectures Dossier
• A kata using it by Matteo Vaccari