- Episode 63
Interesting Language Enhancements in Dotty/Scala 3 Arnold deVos A tour of some selected new language features that can be seen in the latest dotty RC (and will probably be in scala 3). To make it interesting we will try to use these features in example code. Hopefully some of their raison d'être will emerge. -------------- Compile Time Parsing Mark Hopkins Sometimes, rather than constructing a domain object in code, it's clearer to specify it as YAML or JSON. But at the same time, we don't want to give up the compile-time guarantees we get from a programming language, as this would expose us to runtime errors if we made a mistake in the YAML/JSON. Can we write in another language and then check it at compile time? We can, through the power of macros! I'll show how to build useful compiler checking of arbitrary Strings. Key ingredients will be: (a) macros that produce macros (b) string interpolators, and (c) compile-time evaluation. -------------- Why "Names Don't Matter" Matters. Jed Wesley-Smith Increasingly, people are popping up stating the controversial opinion that names don't matter. To most programmers this statement is obviously untrue, as naming is seen as difficult, and critical to semantic expression and communication in their code. To make matters worse, these same people demand fidelity to obscure and difficult names from mathematics, leading to charges of hypocrisy – if names don't matter, why do they care we all use any particular ones? We'll try and tease out these seeming contradictions. We'll look at why "names don't matter" is an important idea, and why its more obvious superficial interpretation is specious.
- Episode 62
Scala In Production, Mark Setchell BoozeBud.com is Australia’s leading online liquor site, and it's written in Scala. This talk assesses the positive and negatives of Scala on the ongoing development and production support of a small to medium sized system over a period of a few years. In conclusion: Scala can provide a stable platform with high developer productivity but is not without traps for the unwary -------------------------------- Refactor ugly procedural code to idiomatic Scala, Karl Roberts
- Episode 61
• What we'll do Life Is A Comonad, Eli Jordan I have recently been grappling with the concept of a Comonad, and found that there are quite a few articles that explain their theoretical footing, but not many that convey an intuitive understanding of Comonads using practical examples. In this talk I will introduce comonads using the Zipper data structure as an analogy, then show how the Store comonad can be used to implement Conway's Game Of Life. • What to bring • Important to know
- Episode 60
Conditional Contexts Mark Hopkins Wouldn't it be nice if Scala would let you write a parametric function that would do different things, depending on whether or not a type class instance was available for the type? For instance • a Set[A](a: A*) function that creates either a TreeSet or a HashSet, depending on whether an Ordering[A] is in scope. • a numerical algorithm doCalc[N : Numeric](n: Matrix[N]) that works for all numeric types N, but uses a (more expensive) numerical stability technique for floating point operations, but not integral (which don't need it). I'll run through the use and implementation of a Haskell library which provides this functionality, then show the (surprisingly simple) Scala implementation. Eff Monad Binzi Cao In this talk, we'll introduce Eff Monad and share some examples based on the library: https://github.com/atnos-org/eff The topics includes: • Some basic FP concepts • The road to Eff Monad and why it matters • Eff Monad by examples Stackless Scala with Free Monads Afsal Thaj • This talk is going to be basic by defining a Free Monad from scratch. This talk will cover the following: Skim through the paper on Stackless Scala using Free Monads: http://blog.higher-order.com/assets/trampolines.pdf . • A few hands-on examples. • Defining a free monad language for logs, and injecting it in our main application.
- Episode 59
SBT plugins for no fun and little profit Tin Pavlinic An overview of how SBT plugins work. Both for those who want to write plugins and those who just want to control their build better. • Explaining project structure • An example plugin • Settings, tasks and commands • Navigating third-party settings and code Combining Free and FreeAp in the wild Cameron Joannidis A talk about using the Free Monad in the wild and how to introduce parallelism into your Free programs with FreeAp. Has a focus on practicality rather than type theory.
- Episode 58 - scala.js special
Functional Webapps with scalajs-react David Barri scalajs-react is a Scala library that allows you to write webapps that remain easy and safe to dev/extend/maintain/reason-about as your project scales from toy -> real app -> behemoth. This talk includes introductions to FP and Facebook's JS library, "React"; an in-depth tutorial to the basics of scalajs-react and some key features; followed by a quick whirlwind tour of other available resources for building a serious, high-quality webapp. Only prerequisite: knowledge of Scala itself. Combinator parsers with scala.js Karl Roberts This talk describes my experience of using scala.js to create a Markdown library, focusing on the use of combinator parsers. It includes a discussion on exposing a JS friendly interface for JS consumers. Creating this library highlighted a few gotchas of using/developing with scala.js, and this talk will highlight some interesting info nuggets for people who want to try it.
- Episode 57
Optics Ren Pillay This talk will walk through some issues with manipulating data in immutable data structures and how Optics can simplify these problems. Taming Transducer Data from the Electric Power Network Arnold deVos We developed a metrics recording system for electric power operations and planning. This talk describes the component, written in scala, that reduces volumes of noisy, irregular transducer measurements to regular time series of reasonable dimensions and other summaries. It is a service, driven by a domain-specific language, fronting a Cassandra cluster. I will describe its design and implementation, drilling down to the scala level in the most interesting areas.
- Episode 56
Property Testing: Finding More Bugs With Less Effort? Charles O'Farrell Testing is an essential part of writing and maintaining correct and reliable software. However, for the most part the best technique we have for writing tests is to capture some examples in the hope that they cover all the known edge cases. Unfortunately these examples almost always missing something. What if we could ask the computer to generate these examples? Not just a handful, but hundreds of them that we never even considered. It turns out we can! By using the technique known as Property Based Testing. This talk will explore the motivation and concepts behind this powerful testing technique. We also introduce a number of simple but useful patterns that can be applied again and again when writing properties. In addition this talk will highlight a handful of compelling examples of Property Based Testing uncovering nasty bugs in real world software. Finally, apart from learning about why and how to use Property Based Testing to write better software, the audience will also realise that testing can be made more enjoyable in the process. A problem with pattern matching in monadic code Mark Hopkins Sometimes Scala code with for comprehensions fail to compile with the confusing error "could not find implicit value for parameter M: scalaz.Monoid[Error]", but it's not immediately clear why, or why it does work when we replace Either/Disjunction with Option. I'll discuss why this occurs, a simple fix to make it work, and compare with similar situations in other languages with pattern-matching and monads (Haskell, Idris, Purescript), ending by identifying a Scala feature that perhaps could be improved in future compiler versions.
- Episode 55
Value, type, kind and type class, why they matter? Amy Wong This is an introductory talk to beginners in functional programming. Value, type, kind and type class are fundamental concepts in FP. The idea is straight forward. But it might not be easy for beginners to understand what they are by learning the Scala implementation. This talk will first introduce a value, a type, a kind and their relationship. Then it will explain what is a type class, why it is important with some daily examples. It will illustrate how to use Scala features to implement them. Hopefully it enable the beginners to easily understand the Scala implementation and its unfamiliar syntax. Akka Streams Stephen Nancekivell Akka streams is a library for efficient stream data processing where the data maybe too big to fit in memory. This talk will be a intro to akka streams and stream processing architectures, as well as where it fits in the software ecosystem. This talk will be a intro to stream processing architectures and where they fit the the ecosystem as well as a intro to the Akka streams library.
- Episode 54
GraphQL for Fun & Profit Tom Adams At Redbubble, we've been building an API for our new mobile app. While initially choosing a RESTful JSON style API, we quickly hit limits with this and moved to GraphQL, a new-ish query language developed at Facebook. This talk will cover the highlights of GraphQL, why you should care, as well as deep diving into Sangria, a GraphQL framework for Scala Haskell on the JVM with Eta Brian McKenna Eta is a fork of the Glasgow Haskell Compiler which provides a JVM backend. Most of GHC’s extensions are supported, allowing a lot of existing Haskell code to run without modification. A few extensions are also provided to allow comprehensive interoperability with Java. I have worked on Eta and understand some details about how it works. I’ll describe how Eta compilation generates JVM bytecode, how Eta’s runtime works to evaluate lazy programs on the JVM and what hope we have of making Eta solve the “JVM problem” for practical programs.