The event was organized basically by three guys (#amazing)
It was a mix of Open Space and Talks.
What a mess! Alfredo Casado
Examples about rewrites of systems that as usually gone bad… is very strange that this kind of things are good idea…
The most important thing is to help the team to evolve, the evolution of the code is a consequence.
There is a paper from Eric Evans (DDD) about how to refactor the system when the evil is still under control. He explain some interesting patterns from this paper. DDD Bubble context and DDD Autonomous Bubble. With some details this patterns are strategies to make a “parallel change” but at the systems level.
Another possibility to make evolutionary architectures are systems optimized for deleting the code (as expressed by Greg Young at The art of destroying software
(great talk by the way)).
talk about the use of scientist at flywire http://engineering.flywire.com/blog/how-we-use-scientist
to make parallel changes for algorithms.
Leaving the monolith, Event Sourcing powered Javier Ferrer
He described how they develop a new version for Lets Go chat as a parallel change using Akka and event sourcing in a AWS infrastructure (using SQS and SNS for messaging).
He gave us some references for event sourcing:
The implementation is a good example of SNS+SQS tipical use… We were talking about the events persistence. They are only storing the messages in S3 but they only use this messages for recovery.
DDD Carlos Buenos Vinos
This was a very introductory talk, so I used my two feets :)
Some of his talks can be viewed at his youtube channel https://www.youtube.com/channel/UCPOAykv_UgFa79_mub4Orbw
Cómo inyectar pasión en un equipo
This was a open discussion about the subject.
Some interesting ideas:
- Book club
- Code review using Mob programming format
Software Economics Carlos Buenos Vinos
This session collapse in a discussion about how to measure economic impact of some of the classical XP practices.
He recommend Martin Fowler @ OOP2014 "Workflows of Refactoring"
(of course this is a great talk)
You can see the complete version of this talk at https://www.youtube.com/watch?v=31QIVxcTOvg
Errores que he cometido. Carlos Ble
As usually, Carlos is a inspiring person who talk with humility and very transparent. The talk was very inspiring.
Lately the effort to be better professional is leading himself to be better person (can you be a good professional without being a good person?)
A workplace is a good place to be better person, we should try to align ourselves as person and as a professional and detect any kind of conflict between this two facets.
One of the most important softskill to develop is empathy.
Is very important the Non Violent Communication (by default we are judging other people all the time, even unconsciously. We should learn how to empathize with other people and always use a Non Violent Communication (no judgement, only facts, not aggressive behaviors).
When you should interact or express your ideas not in your mother language, you can prepare notes or even read part of the ideas…
The best thing to change anything in other people is to change it in ourselves. Be the change that you wish to see in the world.
Is not a good idea to “carry” the responsibility of all the things when this is a shared task, we should share the responsibility and look the problem from lot of points of view.
Is very important the focus/attention on the details. For example in development, there are some small details that change completely the productivity (IDE shortcuts, tools, pomodoros, naming…).
As a result I will give another opportunity to PyCharm and the refactor tool that provides ;)
Task based UI / Event Sourcing Ricardo Borillo
Ricardo explained the architecture that they are using in the fronted and all the frameworks and libraries that inspire this solution. The objective is to create a "task based" UI with an unidirectional flow of the information. They use libraries instead of frameworks, because They don't want to be hijacked by the frameworks (as they prefer to use agile practices and follow YAGNI, SIMPLE design…)
He explained how work react and flux and some other “hipster” frontend stuff like elm, om, etc…
It was interesting that they only have one backend endpoint (using http or even websocket) for process all the commands send by the frontend. These commands can be write commands (as in CQRS) or read commands to query some information. This allow them to implement each command very independent and easy to test and avoid all the overhead related to expose all the entities as rest endpoint (as if all the planet was a CRUD system :) )
The classical rest approach force the client to make tons of requests and to include lot of logic to aggregate/relate and navigation. In my opinion all this rest approach is a bad decision, because any interesting system never is a simple CRUD.
They made this interesting practices:
- They include the commands and functionality of the command as DoD of the their user stories
- They create acceptance tests for each command
The outcome of this session is this interesting document that they and other community members are still improving
Community of Needs vs Community of solutions. Antonio de la Torre
Very interesting talk/discussion about two different kind of person and community and how they map in the Cynefin Framework
For me this was one of the most interesting/inspiring talk of the event. The problem is that it is only the initial point for further investigation and learning (and very difficult to transmit without the conversation).
Madriagil 2016 06 13 Presentación Talk Needs vs Solutions
Interesting discussion about the code for the RPG Kata generated in a previous session. Cesar showed us his tests and the code to obtain feedback (BTW very clean tests).
The discussion derives towards Properties based testing. In this case this approach for the testing improve the readability of the tests or even the design.
Another interesting example was Modesto explaining how in this case a Reactive Approach allow a better evolution of the design.
You can test from the event consuming entry point and maintain lot of the tests even if the game rules change.
For this reactive stuff you can use specific libraries or simple design as objects that consume event in one thread from a queue (is familiar, isn't it?).
References (adapted for python):
- Reactive programming
- Property based testing
Final notes and other references or interesting stuff
As usual in this kind of events the best things are:
- The networking. All the conference is design for generating a good networking environment
- There were lot of great conversations and corridor discussions.
- The format is great and explain/practice how a Complex system can be perfectly managed using few small rules and tons of collaboration. (Is real agility in practice).
- We made a retrospective each day and all the decision/improvement identified in this retrospective were fixed for the next day.
Other random links that can be interesting:
pointed me that property based testing and mutation testing are two completely different beasts... so I remove the references to mutation testing from the Show me the code
session notes, because in fact all the conversation was about property based testing. Thank you Manu
send me lot of typos and improvements for my English :-) Thanks a lot Ruben.