Pre-Conf Workshop Day

Thu, Oct 13
09:30

    Registration - 30 mins

10:00

Functional Conf 2016 Day 1

Fri, Oct 14
08:30

    Registration - 30 mins

09:00
10:00
11:00

    Welcome Note - 15 mins

11:15

    Coffee Break - 15 mins

11:30
12:30
01:15

    Lunch - 45 mins

02:00
03:00
  • Added to My Schedule
    keyboard_arrow_down
    Ravi Mohan

    Ravi Mohan - Equational Reasoning - From Code To Math and Back Again

    schedule  03:00 - 03:45 PM place Grand Ball Room 1 people 8 Interested

    Equational Reasoning [1,2] is an intermediate/advanced FP technique, that sits at the intersection of programming and mathematics and has many interesting uses. It can be used to prove that a piece of code is correct, has specific performance properties,  to drastically reduce the size of a particular piece of code , assure that your code will scale to a bazillion servers, etc etc.

    But how this technique works is often considered a mystery. What is also  missing is a step by step way to learn this method so you can use it in your code. Many books and blog entries show you examples and then you, the reader, are supposed to infer from these examples how Equational Reasoning  works.  When I first ventured into FP, I could (more or less) follow published examples, but never could figure out how this technique works and how to apply it to my code.

    The key to such understanding (as I discovered much later) is to grok the underlying mathematical structure, specifically the nature of the logic and proof technique that provides the working machinery of Equational Reasoning.

    In this presentation, I look at the mathematical underpinnings of this excellent programming technique. Once you understand how the math works [3], it is easy to see how the programming technique works. And once you know how that  works, you can use Equational Reasoning as just another tool in your dev toolbox.

    Once they learn the basics of FP, most programmers are stuck with respect to how to get to the next  level.

    The most common solution  (especially for Haskellers) is to try to deep dive into  Category Theory and Algebra, and their uses in FP.  Which is a good step if you can pull it off, but  in practice this is  much harder than it needs to be (which is the topic of another lecture someday), and many people give up at this point.

    (imo) Understanding Equational Reasoning levels up your FP skills without necessarily having to learn CT structures simultaneously (though, of course nothing prevents you from learning both and combining them, as many Haskellers do), and is a gentler 'level up' than wrestling with Categories and Arrows and such.

    This presentation reveals the nuts and bolts of why and how Equational Reasoning works. Then you can read the existing literature and gain much more out of it than otherwise.

    Essentially, this talk  is what I wish someone had told me when I was trying to learn FP and got stuck.  You might be able to gain from my struggles!

    [1] A blog entry explaining the basics

    [2] A good book with many examples 

    Some quotes from the preface

    ".. I (Richard Bird) was interested in the specific task of taking a clear but inefficient functional program, a program that acted as a specification of the problem in hand, and using equational reasoning to calculate a more efficient one."

    " One factor that stimulated growing interest
    in functional languages in the 1990s was that such languages were good for
    equational reasoning. Indeed, the functional language GOFER, invented by
    Mark Jones, captured this thought as an acronym. GOFER was one of the
    languages that contributed to the development of Haskell, the language on
    which this book is based. Equational reasoning dominates everything in this
    book."

    To be clear, this talk is not about the problems tackled in the book, though I'll use a couple of them as dissection specimens. The book shows (excellent) examples of applied ER, with a focus on generating efficient algorithms. My talk is about how ER works, and bridging the mathematical and programmatic machinery. We'll see, for example, why such derivation of efficient algorithms via ER works.

    [3] I keep the math bits programmer friendly, so don't worry if you are not big on formal math. This is a talk addressed to programmers.  If you can write nested if statements or SQL queries, say, (iow if you have a couple of years of programming experience), specifically if you understand how logical operators (and, or, not) work,  you'll be fine. I'll fill in the rest.

  • Added to My Schedule
    keyboard_arrow_down
    Bartosz Bąbol

    Bartosz Bąbol - Magic at compile time. Metaprogramming in Scala

    schedule  03:00 - 03:45 PM place Grand Ball Room 2 people 8 Interested

    Don't use metaprogramming! Don't use macros! You will often hear those statements. But metaprogramming or speaking more specific macros are heavily used in scala ecosystem. Almost every big project in functional or "reactive" technology stack uses them somewhere under the hood. What are macros? Why they are so controversial? What macros can offer to an engineer? Why they are useful? How they can minimize amount of boilerplate code? After answering those questions by showing small examples, we will start to develop library(or maybe better term will be DSL) for parsing XML.

    But there is something more I didn't mention. If you are familiar with Scala ecosystem and up to date with roadmap of new Scala versions, you should be aware that...MACROS ARE DEAD. So why bother? Because there is new, bright future of metaprogramming in Scala called Scala Meta. We will see that knowledge gained after learning macros will be helpful when we will learn new approach presented in Scala Meta.

03:45

    Coffee Break - 15 mins

04:00

Functional Conf 2016 Day 2

Sat, Oct 15
08:30

    Registration - 30 mins

