location_city Online schedule Mar 25th 02:00 - 02:20 PM IST place Zoom people 31 Interested

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)).

 
 

Outline/Structure of the Demonstration

Rapid-fire demoscene!

I will squeeze as many FizzBuzzes as I can into the time allotted!

Code will be available afterwards to play with!

Learning Outcome

Maybe you really really really learn FizzBuzz, finally forever, and get hired on the spot in your next job interview.

Target Audience

FizzBuzz n00bs and connoisserus alike

Prerequisites for Attendees

You may or may not know FizzBuzz. You may or may not know Clojure. And I certainly may or may not know what you're in for.

Video


schedule Submitted 8 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? 

    • 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 5 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.

    • 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.

    • Aaron Hsu
      keyboard_arrow_down

      Aaron Hsu - DSLs, Architecture, and Structural Design in APL, 3 ways.

      Aaron Hsu
      Aaron Hsu
      Computer Researcher
      Dyalog Ltd.
      schedule 9 months ago
      Sold Out!
      45 Mins
      Talk
      Intermediate

      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. 

    • 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.

    • Quy Dai Nhan Thai
      keyboard_arrow_down

      Quy Dai Nhan Thai / Christopher Anand / Curtis D'Alves - Build and solve type-safe optimization models

      45 Mins
      Demonstration
      Intermediate

      Mathematical optimization has vast applications, e.g., image processing, machine learning. It has a huge impact on the current state of computer science and software engineers.


      Solving optimization problems involves many challenges. First, we need to build and encode the models correctly. Second, almost all useful models are computationally expensive and we need to speed them up. Finally, we need to be able to feed the model to optimization solvers to get the final numerical results.

      Fortunately, we find that Haskell, with its powerful type system and abstraction power, is perfect for this type of problem.

      We introduce HashedExpression, a Haskell-embedded domain-specific language that allows us to build and solve optimization problems. It provides users with a type-safe, correct-by-construction interface that uses Haskell type-level programming to express constraints on correctness which the compiler uses to flag many modeling errors as type errors (at compile time).


      The library implements symbolic expressions with the "hash consing" technique to achieve common subexpression elimination. We will show how using monadic type class instances help us abstract away details of the underlying lookup table and implement symbolic reverse-mode differentiation on top of it.


      For high-performance purposes, we generate low-level C/C++ code for symbolic expressions and provide bindings to open-source optimization solvers such as Ipopt or L-BFGS-B.

    • Debasish Ghosh
      keyboard_arrow_down

      Debasish Ghosh - Functional Programming patterns for designing modular abstractions

      Debasish Ghosh
      Debasish Ghosh
      Principal Software Engineer
      LeadIQ
      schedule 5 months ago
      Sold Out!
      45 Mins
      Talk
      Intermediate

      The biggest power of functional programming comes from the ability to treat functions as first class objects and the power to compose them incrementally to evolve larger functions out of smaller ones. Designing such functions as referentially transparent enables us to treat functions in programming just like functions in mathematics - side-effects are carefully abstracted through “effects” and delayed till the algebra of our program gets submitted to the run time system.

       

      In this talk I will discuss a few idioms and patterns on how using the power of composition can lead to development of modular abstractions. Instead of committing to an implementation prematurely we can define abstractions that focus on “what” it does deferring the “how” part to later stages of the lifecycle. In functional programming terminology we call the “what” part the algebra of our abstraction, and the “how” part the interpreter. Decoupling the two is one of the basic recommendations in functional programming. 

       

      I will use Haskell and Scala for the examples. I will discuss common functionalities that we use everyday in programming our domain models like validations, database interactions, managing exceptions, talking to external services etc. and show how to use the power of typed functional programming to make them more compositional.

    • Aaron Hsu
      keyboard_arrow_down

      Aaron Hsu - Learning APL through Combinatoric Idioms

      Aaron Hsu
      Aaron Hsu
      Computer Researcher
      Dyalog Ltd.
      schedule 9 months ago
      Sold Out!
      90 Mins
      Tutorial
      Beginner

      After learning the basics of APL, the question is often, "What do I do next?" The intermediate process of learning how to write good APL can feel especially challenging to those who are not used to operating in a dataflow, array-oriented style. One valuable resource is the large number of APL Idioms available for use. These are often referenced as a kind of "standard library" of APL functionality, especially for more experienced APL programmers. Studying the idioms is often a source of new insights for APL programmers, but for the uninitiated, it can be unclear what exactly you should learn when looking at an Idiom. Many users mistakenly see Idioms as just a short implementation of what would be a library call in another language, and thus equate Idioms and Libraries as serving the same purpose. In this talk, we will discuss and explore three combinatorial idioms in detail, not only explaining how they work, the thought process behind them, and the lessons that you can learn from them, but also the meta-level question of how to go about extracting these lessons for yourself when reading idioms on your own. 

    help