Here is super short list of the conferences I attended which I found really interesting
Preventing errors before they happen
Since Java 6, it is possible to pass custom annotation processors to javac. Since Java 8, it is possible to add annotations to types. The guys behind the Checker Framework used this to create custom pluggable type systems for your Java programs. These type systems enforce properties on your program, and will emit warnings or errors at compile time otherwise.
Here are a few example :
@Immutable MyObject myObjectto make sure that myObject won’t be muted
@NonNull MyObject myObjectto make sure that myObject is never null
Under the hood, the compiler behaves as if
@Immutable MyObject and
MyObject where completely separate types, and it knows and tracks specific ways of converting between the two. The framework provides a simple API to define your own type systems. They did a live demo showing how to quickly define things like
@Encrypted String or
@Untainted String (which forbids user input strings to avoid SQL injections).
The talk was really interesting, the framework seems lightweight and to integrate well with the typical tool stack. I definitely will give it a try the next time I have a bit of slack time.
Keeping Your CI/CD Pipeline as Fast as It Needs to Be
Continuous Delivery and Microservices are what you need to do, aren’t they ? Well, when actually trying to setup a CI / CD pipeline for all your code, things quickly get complicated pretty fast ! The speaker presented how to deal with this complexity by using metrics from your VCS and build servers to draw an annotated graph of your build pipeline.
- He used the build time to set the size of every node : the longer, the larger
- The color for the change rate : the more often it was built the warmer the color
It was then possible to determine other metrics such as :
- the impact time of every node : build time + build time of all the dependencies
- the weighted impact time : impact time * change rate
- the overall average impact time : sum of all the weighted impact times
- the overall max impact time : max of all the impact times
Using this and your SLAs it is possible to define policies for your build times such as “the max build time should not be more than X”. If you want to speed up your build, you can set a target build time and analyzing the graph should help you to understand what architecture changes you need to make to your system in order to meet this build time (this sounds a lot like Toyota’s Improvement Kata …)
I loved this talk ! I found the speaker captivating, he presented novel ideas which is not always the case.
To Be Continued
I promised 5, and that’s only 2 talks ! Stay tuned, I’ll write about the 3 others in the coming weeks. Here they are.