Vídeos de programación

No matter how crazy this may sound, taking inspiration from the functional world when programming in an OO language like Ruby turns out to be a good idea. In this talk we’re going to look at various functional ideas implemented in Ruby and see how they can improve and simplify our code, making it easier to grow and maintain applications.

Everybody knows monads by now, so a talk about monads would hardly be worthwhile. Lets take it to the next level: monad transformers. Well learn what they are, how they naturally emerge in your code base and how to make good use of them in Scala nd maybe even how to create your on

In this talk, we'll have a look at how Swift's structs work (which have copy semantics), and how they can be used to wrap existing OO APIs (which have reference semantics). This allows us to do FP, building on top of battle-tested frameworks.

Free Monads have become the bread and butter of the pure functional programmer. They help us to move side effects out of our code giving us better testability, as well as separating syntax and semantics of our DSLs. But there's a twist. Some of our programs can end up with dreadful performance, leaving us unhappy and frustrated. In this talk we are going to shed some light on the Codensity Monad which helps us to improve theasymptotic performance of our Free Monad computation keeping us happy and pure. Slides & Code: https://github.com/raichoo/TheFreeAndTheFurious

Leaving side effects aside: the quest for functional purity and the perils of object-orientation Believe it or not, side effects are behind most of the software headaches you suffer at work: if you can't easily reuse, test, optimize, compose, or understand some piece of software, chances are that it's contaminated with side effects, i.e., that it's not made of pure functions. Yet we may think of side effects as necessary evil, since calls to the database, web server, logger, tracker, etc., have to be placed somewhere in your code. So, the problem we face as designers can't be their full removal, but their maximum isolation. In this talk we compare how effective functional and object-oriented patterns are in this segregation or purification process. We show how functional abstractions allow us to extend the realm of purity in our code, far beyond what we can achieve with object orientation. We show how easy we can do that using Scala and the scalaz library, and explain in simple terms the role that monads play in this process. Last, we argue that no matter how hard you try with maps, flatmaps, filters, immutable values, and so forth, if side effects are not properly tamed, you won't get the benefits of functional programming: you won't be able to easily accommodate changes in the way your effects are executed (e.g. asynchronism, NoSQL persistence), perform mock-free unit testing, keep business logic strictly decoupled from non-functional concerns, etc., etc. Slides: https://docs.google.com/presentation/d/1RsCnD7tVOxlCrhpqbdmqpksHs7vHstpgVxEIxvSnl1Y/edit

Laziness, trampolines, monoids and other functional amenities: this is not your father's Java Lambdas are the main feature introduced with Java 8, but the biggest part of Java developers are still not very familiar with the most common functional idioms and patterns. The purpose of this talk is presenting with practical examples concepts like high-order functions, currying, functions composition, persistent data structures, lazy evaluation, recursion, trampolines and monoids showing how to implement them in Java and how thinking functionally can help us to design and develop more readable, reusable, performant, parallelizable and in a word better, code.

We cannot say C# is a functional programming language as such. But it is a multi-paradigm programming language that supports lambda expressions since the year 2007, and it has been adding many functional programming characteristics for the last 10 years. Get to know C# 6.0, and how it has become one of the best programming languages thanks to all these characteristics.

Distributed Systems are a complex topic. There's abundant research about it but sometimes it is hard for a beginner to know where to start. I would like to outline the main concepts of distributed systems, so the interested person can have a clear path on how to start their own research as well. In this talk I will review the different models: asynchronous vs. synchronous distributed systems; message passing vs shared memory communication; failure detectors and leader election problems; consensus and different kinds of replication. I will also review a series of books on distributed systems in order to recommend the best one according to the topics we would like to learn about, or the problems we would like to solve. The goal of the talk is to set a good foundation for people interested in learning more about distributed systems. Slides: https://speakerdeck.com/old_sound/what-we-talk-about-when-we-talk-about-distributed-systems

I heard that computation expressions are kind of like monads, I heard that monads are like burritos or space suits and that they are pretty much magical, I also heard that they are monoids in the category of endofunctors... As a writer of code that sounds awesome, and I want to know and understand (and I'm sure you do too) what those terms actually mean, and most importantly why we should care about them, What are their practical uses?. So, in this talk we are going to attempt to do just that. Failure is possible but the attempt is valuable.

Applying functional programming mindset to solve packaging issues turns out to be a big step forward solving the dependency hell. Moreover, it brings one API as an language to the users and packaging maintainers, removing almost any barrier between the two groups. Haskell ecosystem will be our example through the Nix journey. We will also observe that expanding those ideas to the whole Operating System (and more, a cluster of machines) is trivial once we have the package manager design done. Slides here: http://slides.com/domenkozar/nix-the-functional-package-manager-and-nixos-the-declarative-linux-distribution #/