09:00
  • Added to My Schedule
    keyboard_arrow_down
    John Hughes

    John Hughes - Why Functional Programming Matters

    schedule  09:00 - 09:45 AM place Grand Ball Room people 13 Interested

    25 years ago I published "Why Functional Programming Matters", a manifesto for FP--but the subject is much older than that!

    As software becomes more and more complex, it is more and more important to structure it well. Well-structured software is easy to write, easy to debug, and provides a collection of modules that can be re-used to reduce future programming costs. Conventional languages place conceptual limits on the way problems can be modularised. Functional languages push those limits back. In this paper we show that two features of functional languages in particular, higher-order functions and lazy evaluation, can contribute greatly to modularity. As examples, we manipulate lists and trees, program several numerical algorithms, and implement the alpha-beta heuristic (an algorithm from Artificial Intelligence used in game-playing programs). Since modularity is the key to successful programming, functional languages are vitally important to the real world.

    In this talk we'll take a deep dive into history to revisit our personal selection of highlights.

10:00
11:00

    Important Announcements - 15 mins

11:15

    Coffee Break - 15 mins

11:30
12:30
  • Added to My Schedule
    keyboard_arrow_down
    Sathish Kumar

    Sathish Kumar - Real world functional programming in Ads serving

    schedule  12:30 - 01:15 PM place Grand Ball Room 1 people 5 Interested

    This talk will be about how we applied Typed functional programming and object-functional concepts inspired from languages like Scala, Haskell in building an Ads serving engine using Java 8 and made the stack extensible for multiple Ads serving usecases like App, Desktop, Exchange and ML model execution for CTR prediction, Guaranteed delivery etc.

    This talk will focus on how we solved problems in an Ads serving engine using functional programming constructs for:

    • Relevance and Ranking
    • CTR prediction
    • Bidding models
    • Guaranteed delivery (Convex Optimization)
    • Explore / Exploit (Multi-armed bandit)
    • Attribution, Deduplication etc

    From a language level, it will focus on how we applied our learnings from other functional languages like Scala, Clojure, Haskell in Java 8 to write elegant code for:

    • Composing Ad selection workflows from reusable components
    • Reasoning about code through immutability
    • Defining interfaces like function types. Functions as first class objects to express behaviour.
    • Using Builders and Filter predicates for adding new features
    • Transforming collections using streams, lambdas, map, reduce, flatMap, groupBy
    • Optional for writing null safe code and handling defaults using map, flatMap, orElse
    • Functional operations like partition, zip for simplifying code
    • Pattern matching and other features from libraries
    • Caching and memoization
  • Added to My Schedule
    keyboard_arrow_down
    Monika Kumar Jethani

    Monika Kumar Jethani - "Kotlin is the secret of my functional power", says Android

    schedule  12:30 - 01:15 PM place Grand Ball Room 2 people 9 Interested

    Kotlin is a statically-typed programming language released by JetBrains. With the arrival of Kotlin, Android's functional power has enhanced as Kotlin brings a bouquet of features such as type inference,higher-order functions, lambda expressions, operator overloading, lazy evaluation,immutability,recursive functions and lots of useful methods to work with collections. Kotlin comes up with essential functional facilities such as filter,take & drop, first & last, fold & foldRight, forEach, reduce,etc making it a perfect match for Android .This talk will focus on leveraging Kotlin's functional constructs for Android App development.

     

01:15

    LunchBreak - 60 mins

02:15
  • Added to My Schedule
    keyboard_arrow_down
    Roger Hui

    Roger Hui - A Tour (de Force) of APL in 16 Expressions

    schedule  02:15 - 03:45 PM place Grand Ball Room 1 people 6 Interested

    APL will be 50 years old in November 2016 (50 years from 1966-11-27 15.53.58, to be exact), and it remains unsurpassed in manifesting Kenneth E. Iverson’s five important characteristics of notation

    • ease of expression
    • suggestivity
    • subordination of detail
    • economy
    • amenability to proof

    These characteristics are demonstrated by working through 16 APL expressions. The material is approachable for beginners and yet thought-provoking for experts.

    One of the 16 expressions is a fast computation of the partition function without use of the Hardy-Ramanujan (1918) results.

     

  • Added to My Schedule
    keyboard_arrow_down
    Pushkar Kulkarni

    Pushkar Kulkarni / Mamatha Busi - Going Swiftly Functional

    schedule  02:15 - 03:45 PM place Grand Ball Room 2 people 8 Interested

    Two years after its introduction, the Swift programming language finds itself at rank # 14 on the TIOBE index for July 2016. Some of the prime reasons for Swift’s meteoric rise are its carefully designed syntax and semantics - it borrows heavily from the best features of a wide range of languages. The syntax is intuitive and new Swift learners can often relate it to the language of their choice. Introduced primarily as a client-side language, Swift was open sourced in December 2015 via swift.org. Since then, there has been a community effort on extending its capabilities to the server side too. Swift is available on Linux today, and it is poised to become a language enabling end to end development - from mobile apps to server backends. 

    Swift falls in the category of “modern native languages” - like Rust and Go. These runtimes run code in bare metal, boosting performance. They are statically, strongly typed and with type-inference. This makes them safe. Their modern syntax also makes them expressive enough for high level abstractions like those seen in functional programming. They try to solve some of the tradeoffs that languages of the past battled with. On the other hand, functional programming has found new oxygen in the last couple of years when agile methodologies become as pervasive as multicore hardware . While we do have languages like Haskell that are purely functional and provide excellent support to express functional concepts, it is important to separate functional thinking away from the language. Functional programming is supported by most of the languages today because the returns of it in terms of expression, conciseness, readability, correctness and performance are unmatched. Swift is not a purely functional language. However, it provides syntactic and semantic support for functional programming to a large extent.

03:45

    Coffee Break - 15 mins

04:00
05:00
05:45

    Closing Talk - 15 mins

Post-Conference Workshop Day

Sun, Oct 16
09:30

    Registration - 30 mins

10:00