Book your ticket now

& join the Scala Swarm in Portugal

logo600x143

@ScalaSwarmConf | #ScalaSwarm

is a Scala programming language (and accompanying technologies) conference brought to you by the altruistic crew that organized the #BeeScala conference and introduced a new standard of a great conference. Our approach to conference organization is unconventional and above all holistic - we value every aspect of our attendees and our speakers. We strive for a multilayered and unforgettable experience forged by the people for the people, aim to strengthen the human ties, empower our common potential and raise awareness. We settle for nothing less.

New Topics

Striving to present the most actual topics and bring out the pragmatic value.

30+ speakers

Empowering and insightful talks by established community leaders and novice enthusiasts alike.

Atomicity

Interactions on all levels and exclusion of any manifestation of intellectual elitism.

PROGRAM

Within the context of the conference we will organize two separate workshops, a single track day and a two tracks day due to an overwhelming response from the community. The program can be subject to minor changes.

Ivan Topolnjak

Training: Monitoring Microservices with Kamon

 INTRODUCTION TO MONITORING WITH KAMON
  • Understanding what Kamon is and what it brings to the table.
  • Comparing Kamon with other monitoring libraries.
  • Simple and plain metrics collection.
  • Using the tracer API.
  • Instrumentation and reporting modules’ basics.
PEEKING INSIDE THE MONSTER
  • Anathomy of Play applications and Actor Systems.
  • Getting HTTP, actors, routers and dispatcher metrics.
  • Analyzing JVM metrics and hiccups.
  • Customizing the instrumentation.
  • Setting up distributed tracing.
REPORTERS AND PRETTY CHARTS
  • Setting up open source and commercial reporting solutions (StatsD + Grafana, Datadog and Kamino)
  • Advice and best practices for alerting and dashboard design.
  • Guided walk through the most common crash scenarios and how to detect them.
TAKE IT HOME
  • Open space for questions specific to your application monitoring needs and how to effectively monitor them with Kamon.
More about Kamon

9h

Ivan Topolnjak

Ivan is a curious developer, interested in writing concise and expressive code with Scala, teaching, sharing knowledge and having a good time while doing so. He has spent the last few years monitoring, troubleshooting and learning from production systems, member of Kamon’s core development team and co-founder of Kamino, the next generation APM.

Luc Duponcheel

Training: Functional Event Sourced Applications with Fun.CQRS

INTRODUCTION TO CQRS AND EVENT SOURCING
  • Understand the basic principles of CQRS and Event Sourcing.
  • Why is CQRS and Event Sourcing becoming so popular?
  • When to apply it?
  • Synchronous vs. Asynchronous CQRS applications – pros and cons
AKKA AND EVENT SOURCING
  • Actor Model and Commands
  • Akka Persistence and Event Sourcing
  • Fun.CQRS Akka Backend
  • Transactional Model
FUN.CQRS IN PRACTICE
  • It’s main design principles.
  • Expressing business requirements in terms of Commands and Events.
  • Design meaningful write-models (aka Aggregates).
  • Generate read-models (aka Views) from Event Stream Projections.
  • Write unit tests purely based on Commands and Events.
  • Fun.CQRS interpreter design (bonus)
More about Fun.CQRS

9h

Luc Duponcheel

Luc is a Java/Scala instructor/developer. He worked as an independent for Sun, Oracle and Red Hat. Before that he worked as a researcher on programming language and library design at the University of Utrecht.

Scala Center Hackathon

Scala programmers, open source contributors, midnight hackers! Be sure to attend the premiere edition of the Scala Swarm Conference in Porto, Portugal. Participate in the Scala Center hackathon at the event, a four-hour event devoted to the development of popular Scala tools and libraries in the ecosystem led and moderated by Jon Pretty. This is the perfect time for you to meet with other Scala developers and improve your skills by solving issues in community projects and advancing the state-of-the-art of everyone’s daily toolkit.

4h

All levels

REGISTRATION

1h

Jon Pretty

Opening keynote by Jon Pretty

TBA

1h

Jon Pretty

Jon has been involved in the Scala community for over a decade, having launched the first commercial and open-source Scala software back in 2005. Since then, he has successfully deployed Scala projects into small, medium and large businesses, and UK government, but is best known these days for his work on Rapture, the Scala World conference, and as chair of the Scala Center Advisory Board.

Welcome reception

2h

Surprise Event

1h 30m

REGISTRATION

1h

Konrad Malawski

Keynote by Konrad Malawski

TBA

1h

Konrad Malawski

Konrad is a late-night passionate hakker currently living in Tokyo and still believing in his motto: “Life is Study!”. At Lightbend he’s part of the core Akka team, and has contributed mostly (but not only) to the core, persistence, new remoting as well as maintaining Akka HTTP. He has founded and run multiple user groups (Java, Scala, Computer Science, …), and is part of program committees of awesome conferences such as GeeCON and JavaOne SF. In those rare times he’s not coding, he spreads the joy of computer science by helping local user groups and whitepaper reading clubs. He also holds number of titles, including the “Best ScalaDays NY talk 2016” and Java One RockStar 2015.

