• Liked Morten Kromberg
    keyboard_arrow_down

    Array Oriented Functional Programming with Dyalog

    Morten Kromberg
    Morten Kromberg
    Roger Hui
    Roger Hui
    schedule 7 months ago
    Sold Out!
    480 mins
    Workshop
    Beginner

    Dyalog is a modern, array-first, multi-paradigm programming language, which supports functional, object-oriented and imperative programming based on an APL language kernel. During the morning and early afternoon, we will explore the fundamentals of functional programming in APL. At the end of the day, Dyalog CXO Morten Kromberg will round off with an application development session, showing how a simple application with a HTML5/JS front-end and a RESTful web service can be used to deliver the power of APL to end users, or as embeddable components for other application tools. The "hands on" sections of the workshop can be followed under Mac OS X, Linux, or Microsoft Windows.

  • Liked Bartosz Bąbol
    keyboard_arrow_down

    Magic at compile time. Metaprogramming in Scala

    Bartosz Bąbol
    Bartosz Bąbol
    schedule 8 months ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    Don't use metaprogramming! Don't use macros! You will often hear those statements. But metaprogramming or speaking more specific macros are heavily used in scala ecosystem. Almost every big project in functional or "reactive" technology stack uses them somewhere under the hood. What are macros? Why they are so controversial? What macros can offer to an engineer? Why they are useful? How they can minimize amount of boilerplate code? After answering those questions by showing small examples, we will start to develop library(or maybe better term will be DSL) for parsing XML.

    But there is something more I didn't mention. If you are familiar with Scala ecosystem and up to date with roadmap of new Scala versions, you should be aware that...MACROS ARE DEAD. So why bother? Because there is new, bright future of metaprogramming in Scala called Scala Meta. We will see that knowledge gained after learning macros will be helpful when we will learn new approach presented in Scala Meta.

  • Liked Aloïs Cochard
    keyboard_arrow_down

    Welcome to the Machines

    Aloïs Cochard
    Aloïs Cochard
    schedule 8 months ago
    Sold Out!
    45 mins
    Talk
    Intermediate

    The streaming of data in a purely functional language is a fascinating problem that have been extensively explored over the years.

    In this talk we'll first briefly outline historical solutions to the problem and discuss their advantages and disadvantages,
    we will then follow with a practical introduction to the great `machines` library from Edward Kmett.

    We will see how the library usage compare to other players in the ecosystem (pipes, conduit, ...),
    and walk through real world examples giving us a chance to write our own combinators and understand some of the internals.

  • Liked Pushkar Kulkarni
    keyboard_arrow_down

    Going Swiftly Functional

    Pushkar Kulkarni
    Pushkar Kulkarni
    Mamatha Busi
    Mamatha Busi
    schedule 8 months ago
    Sold Out!
    90 mins
    Tutorial
    Beginner

    Two years after its introduction, the Swift programming language finds itself at rank # 14 on the TIOBE index for July 2016. Some of the prime reasons for Swift’s meteoric rise are its carefully designed syntax and semantics - it borrows heavily from the best features of a wide range of languages. The syntax is intuitive and new Swift learners can often relate it to the language of their choice. Introduced primarily as a client-side language, Swift was open sourced in December 2015 via swift.org. Since then, there has been a community effort on extending its capabilities to the server side too. Swift is available on Linux today, and it is poised to become a language enabling end to end development - from mobile apps to server backends. 

    Swift falls in the category of “modern native languages” - like Rust and Go. These runtimes run code in bare metal, boosting performance. They are statically, strongly typed and with type-inference. This makes them safe. Their modern syntax also makes them expressive enough for high level abstractions like those seen in functional programming. They try to solve some of the tradeoffs that languages of the past battled with. On the other hand, functional programming has found new oxygen in the last couple of years when agile methodologies become as pervasive as multicore hardware . While we do have languages like Haskell that are purely functional and provide excellent support to express functional concepts, it is important to separate functional thinking away from the language. Functional programming is supported by most of the languages today because the returns of it in terms of expression, conciseness, readability, correctness and performance are unmatched. Swift is not a purely functional language. However, it provides syntactic and semantic support for functional programming to a large extent.

  • Liked Viral B. Shah
    keyboard_arrow_down

    Julia - A Lisp for Fast Number Crunching

    Viral B. Shah
    Viral B. Shah
    Shashi Gowda
    Shashi Gowda
    schedule 7 months ago
    Sold Out!
    90 mins
    Workshop
    Intermediate

    Julia is a programming language for data science and numerical computing. Julia is a high-level, high-performance dynamic language, it uses just-in-time compilation to provide fast machine code - dynamic code runs at about half the speed of C, and orders of magnitude faster than traditional numerical computing tools.

    Julia borrows two main ideas from Lisp lore:

    1. Multiple-dispatch: a method is identified by a name and the types of all of its arguments (traditional OOP only uses the type of a single argument) multiple-dispatch allows for a natural programming model suitable for mathematics and general purpose programming. Interestingly, the same feature is responsible for Julia's ability to generate really fast machine code.
    2. Macros: Julia has syntax that is familiar to users of other technical computing environments, however, Julia expressions are homoiconic -- Julia code can be represented as Julia data structures, and transformed from one form to another via hygienic macros. There are some very interesting uses of macros to create domain-specific languages for effective programming. 
  • Liked Morten Kromberg
    keyboard_arrow_down

    Notation for Parallel Thought

    Morten Kromberg
    Morten Kromberg
    schedule 8 months ago
    Sold Out!
    45 mins
    Talk
    Beginner

    Since the original APL\360 interpreter saw the light of day in 1966, a large part of the of primitive functions in APL (A Programming Language) implicitly map operations to all elements of array arguments (and arrays of numbers or characters are the only “types” available in the language). Over the decades, the parallelism at the core of the notation has been extended, to nested arrays in the 80’s and arrays of objects in the 00’s. In this decade, arrays of futures have been added to provide users of APL with the ability to express asynchronous – but deterministic -algorithms.

    This talk will introduce the most important parallel constructs available in current Dyalog APL, which (despite the name) essentially remains an executable mathematical notation.

  • Liked Naresha K
    keyboard_arrow_down

    Pure Functional Programming on JVM with Frege

    Naresha K
    Naresha K
    schedule 8 months ago
    Sold Out!
    45 mins
    Demonstration
    Beginner

    JVM is one of the most widely used platforms and has attracted several languages. Though functional programming support is available through several languages, developers targeting JVM do not have an option that combines static typing with pure functional programming. Frege tries to address this space by providing a Haskell implementation on JVM. It comes with a good support for Java interoperability too.

    I will be presenting this topic from the context of a developer targeting Java platform looking for pure functional programming options, not as a Haskell developer targeting JVM.

  • Liked Roger Hui
    keyboard_arrow_down

    A Tour (de Force) of APL in 16 Expressions

    Roger Hui
    Roger Hui
    schedule 11 months ago
    Sold Out!
    90 mins
    Workshop
    Beginner

    APL will be 50 years old in November 2016 (50 years from 1966-11-27 15.53.58, to be exact), and it remains unsurpassed in manifesting Kenneth E. Iverson’s five important characteristics of notation

    • ease of expression
    • suggestivity
    • subordination of detail
    • economy
    • amenability to proof

    These characteristics are demonstrated by working through 16 APL expressions. The material is approachable for beginners and yet thought-provoking for experts.

    One of the 16 expressions is a fast computation of the partition function without use of the Hardy-Ramanujan (1918) results.

     

  • Liked 	Brian McKenna
    keyboard_arrow_down

    PureScript Front-end Developement

    	Brian McKenna
    Brian McKenna
    schedule 7 months ago
    Sold Out!
    480 mins
    Workshop
    Beginner

    PureScript is a small, typed, functional programming language which compiles to JavaScript. Some of the goals are to require no runtime by compiling to minimal JavaScript and to provide a simple Foreign Function Interface to interact with existing JavaScript. PureScript has seen some commercial adoption and has many libraries available for writing functional web front-ends.

    This workshop will cover writing an interactive web application using PureScript. 

  • Liked Naresh Jain
    keyboard_arrow_down

    Blow Your Mind with Functional Programming Demos

    45 mins
    Keynote
    Beginner

    We've several conference attendees who would show how they've used Functional Programming to do something really awesome! If you are trying to convince other people to use Functional Programming, you should watch these demos and show them these demos.

  • Liked John Hughes
    keyboard_arrow_down

    Property Based Testing

    John Hughes
    John Hughes
    schedule 7 months ago
    Sold Out!
    480 mins
    Workshop
    Beginner

    Property-based testing is an approach that combines test case generation, automated test execution, and the first steps of diagnosis by automatically simplifying failing tests to minimal examples. When used well it seems almost like magic: you give a simple specification of how your code should behave, and in return a tool tells you your bugs. This workshop will introduce the basics of property-based testing, using Quviq's tool QuickCheck. The workshop will be very hands-on, so you will develop property-based tests for simple systems on your own laptop during the day.

    You will learn about properties (the specifications that we test), generators (used to generate test cases), and state machine models (used to specify stateful behaviour). You will be using Erlang to write tests, and testing code in both Erlang and C. Finally we'll dip into race-condition testing, which is something of a "killer app" for this approach.

Sorry, no proposals found under this section.