Functional Roundup for May 27, 2016

• by Maureen Elsberry
• •
• May 27, 2016
• •
• news• scala• functional roundup
• |
• 8 minutes to read.

SI-2712 fix merged adding support for partial unification of type constructors

Well, your weekend is about to get better. Miles Sabin’s SI-2712 fix that blew the collective minds of the Scala community back in April has officially been merged into Scala 2.12.x!!!

Here is the PR description:

“Change is hidden behind -Ypartial-unification … default is off. Compiler and standard library bootstraps with the flag both off and on.

Simple algorithm as suggested by Paul Chiusano in the comments on SI-2712. Treat the type constructor as curried and partially applied, we treat a prefix as constants and solve for the suffix. For the example in the ticket, unifying M[A] with Int => Int this unifies as,

M[t] = [t][Int => t] A = Int

This appears to work well for Cats, Scalaz etc.”

You can view the development in the PR conversation here: SI-2712 Fix Merged

Apache Kafka 0.10 and Confluent Platform 3.0 released

May 24th marked the release of Apache Kafka 0.10 as well as the third version of the Confluent Platform.

The release also features Kafka Streams, a library for building highly scalable, fault-tolerant, distributed stream processing applications on top of Apache Kafka.

The Confluent Platform 3.0 introduces the first commercial offering, the Control Center. The Control Center is a web-based tool for managing Kafka streams.

According to Confluent.io, the two primary components contained in the CC for building streaming data pipelines are:

• Connector Configuration: the ability to configure, edit, and manage connectors on Kafka Connect; you can easily build streaming data pipelines by deploying Kafka connectors to various systems.

• End-to-end Stream Monitoring: for measuring and monitoring your data streams end to end, from producer to consumer. Whether it is tracking the end-to-end latency or the number of 9s on your data, Control Center offers a simple UI for managing and monitoring Kafka.

Apache Kafka 0.10 features an insane amount of improvements and issues. Some of the highlights are:

• #1215: Rack-Aware replica assignment option
• #2511: KIP-31 & KIP-32: message format change + adding timestamp to messages
• #3149: Extend SASL implementation to support more mechanisms
• #3316: Add connect REST API to list available connector classes
• #3007: Implement max.poll.records for new consumer (KIP-41)
• #3304: Add Api Version request/response and server side handling

In total, around 413 JIRA issues and 13 KIPs were resolved with the help of 112 contributors.

Confluent states that upcoming releases will focus on operational simplicity and stronger delivery guarantees.

Dive into the details of these releases here: Announcing Apache Kafka 0.10 and Confluent Platform 3.0

Questions on Kafka or the Confluent Platform? 47 Degrees is a Confluent Consulting and System Integrator partner, get in touch.

Scalaz 7.2.3 released

On Saturday, May 21st, Scalaz 7.2.3 was released.

This is the third maintenance for the 7.2.x series for Scala binary versions 2.10, 2.11, and 2.12.0-M4.

Scalaz 7.2.3 features the following additions and changes:

• #1122: Tap function that is not broken.
• #1145: Backport 1145
• #1148: Ads Coproduct function for folding with two natural transformations.
• #1146: Configure external links in ScalaDoc.
• #1145: Change EphemeralStream.foldLeft to use a tail recursive loop.
• #1154:prioritize implicits. Avoid implicit ambiguity if SI-2712 is fixed.
• #1107: Adding back the deprecated methods.
• #1139: Default executor uses at least 4 threads.

You can view more about the latest release here: Scalaz 7.2.3 released

Scala MOOCs now live on Coursera

Three out of the four highly-anticipated Scala specilization courses run by the Scala Center, went live on Coursera on Monday, May 23rd.

The classes currently available are:

• Functional Programming Prinicples in Scala: discover the elements of the functional programming style and learn how to apply them usefully in your daily programming tasks.
• Functional Program Design in Scala: learn how to apply the functional programming style in the design of larger applications.
• Parallel Programming: learn the fundamentals of parallel programming, from task parallelism to data parallelism.

