This site uses cookies and by using the site you are consenting to this. We utilize cookies to optimize our brand’s web presence and website experience. To learn more about cookies, click here to read our privacy statement.

Learnings from the Windy City Rails

The intention of this post is to recount my experiences from the recent Windy City Rails conference – an annual conference about Ruby and Rails that happens here in the windy city of Chicago. This was my first time going to this conference. I thought the experience was wonderful and mostly enjoyed it. A tech conference is always a fun event with the plethora of talks and the networking opportunities.

So, talking about Windy City Rails, I am going to share my take-aways in the form of snippets about talks that I found really interesting in no particular order. There were some not-so-interesting talks (could be just me!) that I’m not to going to mention about here.

Interpreting SOLID

This particular talk had a broad context that was not specific to Ruby or any programming language in particular. It was about how software teams need to work towards getting out of the SOLID paranoia. For folks who are new to SOLID, these are object oriented design principles laid down by software gurus for building change-able and maintainable software. For more information about SOLID, go here. The talk emphasized the need for adding business value to the software being built over compliance to SOLID. The point was refactoring shouldn’t be some stop-the-world activity that grinds feature delivery to a halt but should be an organic part of the engineering team’s culture where technical debt is paid down in small chunks alongside building new features.

Communicating Code

This again did not pertain to Ruby. It was a language or platform agnostic talk. The talk centered around why one’s code should be self-documenting and things that help in that cause. By adopting these simple techniques, a programmer can write better looking code that’s more readable to the future readers:

  • Consciously naming variables and methods better
  • Using small private methods that convey intent
  • Avoiding superfluous comments and letting the code do the talking
  • Keeping classes small and SRP compliant

Testing as a mindset

The RED-GREEN-REFACTOR mantra is the essence of Test Driven Development. This talk spoke about why there is more to this simple mantra. It is critical for a TDD practitioner to build a test first mindset that helps understanding and breaking a problem down into small testable chunks. This is something that needs to go hand in hand with outside in development or behavior development as it is more commonly referred to.

Passwords are not enough

This talk stressed on the importance of two factor authentication and how we can use the authy gem to implement two factor authentication in a Rails application. With security breaches becoming more commonplace, using passwords alone does not guarantee the security of an application these days. I concur with the speaker that two factor authentication is something that is essential for user facing applications more than ever.

Ruby and Kubernetes

Kubernetes is an open source orchestration system for Docker containers from Google. It caters to the DevOps style of infrastructure management where teams can build immutable infrastructure that can be provisioned painlessly. It also facilitates deployments of applications across containers in a clustered environment and handles resource scheduling. The speaker demonstrated deploying and running a distributed Rails application in a Kubernetes environment.

Overall, I thought it was an interesting conference that is worth going to if you are a Ruby programmer (or just a programmer!).