lambda world 2017

Recursos de programación de lambda world 2017
Everything you didn’t want to know about monad transformer state was a presentation given as part of Lambda World 2017 by Michael Snoyman. Follow: - - - Visit: - for more details ___ Monad transformers are often used in Haskell applications to model state, capture results, and deal with explicit exceptions. In order to make these monad transformer stacks work with concurrency primitives, runtime exceptions, and more, we'll often use libraries like lifted-base, lifted-async, monad-control, and exceptions. But contrary to the expectations of many, surprising things can happen with the implicit state of our transformers. This talk will explain the problem, demonstrate where surprising behavior pops up, and recommend ways to structure your libraries and applications to sidestep the issue entirely.
This presentation was given as part of Lambda World 2017 by Raul Raja and Paco Estevez. Follow: - - - - Visit: - for more details - ___ Kategory is a library that started as a port of Typelevel Scala cats for the Kotlin Programming Language and is now evolving to bring the best of typed FP to Kotlin. This talk will cover some of the main datatypes and abstractions that make typed Functional Programming in Kotlin Possible. Kategory features techniques such as monadic comprehensions, laws, cartesian builders, emulated higher kinds, free monads, and global typeclass instances for the increasingly popular Kotlin programming language. Raul and Paco will discuss some pragmatic applications of Kategory and some of the different styles you can adopt when working with typed FP in Kotlin including transformers, tagless final, and free algebras.
This presentation was given as part of Lambda World 2017 by Alejandro Serrano. Follow: - - - Visit: - for more details ___ In functional programming we often use phrases starting with 'higher'. Each higher thingy generalizes the notion of thingy, allowing more abstractions and thus more code reuse. In this talk we shall look at three different 'higher's: Higher-order functions, which gives us the power of treating a function from values to values as yet another value. From simple functional patterns such as map and folds, to more complex ones such as catamorphisms, all rely on this secret sauce. Higher-kinded types, which gives us the power of speaking of a type constructor, such as List, in the same way as we talk of a ground type such as List. Talking about functors and monads intrinsically uses this ability from our languages. Higher-rank (and impredicative) polymorphism, which gives us the power of using quantification anywhere in our types. As crazy as it sounds, higher-rank types are basic to model lenses in a nice way.
This presentation was given as part of Lambda World 2017 by Daniela Sfregola. Follow: - - - Visit: - for more details. ___ Category Theory has become one of the hot topics in the community. Why is this theory suddenly so interesting for developers? Why are the cool kids talking so much about it? This talk will introduce the general principles of Category Theory in a pragmatic, non-mathematical way. We will show practical examples of how this theory has managed to simplify and solve common challenges that we encounter in our code daily, such as nullable values, error handling, parallel and sequential operations and data validation. Also, we will apply them to create our own category theory library from scratch using Scala and ScalaCheck as the only dependency.
This presentation was part of Lambda World 2017 given by Jarek Ratajski. Follow: - - - Visit: - for more details. ___ You all use lambda expressions. But what does it mean... Lambda? This talk will be about the story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Scala. And of course, you can later impress your friends with some impressive math tricks. There are going to be some very crazy code pieces shown such as a perfectly unusable implementation of boolean (based on lambda expressions). Come and see what purely functional really means.
This presentation was a part of Lambda World 2017 by Yulia Startsev. Follow: - - Visit: - for more details. --- Functional programming has become popular for building robust, complex UIs. Using React and Redux, for example, alleviates many of the issues commonly found in UI programming. In particular, making changes in state clear and predictable rather than the mess found in earlier solutions. However, there are some problems which continue to be painful. Asynchronicity is one such example, since changes to state which are asynchronous are difficult to predict and reason about. In the Firefox debugger, we have explored two options within the react ecosystem for dealing with this: thunk args and sagas. They take two different approaches to the problem of communicating with an async resource and updating the state. Using a recent refactoring of debugger breakpoints as a case study, we will explore the strengths and weaknesses of each. In the process, we will clarify the rationale behind the patterns and show how we came to our chosen solution. While the talk will be focused on the issue from a front-end/UI perspective, it might prove an interesting inspiration for similar problems in other places!
An overview of the Lambda World 2017 in Cádiz, Spain. The event featured over 450 attendees, 31 speakers, 18 talks, 7 workshops, 2 unconferences, a Scala Center Spree, and networking events. Visit: https://www.47deg/events for more information and follow us at and Special thanks to Gold Sponsors: Signify Technology Accenture Technology Microsoft Intelygenz RavenPack Everis
The full title of this presentation is What's Next? (A Friendly Guide To Choosing Your Next Programming Language). This talk was part of Lambda World 2017 and was given by Andrea Magnorsky. Follow: - - - Visit: - for more details. ___ It's an interesting time in a programmer's life when they decide to switch languages. Let's tour the existing programming paradigms and how they help in problem-solving as well as how science generally evolves to try to find an answer to that question.
This presentation was the closing keynote at Lambda World 2017 by Jeremy Gibbons. Follow: - - - Visit: - for more details. ___ Much of the expressive power of array-oriented languages such as Iverson’s APL and J comes from their implicit lifting of scalar operations to act on higher-ranked data, for example to add a value to each element of a vector, or to add two compatible matrices pointwise. It is considered a shape error to attempt to combine arguments of incompatible shape, such as a 3-vector with a 4-vector. APL and J are dynamically typed, so such shape errors are caught only at run-time. Recent work by Slepak et al develops a custom type system for an array-oriented language, statically ruling out such errors. I will show that such a custom language design is unnecessary: the requisite compatibility checks can already be captured in modern expressive type systems, as found for example in Haskell; moreover, generative type-driven programming can exploit that static type information constructively to automatically induce the appropriate liftings. I will also show that the structure of multi-dimensional data is inherently a matter of traversable Naperian applicative functors (and I will explain what this means).
This presentation was the midday keynote of Lambda World 2017 by Bartosz Milewski. Follow: - - - Visit: - for more details. ___ Haskell lens library offers fine-grain declarative access to immutable (persistent) data structures. Its main attraction is that it's compositional: you can focus on substructures of larger structures simply by composing polymorphic higher-order functions. Its most general formulation is known as profunctor optics. I'll talk about the categorical foundation of profunctor optics