The fourth course Big Data Analysis with Scala and Spark and the final capstone project should launch in a few months. All the courses are free, but if you want the verified mini-degree, there is a fee. Don’t let that scare you, it’s currently 10% off the whole program and costs a meesly $355.00 USD. Considering you’d have to add a few more zeros to that number for most college courses, it’s a bargain.

Find out more information about the program here: Three Scala Courses Launched on Coursera!.

Ammonite 0.5.8: Enabling shell-like scripting

Ammonite enables shell-ike scripting in Scala.

It consists of these subprojects:

• Ammonite-REPL: Modernized Scala REPL
• Ammonite-Ops: Scala library for convenient, rock-solid Filesystem Operations
• Ammonite-Shell: Modern repacement for the Bash system shell

According to the changelog, the release of 0.5.8 includes these additions and changes:

• write has been generalized to work on any combination of Array, Traversable and Iterator. e.g. write(foo: Iterator[Iterator[Array[String]]])
• write no longer inserts newlines between items by default.
• Introduced the browse helper to Ammonite-Shell, letting you easily open up large data structures in external editors like Vim or Emacs to browse them without spamming the console.
• Improved the error messages for invalid Path segments to make them more specific and suggest alternatives to what a user is trying to do.
• Broke out the FilePath sub-trait from the BasePath trait, to differentiate those BasePaths are filesystem paths and can be constructed from java.nio.file.Path or java.io.Files (RelPath and Path)from those which can’t (ResourcePath)
• Path.makeTemp has been renamed tmp() and tmp.dir().
• Arrow-keys now work properly in the previously odd case where they were creating \u033O{A,B,C,D}” codes instead of \u033[{A,B,C,D} codes
• Converted all string-encoding methods to take a scala.io.Codec instead of a String or Charset, letting you pass in either of those types and having it be implicitly converted.

Find out more: Ammonite 0.5.8 release

Fetch: A library for simple and efficient data access

A new Scala library for simplifying and optimizing access to data such as files systems, databases, and web services was released this week. Fetch, based off of Cats Free monad, is a library that simplifies and increases the efficiency of code that reads data from remote sources.

Read about Fetch here: Introducing Fetch: A new Scala library for simple and efficient data access

FS2 0.9.0-M2 Update

https://github.com/functional-streams-for-scala/fs2/issues/632

Michael Pilquist updated Functional Streams.

He lists the notable changes as follows:

• #622: Various run* methods on stream return an effect value now instead of returning a Free interpretation.
• #621: Removed suspend from Monad and introduced the fs2.util.Effect type class, which is a Catchable that supports delay and suspend.
• #625: Improved type inference when mixing pure and effectful streams.
• #628: Fixed deadlock in time.awakeEvery.
• #629: More flexible file API.
• #626: Ported the fs2.hash package from 0.8.
• #631: Renamed pull.run to pull.close.

He also published the following libraries to Maven Central:

libraryDependencies += Seq(
"co.fs2" %% "fs2-core" % "0.9.0-M2",
"co.fs2" %% "fs2-io" % "0.9.0-M2",
"co.fs2" %% "fs2-cats" % "0.1.0-M2", // Uses cats 0.6.0
"co.fs2" %% "fs2-scalaz" % "0.1.0-M2" // Uses scalaz 7.2.3
)

The screencasts to introduce Functional Streams are included below.

Suggested information to digest this weekend:

The functional programming community has no shortage of excellent conferences and talks. Here are just a few that were recently released that we recommend checking out if you missed them the first time:

Michael Pilquist:

• Intro to Functional Streams for Scala (FS2)

Part one:

In part two, Michael Pilquist covers chunks, pipes, time delays, and interruptions: Intro to Functional Streams for Scala Pt. 2

Otto Chrons:

• Scala.js for large and complex frontend apps
• Frontend Finland

View the slides here:

Interview series from LX Scala:

• Speaker interviews
• LX Scala - Lisbon, Portugal

Upcoming Events:

Spark Summit June 6 - 8th Hilton Union Square - San Francisco, CA

Scala Days Berlin June 13 - 17th The bcc - Berlin, Germany

Scala at the Sea June 14th Whitepages - Seattle, WA

Have a news tip for us? Tweet to us @47deg or send to us via email here.