schedule Dec 15th 02:15 PM - 03:00 PM place Crystal 1 people 21 Interested

We write programs in a different language than we talk about them. "So we get a request, do the security mumble, pass it to the middleware that grabs ..."

Can we get closer to writing programs that describe the program's desired behavior? And why do such attempts always get poo-pooed by programmers?

This is a foofy cloud shaped drawings exploration of other ways to express software design intent, mostly by cheating.

 
2 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

Annie will maunder on about weird systems she's interested in and invite lots of audience participation. It'll be more a conversation than a lecture. If Annie runs short she'll pull out hand puppets.

Learning Outcome

Audience will come away troubled, asking if it all has to be done with code, and with some ideas for ways to avoid coding.

Target Audience

Bored Programmers

Prerequisite

Basic proficiency with Excel is assumed.

schedule Submitted 3 months ago

Comments Subscribe to Comments

comment Comment on this Submission

  • Liked Anne Ogborn
    keyboard_arrow_down

    Anne Ogborn - let over logic - What functional programming can learn from logic programming

    Anne Ogborn
    Anne Ogborn
    Chief Mad Scientist
    The Elgin Works
    schedule 3 months ago
    Sold Out!
    45 Mins
    Keynote
    Intermediate

    48 years after it's invention, logic programming remains a less frequently used paradigm.

    What can functional programming learn from logic programming?

    Unification and nondeterminism are powerful constructs not strictly relegated to logic programming. We'll look at unification, nondeterministic completion, probabilistic computation, and constraint propagation in functional contexts.

  • Liked Aaron W Hsu
    keyboard_arrow_down

    Aaron W Hsu - Does APL Need a Type System?

    Aaron W Hsu
    Aaron W Hsu
    Computer Scientist
    Indiana University
    schedule 3 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    APL is known for its concise problem-solving expressiveness, and it is used very successfully in places where high-quality and rapid iteration are requirements, not luxuries. Static Type Systems have had tremendous success throughout the computing industry, even receiving positive HCI usability studies that demonstrate their effectiveness on a number of metrics with mainstream and functionally-oriented programming languages. This success leads many programmers to take the value of type systems as a given, especially as mission-criticality and the age of a project increase. Therefore, it comes as a surprise to many, when learning about APL, that it has spent so long as an untyped, interpreted language in domains and use cases where traditional wisdom would suggest the need for a typed, compiled language.

    But APL is not like other languages, and its unique features and historical uses warrant a careful revisiting of the question of type systems. In this talk we will explore whether or not APL needs a type system, whether it would benefit from having one, what that might look like, and how the interaction between APL and type theory might inform the design and use of type systems in general.

  • Liked Anne Ogborn
    keyboard_arrow_down

    Anne Ogborn - Introduction to Logic Programming and SWI-Prolog

    Anne Ogborn
    Anne Ogborn
    Chief Mad Scientist
    The Elgin Works
    schedule 3 months 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 Tony Morris
    keyboard_arrow_down

    Tony Morris - Parametricity, Functional Programming, Types

    45 Mins
    Talk
    Intermediate

    In this talk, we define the principle of functional programming, then go into
    detail about what becomes possible by following this principle. In particular,
    parametricity (Wadler, 1989) and exploiting types in API design are an essential
    property of productive software teams, especially teams composed of volunteers
    as in open-source. This will be demonstrated.

    Some of our most important programming tools are neglected, often argued away
    under a false compromise. Why then, are functional programming and associated
    consequences such as parametricity so casually disregarded? Are they truly so
    unimportant? In this talk, these questions are answered thoroughly and without
    compromise.

    We will define the principle of functional programming, then go into
    detail about common problems to all of software development. We will build the
    case from ground up and finish with detailed practical demonstration of a
    solution to these problems. The audience should expect to walk away with a
    principled understanding and vocabulary of why functional programming and
    associated techniques have become necessary to software development.

  • Liked Michael Snoyman
    keyboard_arrow_down

    Michael Snoyman - Applied Haskell Workshop

    Michael Snoyman
    Michael Snoyman
    Vice President of Engineering
    FP Complete
    schedule 6 months 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 Luka Jacobowitz
    keyboard_arrow_down

    Luka Jacobowitz - Testing in the world of Functional Programming

    Luka Jacobowitz
    Luka Jacobowitz
    Software Engineer
    codecentric AG
    schedule 6 months ago
    Sold Out!
    45 Mins
    Demonstration
    Intermediate

    Testing is one of the most fundamental aspects of being a software developer. There are several movements and communities based on different methodologies with regards to testing such as TDD, BDD or design by contract. However, in the FP community testing is often not a large topic and is often glossed over. While it’s true that testing in functional programming tends to be less important, there should still be more resources on how to create tests that add actual value.

    This talks aims to provide exactly that, with good examples on how to leverage property based testing, refinement types and the most difficult part: figuring out how to test code that interacts with the outside world.

  • Liked Tony Morris
    keyboard_arrow_down

    Tony Morris - Let's Lens

    Tony Morris
    Tony Morris
    Sr. Software Engineer
    Queensland FP Lab, Data61
    schedule 4 months ago
    Sold Out!
    480 Mins
    Workshop
    Intermediate

    Let's Lens presents a series of exercises, in a similar format to the Data61 functional programming course material. The subject of the exercises is around the concept of lenses, initially proposed by Foster et al., to solve the view-update problem of relational databases.

    The theories around lenses have been advanced significantly in recent years, resulting in a library, implemented in Haskell, called lens.

    This workshop will take you through the basic definition of the lens data structure and its related structures such as traversals and prisms. Following this we implement some of the low-level lens library, then go on to discuss and solve a practical problem that uses all of these structures.

  • Liked Markus Hauck
    keyboard_arrow_down

    Markus Hauck - Free All The Things!

    Markus Hauck
    Markus Hauck
    IT Consultant
    codecentric AG
    schedule 6 months ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    Have you ever asked yourself why we only free monads? Turns out there are a lot of other structures that want to be liberated from the constraints of their existence! In this talk, we will investigate what other poor (algebraic) structures we can free from the dirty hands of imperative programmers. Our journey starts with the well-known free monads, but after that we will have a look at all the other interesting structures that can be freed and of course we will also look at what we can do with them.

  • Liked Brian McKenna
    keyboard_arrow_down

    Brian McKenna - Eta and Nix for shipping Haskell to Java environments

    Brian McKenna
    Brian McKenna
    Functional Programmer
    Atlassian
    schedule 3 months ago
    Sold Out!
    20 Mins
    Demonstration
    Beginner

    Eta compiles Haskell code to Java/JVM bytecode. It supplies a Foreign Function Interface for interoperating with Java code. Many existing Haskell libraries (e.g. lens, Servant, QuickCheck) are ported to Eta so it's possible to use them for many traditionally Java environments, including Amazon Lambda functions, Kinesis consumers and Spark jobs.

    The Nix expression language allows writing functions to specify builds. The Nix build tool takes these expressions and instantiates them into static build instructions. These instructions can then be realised and turned into outputs. At each step Nix' tooling provides a layer of purity.

    Using Eta and Nix together, we can use Haskell functions for applications and Nix functions for builds, then deploy them to Java environments!

  • Liked Emily Pillmore
    keyboard_arrow_down

    Emily Pillmore - Pact: An Open Source Language for Smart Contracts

    Emily Pillmore
    Emily Pillmore
    Haskell Engineer
    Kadena.io
    schedule 5 months ago
    Sold Out!
    45 Mins
    Demonstration
    Intermediate

    In this talk we'll discuss the design and implementation of a smart contract property verification tool for Pact.

    The revolutionary idea of putting computer programs in a blockchain to create smart contracts has opened up a whole new world of possibilities. But these programs have very different characteristics from other software. This talk explores these differences, some of the challenges that have been encountered, and then discusses how Kadena is solving these problems with its smart contract language Pact. We'll discuss the design and implementation of a smart contract property verification tool for Pact. We leverage these (lack of) features to build a system capable of proving many properties of contracts via the Z3 SMT solver. We'll also give examples of real bugs caught by the system.

  • Liked Aloïs Cochard
    keyboard_arrow_down

    Aloïs Cochard - The Magnum Opus

    45 Mins
    Talk
    Beginner

    From Ancient Egypt to the Middle Ages humanity lost it's way in the quest to find the philosopher's stone.

    While following the recent advance in machine learning one might think that we are running in that same quest again,
    only differences this time are that our philosopher's stone is deep learning and the promise is general artificial intelligence instead of immortality.

    The current machine learning ecosystem is mainly based on python and pretty much feels like alchemy,
    lot of trial and errors, lack of tooling and good engineering practices, ...

    Let's take a tour of the current ecosystem and see how can we do better and safer high performance machine learning using Haskell!