DSLs, Architecture, and Structural Design in APL, 3 ways.

location_city Online schedule Mar 26th 06:00 - 06:45 PM IST place Zoom people 53 Interested

Beginning functional and APL programmers often express confusion about how to structure large software projects or larger pieces of code. Both APL and FP have a tendency to highlight their low-level features and de-emphasize system architecture patterns. This can leave programmers with a strong sense of how to write a set of small functions, but with less confidence or skill in designing, recognizing, and implementing more cohesive implicit system architectures that hold these lower level functions together. System architectures serve as a method for constraining the overall design of a system to give direction and focus to lower level implementation requirements. Especially in APL, where system architecture is often best implemented implicitly, it behooves the programmer to understand the ramifications of architecture and to implement them in their own systems. This talk unpacks a number of these "architecture level" questions within the framework of the APL programming language by exploring the same topic through 3 different architectural approaches, each of which has a very distinct flavor, presentation, and impact on the resulting source code. Particular attention is paid to the question of domain-specific languages, their design, and how they can interact with APL as tools for architectural exploration and guidance in APL source trees. 

 
 

Outline/Structure of the Talk

(3m) System architecture in the context of FP and APL

(2m) 3 Different Architectures, 1 Problem

(5m) Things to think about with architectures: trade-offs, costs, and benefits

(10m) Approach 1: Embedded DSLs

(10m) Approach 2: Sequence-based enumeration for executable, complete, consistent, correct specification

(10m) Approach 3: Dataflow pipelines at large and small scale

(3m) How to Mix and Match

(2m) Conclusions, Advice

Learning Outcome

* Understand the interplay between language features and architecture

* Understand how different architectures affect concision, complexity, and scalability in various dimensions

* Understand better how to read code with an eye towards system structure rather than low-level detail; how to "think meta"

* Have confidence regarding how to grow and evolve a system architecture and maintain multiple architectures in a single codebase with minimal interference

Target Audience

Programmers and architects that understand low-level programming constructs, but want to gain insights into different high-level structures and backbones of their APL or Functionally-oriented programs.

Prerequisites for Attendees

Knowledge of APL is a plus, but not required to understand the talk. Beginning programmers may feel out of their depth, but those with core programming knowledge should be fine.

Slides


Video


schedule Submitted 9 months ago