COFFEE BREAK

15mins

Silvia Pina

The Programmer’s Guide to Ideology (or The Pervert’s Guide to Programming)

Ideology, while being somewhat of an elusive concept, can be defined as the set of both explicit and implicit beliefs held by an individual or groups of individuals. While often discussed within the scope of politics, cultural history or social cognition, the notion of ideology can be applied to some of the beliefs held by software programmers. Debates about what is the best approach, framework tool or language paradigm to solve a given problem are pervasive in modern software development. Ask individual coders questions such as what they deem as quality code, or what is the best language, and you’ll get a lot of disparate answers. One such example that comes to mind is a recent discussion on HackerNews of the relative merits of Go vs. Scala. Flame wars over disputed PRs also occur periodically in many open source projects and within language communities. The outcome can be oftentimes dictated by whomever possesses the better persuasion tactics, not necessarily the one who is ultimately “correct”. This talk takes its inspiration from the work of Slavoj Žižek, a contemporary philosopher who analysed the concept of ideology in some of his works and notably in the thought-provoking documentary film The Pervert’s Guide to Ideology. I will explore ways to go avoid the more pervasive ideology-based or biased thought patterns, thus going beyond our personal convictions and relying on hard data instead.

20mins

Venue 1

Novice

Silvia Pina

Silvia Pina is a Software Engineer working primarily with Scala. She has studied Computer Science and Psychology and she’s always interested in bringing up topics that intertwine the two fields.

Daniel Beskin

What Orwell’s 1984 Can Teach Us about Programming

One might think that the bleak, anti-utopian reality of Orwell’s 1984 would be a poor choice for a source of constructive ideas about programming. But it so happens, that the three main slogans of the book: “War is Peace”, “Freedom is Slavery” and “Ignorance is Strength” map very neatly into good practices for programming in general and functional programming in particular.

45mins

Venue 1

Intermediate

Daniel Beskin

Daniel is an FP-biased developer with a thing for (esoteric) programming languages.

COFFEE BREAK

15mins

Amira Lakhal

Amira Lakhal: Reactive IoT

IOT has a massive potential and its impact in our daily life is important. However, IOT data collection and processing is challenging due to the complexity of interconnexion and communication. In this presentation, we will see how to build a reactive architecture for IOT using the actor based model.

45mins

Amira Lakhal

Amira is an Agile Scala developer at Actyx AG. She is passionate about functional languages and Big Data. She is one of the Duchess France leaders where she helps women in IT to became role models. TBA

Renato Cavalcanti

Functional Foundation of Event Sourced Application

One of the goals we had when we started with Fun.CQRS was to come up with the definition of the most basic functions that every CQRS and Event Sourced application must support. It’s often said in the CQRS community that frameworks are not needed because the basic operations are quite trivial. This is true, as we are going to see during the talk. However, it’s not that trivial to deal with failure, asynchronicity, concurrency, IO, etc. It turns out that functional programming offers many constructs that can help us to deal with all those aspects while staying pure and principled. We are convinced that a solid functional foundation for CQRS/ES can lay the path for better abstractions and more expressive modeling.

45mins

Ruby Room

Intermediate

Renato Cavalcanti

Renato Cavalcanti is an independent Scala developer based in Belgium. Coming from a totally different field (psychology), he discovered a passion for programming in 1999. Scala aficionado since 2009, he has been hacking in Scala and related technologies for fun and profit. He’s the founder of BeScala, co-founder of Strong[Typed] and author of Fun.CQRS.

LUNCH

1h

Andrzej Ludwikowski

Gatling distilled

In 20 minutes I would like to show: 1. Why is it worth to spend some time and learn Gatling – a tool for integration/performance test of your web application? 2. Under what circumstances it is necessary to have Gatling in your toolbox? 3. How does it look in comparison to other similar and popular tools? 4. What are Gatling cons and what kind of problems can you expect? For sure there is no silver bullet in testing tools area, but you will definitely love Gatling DSL.

20mins

Ruby Room

Intermediate

Andrzej Ludwikowski

Miller at SoftwareMill. A devotee of DDD, Event Sourcing and Polyglot Persistence. Continuously chasing the dream of a perfect software architecture, fulfilling all of the requirements and trends, even the strangest ones.

Heiko Seeberger

Learn you Akka Streams for great Good!

Stream processing has become ubiquitous and Akka Streams, an implementation of the Reactive Streams specification, is one of the hottest kids on the block. In this talk we not only cover the essentials, but also introduce some advanced features like working with materialized values and cyclic graphs. As we strongly believe in writing code as the best way to learn coding, we show zero slides, but a lot of live code and live demos instead.

45mins

Ruby Room

