Archive for the ‘Functional Reactive Programming (FRP)’ Category

LamdaConf 2015 – May 22-25 Boulder CO

Sunday, February 15th, 2015

LamdaConf 2015 – May 22-25 Boulder CO

Early Bird Registration (self payment) ends Feb. 28, 2015

From the webpage:

Ignite your functional programming skills at the second annual LambdaConf — the largest interdisciplinary functional programming conference in the Mountain West.

With more than 40 speakers and two and a half days worth of content, LambdaConf brings together attendees with a diverse set of skills and backgrounds, united by a common passion for the power of functional programming.

Students, researchers, and programming professionals of all persuasions will find relevant topics, including introductory material on functional programming, PL and type theory, industry case studies, language workshops, and library tutorials.

In addition to two and a half days of content, the conference has ample opportunity for networking, including five group meals, one drink social, one group activity (hiking or tea), a half day unconference, and unscheduled time Saturday evening.

A non-final list of presentations:

  • How to Learn Haskell in Less Than 5 Years by Chris Allen
  • The Abstract Method, In General by Gershom Bazerman
  • Make Up Your Own: “Hello World!” by Justin Campbell
  • Why I Like Functional Programming by Adelbert Chang
  • Scalaz-Streams: A Functional Approach to Compositional, Streaming I/O by Derek Chen-Becker
  • HTTP through Functional Programming by Andrew Cherry
  • Reactive Programming with Algebra by André van Delft and Anatoliy Kmetyuk
  • Shipping a Production Web App in Elm by Richard Feldman
  • ooErlang: A Programmer-Friendly Approach to OOP in Erlang by Emiliano Firmino
  • Scalaz 102 – Taking Your Scalaz Usage Up a Notch! by Colt Fredrickson
  • Loom and Functional Graphs in Clojure by Aysylu Greenberg
  • Dynamic vs. Static: Having a Discussion without Sounding Like a Lunatic by David Greenberg
  • The Meaning of LFE by Zeeshan Lakhani
  • What’s New in Scala by Marconi Lanna
  • Idiomatic Scala: Your Options Do Not Match by Marconi Lanna
  • Introducing Emily: Simplifying Functional Programming by Andi McClure
  • Pattern Functors: Wandering Around Fix-points, Free Monads and Generics by Alejandro Serrano Mena
  • Accelerating Haskell: GPGPU Programming with Haskell by Joe Nash
  • Programs as Values: Pure Composable Database Access in Scala by Rob Norris
  • Type Theory and its Meaning Explanations by Jon Sterling
  • A Bird’s Eye View of ClojureScript by Chandu Tennety
  • Building Concurrent, Fault-Tolerant, Scalable Applications in F# using Akka.Net by Riccardo Terrell
  • Fault-Tolerance on the Cheap: Making Systems That (Probably) Won’t Fall Over by Brian L. Troutwine

With more content in the form of lighting talks, workshops, etc.

You have seen languages modifying themselves to become more functional.

Now see languages that are functional!

Functional and Reactive Domain Modeling

Monday, November 17th, 2014

Functional and Reactive Domain Modeling by Debasish Ghosh.

From the post:

Manning has launched the MEAP of my upcoming book on Domain Modeling.

functional-reactive programming cover

The first time I was formally introduced to the topic was way back when I played around with Erik Evans’ awesome text on the subject of Domain Driven Design. In the book he discusses various object lifecycle patterns like the Factory, Aggregate or Repository that help separation of concerns when you are implementing the various interactions between the elements of the domain model. Entities are artifacts with identities, value objects are pure values while services model the coarse level use cases of the model components.

In Functional and Reactive Domain Modeling I look at the problem with a different lens. The primary focus of the book is to encourage building domain models using the principles of functional programming. It’s a completely orthogonal approach than OO and focuses on verbs first (as opposed to nouns first in OO), algebra first (as opposed to objects in OO), function composition first (as opposed to object composition in OO), lightweight objects as ADTs (instead of rich class models).

The book starts with the basics of functional programming principles and discusses the virtues of purity and the advantages of keeping side-effects decoupled from the core business logic. The book uses Scala as the programming language and does an extensive discussion on why the OO and functional features of Scala are a perfect fit for modelling complex domains. Chapter 3 starts the core subject of functional domain modeling with real world examples illustrating how we can make good use of patterns like smart constructors, monads and monoids in implementing your domain model. The main virtue that these patterns bring to your model is genericity – they help you extract generic algebra from domain specific logic into parametric functions which are far more reusable and less error prone. Chapter 4 focuses on advanced usages like typeclass based design and patterns like monad transformers, kleislis and other forms of compositional idioms of functional programming. One of the primary focus of the book is an emphasis on algebraic API design and to develop an appreciation towards ability to reason about your model.

An easy choice for your holiday wish list! Being a MEAP, it will continue to be “new” for quite some time.


Taming Asynchronous Workflows…

Thursday, July 3rd, 2014

Taming Asynchronous Workflows with Functional Reactive Programming by Leonardo Borges.

Unfortunately just the slides but they should be enough for you to get the gist of the presentation. And, Leonardo finishes with a number of pointers and references that will be helpful.

Managing subject identity in a workflow could have interesting implications for security. What if there is no “stored” data to be attacked? Either you were listening at the right time or not, to receive all the transmissions necessary to assemble a text? Or you were listening to all the right sources? And you need not store the message after receipt, it can always be re-created by the same processes that delivered it.

Lots of room for innovation and possible security improvements when we stop building targets (static data stores).

BTW, Leonardo is currently writing: “Clojure Reactive Programming: RAW.” (Packt) I like Packt books but do wish their website offered a search by title function. Try searching for “reactive” and see what you think.

(Functional) Reactive Programming (FRP) [tutorial]

Tuesday, July 1st, 2014

The introduction to Reactive Programming you’ve been missing by Andre Staltz.

From the post:

So you’re curious in learning this new thing called (Functional) Reactive Programming (FRP).

Learning it is hard, even harder by the lack of good material. When I started, I tried looking for tutorials. I found only a handful of practical guides, but they just scratched the surface and never tackled the challenge of building the whole architecture around it. Library documentations often don’t help when you’re trying to understand some function. I mean, honestly, look at this:

Rx.Observable.prototype.flatMapLatest(selector, [thisArg])

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element’s index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.

Holy cow.

I’ve read two books, one just painted the big picture, while the other dived into how to use the FRP library. I ended up learning Reactive Programming the hard way: figuring it out while building with it. At my work in Futurice I got to use it in a real project, and had the support of some colleagues when I ran into troubles.

The hardest part of the learning journey is thinking in FRP. It’s a lot about letting go of old imperative and stateful habits of typical programming, and forcing your brain to work in a different paradigm. I haven’t found any guide on the internet in this aspect, and I think the world deserves a practical tutorial on how to think in FRP, so that you can get started. Library documentation can light your way after that. I hope this helps you.

Andre is moving in the right direction when he announces:

FRP is programming with asynchronous data streams.

Data streams. I have been hearing that a lot lately. 😉

The view that data is static, file based, etc., was an artifact of our storage and processing technology. Not that data “streams” is a truer view of data but it is a different one.

The semantic/subject identity issues associated with data don’t change whether you have a static or stream view of data.

Although, with data streams, the processing requirements for subject identity become different. For example, with static data a change (read merger) can propagate throughout a topic map.

With data streams, there may be no retrospective application of a new merging rule, it may only impact data streams going forward. Your view of the topic map becomes a time-based snapshot of the current state of a merged data stream.

If you are looking for ways to explore such issues, FRP and this tutorial are a good place to start.