Long Talks (45 minutes)
I started work on Fury on my flight home from NE Scala 2018, so this year’s symposium marks an important anniversary for Fury, as it approaches a first release.
Fury is a radical new build tool for developing software written in Scala and other JVM languages. It starts with a completely blank canvas and not only takes on the challenges of developing maintainable and composable build definitions, but has bold aspirations to shake up the way we publish and distribute software, too: Fury aims to make binary compatibility issues a thing of the past.
This talk will be a rapid, but practical demonstration of using Fury. You will learn how easy it is to create builds for existing Scala projects and for new ones. You will discover how fast, intuitive and responsive Fury’s user interface is, and will get to see Fury’s out-of-the-box support for common (but traditionally difficult) build tasks like code generation, benchmarking and publishing.
Have you solved a Rubik’s Cube Yet?
In five minutes, I’ll teach everything you need to know to solve it. Really! Then, with the easy stuff out of the way, we’ll dive into the math behind the solution, teach it to a computer, and demonstrate the result with a live solve on a Bluetooth Rubik’s Cube.
The Rubik’s Cube is a famous puzzle that’s notorious for being difficult to solve. In this talk, we’ll show how math can be used to simplify the problem to the point that a human can solve it intuitively or write a clear and concise program do so.
We’ll begin by covering some basic Group Theory concepts, and demonstrate how these can be used to model a Rubik’s Cube in a simple way that lends itself well to analysis. Examples will be demonstrated using a Bluetooth enabled Rubik’s Cube that allows for automatic analysis on the big screen while preserving speed and flexibility. Next, we’ll code up a solution that directly takes advantage of this mathematical structure. For this we’ll leverage an existing scala library for computational group theory. Finally, we’ll test this program with a live solve on our Bluetooth Rubik’s Cube, so we can analyze the produced solution in a step-by-step fashion.
Notebooks are interactive environments which combine code, markdown, plots and interactive forms. This talk will highlight unique development workflow benefits that notebooks provide, by demonstrating building and training machine learning models for image classification using Apache Zeppelin.
In this talk, we discuss how to use Domain knowledge around your product to help improve your Software Quality. We use Domain Driven Testing tools to ensure we validate what your customers work with, rather than what you think they might use.
“I tested it how you told me to,” “Requirements say it’s expected,” “I assumed it’s fine” – these are the common phrases you hear when customer cases come up. Unfortunately, it is nothing unusual in our industry to be detached from customers’ actual needs. As a result, teams regularly fail when they prioritize requirements over actual behaviour that the customers expect.
This problem of misaligned teams’ focus is where Domain Driven Testing (DDT) comes into play. DDT helps developers to put themselves into the customers’ shoes and see the product for what it is. This prioritization of the actual behaviour over the mere following of the requirements is what defines Domain Driven Testing.
In this talk, we discuss how knowledge of your company’s domain (aka, the focus of your business) can improve your testing practices. We talk about Domain Driven Design techniques, Exploratory Testing, and other methods which emphasize software quality through customers’ success. We touch bases on tools you can integrate into your system using Domain Driven Test Pyramid, and what common mistakes you should avoid when implementing Domain Driven Testing.
Are you a bit terrified when merging to master?
Do you loathe having to read hundreds of LOC to understand that PR you got tagged in?
Do you polish and re-polish before asking for a review?
Then you should come to my talk. We’ll talk about how your team can be awesome at reviewing code.
There is general consensus on the fact that code reviews are an important step for a successful development workflow. Most organizations undergo code reviews of some form.
However, it’s all too common to see reviewers that barely scratch the surface of the work being put forth, or that offer feedback that is unclear or hard to act upon. This robs the team from the opportunity to speed up learning, share knowledge and context, and from generally raising the quality bar on the software being built.
In this talk, I will share my story of encountering a new code review process when joining Shopify, and the surprising learnings I found - even as an experienced developer. I will discuss the tremendous gains individuals and teams can reap from a thoughtful, well structured review process. I will also share some practical techniques we use to help both the reviewers and the reviewees do a fantastic job at crafting solid deliverables.
Nulls. Exceptions. We’ve all been there. But what’s the alternative? Lucky us, Scala gives us three solutions out of the box. Learn how to be more functional about handling your errors. There might even be monads!
Nulls and exceptions are common tools for encoding error handling through
Java code, but they can be challenging to manage. Fortunately, Scala’s
standard library offers more functional solutions to encoding error
scenarios. Learn about how to use
As long as there are Scala developers who write new code that returns
or throws exceptions, there will be a need for a talk like this. This talk
is foundational for more advanced functional solutions like
Implicits. Dark magic or powerful tool? Learn about Scala’s most unique and powerful feature, the different kinds of implicits, and where they are best to use. You too can be a functional implicit rockstar wizard.
Implicits in Scala are a uniquely powerful tool that not everyone understands. We will outline the difference between implicit classes and implicit parameters. We will cover where implicits are appropriate to use and how library authors leverage them.
The talk is on “Kafka meets FP”, and the ultimate intention of proving the fact that “Nothing actually stops us from striving to write a good piece of software”, and how Functional Programming in Scala can make us achieve it.
Having worked for various clients as a software consultant, it has always been my responsibility to write and make write good software - program that is type-driven, purely functional and maintainable. With this talk, we intend to prove that, regardless of the complexities and impurities that we have to deal when implementing a use-case, the software that we expose to clients can still be made reasonable, testable, deterministic and typesafe. This is done by taking a Kafka streaming application as the use case.
As Kafka becomes a powerful stack for various companies to solve their business use cases, I believe it is important to talk about how Scala and FP can make us write good software that works with Kafka. Hence I am titling my talk to be “Kafka meets Functional Programming”.
Starting from listing down some of the runtime complexities and consequent challenges that we faced when playing with Kafka, I will describe a part of the use case we implemented for an insurance company, where we wanted to abstract out a Kafka streams application that can work for multiple mobility datasets.
After listing down the challenges and then describing a streaming use-case,
we will start with an initial version of the solution written in Scala with
a few type class constraints. Then, we will list down a bunch of issues
with the code, motivating us to further improve. Then we go step by step
towards a final code base listing down the issues motivating us to improve
the code at every stage to finally reach somewhere we see
type class constraints playing out nicely.
Next, we will focus on writing test cases for a Kafka application that
involves playing around with an unsafe data type such as Avro’s
GenericRecord. This part of the talk intends to prove that, “If bad things
are done for reasons, make sure we do good things in the test package.” We
will see some nice examples that gets us away from mutability horribleness
by making use of any
F that can form
reaching out to
scalacheck.Gen as an instance.
We will also touch base through an upcoming plugin sbt-kafka-compose that abstracts out the vagueness and fragility of docker integration tests with Kafka. This is also a place where John’s effect rotation code using ZIO being applied !
And hopefully, I will have more things to show, such as a pure tagless final code base streamlining a kafka application. Finally we are here to prove, how all these make our code extremely robust and safe!
Haskell, the infamous! Improve your functional programming in Scala by learning a tiny bit of Haskell and revealing the true essence behind type classes and data classes.
Haskell is often brought up when learning functional programming in Scala, but the relationship between the two can be unclear. Haskell’s syntax can be foreign and unapproachable to those with traditional OOP backgrounds. We will compare and contrast how concepts are encoded between Haskell and Scala.
In this talk, we discuss how to manage your day and avoid the daily stressors of any engineering team. The main takeaways of this presentation are not only how to prevent stress from being accumulated at work, but also how to organize the work itself in a productive way.
When was the last time you took a day off? How many times this week have you worked overtime? These questions are related to one thing we all experience on a daily basis - stress. Employees who are trapped by their routine to “deliver business value at all cost”, often forget to take care of themselves. Unfortunately, this work-related stress affects our loved ones too, because work-life balance that we all hear about, usually means work-life stress.
What if I were to say that it does not have to be this way? In this talk, we discuss ways how to relax and avoid “Stress Driven Development.” We deep dive into common stressors, and draft a comprehensive guide to removing stress at work and in our personal lives.
- Understanding of why few qualified individuals of Diversity work in IT
- Strategies that technology companies can use to recruit more qualified people of diversity in the IT world
- Novel recruitment policies that will enable technology companies to employ more qualified Minorities
This presentation will discuss how to cope with conversing with those who are from diverse backgrounds with ease and accomplish your daily connections with co-workers, who come from different backgrounds, with a common goal of comprehension.
Necessities that makes you distinct, skills that make you stand out. The diversities that make us rare and unique if it’s your ethnic background, race, ethnic customs, religious beliefs, sex, sexuality, or form of individuality may also be a cause of contention.
Discover how to bring out that, which is already within you and communicate, work with individuals who are diverse as well as, striking-up great conversation between one another.
Also, this presentation will contribute to you your attendees with fostering a positive change and cultivate a more inviting place of work.
This presentation will discuss the impacts of diversity collectively using identifying what variety can be combined with how it affects a business.
The presentation will assist with explaining what it signifies being an inclusive place of work, offer comprehensive measures to assess best what degree one’s place of work fosters inclusion a and diversity.
The workshop, through means of role-playing scenarios, present ways you can take to impact positive philosophies at your place of work.
Individuals will take with them an increased perception of the implications of a tolerant, inclusive and diverse place of work.
Individuals will take with them, along with personal skills, which one will utilize to develop into promoters of social change, that will build a more diverse workplace.
The Reader monad sounds rather intellectual, but we can derive it from the very concrete problem of passing dependencies to some computation. We’ll deconstruct a number of FP concepts this way, to demystify them so you can feel more confident using them and teaching them to others.
Y-combinator? Reader monad? Catamorphisms? Functional programming concepts can seem intimidating, but in this talk we’ll see that we can view them as solutions to refactoring problems. For example, the Reader monad sounds rather intellectual, but we can derive it from the very concrete problem of passing dependencies to some computation (dependency injection). We’ll deconstruct a number of FP concepts this way, to demystify them so you can feel more confident using them and teaching them to others.
Why does your datastore exist? So you can query it, right?
Wrong! It’s so you get confused by strange annotations that cause opaque behaviors! —Sincerely Hibernate.
Wrong! It’s so you can go mad reading Query Shapes and Mapping Projections! —Sincerely Slick.
You Bet! —Sincerely Quill.
When in the course of software development it becomes necessary to dissolve the pointless limitations of misguided query generation frameworks, and assume the separate and equal station to which the Laws of Mathematics and Principles of Good Programming inspire them, a decent respect to the notions of sanity require that they should declare the principles that impel them to architect Quill.
We hold these truths to be self-evident. That all Queries should be typesafe and composeable, and that they should be endowed by their framework with Functional and Monadic Properties.
- That to allow these capabilities in production environments, requires the consent of Ops and DBAs - who have the unalienable Right, to see the freaking query that will be executed in their environment before getting a 2am phone call!
- That it is within the power of developers to generate queries during compile-time, such that the requirements of the previous point can easily be accommodated. This is furthermore facilitated by the use of Typeclasses to allow abstractions over query compositions during compile-time.
- Whenever any form of database becomes conducive to these ends, it is within the capability of the developers to easily extend the powers of Quill onto it, in order to ensure their sanity and happiness.
- Nor have we been wanting in attentions to our asynchronous and streaming- inspired colleagues. We have appealed to the wonderful capabilities of Monix, and we have faithfully conjured them by the integrations of our JDBC and Cassandra modules.
We therefore, the developers, and users of the Quill Language Integrated Framework, humbly extend our welcome to all newcomers who would like to participate in our Gitter channel, our Issues lists, and our sacred Pull Requests!
Medium Talks (30 minutes)
Java’s (N)IO interfaces are insoluble in idiomatic Scala, so I wrote an alternative in portable Scala.
It reads local files, HTTP URLs, and cloud-store objects, bakes in block-LRU-caching, captures effects with the tagless final pattern, and more.
I’ll demo it and discuss designs and alternatives!
Java NIO is a standard way to read and write remote files using familiar local-IO interfaces, but it leaves a lot of type-safety and ergonomics on the table: - various URI schemes are supported via brittle SPI classloader tricks - the API surface is large, and not applicable to many file stores; UnsupportedOperationExceptions ensue - excessive mutability is assumed, e.g. channels typically have both read and write capabilities, but only use one - etc.
After years of frustration, I made an attempt at a pure, portable, Scala NIO replacement. I use it in server- and web-apps, and it lets my portable libraries’ tests assert against “expected” values serialized to local files, removing an awkward asymmetry between JVM- and JS-based tests. It solves many points I had, that also seem close to but not covered by http4s or fs2.
I’ll show a range of prior art I studied and drew inspiration from
(buffering, caching, ahead-looking Java InputStreams,
request Node libraries, etc.), and discuss the pros and cons of bringing heavy Scala abstractions (cats-effect!) to bear on the classic task of reading and writing files.
In this talk I explain what techniques I have found most effective for teaching Scala. I hope it will be useful for leaders of all sorts and anyone who wants to consider their own learning journey.
We all teach more than we think and doing it better results in more learning and more fun!
In this talk I explain what techniques, strategies, and models have proven most effective for teaching Scala. I hope this talk will be useful for senior developers who find themselves mentoring juniors, people who want to get involved in community events such as ScalaBridge, and anyone who wants to consider their own learning journey.
This talk is focused on what I have found to be most effective for teaching Scala. It includes recommendations in three categories. I will explore teaching techniques, such as peer learning. I will also describe suggestions specific to teaching programming, such as the differences between experts and novices, notional machines, and more. Finally I will share programming strategies and a suggested curriculum specifically targeted to teaching Scala. Improved teaching results in a better experience for all parties. That means more learning and more fun!
Many programmers who need database support either use an Object Relational Mapper or give up and use SQL strings and manually parse result sets. Both approaches have significant drawbacks for the developer and the business, including poor reuse (monolithic, non-reusable query fragments), poor composability, poor type safety, and poor testability.
In this talk, the author will present Slick, a Functional Relation Mapping library for Scala. Slick allows you to express queries in an embedded, type-checked, collections-like DSL, which is compiled at runtime into SQL and executed on the underlying database.
The author will then show you techniques enabling you to implement database queries in a generic, reusable, self-contained, modular fashion. This enables application-level functionality to be implemented once, efficiently and correctly, using functional programming techniques to provide reuse, compositionality, type safety, and testability, all without sacrificing high performance. Time permitting, we’ll briefly venture into the Category Theory basis underlying the approach.
Discover how functional programming takes the real world challenges of database access, helping programmers to be more productive, and making business applications smaller, faster, easier to maintain, and less buggy.
Scala’s tooling experience has improved and now there’s an increasing number of tools to choose from. We can feel the hype but might not be fully aware of tools that exists, alternatives, trade offs or even recent efforts such as LSP initiative. This talk’s goal is to create such tooling awareness.
We are going to explore and compare some build tools with special focus on LSP/BSP implementations, IDEs and text editor’s support. For the sake of empower audience’s judgement about the tools that could suit better for their particular needs this talk aims to get attendees familiar with terms like SemanticDB, Metals, Bloop, SBT, Pants, Bazel, Ensime, IntelliJ IDE, Scala IDE, Dotty IDE and other honorific mentions.
You may have heard of Free Monads, but there are other “Free” structures. Another useful type are Free Boolean Algebras, which give us Boolean logic for a set of primitives “for free”. We’ll derive the Free Boolean Algebra and show how you can use it in your programs.
FS3 is the code name for the next major version of FS2. In this talk, we’ll look at how pull based streaming may be implemented in FS3 and how various API decisions guide the design process. As a result, I hope a few will be inspired to help make FS3 reality.
The Functional Streams for Scala (FS2) library provides core infrastructure for many critical components of the open source Scala ecosystem, including libraries like http4s and doobie. In this talk, we’ll look at a possible future direction for FS2 (code named FS3), focused on replacing the internal pseudo-Free interpreter with a more direct encoding. We’ll also look at how various API decisions constrain the solution space. Attendees will leave with a better understanding of the FS2 API and hopefully, a few will be inspired to help work on FS3.
I’m going to show a way to write programs that are easy to understand, test, refactor and change, using only pure functions and immutable data types.
In the beginning, there were only functions and data. Maybe it’s enough? We’ll look at the advantages of pure functions and immutable data. Then, we’ll go for an adventure of programming with only that, and see whether we’re missing anything. Hopefully, we’ll see that it’s entirely possible and reasonable to write programs that are: - just as useful as the ones written with mutability, runtime reflection, dependency injection frameworks, side effects and exceptions - much easier to test, parallelize, refactor and change than otherwise by only using pure functions and immutable data types.
As a functional programming teacher and mentor, I’ve experimented in many ways to visualize types and their signatures to help my students and peers learn new concepts like functors or monads. In this talk I’ll share the techniques that have helped the most, so you try them out yourselves.
Good examples are essential for effective teaching, but what techniques can we use to bridge between concrete examples and the (perhaps hidden) abstractions? And how can we teach the manipulation of abstractions at higher levels? Often these ideas can be expressed in the language of types.
As a functional programming teacher and mentor, I’ve experimented in many ways to visualize types and their signatures to help my students and peers learn new concepts like functors or monads. In this talk I’ll share the techniques that have helped the most, so you try them out yourselves.
- Learn how to read type signatures
- Learn how to visualize the “flow” of types in expressions and evaluations
- See how type visualization can help to compare and contrast various abstractions
This talk will introduce a new free structure, the free boolean algebra, and show you how this is super useful in production, too. What’s not to love?
Free Structures are pretty awesome, but besides Free Monads and maybe Free Applicatives, other Free structures are mostly unknown. This talk will introduce an overlooked Free structure, the Free Boolean Algebra and use it to solve a real world day-to-day problem in a super elegant and awesome way.
The FreeBooleanAlgebra is the perfect framework for a predicate-powered DSL and we will see some of the following key aspects: - the DSL we get - ways to enrich your DSL with more operations - flexible interpretation - partial evaluation - serialization - …
If you don’t think you would ever using any fancy free monad stuff in your day-to-day job, this talk is perfect for you!
Lightning Talks (15 minutes)
- Creative Problem Solving
- Customer Service & Support
- Generational Gaps & Workplace Diversity
- Goal Setting
- Leadership and Influence
- Employee Efficiency
- Using Group Dynamics
- The loss of translation in a text/email
- The value of how things are said
- How someone hears a word
This program is ideal for individuals who work in a group setting and who have Teams working in the areas of Engineering, Programming, and DevOps.
- This concept has proven SOUND and EFFICIENT in regards to producing advanced degrees of SUCCESS in the areas of administration performance and TEAM-ROLE awareness.
- This lecture is designed to enhance the characteristics of a PHP team and allow them to be cross-efficient and well-informed of frameworks and sufficient-enough to the sense where they can offer all essential skillsets.
- My approach derives from my experience as an adjunct professor (psychology & group dynamics) and experience as an interrogator/profiler and hostage negotiator. My proficiency with said skills has allowed me to assemble a METHOD, which will INTEGRATE your TEAM sectors.
- The lecture/ is aimed at offering Development teams’ novel methods for applying agendas for the publication of a new variety of team projects.
- My RESEARCH and practice will assist companies, organizations, and groups by merging psychology in consort with Active Listening Skills (ALS), which will result in an ACCELERATED-advance technique, devised to build rapport as well as enhanced recruiting methods.
- The lecture/ is designed to bring out individuals exceptional communication and administrative abilities and skills to function efficiently as an element of a team.
- This presentation will allow businesses to use the TEAM PROJECT MODEL to help their team members cooperate, with the focus on utilizing distinctive intensities within individual elements among members of a team.
- Team leaders will take with them newer methods to develop a team of energetic, driven individuals who are enthusiastic regarding assisting the corporate endure to climb to new elevations.
- This presentation also motivates an even more distanced method of diverse aspects regarding a project.
- My presentation will illustrate that the above model is acceptable. However, a team will not communicate effectively if a team that has been taken apart and separated due to disconnection and lack of communication.
- By using ACTIVE LISTENING SKILLS (ALS), a method developed by the FBI, every team member will increase productivity regarding their specific missions, and when united, the team members will form successful finalization of their team-goal. By applying ALS, the team’s entire task will be the result of collective productive representation of their work.
- As with all teams, each team was placed together because at the initial conception of the group; it was assumed that the team element is within the excellent working order. However, the appreciation of the team model must be well-oiled, and if not, members of the team will individually lack the proper function that is necessitated for TEAMWORK and fail to produce.
RESEARCH HAS PROVEN THAT THE KEY CATALYST REGARDING TEAM FAILURE IS COMMUNICATION AND THE LACK OF PROPER USAGE OF ONE’S COMMUNICATION SKILLS.
"Can you make a
Monoid[A] for any
It seems impossible, but you can do it if you cheat.
The talk is on Generic Programming in Scala, starting from basics, to shapeless, and all the way to concepts in scalaz-deriving. We will showcase an algorithm built to compute state of cloud infrastructure, and explain how important it is to know these concepts to make robust solutions.
Generic Programming in Scala has always been an interesting topic. Dozens of libraries that we use in scala is based on the concepts that we will be covering in this talk.
Recently, we have had a chance to write a web application that tries to deploy a multi-tenanted infrastructure in cloud. We will share the success story of how quick and easy was it to implement the same with the backing of Generic Programming and FP concepts, and thereby produce an application that was bang on in the production environment with seriously no bugs. In short, we have got a resource differencing algorithm written in scala using automatic type class derivation. The application then performs a fast and robust refresh of resources in the cloud based on the declarative HOCCON based DSL written by the user.
I will cover the concepts in shapeless, share the logic of resource differencing algorithm, discuss the must-know concepts of scalaz-deriving and in fact discuss about how can we do this with macros in Scala directly. I will not forget to mention about Generic Programming coming up in Scala 3 while discussing about the pros and cons of all these approaches.
The talk is intended to motivate the FP lovers to look much more deeper into the power of Scala, and enable developers to easily uncover the possibility of building much more robust libraries for their clients.
Overwhelmed by deciding between many deep learning libraries? Want to train in one context and inference in another? Open Standards! Finding Python solutions lacking in type safety & support for higher-level/pure functional programming constructs? Functional, typeful Scala! Meet ONNX-Scala.
An ONNX (Open Neural Network Exchange) API and Code Generator for Typeful, Numerically Generic, Functional Deep Learning in Scala
This project currently provides:
A) a complete, versioned, numerically generic, type-safe / typeful API to ONNX(Open Neural Network eXchange, an open format to represent deep learning and classical machine learning models), derived from the Protobuf definitions and the operator schemas (defined in C++) via the JavaCPP Preset for ONNX.
This API is expressed via traits, with version-named methods.
B) a program generator, capable of translating ONNX model Protobuf (.onnx) files into Scala programs written in terms of this API.
ONNX-Scala will also be home to:
C) at least one, eventually many backend implementations of ONNX accessible from the JVM.
Currently there is a rough sketch of an nGraph backend, which is capable of running a single ReLU node network, based on the new nGraph JavaCPP Preset.
All together, these should enable model inspection and modification, extra compile-time assurances, mixing/matching of backend operator implementations and integration into JVM-based production systems, for a start.
Monad, Monoid, Functor, Semigroup. What’s the difference!? Become a type class master with these handy visual aids! Learn their powers and the relationships between them. Gotta catch ‘em all!
Learning the type classes from Cats and Scalaz can be difficult without a guide. By presenting the most well-known type classes visually, we can more easily understand their capabilities and the relationship between them.