Intermediate

Heiko Seeberger

Fellow at codecentric. Scala and Akka advocate, Rust enthusiast. Free climber and half marathon runner. FC Bayern München supporter.

COFFEE BREAK

15mins

Alexandru Nedelcu

Purely Functional Concurrency Handling

Concurrency and asynchronicity are hard topics, being among the biggest problems that we face as software developers. And the problem with concurrency is that one has to force the ordering of operations, to manage sequencing and parallelism, along with producer/consumer communication workflows, while still being able to make some sense of the code for maintainability purposes. This talk is about how functional programming and its abstractions can help us to write highly concurrent code that’s still reasonable, touching on usage of data types defined in the Monix project and inspired by Haskell, such as Task and MVar.

45mins

Alexandru Nedelcu

Alexandru is a software developer living in Bucharest, Romania, currently working for Eloquentix. A startup guy, by day he’s been helping with projects for powering the next generation energy grid solutions and for advancing the health-care industry. By night he’s fuelled by his work on the Monix project, the Scala library for composing asynchronous and event-based programs. He’s also a proud father, husband, has a very unhealthy sleep schedule and appreciates talking about programming over beer. Sometimes he blogs at: https://alexn.org

Niko Will

Akka cluster management and split brain resolution

Akka is a toolkit that brings the actor model to the JVM and helps developers to build scalable, resilient and responsive applications. With location transparency and asynchronous message passing it is designed to work distributed from the ground up.

While distributed systems help to solve some problems like availability, a new set of problems arise. For example how do we scale the cluster up or down? What happens if the network is at least partially not available? Akka provides a comprehensive set of cluster features that enable developers to monitor and manage the cluster manually or in most cases even automatically.

In this talk I will introduce some of these features and explain what you need to be aware of. You will learn how to start a cluster correctly and add / (gracefully) remove nodes to / from a running cluster. Additionally I will show how to handle failure scenarios like network partitions by using an existing or implementing a custom split brain resolver.

45mins

Ruby Room

Intermediate

Niko Will

Software developer interested in solving complex problems with simple solutions, scalable & distributed systems, event sourcing & CQRS, software architecture in general, fast & big data architectures, microservice architectures, self contained systems. Currently working a lot with Akka and Scala.

COFFEE BREAK

15mins

Andrew Kozlov

Akka support in IntelliJ IDEA

Since Akka is one of the most popular Scala related frameworks, its support in IntelliJ IDEA has been just a matter of time. The purpose of the talk is to introduce one to Akka specific features of IntelliJ IDEA. Moreover this talk could be considered as an opportunity to suggest a killing feature that may be soon introduced.

45mins

Ruby Room

Intermediate

Andrew Kozlov

Andrew has been a JetBrains employee since graduating with a B.Sc. degree in Computer Science. After falling in love with Scala joined the Scala plugin team. Currently is working on Akka and Dotty support in IntelliJ IDEA. Besides programming is interested in public speaking: has participated in several conferences (including ScalaDays), has been teaching programming courses for high school and university students for more than 5 years.

Tamer AbdulRadi

How to program the type system

Scala has a rich static type system which provides powerful features such as implicits and typeclasses. In this talk we will explore a real world use case combining typeclasses, literal types, shapeless and scala.meta to program the type-system to understand and validate simple SQL queries. The resulting solution will ensure they match a given schema without requiring a database connection. The code examples are based on Troy, an open-source Cassandra driver which allows developers to paste raw queries within Scala code in a way such that they get compile time schema validation and derivation of case-class marshallers for free. The talk targets established Scala developers who would like to know more about advanced Scala features and libraries. You will learn how to program the type system, use HLists, and augment all of that using a pinch of scala.meta on the top!

45mins

Ruby Room

Intermediate

Tamer AbdulRadi

Tamer is the author of Troy, the schema-safe Scala Cassandra driver. He has been building stuff with Scala since 2012, now he is a senior software engineer at Cake Solutions. Check Tamer’s tweets under @tabdulradi and posts at abdulradi.com

REGISTRATION

1h

Maria Livia Chiorean

The path to generic endpoints using Shapeless

Programming in Scala is sometimes very time consuming. Finding the most efficient way to solve a problem can end up in days of frustration. This talk is a story of trail and error with a twist at the end. It’s a story of API endpoints, generic programming, Shapeless and what happens when they all come together. Everything with examples and plenty of code.

20mins

Ruby Room

Novice

Maria Livia Chiorean

Computer Science. A couple of months later, in September 2015, I joined the Guardian digital team as a Graduate Software Developer. Ever since I’ve been learning Scala, tried different teams and experimented with many technologies.

Nick Stanchenko

Visualize your data structures!

