Application configuration and initialization are tangential to delivering business value, yet we frequently get bogged down by their incidental complexity. They crosscut various (Dev/QA/Prod etc.) environments and impact the workflow in subtle, disparate ways. In this session, I will discuss the experience of tackling this beast for several projects in a large team using an elegant functional programming approach. The approach was turned into a data-driven Clojure framework for applications to use. This success story is over two years old in production and it scales from a junior developer looking to learn the ropes to experienced folks focusing on advanced use cases. I will discuss the fundamentals of this approach, how it is used in production, in QA, and in development. I will also share the REPL-enabled development workflow and how it facilitates automated unit and integration testing.

 
 

Outline/Structure of the Talk

The outline is as follows:

  • Why libraries are not enough
  • Config files (sources, defaults, overrides)
  • Application initialization as a workflow
  • Modular, extensible, configurable initialization
  • Entry points (CLI, Tests, Explicit vs implicit config, REPL, Maintenance tasks)

Learning Outcome

Attendee would learn the following:

  • Application bootstrapping/initialization as a first class concern
  • Various subtle aspects of application initialization
  • Deal with application configuration
    • Configuration chaining
    • Defaults and overrides
    • Shipping configuration with application
  • Deal with application initialization
    • Functional approach
    • Similarity with Finite Automata
    • Repeatable across applications
    • Extensible workflow
  • Reduce incidental complexity in application development

 

Target Audience

Those familiar with basic Functional Programming principles

Prerequisites for Attendees

Attendees should have some familiarity with functional programming. Knowledge of the Clojure programming language would be greatly beneficial to make the most out of the session.