Public Feedback


    • Francesco Cesarini
      keyboard_arrow_down

      Francesco Cesarini - Shape future of the Erlang Ecosystem

      20 Mins
      Keynote
      Beginner

      The Erlang Ecosystem Foundation's goal is to grow and support a diverse community, encouraging the continued development of technologies and open source projects based on and around Erlang, Elixir, other BEAM languages and their runtime. In this talk, we will discuss some of the challenges, success stories and plans of some of the most active work groups, let you know how you can get involved, contribute and help influence. 

    • Bruce Tate
      keyboard_arrow_down

      Bruce Tate / Francesco Cesarini - Navigating the loop in water, on land and in programming models

      45 Mins
      Keynote
      Intermediate

       Loops are among the most critical programming constructs. These features shape core ideas about programming in the Erlang ecosystem; from how languages work to how programming features interact with other code and the outside world. How systems scale and are resilient. They are also metaphors for the way we think, build things, and grow. In Erlang and Elixir, loops define servers that form reliable, fault tolerant and scalable services. This keynote will explore Elixir and Erlang's approach to concurrency with a nautical adventure called the Great Loop.

    • Naresh Jain
      keyboard_arrow_down

      Naresh Jain - Important Announcements and Updates

      Naresh Jain
      Naresh Jain
      Founder
      Znsio
      schedule 3 months ago
      Sold Out!
      15 Mins
      Keynote
      Beginner

      We'll go over important updates and announcements. If you've any questions about the conference, like how do I get the videos, etc. this session will help you answer all those questions. So don't miss it.

    • Naresh Jain
      keyboard_arrow_down

      Naresh Jain - Welcome and Conference Overview

      Naresh Jain
      Naresh Jain
      Founder
      Znsio
      schedule 3 months ago
      Sold Out!
      20 Mins
      Keynote
      Beginner

      Welcome Address and Functional Conf Overview. Here you will get al the important details you need about the conference. So don't miss it.

    • Richard Feldman
      keyboard_arrow_down

      Richard Feldman - The Essence of Functional Programming

      Richard Feldman
      Richard Feldman
      Head of Technology
      NoRedInk
      schedule 5 months ago
      Sold Out!
      45 Mins
      Keynote
      Beginner

      This talk dives into the origins of functional programming, going all the way back to where the term was first introduced, to see how it evolved over time into our modern understanding of what FP essentially involves.

    • Dean Wampler
      keyboard_arrow_down

      Dean Wampler - Lessons Learned from 15 Years of Scala in the Wild

      Dean Wampler
      Dean Wampler
      Director of Engineering
      IBM Research
      schedule 5 months ago
      Sold Out!
      45 Mins
      Keynote
      Advanced

      Scala 3 was introduced last year. It introduced significant changes to the language, many of which were motivated by the lessons learned from the past 15 or so years of actual use in many open-source and commercial applications.

      I'll explore these lessons and how Scala 3 addresses them. Many revolve around the pros and cons of implicits. Also, changes to the type system make it more "regular", robust, and expressive. Finally, the new, optional, and controversial "Python-like" syntax promotes even more brevity. It also acknowledges how influential and pervasive Python has become across our industry.

      But there are many practical areas where future work is required, many of which are larger than the scope of Scala itself. We still live in "dependency hell". We still use too many obsolete idioms that hide accidental complexity, rather than forcing us to fix it. What should we do about these issues? 

    • Bryan Hunter
      keyboard_arrow_down

      Bryan Hunter - Distributed Elixir (lessons from HCA Healthcare’s project Waterpark)

      Bryan Hunter
      Bryan Hunter
      Enterprise Fellow
      HCA Healthcare
      schedule 5 months ago
      Sold Out!
      45 Mins
      Keynote
      Intermediate

      At HCA Healthcare, we built Waterpark– a continuously available, geographically distributed, high velocity Enterprise Integration Platform. We built it from scratch in Elixir. Elixir and the ErlangVM are very powerful tools. Need to model millions of things? No problem. Need processes to self-heal when things break? No problem. Need to model millions of things that self heal on computers scattered across a continent? Hmmm… for that you’ve got some work to do, but in Elixir that work is very doable and fun. In this nuts-and-bolts session, we will discuss the distributed computing bits that are in-the-box with Elixir and what is missing. We will cover the missing bits that we built and “why”. Topics include: hashing functions, distributed process registries, the mailroom pattern, server topology, leader election, consensus, actor replication and recovery, and hot code loading. 

    • Michael Snoyman
      Michael Snoyman
      VP, Engineering
      FP Complete
      schedule 5 months ago
      Sold Out!
      45 Mins
      Talk
      Intermediate

      Many of us in the functional programming community believe that FP is a significant improvement over object oriented programming, arguably the dominant programming paradigm today. That of course begs the question: how did an inferior paradigm grab so much mindshare and market share and rise to prominence? I'm going to tell the story a bit differently, exploring a different take on the strengths of OOP, and how that affects those of us who advocate for functional programming.

    • Nikhil Barthwal
      keyboard_arrow_down

      Nikhil Barthwal - Implementing Event-Driven Microservices architecture in Functional language

      Nikhil Barthwal
      Nikhil Barthwal
      Sr. Software Engineer
      Facebook
      schedule 4 months ago
      Sold Out!
      45 Mins
      Tutorial
      Intermediate

      Web services are typically stateless entities, that need to operate at scale at large. Functional paradigm can be used to model these web services work and offer several benefits like scalability, productivity, and correctness. This talk describes how to implement Event-Driven Microservices in functional programming languages with examples in F#.

      Immutability allows infinite scalability as it eliminates the need to worry about a mutex, a lock, or a race. As functional code is much more terse compared to object-oriented code, it provides productivity benefits. Its strict typing makes writing correct code easy as mismatches of types are caught at compile time.

      The objective of the talk is to show how to create a scalable & highly distributed web service in F#, and demonstrate how various characteristics of functional paradigm captures the behavior of such services architecture very naturally.

    • 20 Mins
      Talk
      Beginner

      Some people even say names don't matter. While it is widely held that good naming is one of the most important aspects of programming, is there such a thing as an objectively good name?

      As part of a discussion of the philosophy of programming, we'll look at what are the real aims of naming things well, and what considerations we should have in mind when discussing them. We'll have a look at alternatives and what they bring that names do not.

    • Dave Yarwood
      keyboard_arrow_down

      Dave Yarwood - Clojure through the lens of music

      Dave Yarwood
      Dave Yarwood
      Senior Software Engineer
      Kevel
      schedule 4 months ago
      Sold Out!
      45 Mins
      Talk
      Intermediate

      You may be familiar with what map, filter, and reduce do. But have you ever heard how these functions sound?

      The Alda language is centered around the idea that music can be represented as data. alda-clj is a Clojure library that maps Clojure data structures to the music theory concepts in the Alda language, including notes and chords. The library serves as an interface that takes Clojure code as input and produces music as output.

      In addition to the basic functions that you will find in the standard libraries of most functional programming languages, Clojure's standard library offers a wealth of interesting and useful functions that facilitate working with immutable data. In this talk, we will explore the Clojure standard library by applying interesting functions like cycle, mapcat, partition and reductions to transform data that represents music. Using the alda-clj library, we will not only see the result of each function call, we will also hear the results and observe how they can help us understand how each function works.

    • Simon Thompson
      keyboard_arrow_down

      Simon Thompson - Language-independent refactorings through language-specific rewrites

      45 Mins
      Talk
      Intermediate

      Programming language may share much in common, but each language has its own particular syntactic and semantic features. For example, a function application in Haskell can be an operator section, while in Erlang it can be an application of the apply function. This talk presents generic, language-independent refactoring schemes that are realised in each language by a particular set of rewrites, and is illustrated by examples from Erlang, Haskell and OCaml.

    • Daniel Steinberg
      keyboard_arrow_down

      Daniel Steinberg - Stumbling over State

      Daniel Steinberg
      Daniel Steinberg
      Author
      dimsumthinking.com
      schedule 4 months ago
      Sold Out!
      45 Mins
      Tutorial
      Beginner

      We each follow similar paths into the forest of functional programming. Some languages are better suited than others but we all hit a wall on our way to mastering monads. In this talk, I'll use examples from the Swift programming language to trace our understanding from types  that feel like containers such as Array and Optional to types that definitely don’t such as Reader and State Monads. We’ll learn to perform many magic tricks along the way.

    • Tony Morris
      keyboard_arrow_down

      Tony Morris - Type-hole development

      Tony Morris
      Tony Morris
      Software Engineer
      Simple Machines
      schedule 4 months ago
      Sold Out!
      45 Mins
      Tutorial
      Intermediate

      In this presentation, we will see coding problems, similar to those which can be found at https://github.com/system-f/fp-course/ using the Haskell programming language.

      Solving problems such as these can be daunting for many reasons and especially for beginners. A common stumbling block to these types of problems is coming up against unfamiliar problem-solving methods. For example, everyone knows how to add up the numbers in a list with a for-loop. This is a well-understood method of solving this particular coding problem.

      And then you hear the functional programmers, "just use the types" and "well you just do the only obvious thing to solve it." While true, this is not particularly helpful to someone who is not already fluent with this approach to problem-solving.

      You may have heard of using type-holes to solve coding problems. We'll be using type-holes, and a few other techniques, with the Haskell programming language to live-solve coding problems. We will solve both trivial and not-so-trivial problems while "thinking out aloud." Feel free to follow along! You'll just need Glasgow Haskell Compiler (GHC) and a text editor installed.

    • Allister Beharry
      keyboard_arrow_down

      Allister Beharry - The Z3 SMT solver and functional programming

      Allister Beharry
      Allister Beharry
      Open-source developer
      Freelancer
      schedule 8 months ago
      Sold Out!
      45 Mins
      Demonstration
      Advanced

      Satisfiability modulo theories (SMT) solvers are extremely powerful tools that are indispensable in a number of applications of functional programming from mathematical analysis and optimization to computer security to program verification. SMT solvers allow you to determine if certain logical and mathematical formulas are satisfiable or (just as importantly) unsatisfiable in the context of theories like real arithmetic or set theory, and can provide definitive answers to commonly encountered programming problems involving logic, arithmetic, equations, and constraints.

      Z3 is one of the most popular SMT solvers available today with APIs available for many different programming languages. Although Z3 is most commonly used from Python, functional languages like F# provide powerful metaprogramming facilities that make it very easy to translate F# code and expressions to Z3 expressions without the need for custom types or operators.

      This presentation describes how the Z3 solver can be used from F# via quotations to quickly and easily solve common programming problems from Boolean formula satisfiability to arithmetic expression equality to linear programming to verifying fragments of source code.

    • Ben Evans
      keyboard_arrow_down

      Ben Evans - Do We Really Do FP in Java?

      Ben Evans
      Ben Evans
      Senior Principal Engineer
      Red Hat
      schedule 5 months ago
      Sold Out!
      45 Mins
      Talk
      Beginner

      Many Java developers believe that FP arrived in Java 8, with the addition of first-class lambda expressions and the Streams API. But is this really true? In this talk, Ben Evans will talk about what FP really is, examine whether Java can really be said to be FP or not - and consider whether things have improved with more recent versions, as well as some possibilities of how we could have done things differently (in another world).

    • Rodrigo Girão Serrão
      keyboard_arrow_down

      Rodrigo Girão Serrão - Why APL is a language worth knowing

      Rodrigo Girão Serrão
      Rodrigo Girão Serrão
      Consultant
      Dyalog Ltd.
      schedule 5 months ago
      Sold Out!
      45 Mins
      Talk
      Beginner

      “A language that doesn't affect the way you think about programming, is not worth knowing.” ― Alan Perlis, in “Epigrams in Programming”

      Following Alan Perlis's words, this talk will show why APL is a language worth knowing. In other words, I will devote the talk to showcasing characteristics of APL that are likely to, on the one hand, influence the way you use other programming languages, and, on the other hand, understand concepts of computer science.

      By listening to this talk, I hope to convince you that learning a language that is radically different from all the other languages you know isn't harmful. Learning a language that is radically different from all other languages you know won't scatter your knowledge or spread your brain too thin. In fact, learning a language that is radically different from all other languages you know will cement your programming  knowledge, helping you build bridges between topics you didn't even know were connected.

      To drive my point home, we take a closer look at two characteristics of APL: the fact that Boolean values are represented by the integers 0 and 1, and the fact that APL is an array-oriented language. In studying these two things, we draw connections to the traditional if statement and to list comprehensions, deepening our understanding of those.

    • Aditya Athalye
      keyboard_arrow_down

      Aditya Athalye - n ways to FizzBuzz in Clojure

      20 Mins
      Demonstration
      Beginner

      FizzBuzz is back in fashion! Everybody is doing it again (and again, and again). So I figured why should I miss out on the action?

      Why not use (and abuse) as many features as possible, of my favourite FP language Clojure, to FizzBuzz in as many ways as I can possibly muster?

      Why not up the ante by leaking the four other ways I discovered so far? And why not make it harder on myself by committing to spectacular public failure if I can't find more? Why. Not?!

      So here we are...

      (def range-of-fizzbuzzees (range 1 101))

      (def fizbuzz map)

      (= (fizzbuzz canonical-fizbuzzer
                   range-of-fizzbuzees)
         (fizzbuzz or-fizbuzzer
                   range-of-fizzbuzees)
         (fizzbuzz juxt-fizbuzzer
                   range-of-fizzbuzees)
         (fizzbuzz lookup-fizbuzzer
                   range-of-fizzbuzees)
         (fizzbuzz (fn [f n] (f n))
                   cyclical-fizbuzzer
                   range-of-fizzbuzees))

      The chase has begun! Who knows what will happen?

      (Edit: 2022-03-05: Well. What happened was demofail due to networkfail.

      But, Plan B is live... the blog post is up with even more detail than the talk (see also, links below)).

    • Dhananjay Nene
      keyboard_arrow_down

      Dhananjay Nene - Snippets from an algorithmic trading system in Kotlin

      45 Mins
      Talk
      Intermediate

      This talk will introduce the audience to algorithmic trading, the design of an algorithmic trading system, and various snippets written in Kotlin that fulfil specific tasks that collectively contribute towards a full trading system. The rough sketch will be as follows

    • Shakthi Kannan
      keyboard_arrow_down

      Shakthi Kannan - Fast and Curious: Benchmarking (Multicore) OCaml

      Shakthi Kannan
      Shakthi Kannan
      Senior Software Engineer
      Tarides
      schedule 8 months ago
      Sold Out!
      20 Mins
      Experience Report
      Beginner

      An oft overlooked aspect of programming language development process is benchmarking. While popular CI/CD tools such as Azure pipelines, Gitlab CI, Circle CI, Drone.io and Github Actions are regularly used for continuous testing and deployment, there is a dearth of such tools for continuous benchmarking. This is because benchmarking well is challenging due to the care needed to choose appropriate benchmarks, the complexity of modern OSes and hardware that makes it hard to obtain reproducible results, and a powerful dashboard needed to surface resultant metrics in a useful manner that can be explored interactively by the developer.

      For benchmarking the compiler of the OCaml [1] programming language, we have developed Sandmark [2]. Sandmark is a (a) suite of well chosen benchmarks aimed at exercising different performance axes including CPU, memory and IO (b) a tool to run the benchmarks, building the compiler and its dependencies under varying configuration settings and (c) a dashboard [3] to interactively explore the results of the benchmark runs. Sandmark was originally developed for supporting the Multicore OCaml [4] project, which aims to add native support for concurrency and parallelism to OCaml, and has undergone significant improvements since the initial release [5]. 

      We have learnt several useful lessons in building a continuous benchmarking infrastructure that we would like to share in this talk, which may benefit developers who work on projects where performance is critical. In this talk, I will describe the Sandmark tool, illustrate the quirks of modern OSes and hardware and how we overcame them, highlighting useful takeaways for setting up continuous benchmarking for your own projects.

      References:

      [1] OCaml: https://ocaml.org/
      [2] Sandmark: https://github.com/ocaml-bench/sandmark
      [3] sandmark-nightly: https://github.com/ocaml-bench/sandmark-nightly
      [4] Multicore OCaml: https://github.com/ocaml-multicore/ocaml-multicore/
      [5] Tom Kelly. Benchmarking the OCaml compiler: our experience, OCaml Workshop 2019, https://icfp19.sigplan.org/details/ocaml-2019-papers/3/Benchmarking-the-OCaml-compiler-our-experience

    help