location_city Bengaluru schedule Oct 14th 02:00 - 02:45 PM place Grand Ball Room 2 people 7 Interested

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.  

 
 

Outline/Structure of the Experience Report

  1. Motivation behind GHCVM
  2. Overview of the Core & STG intermediate languages 
  3. Architecture of the GHCVM Code Generator
  4. Architecture of the GHCVM Runtime System
  5. Execution of a Simple Program
  6. Interoperation with Java

Learning Outcome

1. Be able to understand Core and STG dumps from GHC(VM).

2. Be able to analyze the performance of Haskell programs.

3. Be able to understand how GHCVM maps GHC concepts to the JVM.

Target Audience

Haskell programmers interested in the internals of GHC(VM)

schedule Submitted 4 years ago

Public Feedback


    • John Hughes
      keyboard_arrow_down

      John Hughes - Why Functional Programming Matters

      John Hughes
      John Hughes
      Creator
      QuickCheck
      schedule 4 years ago
      Sold Out!
      45 Mins
      Keynote
      Beginner

      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.

    • Aloïs Cochard
      keyboard_arrow_down

      Aloïs Cochard - Welcome to the Machines

      45 Mins
      Talk
      Intermediate

      The streaming of data in a purely functional language is a fascinating problem that have been extensively explored over the years.

      In this talk we'll first briefly outline historical solutions to the problem and discuss their advantages and disadvantages,
      we will then follow with a practical introduction to the great `machines` library from Edward Kmett.

      We will see how the library usage compare to other players in the ecosystem (pipes, conduit, ...),
      and walk through real world examples giving us a chance to write our own combinators and understand some of the internals.

    • Shantanu Kumar
      keyboard_arrow_down

      Shantanu Kumar - Performance optimization with Code-as-data in Clojure

      Shantanu Kumar
      Shantanu Kumar
      Principal Engineer
      Concur
      schedule 4 years 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.

    • Debasish Ghosh
      keyboard_arrow_down

      Debasish Ghosh - An algebraic approach to functional domain modeling

      45 Mins
      Talk
      Intermediate

      Domain modeling is usually implemented using OO design. In this approach of "nouns-first" we design object hierarchies using subtyping to model the various elements of the domain. In this talk we will take a different approach using Scala:

      1. Start with focus on verbs first
      2. Think how we can model domain behaviors using pure functions grouped within extensible modules
      3. Use an algebraic approach towards evolution of modules,the algebra being composed of functions,types & laws
      4. See how the domain algebra can be constructed from categorical structures like monoids, functors & monads
      5. Discuss how the functional patterns lead to compositionality - an extremely important quality that scales your domain model.

    • Yogesh Sajanikar
      keyboard_arrow_down

      Yogesh Sajanikar - Implementing Spark like system in Haskell

      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

       

       

    • Abdulsattar Mohammed
      keyboard_arrow_down

      Abdulsattar Mohammed - Dependently Typed Programming with Idris

      45 Mins
      Talk
      Intermediate

      Types allow us to structure data to match the functional requirements of the problem we are trying to solve. But, in most languages, we end up choosing/building types that are the closest to our requirement. They don't exactly fit our bill, as a result of which, we write runtime code to enforce those conditions. Then we write tests because the compiler can't help us. Dependently Typed Languages like Idris allow us to encode a wide range of invariants into the type itself allowing us to possibly have zero runtime errors.

    • Ravi Mohan
      keyboard_arrow_down

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

      Ravi Mohan
      Ravi Mohan
      CEO
      AxiomChoice
      schedule 4 years 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.

    • Shakthi Kannan
      keyboard_arrow_down

      Shakthi Kannan - A World of Emacs

      Shakthi Kannan
      Shakthi Kannan
      DevOps Engineer
      Consultant
      schedule 4 years ago
      Sold Out!
      45 Mins
      Demonstration
      Beginner

      GNU Emacs is a popular text editor for functional programming (Clojure, Haskell, Idris et. al.). This talk provides a demonstration of using GNU Emacs as part of your daily workflow. The different topics that will be addressed include project and time management, development, IRC, DevOps, managing secret files, e-mail, listening to music, reading news feeds, blogging, book publishing, etc. Emacs Lisp code snippets will be shared to demonstrate the setup and customization. The ~/.emacs.d configuration is available at:

      https://github.com/shakthimaan/cask-dot-emacs

    • Shantanu Kumar
      keyboard_arrow_down

      Shantanu Kumar - Dependency Injection Made Easy with Clojure

      Shantanu Kumar
      Shantanu Kumar
      Principal Engineer
      Concur
      schedule 4 years ago
      Sold Out!
      45 Mins
      Talk
      Intermediate

      Dependency inversion is an architectural cornerstone of well implemented Clojure applications. However, many Clojure applications start out with an ad-hoc, poorly abstracted initialization model - since application initialization needs to include dependency inversion in most cases, the latter is often omitted or not given the due attention it deserves.

      Not treating dependency inversion as a first class concern has devastating consequences on testability (hence robustness), comprehension and maintainability of code, and causes a vicious circle of broken-windows effect.

      In this talk I will go into the details of why and how such things happen, and how one can avoid those. I will discuss dependency injection as a flavour of dependency inversion and as a practical solution to achieve cleaner application design. I will illustrate the use of dependency injection mechanism through code examples and will share my experience of using the mechanism in real world projects.