ABCDEFGHIJKLMNOPQRSTUVWXYZAAAB
1
nameemail (opt)twitter handlecompany (opt)talk duration (5-20 min)talk titletalk description
day preference
2
Travis Brown@travisbrown20 minutesThe future of decoding in circehttps://github.com/travisbrown/circe-algebraFriday
3
Adelbert Chang@adelbertchangTarget10 minutesFP: All Questions AnsweredCome ask me any/all your FP questions. What's a monad, what is finally tagless, difference between Validation and Either, whateverFriday
4
Babatunde FashiolaTwitter10 minutesWebhooks Delivery At ScaleTwitter users create thousands of tweets and direct messages every second; a combined volume of nearly a billion events per day. The ingestion of high volume of data and its realtime, concurrent delivery are difficult to do in a fast, lossless manner with high fidelity.Friday
5
Ryland Degnanryland@netifi.com@rjdegnanNetifi (former Netflix)10 minutes
Reactive Microservices: RSocket and Beyond
http://proteus-java.readthedocs.io/Thursday
6
Remy DeCausemakeropensource@twitter.com@remy_dTwitter10 minutesOpen Source at Twitterhttps://github.com/twitter/ossdecks/blob/master/ossdeck.pdfEither
7
Ken Kruglerken@scaleunlimited.com@kkruglerScale Unlimited10 minutesA Flink-based Web CrawlerI'll talk about building an efficient, focused web crawler on Flink with minimal other infrastructure. I'll describe some of the challenges of using Flink's new AsyncFunction support, why iterations need throttling, and the beauty of being able to leverage the Common Crawl dataset.Friday
8
Ryan Delucchiryan.delucchi@fp.engineering@ryanonsrcVerizon Labs10 minutes
Purely Functional Expression DSL Builder Library
https://github.com/ryanonsrc/espressoThursday
9
John A. De Goesjohn@degoes.net@jdegoesSlamData10 minutesTurning Side Effects into ValuesA function has a side effect if it has ANY effect other than deterministically producing its return value. Purely functional programs are composed from functions without side effects. Learn how they still interact with the real world and how this purity enables powerful new levels of composition and equational reasoning not possible with side-effecting functions.Friday
10
Justin Coffeyj.coffey@criteo.com@jqcoffeyCriteo15 minutesAsk an Engineering Manager AnythingI grew into being an engineering leader in a large engineering org and now lead 35 amazing devs. I'll give a 5 minute spiel about what I think is the most important part of making it all work and then you can ask me anything!Thursday
11
Jon Prettyjon.pretty@propensive.com @propensive20 minutesMagnolia: Deriving PleasureIn the last few years, typeclasses have become an increasingly popular tool for solving a wide variety of problems Scala developers encounter every day. But while typeclasses can be composed in entirely predictable ways from smaller primitive types to support larger abstract datatypes, there's no support offered from the language to do this.

For a while, Shapeless has been an admirable enabler, leveraging implicit search and a couple of macros to provide automatic derivations, but its approach to the problem is the cause of very slow compile times; the definitions needed to derive a typeclass are often verbose, type-heavy and complex; and, when derivation fails, the user gets no debugging feedback.

Magnolia basically fixes all of these problems.		no preference
12
Jon Pretty jon.pretty@propensive.com @propensive20 minutes
Impromptu: Encoding async graphs with Dependent Types
Writing asynchronous code is often an uneasy fit for a language like Scala. While high-level constructs like Futures facilitate asynchronous programming, syntactic limitations often make blocking or the unchecked access of asynchronously-computed values more natural than the safer alternatives.

In this talk, you will discover Impromptu, a lightweight Scala API for safely defining and executing graphs of dependent tasks, avoiding blocking and preventing access of not-yet-completed values, guaranteed the type system.

You will use a combination of several advanced type-system features to encode a task's dependencies, then use these types as constraints to restrict access within a task only to the results of dependent tasks which are known to have been completed. You will further take advantage of Scala's type inference to avoid polluting the code with cumbersome type ascriptions. This gives you very lightweight and natural syntax, without blocking or unsafe access.

During this talk, you will explore how Impromptu is implemented, and learn how dependent types allow the library to be written in just 30 lines of code. Furthermore, you will take advantage of current research into implicit functions in Dotty to remove the small amount of remaining boilerplate from Impromptu task definitions.		no preference
13
Jeremy Smithjeremyrsmith@gmail.com@jeremyrsmithNetflix20 minutesScala <3 MathIntroducing some libraries I'm working on for solving math needs with Scala:
* Linear algebra, off-heap with MKL. Giant vectors and matrices (up to 2^63 elements), and compile-time optimizing expression API over BLAS/LAPACK/MKL. Off-heap data structures have APIs that make them transparent(ish) to work with, and passing only pointers through JNI minimizes overhead.
* Auto-differentiation API for creating differentiable, parametrically polymorphic mathematical functions easily; they can be differentiated using forward auto-diff (returning another differentiable function)
* Symbolic functions which are inlined at the call site, and can be differentiated at compile time to produce another symbolic function.

I'll talk about how these things work, too. How they're implemented. There are two different strategies used to do things at compile time (and fail compile if necessary) - proof derivations and macros. It will be an interesting challenge to see how much I can cover in 20 minutes!		Friday
14
Manoj Mahalingammanojlds@gmail.com@manojldsIndix10 minutes
Sparkpkug - "plug" holes in your data with SQL condition based rules
https://github.com/indix/sparkplug
15
Scott Calvertscott.issac.calvert@gmail.com@moosefatherTripit/Concur20 minutesConsidering Free/Tagless Pure IOThere are some great libraries for doing interesting real world stuff with {(Free {Applicative, Monad}), tagless} algebras. Doobie, http4s, probably more. But seriously what if I just want to work with a file system or a cloud storage provider? What if I need a real version of one of those toy logging algebras in all Free/Tagless examples? Hmph, guess you better write it. There are easily a dozen obvious integrations where it would be nice to have a decent algebra and some back ends ready for download.

I'm working on both the FileIO problem, and hopefully an ecosystem for "it just works" Free/Tagless algebras and interpreters in general. At the moment I'm trying to make some good initial decisions about scope, underlying libraries, API design, and general best practices. This may never see the light of day of course, but I'm going to try.

I'm hoping to have a group discussion about what design choices would be good, and even more importantly which ones would be terrible. Should I pick Free and avoid tagless (like Doobie?). Should I provide both options? Anybody have real world experience with Freestyle? Is there a practical alternative to depending on FS2 in the interface if I want to do resource safe streaming? (I love FS2, but I am trying to be general). What about parameterizing for Free Monad vs Applicative? Is there any call to use the introspective power of using Applicatives where possible?
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100