schedule Submitted 6 years ago

  • Manuel Chakravarty
    keyboard_arrow_down

    Manuel Chakravarty - Haskell SpriteKit - a Purely Functional API for a Stateful Animation System and Physics Engine

    45 Mins
    Demonstration
    Intermediate

    Graphics, animation, and games programming in Haskell faces a dilemma. We can either use existing frameworks with their highly imperative APIs (such as OpenGL, Cocos2D, or SpriteKit) or we waste a lot of energy trying to re-engineer those rather complex systems from scratch. Or, maybe, we can escape the dilemma. Instead of a Haskell program directly manipulating the mutable object-graph of existing high-level frameworks, we provide an API for purely functional transformations of a Haskell data structure, together with an adaptation layer that transcribes those transformations into edits of the mutable object-graph.

    I this talk, I will explain how I used this approach to architect a Haskell binding to the animation system and physics engine of Apple’s SpriteKit framework. I will discuss both how the binding is structured and how it achieves the translation of Haskell side changes to SpriteKit and vice versa, such that it is sufficiently efficient. Moreover, I will demonstrate by example how to use the Haskell library to implement a simple game.

  • Tony Morris
    keyboard_arrow_down

    Tony Morris - Functional Programming in Aviation

    Tony Morris
    Tony Morris
    Software Engineer
    Simple Machines
    schedule 6 years ago
    Sold Out!
    45 Mins
    Case Study
    Beginner

    In this talk & demo, we have a look at some of the low-hanging problems in general aviation and how functional programming can be applied to provide significant improvements in efficiency and air safety. The current solutions to problems such as navigation, traffic/terrain collision avoidance and weight/balance calculations will be demonstrated to the audience, mostly for amusement. More seriously, we will have a look at the legacy that has led to the way things are, and how to improve by applying our programming skills.

    We will look at:

    • how aviation safety is regulated.
    • how aeronautical services are provided to flight operators.
    • how aeronautical navigation is conducted and regulated.
    • how the weight and balance for a flight is conducted.
    • the methods by which aircraft and ground coordinate between each other.

    We will see:

    • some real (and basic) data management problems in aviation, that very obviously threaten safety, then solve them, using programming.
    • we will see a live demonstration of aeronautical navigation methods, investigate incident reports where lives were lost as a result, and consider how our programming skills can yield improvements, possibly even save lives.
    • we will conduct a real weight&balance calculation for a flight, then once hilarity inevitably ensues, we will look at the problems that arise by this method, then solve them using data structures and functional programming. Some
      of these practical problems are obvious, even to a non-aviator, and the predictable incident reports are the end result.
    • finally, we will have a look at a live demonstration of a software defined radio (SDR), receiving ADS-B transmissions from aircraft (live), an AHRS implementation and GNSS receiver using off-the-shelf, low-cost parts. We will look at why these instruments are helpful to aircraft pilots and interact with that device using the Haskell programming language.
  • Roger Hui
    keyboard_arrow_down

    Roger Hui - Tests, Derivations, Proofs

    Roger Hui
    Roger Hui
    programmer
    Dyalog Ltd.
    schedule 6 years ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    John Hughes and Mary Sheeran in Why Functional Programming Matters [0] list “algebra as a litmus test” as one of the four salient features of functional programming, and Ken Iverson in Notation as a Tool of Thought [1] lists “amenability to formal proof” as one of the five important characteristics of notation. Using the language APL, we prove the correctness of some programs, derive simplifications, and illustrate design validation and program test techniques for functional programs.

    [0] Hughes, John, and Mary Sheeran, Why Functional Programming Matters, Code Mesh, London, 2015-11-02 to -04.

    [1] Iverson, Kenneth E., Notation as a Tool of Thought, Communications of the ACM, volume 23, number 8, 1980-08.

  • Aloïs Cochard
    keyboard_arrow_down

    Aloïs Cochard / 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.

  • Ravi Mohan
    keyboard_arrow_down

    Ravi Mohan - Predator: A Framework for Developing Programmatic Players for Complex Board Games

    Ravi Mohan
    Ravi Mohan
    CEO
    AxiomChoice
    schedule 6 years ago
    Sold Out!
    45 Mins
    Experience Report
    Beginner

    Summary: An Experience Report on How a very time constrained Haskeller learned Erlang and PureScript "in small pieces" to create programmatic opponents aka 'bots' for complex boardgames

    Every experience report tells a story - the story of a project, unvarnished and without artifice, programmer to programmer, out of the sight and hearing of the manager folks, often involving one or more of comedy, tragedy, farce etc. This report is no exception.

    I have a fulltime 'dayjob' and my standard 'language toolkit' is Haskell + C + Lua. My co-founder is a bit of an Erlang maniac, and challenged me to learn Erlang and actually building something in it and *then* go on about the superiority of Haskell.

    This is the story of my response to the challenge and how I learned and coded Erlang/Elixir in very small chunks of time (about 10 - 20 )minutes a day max) and attacked an interesting problem. This severe time constraint (and lack of any previous knowledge of Erlang) shaped the nature of the (still evolving) system.

    The problem:

    The number of boardgames that you can whip out at a gathering and expect people to want play is very small.. Monopoly, Snakes and Ladders, and maybe, if you are *very* lucky, Settlers of Catan. And that's about it.


    Getting people to play these games is relatively easy.

    However the world of boardgames is *much* wider.

    There are literally tens of thousands of boardgames that simulate everything from very abstract geometry puzzles to ones that simulate complex economies and political situations.

    Some of the latter are used in very unexpected ways, e.g to train spies and military officers.

    Here is an example of an interesting game.

    A Distant Plain (by GMT Games) is a boardgame for 4 players that put them in the roles of the US military forces, the Afghan government, the Taliban, and Warlords/drug dealers, all competing for power in Afghanistan.

    ADP

    adpcards

    Here is another
    The War of the Ring, a game for 2 players.

    "In War of the Ring, one player takes control of the Free Peoples (FP), the other player controls Shadow Armies (SA). Initially, the Free People Nations are reluctant to take arms against Sauron, so they must be attacked by Sauron or persuaded by Gandalf or other Companions, before they start to fight properly ...."

    WarOfRings1

    And one more

    "The battle of Sekigahara, fought in 1600 at a crossroads in Japan, unified that nation under the Tokugawa family for more than 250 years.

    Sekigahara allows you to re-contest that war as Ishida Mitsunari, defender of a child heir, or Tokugawa Ieyasu, Japan's most powerful daimyo (feudal lord)."

    ."

    What these games have in common
    1. They are wonderful games, immersing you into their respective worlds.
    2. They have (relative to Snakes and Ladders or Monopoly) complex rulesets, which take effort and time to master.
    3. They are rarely played in India.
    4. Even when people own them, opponents are almost impossible to find and schedule.

    Which means that if you own these games and live in India, getting to actually play these games is close to impossible.

    Which is a problem.

    The (incomplete, but ongoing) solution

    Being a programmer, I solve this problem by writing programmatic opponents (aka 'bots') to take the place of other players. This involves all kinds of interesting sub problems - game representation, logic processing for rules, building AI 'smarts' for your opponents, gui and event handling etc.

    Since I am doing this in my non existent spare time, and this being a response to an Erlang user's challenge, I learned (am sill learning) Erlang and Elixir (and some minimal PureScript), and built ( am still building) the system at the same time..

    This talk is about the many challenges I faced in building automated game players (and extracting common frameworks/libraries) from them, while simultaneously learning two FP languages.

    Since this is an experience report, it is basically a highly subjective list of lessons learned, victories *and defeats*, what worked *and more importantly what didn't work*.

    If you can't use FP at work, but are considering doing so on a personal project, or want to learn how to get going on an FP learning effort, you might benefit from my experience - both successes and failures. I also talk about how to go about learning Erlang/Elixir in the shortest possible time.

  • Cameron Price
    keyboard_arrow_down

    Cameron Price - Making it Fast: The Power of Benchmarking

    Cameron Price
    Cameron Price
    CTO
    TRX.tv
    schedule 6 years ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    There's an old expression, usually attributed to Kent Beck, that we should "Make it work, make it right, make it fast", in that order. This talk is going to focus on making it fast.

    Not long ago, I was working on a little problem in Elixir that involved a two dimensional array. Now, Elixir doesn't really have arrays, it has lists, maps, tuples, and binaries, so the one thing we can be sure about when implementing a 2-d array is that we're going to be simulating it using something else. What I discovered was surprising, and served as an important lesson about actually benchmarking things.

    In this talk, we'll discuss the importance of benchmarking, demonstrate some tools that make benchmarking in Elixir very simple, and show you some surprising results about which approaches are faster in this language.

  • Manoj Govindan
    keyboard_arrow_down

    Manoj Govindan - Learning Computer Architecture

    Manoj Govindan
    Manoj Govindan
    Director, Engineering
    Perfios
    schedule 6 years ago
    Sold Out!
    45 Mins
    Experience Report
    Intermediate

    Computer Architecture begins with electronics. As computers are built layer upon layer starting with primitive gates baked into silicon, followed by chips and logic gates, hardware platform including ALU, RAM, cache etc., and so on, so is the study of computer architecture a study of each of these layers of abstraction.

    Students of computer architecture usually rely on simulators, often written in Java or similar imperative/object oriented languages, to aid their learning. Here are some examples of such a program:

    Simulating XOR gate

    As an Erlang/functional programming enthusiast studying computer architecture I decided to write my own equivalent tools in Erlang and TypeScript as I went about my learning. I am studying computer architecture and simultaneously writing the required simulators and other tooling in Erlang and TypeScript.

    Building such emulators and tools in Erlang and Typescript results in distinctly different architectures. I'll be demoing the simulator I built and talking about lessons learned doing this.

  • Abhiroop Sarkar
    keyboard_arrow_down

    Abhiroop Sarkar - Wormholes and teleporting with Transient.

    45 Mins
    Talk
    Intermediate

    The transient library in Haskell/Eta composes arbitrary pieces of software in concurrent, parallel and sequential settings using standard Haskell/Eta combinators like applicative, alternative, bind etc. It provides algebraic and monadically composable primitives for concurrency, parallelism, event handling, transactions and multithreading

    It liberates the programmers from dealing with state machines, objects frameworks, routes, configurations and callbacks. Transient expresses business functionalities as compact category theoretical expressions which compose. These compositions are verified during compilation, although the code might be executing in different machines.

    It presents a fresh new approach to programming concurrent and distributed systems.

     

help