filter_list help_outline
  • Liked Bruce Tate
    keyboard_arrow_down

    Bruce Tate - Joy - Maintaining Passion for Programming

    Bruce Tate
    Bruce Tate
    Founder
    Groxio
    schedule 9 hours ago
    Sold Out!
    45 Mins
    Keynote
    Intermediate

    Many people in our industry are programmers because we're curious and passionate about coding. Each of us can remember latching onto a trivial programming problem and staying with it deep into the night. For far too many of us, that passion for programming fades under the slow, wilting heat of the day to day grind.

    In this talk, Bruce Tate, author of Seven Languages in Seven Weeks, takes a frank look at the grind and offers some practical advice on putting the "fun" back into "functions". We'll introduce some pragmatic ideas to get you excited about the journey again. We can't always dramatically change our circumstances, but we can often make small tweaks to how we approach problems.

    Come along. Enjoy the journey.

  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W Hsu - Programming Obesity: A Code Health Epidemic

    45 Mins
    Keynote
    Beginner

    Programs are getting fat. They're becoming slow. They're taking up more computing resources. They're getting harder to maintain and more complex from the ground up. Layer upon layer of sophistication is causing us to lose our ability to predict what software will do. Where's that bug? Why is everything going so slowly? Am I even using the right data structures? Where's that important point in the documentation again?

    What's happened to us? In this meta-dive into the nature of our approach to programming, we will explore some of the dangers of our current approaches to programming and the how/why of our current programming obesity problem. We will look at real case studies and see just how bad the situation can be.

    But we will also explore how we can battle these sources of obesity. In this passionate plea for code that we can gain control over again, we will look at examples of how we can return to a state of high-performance on all levels, from code size to code scalability. We will look at the principles that can help us to reach leaner, more efficient, more usable, less buggy code. We will hopefully find some light at the end of the tunnel, and how we can change our outlook on programming to push ourselves towards code that benefits not only ourselves, but also those that will come after us.

  • Liked Andrea Leopardi
    keyboard_arrow_down

    Andrea Leopardi - Software Librarians

    Andrea Leopardi
    Andrea Leopardi
    Core Team Member
    Elixir Lang
    schedule 1 month ago
    Sold Out!
    45 Mins
    Keynote
    Beginner

    Libraries are the building blocks of software. All applications I've worked with make heavy use of libraries. But who writes the libraries? In this talk, I want to share my perspective as a library author, and talk about library design, open source, extensibility, documentation, and people.

  • Liked Bruce Tate
    keyboard_arrow_down

    Bruce Tate - Coding LiveView

    Bruce Tate
    Bruce Tate
    Founder
    Groxio
    schedule 1 day ago
    Sold Out!
    45 Mins
    Demonstration
    Intermediate

    Startups and web developers take note. Phoenix LiveView is the revolutionary framework that allows rapid development of real-time web interactive applications without custom JavaScript. You read that right the first time, and the Elixir community is buzzing. So far, the performance numbers have been nothing short of earth-shattering.

    In this session, you’ll see how it all works. We will do some live coding to show you LiveView under the hood.

  • Liked Bruce Tate
    keyboard_arrow_down

    Bruce Tate - Designing Elixir Systems with OTP

    Bruce Tate
    Bruce Tate
    Founder
    Groxio
    schedule 1 day ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    You know how to code in Elixir; now learn to think in it. Learn to design libraries with intelligent layers that shape the right data structures, flow from one function into the next, and present the right APIs. Embrace the same OTP that’s kept our telephone systems reliable and fast for over 30 years. Move beyond understanding the OTP functions to knowing what’s happening under the hood, and why that matters. Using that knowledge, instinctively know how to design systems that deliver fast and resilient services to your users, all with an Elixir focus.

    Elixir is gaining mindshare as the programming language you can use to keep your software running forever, even in the face of unexpected errors and an ever-growing need to use more processors. This power comes from an effective programming language, an excellent foundation for concurrency and its inheritance of a battle-tested framework called the OTP.

    If you’re using frameworks like Phoenix or Nerves, you’re already experiencing the features that make Elixir an excellent language for today’s demands. This book shows you how to go beyond simple programming to designing, and that means building the right layers. Embrace those data structures that work best in functional programs and use them to build functions that perform and compose well, layer by layer, across processes. Test your code at the right place using the right techniques. Layer your code into pieces that are easy to understand and heal themselves when errors strike.

    Of all Elixir’s boons, the most important one is that it guides us to design our programs in a way to most benefit from the architecture that they run on. The experts do it and now you can learn to design programs that do the same.

  • Liked Anne Ogborn
    keyboard_arrow_down

    Anne Ogborn - Introduction to Logic Programming and SWI-Prolog

    Anne Ogborn
    Anne Ogborn
    Software Engineer
    Hasura.io
    schedule 3 weeks ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    As machine learning matures, it is becoming obvious that we need explainable solutions. As functional programming matures it becomes obvious that we need inference and nondeterminism. And linked open data demands reasoning. This all day workshop will introduce the logic programming paradigm, in which programs are expressed as a set of logical rules and executed by finding proofs of queries.

    SWI-Prolog is the most highly developed and widely used language for logic programming.

    The language, which has been in continuous use in academic research settings since it's invention in 1972, provides unparalleled power. Many problems which would be difficult to express in other languages are simple in SWI-Prolog. SWI-Prolog is a 'batteries included' modern language, ready for real world tasks like web development and process control.

    In this dynamic hands on workshop we'll learn the basics of SWI-Prolog, and look at some of the amazing things it can do.

  • Liked Michael Snoyman
    keyboard_arrow_down

    Michael Snoyman - Your first Haskell web app with WAI and Warp

    Michael Snoyman
    Michael Snoyman
    VP, Engineering
    FP Complete
    schedule 2 weeks ago
    Sold Out!
    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.

  • Liked Alexander Granin
    keyboard_arrow_down

    Alexander Granin - Hierarchical Free Monads and Software Design in Functional Programming

    Alexander Granin
    Alexander Granin
    Sr. Haskell Developer
    Juspay
    schedule 2 months ago
    Sold Out!
    45 Mins
    Talk
    Advanced

    Functional Programming is going through the same process of rethinking as Object Oriented Programming has passed already. FP today is not only something mystical, something barely applicable for day-to-day tasks, but rather a whole philosophy of building big, complex applications, with own tools, approaches and methodologies. We can see a lot of ideas about software design and architecture emerging from the FP community: talks, books, articles. We’re actively discussing Final Tagless, Free Monads, effect systems and other approaches, but it seems the theme not yet covered and we don’t know about possibilities we have.

    In this talk, I’ll tell you about the power of Free Monads in building complex applications in Haskell and PureScript. These applications will be satisfying the requirements like maintainability, testability, simplicity. You’ll know how to create a safe concurrent application state, how to divide the application into layers and how to keep the code sane. In fact, you can do the same with Final Tagless or extensible effects, but the approach with hierarchical Free Monads has some specific properties making it the best tool to separate concerns and create a very interesting eDSLs with different semantics.

    The talk is based on the ideas I’m describing in my book “Functional Design and Architecture”. I also gave several talks about this theme earlier (you can find all my talks here).

    I’ve used these ideas to build software for different companies, including Juspay (Bengaluru), Restaumatic (Poland), Enecuum (Hong Kong). We’ve created several interesting technologies that were not possible to make without Free Monads. Some of them are open sourced.

  • Liked Michael Snoyman
    keyboard_arrow_down

    Michael Snoyman - Applied Haskell Workshop

    Michael Snoyman
    Michael Snoyman
    VP, Engineering
    FP Complete
    schedule 2 weeks ago
    Sold Out!
    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.

  • Liked Tony Morris
    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.

  • Liked Tony Morris
    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").

  • Liked Tamizhvendan S
    keyboard_arrow_down

    Tamizhvendan S - Building an E-Commerce Marketplace Middleware in Clojure

    Tamizhvendan S
    Tamizhvendan S
    Lead Consultant
    Ajira
    schedule 3 weeks ago
    Sold Out!
    45 Mins
    Case Study
    Beginner

    Have you ever wondered how we can build a real-world, production-ready, end-to-end application using the functional programming principles? Immutability, Pure Functions and all other functional programming things sound good on paper but How can we build something useful by applying it?

    At Ajira, We recently built an e-commerce marketplace middleware in Clojure for a leading retail chain to sell their products on multiple e-commerce sites seamlessly. In this case study, we are going to build a minimal version of this project using which I will be sharing how we implemented it.

  • Liked Morten Kromberg
    keyboard_arrow_down

    Morten Kromberg - Delivering your APLs

    Morten Kromberg
    Morten Kromberg
    CTO
    Dyalog Ltd.
    schedule 3 weeks ago
    Sold Out!
    45 Mins
    Tutorial
    Beginner

    Most talks on APL at FunctionalConf have focused on the way array oriented programming allows you to quickly deliver concise and efficient solutions to problems with an analytical core. This talk will focus on the development environment, and follow the life of an APL code snippet from it's interactive discovery, via testing and debugging, through to delivery as a web service and a shared object, embedded into a solution implemented in Python.

  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W 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.

  • Liked Tony Morris
    keyboard_arrow_down

    Tony Morris - Introduction to Functional Programming using Haskell

    480 Mins
    Workshop
    Beginner

    We will be spending the day learning the fundamentals of Functional Programming (FP) using the Haskell programming language. The exercise material will be a condensed selection of the NICTA/course which is regularly held in Australia over three days.

    This one day session is targeted to experienced industry programmers who are looking to break into Functional Programming and develop the rudimentary skills and techniques that enable continued independent study. A refresher on Haskell syntax will be provided, however, it is highly recommended to practice with the syntax and development tools prior to obtain the best outcome for the day.

    You will be required to bring a suitable development machine (portable) for working through the exercises. You will also need to install Glasgow Haskell Compiler (http://www.haskell.org/ghc/) version 7.8 or higher on that machine prior to the day.

  • Liked Harald Schult Ulriksen
    keyboard_arrow_down

    Harald Schult Ulriksen - From C# monolith to functional actors with Orleans and F#

    45 Mins
    Talk
    Intermediate

    This is an experience talk from my work with NRK, the

    Norwegian Broadcasting Company, Norway's public broadcaster.

    Over the last 3-4 years we've taken the TV and radio streaming sites from a monolith to multiple

    domain based services. We'll look at how we've transitioned the from a pure object oriented development team to a function friendly organzation, how gorwing the organization forced us to work with Conways law, as well as a deep dive into the bounded context of personalization.

    Keeping track of user progress and favorite shows is the responsibility of Personalization domain, with high performance requirements and surprisingly

    complex business rules. With new business rules and changing architecture, Personalization was in dire need of work. Combining FSharp and its typesystem and immutability with Orleans, an open source Virtual Actor platform for distributed high-scale computing applications, provided us with functional programming with OO principles in a fast and scalable platform. I'll show why we chose this path, the benefits we gained going from C# to F# and some of the lessons learned building on an actor model.

  • Liked Harendra Kumar
    keyboard_arrow_down

    Harendra Kumar - Streamly: Declarative Concurrency and Dataflow Programming in Haskell

    45 Mins
    Talk
    Intermediate

    Overview: Streamly is a Haskell library for writing programs in a high level, declarative data flow programming paradigm. It provides a simple API, very close to standard Haskell lists. A program is expressed as a composition of data processing pipes, generally known as streams. Streams can be generated, merged, chained, mapped, zipped, and consumed concurrently – enabling a high level, declarative yet concurrent composition of programs. Programs can be concurrent or non-concurrent without any significant change. Concurrency is auto scaled based on consumption rate. Programmers do not have to be aware of threads, locking or synchronization to write scalable concurrent programs. Streamly provides C like performance, orders of magnitude better compared to existing streaming libraries.

    Motivation: Haskell has a beautiful abstraction capability. Haskell lists, several streaming and concurrency libraries are some examples of good programming abstractions. The problem is that concurrency is not handled elegantly and declaratively by these libraries. Moreover, the lack of good performance gives rise to special purpose performance centric libraries like text and bytestring creating more confusion. Streamly unifies, lists, streaming, concurrency, logic programming and reactive programming with unparalleled performance. We can finally have a unified string handling.

    Audience: Streamly is designed to express the full spectrum of programs. Do not think that if you are writing a small and simple program it may not be for you. It expresses a small program with the same efficiency, simplicity and elegance as a large scale concurrent application. It unifies many different aspects of special purpose libraries into a single yet simple framework. It is especially suitable for high performance and scalable backend data processing systems. If you use or plan to use any real time streaming or data flow programming frameworks including Apache Flink, Apache Spark or asynchronous/reactive programming frameworks like ReactiveX/RxJs then you may be interested in Streamly.

  • Liked Saurabh Nanda
    keyboard_arrow_down

    Saurabh Nanda - Getting property-based testing to work after struggling for 3 years

    Saurabh Nanda
    Saurabh Nanda
    Founder
    Vacation Labs
    schedule 2 weeks ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    I got excited about property-based testing after hearing John Hughes talk at Functional Conf 2016. I tried it that year with QuickCheck, but failed miserably (it almost derailed the entire project delivery). I cribbed about it in my talk at Functional Conf 2017. In 2018, Srihari's talk got me excited again. This time, I tried with Hedgehog, and got it to work!

    This talk is about this journey and its learnings. We'll talk about how Hedgehog was used to test [1]:

    • A Postgres backed task/job queue
    • A small Wai/Servant based webapp

    And no, we will not talk about the most common (and completely useless) example of reversing a list!

    [1] Both of these are part of an open-sourced task/job queue library.

  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W 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."

  • Liked Aditya Athalye
    keyboard_arrow_down

    Aditya Athalye - Dr. StrangePipes or: How I learned to stop worrying && "function" in Shell

    Aditya Athalye
    Aditya Athalye
    Programmer
    λ
    schedule 1 month ago
    Sold Out!
    90 Mins
    Workshop
    Intermediate

    What scares the Shell out of people?

    Artefacts of the long and idiosyncratic history of Unix.

    We have so many powerful, stable, widely-available Unix tools and standards, but also plenty of inconsistencies, variants, and arcane caveats; enough to help us... surprise... ourselves in creative new ways. See that cliff you're currently falling off? Yeah, someone went down that road when you were still eating chalk in kindergarten. (Or perhaps you fell off it once before, when I was eating chalk in kindergarten, but it was so long ago that you forgot you've been there done that :-))

    Worse, there's no adult supervision, only user manuals. Within Shell's neon-lit environs, one must learn to tread with care, creativity, and cool calculation.

    One must learn to accept the silent echo as reward for success.

    Why go to Shell at all?

    Several of us already get by just fine with a few memorised spells from Shell. That's not a bad way to live, but we miss out on tremendous everyday value that we can unlock with the Unix way.

    For there exists a vast no-man's land between memorised tricks and large scale "designed" solutions; wherein no single software tool can really solve all the problems we encounter.

    Yet, any modern *nix PC has all one needs to adequately and speedily tailor-make solutions for almost any problem we may encounter in the underserved no man's land.

    Solutions that we can use effectively until we truly hit the kind of scale problems or domain complexity that merit use of specialised tools.

    Unix nature is deeply Functional

    The Unix tools philosophy naturally leads to functional architectures that can scale almost effortlessly. And functional programmers could do worse than learn to exploit such power.

    I'll just leave you with Douglas McIlroy's answer to "Read a file of text, determine the n most frequently used words, and print out a sorted list of those words along with their frequencies.", as seen in More Shell, Less Egg:

    tr -cs A-Za-z '\n' |
    tr A-Z a-z |
    sort |
    uniq -c |
    sort -rn |
    sed ${1}q

    A purely functional, automatically buffered data processing pipeline, built with standard reusable parts, written in 1986, directly usable on today's computers.

    Imaginative Functional Programmers (aren't we all?!) will find striking parallels between the facilities, concepts, and design principles available in their $Langs, and their *nix environments.

    No surprise, because in the dreamy mists of time, the wise hackers of Unix lore, and SmallTalk lore, and APL lore, and Lisp lore, and Forth lore etc... were all different, but they were all together, too.