Q & A Session With Functional Conf Speakers
During the conference you might have had questions that did not get answered, this is your opportunity to get them answered by our expert panel group
Outline/Structure of the Keynote
Q & A sessions in a fish-bowl style panel.
Target Audience
All
Video
schedule Submitted 2 years ago
People who liked this proposal, also liked:
-
keyboard_arrow_down
Naresh Jain / Andrea Leopardi / Bruce Tate / Mohammad Maqbool Alam / Nikhil More / Ravi Chandra Padmala / Sujatha Hemmady - Q & A Panel Discussion with Code Beam Lite India Speakers
Naresh JainFounderZnsioAndrea LeopardiCore Team MemberElixir LangBruce TateFounderGroxioMohammad Maqbool AlamSoftware DeveloperUnderjord ABNikhil MoreSr. EngineerVolansysRavi Chandra PadmalaPartnernilensoSujatha HemmadyTech LeadRedbusschedule 2 years ago
45 Mins
Talk
Beginner
During the Code Beam Lite conference you might have had questions that did not get answered, this is your opportunity to get them answered by our expert panel group
-
keyboard_arrow_down
Michael Snoyman - Your first Haskell web app with WAI and Warp
45 Mins
Tutorial
Beginner
Haskell's Web Application Interface (WAI- pronounced "why") provides an abstraction between web applications and web servers. This allows many different web frameworks (e.g., Yesod, Spock, and Servant) to share servers like Warp and middlewares.
Haskell's web frameworks offer a wide variety of feature sets, type-level and metaprogramming, and intended use cases. And for most use cases, I would recommend using an existing web framework, which will help you avoid common pitfalls and more quickly address common use cases.
But not today! In this tutorial, we're going to step through building a functioning web server using just the bare-bones WAI interface and Warp as a server. Familiarity with the basics of Haskell will be a plus, but this will be a talk open to all FP and Haskell skill levels.
-
keyboard_arrow_down
Michael Snoyman - Applied Haskell Workshop
480 Mins
Workshop
Intermediate
This full day workshop will focus on applying Haskell to normal, everyday programming. We'll be focusing on getting comfortable with common tasks, libraries, and paradigms, including:
- Understanding strictness, laziness, and evaluation
- Data structures
- Structuring applications
- Concurrency and mutability
- Library recommendations
By the end of the workshop, you should feel confident in working on production Haskell codebases. While we obviously cannot cover all topics in Haskell in one day, the goal is to empower attendees with sufficient knowledge to continue developing their Haskell skillset through writing real applications.
-
keyboard_arrow_down
Aaron Hsu - APL Training Wheels
45 Mins
Tutorial
Beginner
APL is getting a lot of attention lately due to its potential for very high performance portability and suitability for both rapid prototyping of complex solutions as well as deployment of complex algorithms to high-speed, modern parallel hardware. It has the potential to vastly improve the speed, scalability, and size of your code bases. But APL has a reputation as an intimidating language to learn.
In this back to the basics tutorial, we will explore the core of APL, and focus on those areas that usually trip up the beginner in learning APL. We will also walk you through how to approach an APL expression, how to reason about them, and how to read them efficiently. We will teach you the skills that the expert APLer has internalized, and how you can work through these skills externally and explicitly in a way that will help you to eventually internalize these critical skills in a way that makes you efficient at using APL on real world problems.
-
keyboard_arrow_down
Tony Morris - An Intuition for List Folds
45 Mins
Talk
Beginner
In this talk, we go back to first principles, defining and examining the definition for a cons list, then take a look at the ubiquitous right and left fold functions on a list.
The primary focus of this talk is to develop an intuition for how these functions work so that we can best decide when to apply them. Multiple programming languages will be used to help emphasise the independence of the gained intuition. This talk will generally be interactive with the audience as we solve problems and build confidence in our new knowledge.
Knowing how to apply the various list fold functions is a common question by the student of FP. This talk aims to provide a solid, reliable answer to this question. No prior understanding of list folds is necessary.
-
keyboard_arrow_down
Tony Morris - Zippers
45 Mins
Talk
Intermediate
The term zipper is a colloquial used to describe n-hole (most often, 1-hole) contexts. That is, a data structure that has a _hole_ or _pointer_ focused on a specific element with the ability to efficiently traverse to its neighbouring elements, providing an elegant solution for the need to efficiently traverse and _modify_ immutable data structures.
In this talk, we will look at examples of zippers for canonical data structures such as lists and other products and sums. We will then define comonads and see the relationship between zippers and comonads.
Most of this talk will be spent on the practical application of zippers in everyday programming. We will solve some simple problems using zippers. We will then contrast why we might use a zipper, compared to a lens.
Finally, for a fun and interesting observation, we will look at the algebraic structure of products and sums, then compute the derivative of these structures. Turns out, a derivative of a data structure is its zipper ("McBride, Conor, et al (2005). ∂ for Data: Differentiating Data Structures").
-
keyboard_arrow_down
Aaron Hsu / Morten Kromberg - APL Workshop Intensive
480 Mins
Workshop
Beginner
This is an intensive workshop for those who are interested in learning how to think, read, and write APL. It will help give you the tools, mental framework, and structure for doing things "the APL way." In this workshop, you will have the chance to spend intensive time thinking like an APL programmer. What makes it different? How does the code look at the end? What thought process do you go through to get there? Get a chance to play around with a wide array of problems and solving them "the APL way."
Taijiquan Classics say, "Four ounces deflects a thousand pounds."
APLers might say instead, "Fifty characters solve a thousand problems."
-
keyboard_arrow_down
Sujatha Hemmady - My journey with Erlang at Redbus
45 Mins
Talk
Beginner
Going from Java to Erlang is not hard if given proper support. This talk is about the roller coaster journey with Erlang to build a scalable, soft real-time transaction platform. If you are a Java developer struggling to understand and adapt to Erlang this talk is for you.
-
keyboard_arrow_down
Tamizhvendan S / Ravindra Jaju - JVM Language Interoperability
Tamizhvendan SLead ConsultantAjiraRavindra JajuSolutions ConsultantSahaj Softwareschedule 2 years ago
45 Mins
Demonstration
Beginner
Language interoperability is the capability of two different programming languages to natively interact as part of the same system. Interoperability is advantageous because different programming languages are optimized for specific tasks, and allowing them to communicate can create better systems.
Apart from the Java language, the most common or well-known JVM languages are:
- Scala, a statically-typed object-oriented and functional programming language
- Clojure, a modern, dynamic, and functional dialect of the Lisp programming language
- Kotlin, a statically-typed language
In this session, we'll demonstrate how your program can interop with different JVM languages.
-
keyboard_arrow_down
Anmol Sahoo - GADTs in OCaml
90 Mins
Tutorial
Intermediate
OCaml is a multi-paradigm programming language with a pragmatic mix of functional and imperative programming features. OCaml, which has been around since 1996, has grown to be a battle tested language, widely deployed and used in production systems. In this talk, we will look at the support for Generalized Algebraic Data Types (GADTs), a powerful generalization of the more mundane Algebraic Data Types (ADTs). We will start with an example of building an interpreter for a small language and add type safety through GADTs. We will then look at a few powerful type-safe design patterns that GADTs enable.
-
keyboard_arrow_down
Dhaval Dalal - Booting into FP
90 Mins
Tutorial
Beginner
This session is an whirlwind tour of the FP land and is primarily meant for developers wanting to embark on their functional programming journey. We will use Java to understand most of the concepts, however, where it falls short to explain certain concepts, we will use Scala or Groovy or Clojure or even Haskell to demonstrate it. Starting with the basics - introducing the concepts with examples, we will evolve our understanding to take the mystery out of the monads (hopefully!)