• Liked Rahul Muttineni
    keyboard_arrow_down

    Bringing the Power of Haskell to the JVM

    Rahul Muttineni
    Rahul Muttineni
    schedule 7 months ago
    Sold Out!
    45 mins
    Experience Report
    Advanced

    The JVM is a state-of-the-art, cross-platform virtual machine supported by the vast Java platform and ecosystem, but is cursed with an ancient and clumsy language that is slowly modernizing. Haskell is a state-of-the-art programming language with immature platform and tooling and no commercial development of its primary implementation. GHCVM's objective is to combine the best of both worlds and reap the benefits.

    In this talk, I will share my journey of how I waded through the internals of GHC and got Haskell and Java to play nice with each other.  

  • Liked Yogesh Sajanikar
    keyboard_arrow_down

    Implementing Spark like system in Haskell

    Yogesh Sajanikar
    Yogesh Sajanikar
    schedule 11 months ago
    Sold Out!
    90 mins
    Demonstration
    Intermediate

    The session will present design and implementation of Hspark. A library that implements a framework to enable running a distributed map-reduce job over a set of nodes. The session will also showcase an extensible DSL to specify distributed map-reduce job.

    The session will focus mainly on 

    • Creation of DSL (Specification) for map reduce. The DSL is similar (actually based on) Apache Spark
    • Translation of DSL into scheduling the jobs across the nodes, and
    • Executing and handling failures.

    Current implementation of hspark is at https://github.com/yogeshsajanikar/hspark and implements first two points mentioned above. Currently, I am trying to enforce it with separation of execution framework so that failures can be handled correctly.

    Note that this project was implemented as a part of course project for CS240H at Stanford. The implementation details can be found at http://www.scs.stanford.edu/16wi-cs240h/projects/sajanikar.pdf

     

     

  • Liked Shantanu Kumar
    keyboard_arrow_down

    Performance optimization with Code-as-data in Clojure

    Shantanu Kumar
    Shantanu Kumar
    schedule 7 months ago
    Sold Out!
    45 mins
    Talk
    Advanced

    Homoiconicity (code as data, data as code) is one of the hallmarks of Lisp. Clojure, a Lisp-1 language, has this wonderful feature too. In this talk I will discuss about performance optimization techniques that leverage homoiconicity.

    No discussion on performance optimization can happen without discussing performance benchmarking. In this talk I will show how to do comparative benchmarking while trying to find performance bottlenecks. I will then proceed to showing techniques on using Clojure's homoiconicity to optimize performance. I will also show how to discover latency breakup of any Clojure code in a waterfall-chart model using homoiconicity.

  • Liked Ankit Solanki
    keyboard_arrow_down

    Using F# in production: a retrospective

    Ankit Solanki
    Ankit Solanki
    schedule 6 months ago
    Sold Out!
    45 mins
    Experience Report
    Intermediate

    We (ClearTax) build a full product in F#, and it's been in production for two years now. This talk will cover our learnings from building this product – what we did well and what went wrong. We will discuss the joys and the challenges that come with using a functional language day-in and day-out.

    I want to share our journey, so the community can learn from our experiences and we can get feedback from the experts as well.

     

     

  • Liked Ravi Mohan
    keyboard_arrow_down

    Equational Reasoning - From Code To Math and Back Again

    Ravi Mohan
    Ravi Mohan
    schedule 7 months ago
    Sold Out!
    45 mins
    Talk
    Beginner

    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.

  • Liked Monika Kumar Jethani
    keyboard_arrow_down

    "Kotlin is the secret of my functional power", says Android

    Monika Kumar Jethani
    Monika Kumar Jethani
    schedule 8 months ago
    Sold Out!
    45 mins
    Demonstration
    Beginner

    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.

     

  • Liked 	Robert Virding
    keyboard_arrow_down

    Deep Dive into Erlang Ecosystem

    	Robert Virding
    Robert Virding
    schedule 6 months ago
    Sold Out!
    480 mins
    Workshop
    Beginner

    Full day hands-on workshop on building concurrent, fault-tolerant and scalable systems in Erlang/OTP in the Erlang Ecosystem. We will look at three languages in the Ecosystem, Erlang, Elixir and LFE, and show how they can all be used together when building systems.

Sorry, no proposals found under this section.