Scala at Sumo: grab bag of tricks - Blog post
Sign Up Free Request Demo

Scala at Sumo: grab bag of tricks

As mentioned previously on this blog, at Sumo Logic we primarily develop our backend software using the Scala programming language. In this post we present some (very) miscellaneous Scala tidbits and snippets that showcase some interesting features we have taken advantage of in our own code.

Laziness

Scala borrows many ideas from the world of functional programming, including “laziness”.  The essential idea of a lazy collection is that its contents are not computed until they are needed. For example, one could construct a lazy abstraction layer over expensive external resources like disk or database accesses.  This abstraction can then be created and passed around without incurring the expense of populating it until the values are actually read out by some other part of the program. This post dives into the performance implications of laziness, here we present a very contrived example that illustrates the basic concept.

In the first version, a strict Range is created and mapped over.  The map is eagerly evaluated, simultaneously populating the mutant ListBuffer with values and producing a sequence of Boolean values. The exists method is then called with an identity argument, returning true after reading the second value in the sequence, which is true because 1 > 0.  However the fact that our ListBuffer contains the value (0,1,2,3) tells us that the map was computed over all elements of the Range; this is because that entire computation happens “before” exists begins consuming the values.

In the second version, we call view on the strict Range to create a lazy sequence.  The mapping function is then only called when elements of this sequence are consumed by the exists method.  Once exists hits the true value, it short-circuits and returns true without consuming the rest of the sequence.  This is why we see 0 and 1 only in the ListBuffer.  The map computation was only evaluated on an “as-needed” basis to supply values for exists to consume,  and exists only needed to consume 0 and 1 before terminating with a value of true.

Note that we are using side-effects and a mutable data structure within the mapping function here for illustrative purposes only!  In actual code this could easily introduce nasty bugs, as demonstrated by the mildly surprising result of our little experiment.

Regex unapply magic

When using a regular expression to parse values out of a string for further processing, it is fairly common to see code resembling the following:

Conveniently, the Regex class can be combined with Scala pattern-matching machinery to directly bind captured groups to local variables in one shot:

This specific instance is a particularly nice example of the general usefulness of Scala case classes, pattern matching, and extractors.  If you are interested, these mechanisms are a good place to start digging deeper into how this trick works.

Handling nested Java null checks

In Scala, the use of null is generally avoided upon due to the availability of the much nicer Option. However, occasionally we need to follow a nested series of calls against null-riddled Java code where if any value in the chain returns null, we would like to return some default value.

In this case we can combine a common Scala trick (looping over Option values with for-comprehensions) with the fact that Option can be used as a wrapper of potentially-null values.   For the simple case of nested-access with potential lurking nulls, this snippet is much easier on the eyes than an equivalent set of nested if-thens:

Executing this App yields the desired behavior:

Any null in the chain defaults to authority -1
-1
-1
-1
Complete non-null chain yields correct authority
76

Get Started Today!

Sign up for your FREE Sumo Logic Trial.

Sign Up Free

Request A Free Sumo Logic Demo

Fill out the form below and a Sumo Logic representative will contact you to schedule your free demo.
“Sumo Logic brings everything together into one interface where we can quickly scan across 1,000 servers and gigabytes of logs and quickly identify problems. It’s awesome software and awesome support.”

Jon Dokuli,
VP of Engineering

Thank you for signing up for Sumo Logic.

We are creating your account now.
Please check your email.
Need more help? Contact Us
Sign up for Sumo Logic Free*
Sign up for Sumo Logic Free*
  • No credit card required to sign-up
  • Create your account in minutes
  • No expiration date*
  • *After 30 day trial period, reverts to Sumo Logic Free
    • Please Enter your email address.
    • Please enter a valid email address.
    • This email is already in use for another account.
    • Please use your company email to create an account.
    • Please agree to the Service License.
    • Free trial provisioning is temporarily offline, please call 855-LOG-SUMO to get started.
    View All Pricing Options
    Already have an account? Login