Reftree is a Scala library for producing pretty diagrams and animations of data structures (http://stanch.github.io/reftree/demo). It can be used for documentation, live coding or as an interactive tool for understanding how stuff works.

45mins

Room 2

Nick Stanchenko

Nick is a Lisbon-based Scala enthusiast with background in computer science and human-computer interaction. Previously known in the Scala community as the creator of Macroid, a composable UI DSL for Android, Nick is currently fighting fraud with machine learning at Feedzai. His interests include functional programming, usability and data visualization.

Daniela Sfregola

Easy and Efficient Data Validation with Cats

Often when we create a client/server application, we need to validate the requests: can the user associated to the request perform this operation? Can they access or modify the data? Is the input well-formed? When the data validation component in our application is not well designed, the code can quickly become not expressive enough and probably difficult to maintain. Business rules don’t help, adding more and more requirements to add in our validation, making it more and more complex to clearly represent and maintain. At the same time when the validation fails, it should be fairly straight forward to understand why the request was rejected, so that actions can be taken accordingly. This talk introduces Cats, a Scala library based on category theory, and some of its most interesting components for data validation. In particular we’ll discuss some options to achieve efficient and expressive data validation. We will also argue that, compared to other options in the language, Cats is particularly suited for the task thanks to its easy-to-use data types and more approachable syntax. Throughout the talk, you will see numerous examples on how data validation can be achieved in a clean and robust way, and how we can easily integrate it in our code, without any specific knowledge of category theory.

45mins

Ruby Room

Intermediate

Daniela Sfregola

Daniela Sfregola is a Software Consultant based in London, UK. She has worked as Java developer before moving towards Scala. She is an active contributor to the Scala Community and a passionate blogger at http://danielasfregola.com.

COFFEE BREAK

15mins

Ivan Topolnjak

Keeping it alive with Kamon

Being able to monitor your application’s behavior is nice; knowing that everything is being measured and reported somewhere makes you feel like you are doing the right thing, but, are you? Simply measuring everything like there is no tomorrow doesn’t bring any good unless you are analyzing that data! In this talk we will learn how to interpret the metrics data collected by Kamon and how to apply this knowledge when troubleshooting real world performance problems.

45mins

Ruby Room

Ivan Topolnjak

Ivan is a curious developer, interested in writing concise and expressive code with Scala, teaching, sharing knowledge and having a good time while doing so. He has spent the last few years monitoring, troubleshooting and learning from production systems, member of Kamon’s core development team and co-founder of Kamino, the next generation APM.

Holden Karau

Apache Spark Beyond Shuffling

Apache Spark is one the most popular general purpose distributed systems in the past few years. Apache Spark has APIs in Scala, Java, Python and more recently a few different attempts to provide support for R, C#, and Julia. This talk looks at Apache Spark from a performance/scaling point of view and the work we need to do to be able to handle large datasets. In essence parts of this talk could be considered “the impact of design decisions from years ago and how to work around them.” It’s not all doom and gloom though, we will explore the new APIs and the exciting new things we can do with them with a brief detour into how to work around some of the trade-offs in the new APIs – but mostly focused on the new exciting shiny things we can play with. A basic background with Apache Spark will probably make the talk more exciting or depressing depending on your point of view but for those new to Apache Spark just enough to understand whats going will be covered at the start. The presenter would of course encourage you to buy and read her books on the topic (“Learning Spark” & “High Performance Spark”), because which presenter doesn’t do that.

45mins

Ruby Room

Intermediate

Holden Karau

Holden Karau is transgender Canadian, and an active open source contributor. When not in San Francisco working as a software development engineer at IBM’s Spark Technology Center, Holden talks internationally on Spark and holds office hours at coffee shops at home and abroad. Holden is a co-author of numerous books on Spark including High Performance Spark (which she believes is the gift of the season for those with expense accounts) & Learning Spark. She is a Spark committer and makes frequent contributions to Spark, specializing in PySpark and Machine Learning. Prior to IBM she worked on a variety of distributed, search, and classification problems at Alpine, Databricks, Google, Foursquare, and Amazon. She graduated from the University of Waterloo with a Bachelor of Mathematics in Computer Science. Outside of software she enjoys playing with fire, welding, scooters, poutine, and dancing.

LUNCH

1h

Paweł Dolega

How to ditch your server altogether (or entry-level intro to serverless with Scala)

This will be a quick introduction to serverless architecture. We’ll be using Amazon infrastructure (Lambda) and Scala code. We’ll cover basic concepts & ideas together several sample applications. I strongly believe that serverless is a trend that will have a major impact on how we develop and deploy software 5-10 years from now. Goal of this presentation would be to give you a basic idea how things work, show you couple of simple and more complicated applications and basically give you a good start to experiment on your own. From the perspective of serverless architecture this will be introductory material (no prior knowledge & experience needed). We would be using a bunch of other services from Amazon infrastructure (S3, RDS etc) but no advanced knowledge is needed here either.

45mins

Ruby Room

Intermediate

Paweł Dolega

Software engineer / entrepreneur. Worked in international corporations, small local software houses (two of which I co-founded) . In the meantime I’ve been involved with Australian start-up. These days my weapon of choice is mostly Lightbend stack (Scala / Akka / Play) though I am trying to remain flexible and not being too orthodox. As of now working together with VirtusLab – Lightbend partner in Poland.

Petra Bierleutgeb

Introduction to gRPC with ScalaPB

This talk will introduce the audience to writing gRPC applications in Scala using ScalaPB. gRPC is a modern, high-performance, open-source RPC framework focused on the requirements of connecting polyglot services in microservice-oriented systems. Its support of HTTP/2, protocol buffers, bi-directional streaming and type-safety make it an attractive alternative to traditional REST/JSON based service communication. Support for Scala is available through ScalaPB – a community provided protocol buffer compiler. Once integrated, ScalaPB will automatically generate the source code required for the implementation of the defined services, clients and exchanged messages. This talk will start with a short introduction to gRPC and its principles, followed by live coding examples of setting up gRPC with ScalaPB and implementing services and clients using various forms of gRPC communication styles. As a bonus – and if time allows – there will also be a demonstration about how to integrate gRPC with Akka Streams.

45mins

Ruby Room

Intermediate

Petra Bierleutgeb

Petra Bierleutgeb is an independent software engineer and consultant with 10+ years of experience in the fields of software development and distributed systems. Away from the keyboard, she greatly enjoys rock climbing and the outdoors.

COFFEE BREAK

15mins

Krzysztof Ciesielski

Reactive Kafka with Akka Streams

Apache Kafka is now widely adopted among modern distributed systems. In this presentation we will see how Akka Streams can add even more power to Kafka by exposing it as a reactive stream. We will see some examples of how the Reactive Kafka library can be leveraged to build a well-fitting and elegant match of partitioned, pull-based distributed log and asynchronous, backpressured streaming model.

45mins

Ruby Room

Intermediate

Krzysztof Ciesielski

Krzysztof is a Scala enthusiast working remotely at SoftwareMill in Poland. Fascinated about BigData, FastData and distributed systems, Krzysztof explores technologies like Akka, Kafka and Functional Programming.

Tudor Palanga

Testing microservices built with Akka HTTP and Akka actors

Many teams choose Akka HTTP in combination with Akka actors to write services but, while Akka is a very powerful technology, it is very easy to introduce bugs if you’re not testing it thoroughly. In this presentation I am going to show you how to build a simple microservice with Akka HTTP and Akka and explore different aspects of testing it: actor level unit testing, route testing, API level testing, with lots of code examples. By the end of this talk, you should have a good idea about how to write such a microservice and validate it with a solid test-suite from day one.

45mins

Ruby Room

Intermediate

Tudor Palanga

Tudor is a Software Consultant based in London with more than 15 years of software development experience. After working for a while as a Java engineer for some well known clients (Oracle, BNP Paribas, Sony Playstation Network) he decided to steer his career to Scala and eventually he’s joined Expedia/Hotels.com where he’s writing software as part of the SEM Tools team.

COFFEE BREAK

15mins

Gideon de Kok

Reactive Microservices: going from 0 to 100 real quick

Organizations can reap large benefits from migrating from a monolith to a microservice-based architecture, because microservices provide much more flexibility to adjust applications to changing business needs. Since such a migration affects every layer of an application, the big-bang strategy is often perceived to be the best path of a migration. Reality shows that making the “final switch” at the end of a big-bang is a very hard choice to make. Frequent slipping deadlines and not delivering business value in the meantime puts the development process under large and unnecessary pressure.  In this talk, Gideon will dive into a different strategy for the disentanglement of monoliths. Using an incremental angle, the promise of increased business flexibility can be fulfilled from day one. An incremental process, however, adds architectural complexity to the migration. Should you start with disentanglement over a horizontal axis; starting with a view layer first and interleaving “dumb” microservices? Or is a domain for domain process viable and worth the trade-offs? Using an example built on Lagom, Gideon will share the design choices to be made in an incremental migration and how the battle-tested reactive principles powering Lagom can be used jump-start vertical disentanglement strategies.

45mins

Ruby Room

Gideon de Kok

Gideon de Kok is a software consultant with a strong passion for building end-to-end reactive systems. With a background in both software engineering as infrastructures, he helps organizations in embracing the intricacy of software development to regain a grip on their software development process.

REGISTRATION

1h

Maxim Novak

Capitalizing on a great IDEA (Becoming a super user with IntelliJ)

IntelliJ IDEA is the best IDE I’ve ever worked with, partially because it has so many features that allow me to boost my productivity in my every-day job; features, that many developers just don’t use. In this talk I will give you the tools to become a super-user, do the same things only faster and easier. I’ll showcase live-coding use-cases to cover, among other tips, useful shortcuts, easier editing, navigation, and refactoring.

20mins

Tawny Room

Intermediate

Maxim Novak

Maxim is full of enthusiasm for innovation, and passionate about technology. He’s been in the R&D field for 9 years and his experience includes developing, designing, and leading large-scale software projects. In the last three years – an avid SCALA advocate! He currently leads core back-end projects that empower Wix’s platform to serve over 100 million sites with over 200 micro-services.

Harry Laoulakos

Monad Stacks or: How I Learned to Stop Worrying and Love the Free Monad

When advanced techniques are presented to beginner or intermediate programmers, they usually cannot grasp their usefulness and applicability to real-world cases. In this talk, I will demonstrate various techniques, such as: – Monad Transformers – Effects libraries – Free monads These techniques can be used to transform scala “spaghetti” code (that is embedded maps, flatmaps and pattern matching) to cleaner code that almost looks like imperative code. [Disclaimer: Some familiarity with these techniques might be useful, but not necessary to follow the talk.]

45mins

Tawny Room

Intermediate

Harry Laoulakos

Functional programmer, enjoying programming in Scala, Play framework, Akka, Typelevel stack: cats, shapeless, etc

Andrea Peruffo

Don’t call me frontend framework! A quick ride on Akka.Js

We will start from the very basics and learn how Akka actor model applies properly in business logic, software infrastructure as well as in managing UI. In the end we will take a look at some of the features under development and what we are trying to achieve.

45mins

Tawny Room

Intermediate

Andrea Peruffo

Andrea Peruffo is an all-around software developer with hands-on experience in delivering any kind of software system from large scale cloud to embedded devices.

COFFEE BREAK

15mins

Tomer Gabel

Scala Refactoring for Fun and Profit

New Scala practitioners often experience the uncomfortable feeling of “not quite getting it.” If you’ve studied the syntax and written tests, maybe production code; if you’re becoming comfortable with the language and libraries, but keep worrying that there’s “a better way”, or that your code isn’t “idiomatic enough” – this session is for you. By refactoring a real, live codebase, this talk will provide you with new tools and increased confidence. Between the provided examples and the ensuing discussion, you will walk away with a better feel for Scala and how to employ it in the real world.

45mins

Tawny Room

Intermediate

Tomer Gabel

A programming junkie and computer history aficionado, Tomer’s been around the block a few times before settling at Wix as a system architect. In the last few of years he’s developed a major crush on Scala, promoting it within the Israeli software industry as part of Java.IL (Israeli Java user group) and Underscore (Israeli Scala user group) and organizing the annual Scalapeño conference in Tel-Aviv.

Tzofia Shiftan

Scala Performance Under the Hood

In this talk we will dive deep into the JVM in order to understand how Scala does its magic. We will see what is the real difference between val, var and def, what happens when we use objects vs classes vs traits, how does lazy works, and much more. At the end of the talk we will be able to better evaluate the performance of our own code.

45mins

Tawny Room

Intermediate

Tzofia Shiftan

Tzofia is a team leader at OverOps (formerly Takipi), helping developers know when and why their code breaks in production. She recently completed her Masters Degree in Computer Science, wherein she dealt with how to apply deep learning methods to enhance image quality. Previously, Tzofia worked on big data distribution storage systems at Thomson Reuters. She is passionate about code simplicity, and about culture in development teams.

LUNCH

1h

Mirco Dotta

Compiling like a boss!

We all love Scala, but the one aspect we have a hard time accepting are long compile times. It’s not uncommon for a project to experience compilation times of a handful of minutes, if not worse. On top of that, compilation times are unpredictable, depending on a combination of language features, external libraries, and type annotations. A single line change may increase compilation times ten fold. What can we do? It’s paramount we gain greater insight into the tools and libraries we use. There are also established (anti-)patterns that you should know about, if you fancy to keep compilation times to a minimum. And why not utilizing all cores when compiling? The stock Scala compiler can’t do it, but Triplequote Hydra is here to change that. Sit tight and let’s cut down on compilation time!

45mins

Tawny Room

Intermediate

Mirco Dotta

Co-founder Triplequote LLC, a company aiming at boosting Scala teams’ productivity. Mirco has 10+ year experience with Scala, and he has contributed to several open source projects such as Lagom, Playframework, Scala IDE for Eclipse, and the Scala language. Before founding his own company, he worked at Lightbend (formerly known as Typesafe), where he wore different hats: from engineering, to consulting, and, fun fact, even sales! He is a certified Lightbend trainer for Akka, Playframework, and Scala. He loves meeting people and sharing experiences. In his freetime, he plays chess and studies wine – both theory and practice! 🙂 You can find him on twitter at @mircodotta.

Paweł Szulc

Going bananas with recursion schemes for fixed point data types

In 1991 Erik Meijer, Maarten Fokkinga, and Ross Paterson published “Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire.” This paper is a classic one, widely recognizable in the FP community. Constructs described – known as recursion schemas – have real world applications. Strictly speaking, explicit recursion is the ‘goto’ of pure functional programming. Recursion schemas provide same level of sanity as loops did for structural programming back in the day. Over the years a lot of the progress have been made. Papers like “Recursion schemes from comonads” by Tarmo Uustalu, Varmo Vene & Alberto Pardo or “Unifying Structured Recursion Schemes” by Ralf Hinze, Nicolas Wu & Jeremy Gibbons – pushed the concept forward. This talk is about generalization of a very specific recursion schema (called catamorphism) over fixed point data type. After providing introduction the concept of catamorphism, we will jump straight to fix point data types trying to solve some real-world problems. Code examples are in Scala. Code examples use Matryoshka – which is an open sourced project design to generalize folds, unfolds, and traversals for fixed point data structures in Scala.

45mins

Tawny Room

Intermediate

Paweł Szulc

Paweł Szulc is primarily a programmer. Always was and always will be. Experienced professionally in JVM ecosystem, currently having tons of fun with Scala and Haskell. Humble apprentice of Functional Programming. Runs a blog http://www.rabbitonweb.com

COFFEE BREAK

15mins

Gabriele Petronella

Monad Trasformers for the working programmer

Monad Transformers. “WAT?” “Exactly” In this session we’ll see what monad transformers are, where their need comes from and how to use them effectively We’ll walk through this rather complicated topic guided by real-life examples, with the noble intent of making our code more readable, maintainable and pleasant to work with. Finally we’ll see how Monad Transformers are just one of possible tools to solve the “effect stacking” problem and hint at other possible solutions. WARNING! This talk contains slides that some viewers may find disturbing, most of them containing words like “monad” and/or “functors”. Listener discretion advised

45mins

Tawny Room

Intermediate

Gabriele Petronella

Gabriele is co-founder of Buildo, where he’s a software engineer, working with Scala, JavaScript and Swift. He founded the Scala User Group in Milan and he’s an organizer of Scala Italy, the Italian conference on Scala. In the – rare – free time, you’ll find him on a plane or at the basketball court.

Noel Markham

Noel Markham: TBA

TBA

45mins

Tawny Room

Intermediate

Noel Markham

Functional programmer. Blue sky thinker.

COFFEE BREAK

15mins

Johan Andrén

Building reactive distributed systems with Akka

Akka Cluster is one of the most interesting parts of Akka, leveraging the actor model for building reactive and distributed systems. In this talk we’ll cover a bit of basics around Akka Cluster and then focus on the various tools for building distributed systems available out of the box: singleton, sharding, distributed pub-sub and distributed data. For each of the tools we’ll discuss what use cases it covers and where it is on a scale from consistency to availability.

45mins

Tawny Room

Intermediate

Johan Andrén

Johan is a developer, in the core the Akka Team at Lightbend, based out of Stockholm, Sweden. He has been working as a consultant and mentor around Scala, Akka and Play Framework the last 5 years and Java the last 10. In his spare time he co-organizes Scala Usergroup Stockholm and when not in front of a keyboard he enjoys mountainbiking and bouldering.

COFFEE BREAK

15mins

CLOSING PANEL

45mins

Douro River Cruise & Port Wine Caves Crawl

After the closure of the conference and a night out on the town celebrating São João, we will be organizing a guided boat trip and finish the day in one of the many Port wine caves in Gaia. This event is optional and will incur in additional surcharge.

12hrs

20

Nationalities represented

30

Speakers

2

workshops

300

attendees

OUR SPEAKERS

Scala experts who are also enthusiasts, altruists and generally great people worth getting to know

plus

Amira Lakhal

Actyx AG

plus

Renato Cavalcanti

Strong[Typed]

plus

Andrea Peruffo

Nokia

plus

Heiko Seeberger

Codecentric AG

plus

Jon Pretty

Propensive

plus

Ivan Topolnjak

Kamino

plus

Niko Will

innoQ

plus

Noel Markham

47 Degrees

plus

Mirco Dotta

Triplequote

plus

Tomer Gabel

Wix

plus

Pawel Dolega

VirtusLab

plus

Gabriele Petronella

Buildo

plus

Holden Karau

IBM Spark Technology Center

plus

Silvia Pina

Zalando SE

plus

Daniela Sfregola

Daniela Tech

plus

Johan Andrén

Lightbend

plus

Andrew Kozlov

JetBrains

plus

Daniel Beskin

ironSource Mobile

plus

Alexandru Nedelcu

Eloquentix

plus

Gideon de Kok

Xebia

plus

Tzofia Shiftan

OverOps (formerly Takipi)

plus

Andrzej Ludwikowski

SoftwareMill

plus

Harry Laoulakos

Lunatech

plus

Maxim Novak

Wix

plus

Krzysztof Ciesielski

SoftwareMill

plus

Petra Bierleutgeb

Freelancer

plus

Konrad Malawski

Lightbend

plus

Tamer AbdulRadi

Cake Solutions

plus

Nick Stanchenko

Feedzai

plus

Maria Livia Chiorean

The Guardian

plus

Tudor Palanga

Expedia Inc.

plus

Pawel Szulc

SlamData

venue

Ferreira Borges Market is located in the city’s historic center, in the riverside Ribeira district, a part of the UNESCO World Heritage site.

Hard Club

Rua do Infante D. Henrique,
4050 Porto,
Portugal

more information

Accommodation
Alternatives

rotapontual250x76

We are collaborating with a friendly tourist agency in Porto. Send an email to jose.coelho@rotapontual.com with a subject SCALA SWARM in order to get their best hotel price possible.

REGISTER

Conference tickets

Trainings and post conference excursion

TRAINING

Register for an in-person training course before the Scala Swarm conference. Both trainings are a single day trainings and will take place Tuesday and Wednesday June 20th -21st, 2017.

Monitoring Microservices with Kamon (7 hours + Open Space), Tuesday June 20th

What is this workshop about?

Developers attending this workshop will learn everything that is needed to go from not doing monitoring at all to having a solid understanding of how to setup metrics collection and tracing in any JVM application using Kamon. Throughout the workshop we will take a Play! + Akka application and study how they work under the hood, understand the key elements that should be monitored and ensure that all our precious metrics data is properly delivered to a few of the supported metric backends.

What will you learn?

INTRODUCTION TO MONITORING WITH KAMON
  • Understanding what Kamon is and what it brings to the table.
  • Comparing Kamon with other monitoring libraries.
  • Simple and plain metrics collection.
  • Using the tracer API.
  • Instrumentation and reporting modules’ basics.
PEEKING INSIDE THE MONSTER
  • Anathomy of Play applications and Actor Systems.
  • Getting HTTP, actors, routers and dispatcher metrics.
  • Analyzing JVM metrics and hiccups.
  • Customizing the instrumentation.
  • Setting up distributed tracing.
REPORTERS AND PRETTY CHARTS
  • Setting up open source and commercial reporting solutions (StatsD + Grafana, Datadog and Kamino)
  • Advice and best practices for alerting and dashboard design.
  • Guided walk through the most common crash scenarios and how to detect them.
TAKE IT HOME
  • Open space for questions specific to your application monitoring needs and how to effectively monitor them with Kamon.

Who should come?

If you have any piece of software running on production (or soon to be running) this workshop is for you! Attendants should have experience with JVM languages (Java/Scala preferred), experience using Play Framework and Akka is not required but will definitely make it easier for you.

Functional Event Sourced Applications with Fun.CQRS

(7 hours + Open Space),

Wednesday June 21st

What is this workshop about?

This workshop is designed to give developers the necessary skills to start building CQRS and Event Sourced applications using Fun.CQRS.

You will learn the basic principles of CQRS / ES and how to model a domain in terms of Commands and Events. We will explore some strategies that can be applied when designing aggregates (write-models) and views (read-models).

If time allows we will have a deep dive into Fun.CQRS internals and explore some design choices we have made while building its interpreter and its different backends.

What will you learn?

INTRODUCTION TO CQRS AND EVENT SOURCING
  • Understand the basic principles of CQRS and Event Sourcing.
  • Why is CQRS and Event Sourcing becoming so popular?
  • When to apply it?
  • Synchronous vs. Asynchronous CQRS applications – pros and cons
AKKA AND EVENT SOURCING
  • Actor Model and Commands
  • Akka Persistence and Event Sourcing
  • Fun.CQRS Akka Backend
  • Transactional Model
FUN.CQRS IN PRACTICE
  • It’s main design principles.
  • Expressing business requirements in terms of Commands and Events.
  • Design meaningful write-models (aka Aggregates).
  • Generate read-models (aka Views) from Event Stream Projections.
  • Write unit tests purely based on Commands and Events.
  • Fun.CQRS interpreter design (bonus)

VOLUNTEER

All Crew Volunteers will be required to work on Wednesday June 21st from 12:00 PM - 6:30 PM as well as another shift on Thursday June 22nd or Friday June 23rd. In return for helping with the conference, Crew Volunteers will have free access to the conference and all social events. Apply CREW as discount code at registration. If you are an academic wanting to participate fully in Scala Swarm Porto you can send an email with a copy of your student ID to Gorazd Kozmus, gorazd@scala-swarm.org, and in return you will receive a discounted rate for conference attendance. If you have any questions regarding crew volunteering or academic rate please contact Gorazd Kozmus, gorazd@scala-swarm.org.

OFFICIAL PARTNERS

Without heroes no fairy tale is possible - here are ours.

SPONSORS

Proudly presenting companies with highly developed sense for community.

SUPPORTERS

MEDIA PARTNER

scalatimes250x100

ENDORSED BY

lightbend261x56

CONNECT WITH US

We adhere to the No Bullshit and No Spam policy.

Scroll Up