canonical-ci-engineering team mailing list archive

[Thomi Richards <thomi.richards@xxxxxxxxxxxxx>]

Hello y'all,


Here's something to distract you from your work:

I attended codemania (http://www.codemania.co.nz/) on Friday, and had an
absolute blast. The conference video's aren't online yet, but I wanted to
send you a quick report while it's all still fresh in my head.

*Adrian Cockroft*

Adrian gave the first keynote, and spoke about micro-services. I also
managed to quiz him over lunch. Those two sessions combined left me with a
few ideas:


   - A microservice architecture makes your development story super simple,
   but necessarily makes your deployment story more complicated. At one point
   Adrian said "yeah, but doesn't juju do all that for you?", to which I
   laughed... then cried.
   - Adrian spoke about micro-services at netflix being owned by one or two
   developers. If our services are so simple that they can be easily
   understood, why are we so worried by silo-isation? Surely it's OK to 'own'
   a service that you built?
   - It's really really really hard to build micro-services without strong
   coupling between them. netflix use a dozen custom tools, including a
   full-blown service registry to solve this problem.

There's a difference between internal complexity and external complexity. A
microservice architecture allows you to minimise the internal complexity of
a service, but requires significant investment in a deployment tool that
works for your specific situation (the netflix tools may well not work for
us).

*Kelsey Gilmore-Innis*

Kelsey gave a talk about the benefits of immutable data *other than*
concurrency
and thread safety. While those aspects are certainly important, there's
also a dozen other talks out there talking about immutable data and
concurrency.

The main benefit that resonated with me is that an immutable data structure
gets validated during construction, and therefore is guaranteed to always
be valid (since, after construction you can't change it). This nicely
mirrors what we were talking about at Austin about how to ensure message
payloads were always valid.

*Josh Robb*

Josh Robb's talk introduced me to the idea of Connascence - how have I
survived for all these years without knowing about this? Connascence is a
way to measure coupling and cohesion in code. It allows you to reason about
why certain code should be refactored, and what the refactored code should
look like.

In terms of learning new things, this talk was probably the most valuable
for me.

*Andrew Sorenson*


-- 
Thomi Richards
thomi.richards@xxxxxxxxxxxxx