SeaJUG: How The Scala Way Gets in Scala’s Way & Oracle JDK vs Open JDK

TALK 1) How The Scala Way Gets in Scala’s Way

As a veteran Java developer, over the course of three college courses and my three most recent jobs, I’ve gone from being apprehensive of Scala to accepting Scala as my all-purpose first-choice programming language.

And yet, at the same time, I’ve become all the more skeptical of a certain opinionated way of doing Scala that has taken hold in the Scala community, something I’ll call “The Scala Way.” Its hallmarks:loc 20/

An all-consuming, almost academic focus on writing purely functional code, to the neglect of Scala’s object-oriented side.
An NIH “not invented here” rejection of anything Java.

Nowhere are the perils of the “The Scala Way” more evident than in the community’s fraught relationship with dependency injection. I’ll go over the various ways that DI is, or isn’t, done in Scala. I’ll cover the demise of the Spring Scala project. And I’ll offer some unobtrusive techniques to introduce Spring into a Scala code base.

DI then becomes the springboard for identifying two tenets of Scala thinking that are assumed to be inextricably linked. I’ll argue that in fact they can be decoupled.

Building on that insight, I’ll expand the discussion with some heterodox perspectives on:

Annotations.
Exception handling.
Configuration.
Database clients.
And build tools.

I’ll show examples of how code written The Scala Way, by bona fide Scala experts, violates the core ethos of favoring essence over ceremony, and how to take that code and make it simpler, more testable, and more maintainable–i.e. make it better–all without straying from writing idiomatic Scala or from compromising on being functional and immutable where you need to be.

This isn’t just a talk about Scala. This is a reflection on software engineering ecosystems, cultures, and values; on dealing with limited knowledge and imperfect information; and on the tension between breadth and depth. If you’re working with Scala, this promises to be the most provocative talk you’ve attended in a while. It’s the talk the Scala consultants don’t want you to hear. And if you’re not working with Scala, this promises to expand your perspective.

SPEAKER: Mitch Gitman

Mitch is a senior software engineer at T-Mobile where he’s the dev lead on T-Mobile for Business’s emerging reactive big-data platform built on Kafka and Cassandra. He has close to 20 years of software engineering experience. Most recently he’s given talks to the local Cassandra community.

TALK 2) Oracle JDK vs Open JDK
Big changes have come with the new Java licensing model and JDK release train for Oracle. The full impact may not yet be felt. We’ll look at the pros and cons and discuss some defensive strategies to help avoid potential build issues.

We’ll look at:

History of Java versioning
New licensing model and Oracle communications on the topic
Risks and rewards of the new licensing model, new support models, and the new release train
Defensive strategies for your build pipeline
Establishing a corporate policy

Speaker bio:

Michael Ashby is the Principal Architect at Logic20/20. With over 20 years of experience in software architecture, design, and implementation. He has architected and implemented real-time streaming platforms, web services, and machine-learning platforms for clients nationally. Currently working across 7+ amazing development teams in Seattle, Bellevue and Bothell.

As a solution architect, Michael is responsible for ensuring that every project that he delivers exceeds the client’s expectations and continues to add value to the client’s business. To do so, he works closely with the client’s business, operations, security, infrastructure, and engineering stakeholders to ensure that the designs are secure, testable, performant, reliable, scalable, cost-effective, continuously deployable and maintainable.​

Michael is a graduate of San Francisco State University and has a degree in Linguistics.