Friday, June 25, 2021

Limited work-in-progress for developers
Dmitry Kandalov
Dmitry Kandalov
Code Mine

The idea of limited work-in-progress (WIP) is coming from Lean methodologies. At its core, it means that new tasks should only be started when the current piece of work is done and delivered. Finding the right work-in-progress limit can increase overall system (organization) throughput. This idea can be applied on many levels including writing code. In this live coding session, I will write FizzBuzzWoof code kata in Kotlin showcasing software development workflows that can be used for limiting work-in-progress. In particular: change size notifications, auto-revert, TDD, TCR (test && commit || revert).

`Huh?` to `Aha!`: A Refactoring Story
Gopal S Akshintala
Gopal S Akshintala
Salesforce, Senior Software Engineer

"Entropy is the price of a Structure". But sometimes, the price turns too high to pay. Is your codebase turning untestable, unreadable, and unmaintainable? Does your costs to add new features aren't meeting the ROIs. It's time to ask your manager to fund Refactoring!

In this demo-driven talk, using a real-world service, we shall identity some common reasons for a codebase to rot and how to weed them out using principles from Clean Architecture and Functional Programming, along with achieving 95% test coverage and ~50% reduction in Cognitive complexity (https://www.sonarsource.com/docs/CognitiveComplexity.pdf).

Audience & Take-aways

This applies to software developers at all levels. I use Java to demonstrate the code snippets, but this talk is about Software Design and Testing and is agnostic of programming language. The major take-aways for the audience are:

- Pragmatically apply the principles of Clean-Architecture and Functional programming in real-world refactoring. 

- How to completely eliminate Exceptions from your code using ADTs (Algebraic Data Types). 

- How to replace Shared Global mutable state on your Shared Code with Data Transformations. 

- How separating out What-to-do from How-to-do can bring in a lot of flexibility to your code-base.

- How following all of the above organically boost your Testability without falling into any anti-patterns of testing. 

Let's talk about Complexity and how to objectively measure the reduction we brought with our refactoring.

Functional Kotlin with Arrow
Karin-Aleksandra Monoid
Karin-Aleksandra Monoid
Delivery Hero, Senior Software Engineer

What is a monad? Do I need a Ph.D. to write in a functional style? How do I do that in Kotlin? And other questions that you were afraid to ask.

In this talk, we'll walk through Arrow Core, the functional companion to the Kotlin standard library. We'll cover both the concepts that every software engineer may add to their project right now and more advanced structures, starting from the non-empty list, going over Validated, and Either followed by monad comprehension.

Saturday, June 26, 2021

Julien Lengrand-Lambert
Julien Lengrand-Lambert
ING, Software developer

picoCLI is a small library that can be used to create JVM based command line interface applications.

Within 30 minutes, we’ll look at how to setup a project, create a small application and package it for others to use.

picoCLI is nice for several reasons : CLIs are a great way to automate some commands we run every day. And because it supports Java and Kotlin, we can keep using our main language of choice rather than having to dive into bash or node. Finally, pico applications can be turned into native images using GraalVM, which allows for a nice end-user experience.

This talk is a third introduction to the topic, a third live-coding in the IDE, and a third best practices when creating CLI applications, especially in Java or Kotlin.

By the end of this talk, you’ll have a basic knowledge of what picoCLI can do, how to set it up, and should have ideas of use cases to run it with!

Custom IDE inspections for effective testing
Alex Levin
Alex Levin
Senior software engineer

When writing tests from scratch or especially when migrating them from one JVM language to another (or even framework), the modern IDEs (especially IntelliJ IDEA) are very handy, as there are a lot of inspections out of the box. The thing is, sometimes, they are not enough or not suggesting idiomatic replacements.

In this talk, we are going to cover the following:

- Definition of idiomatic pattern of a library/framework/language

- Usage of structural search and replace in IntelliJ IDEA

- Creating inspections using structural search and replace

- Sharing your inspections with everyone

Examples will be demonstrated in Kotlin