As a brief note, here are a couple of examples about why you shouldn’t use double or float values for currency, courtesy of Joshua Bloch’s Effective Java book:
scala> 1.03 - .42 val res0: Double = 0.6100000000000001 scala> 1.00 - 9 * 0.10 val res1: Double = 0.09999999999999998
If you ever need a Scala method/function to convert a string with newline characters in it to a sequence of strings (Seq[String]), here you go:
def convertStringWithNewlinesToSeq(s: String): Seq[String] =
s.split("\n").toVector
You can convert the final result to a Vector, Seq, List, ArrayBuffer, Array, etc., but I prefer Vector. The Scala REPL demonstrates how it works:
scala> convertStringWithNewlinesToSeq("")
res0: Seq[String] = Vector("")
scala> convertStringWithNewlinesToSeq("foo")
res1: Seq[String] = Vector(foo)
scala> convertStringWithNewlinesToSeq("foo\nbar\nbaz")
res2: Seq[String] = Vector(foo, bar, baz)
scala> convertStringWithNewlinesToSeq("foo\nbar\nbaz\n\n")
res3: Seq[String] = Vector(foo, bar, baz)
Scala FAQ: Can you use a question mark to end a Scala method name?
Answer: Yes, you can. Just use an underscore character before the question mark. For instance, here’s a method named alive_?:
def alive_? = true
Another possible approach you can use is to use backtick characters around the method name, without using an underscore...
This is the Index entry for recursion in the third edition of Programming in Scala. :)
Lightbend has a case study of how Groupon uses Akka and Play to meet their demanding performance needs. The article doesn’t say if they use Scala or Java,
I’m horrible at date calculations — what do you mean by “between”? — but I do know that April 10th is the 100th day of all non-leap year years.
Scala string FAQ: How do I convert a multiline String to an Array or Seq or List in Scala?
I was just working on a program to parse Apache access log records, and ran into this situation. Here’s the solution.
Given a multiline string, like this:
One of the many things I like about Scala is that you can make it as complicated as you want to, but you can also write a little code like this and show it to someone who has never written a line of code in their life, and they can pretty much tell you what’s going on.
This scala-lang.org documentation page shares a good reason to use “sealed” traits and classes: When you created sealed traits, the compiler can easily tell all of the subtypes of your class or trait, and as just one benefit, you don’t need to add a default, “catch-all” case in your Scala match expressions.
The image shows how Scala 3 (Dotty) enums expand into other Scala code. I thought that was interesting, and you can learn more at this URL.
The image shows the beginning of this Scala 3 SIP `main` method proposal that was just added yesterday, March 25, 2019. See that link for more details and an interesting discussion.
contributors.scala-lang.org has become my favorite website this past week. It’s very interesting to read through the debates about new language features for Scala 3 (Dotty). For instance, in the Make concrete classes final by default discussion I think everyone agrees they wish they had gone that way with Scala 2, but it would cause too many problems if they tried to make this a new standard in Scala 3. The discussion — in addition to reading Effective Java — makes me wish I had used final before all of my classes.
In another discussion titled, Why does Scala need its own build tool (SBT), someone makes a claim that Martin Odersky and his team created SBT as a build tool solution, and Mr. Odersky replies, “Definitely not my answer. I was always very skeptical of SBT’s approach and remain so.”
I had read that Bloop was faster than Scala compiler tools like scalac and fsc, so I wondered if it was faster than SBT, and if so, how much faster. So I downloaded Eric Torreborre’s specs2 source code, which has 880 source code files, and compiled the entire project with both SBT and Bloop.
To test SBT’s speed, I ran all the commands from inside the SBT command prompt, which I usually do anyway to avoid the SBT/JVM startup lag time. I also ran clean and compile several times before recording SBT’s speed, because I thought that would be a better reflection of real-world usage and performance. I ran the tests four times, and the average time with SBT was 49 seconds, and that was very consistent, always coming in between 48 and 50 seconds.
The people at Triplequote looked at the performance of Scala compilers on different Amazon EC2 instance types in an effort to answer the question, “What is the (cloud) cost per build?”
March 5, 2019: For a limited time only, I put the paperback version of “Hello, Scala” on sale for $10 (US) on Amazon.
P.S. - It won’t get any cheaper than this.
A funny thing about writing books, or at least writing books with O’Reilly in 2013, is that I never received a final copy of the Scala Cookbook in PDF format. Fortunately I have the original Word docs, which is what they used at the time, so I carry those around on my laptop.
I’ve used Jenkins before, but hadn’t used it in a while, so when I got it running with Scala, SBT, ScalaTest, and Git, I made some notes about how to configure it. You can get Jenkins going with Docker, but I just got Jenkins running by starting its WAR file like this:
java -jar jenkins.war
My notes on getting everything up and running are a little cryptic, but if you have a little experience with Jenkins I hope they’ll make sense. Here they are:
I put my Scala String Utilities library on Github a few days ago. It includes my Q String Interpolator, and several other string utility functions. It also demonstrates how to write ScalaTest and ScalaCheck tests with an SBT project.
Scala community build is an interesting project, which is described like this:
“This repository contains configuration files that enable us to build and test a corpus of Scala open source projects together using Lightbend's `dbuild`. How big is it? It’s 3.2 million lines of Scala code, total, from 185 projects (as of January, 2019), and takes about 15 hours to run.”
“Why do this? The main goal is to guard against regressions in new versions of Scala (language, standard library, and modules). It’s also a service to the open source community, providing early notice of issues and incompatibilities.”
Here’s a link to my Scala String utilities, which includes a few hopefully-useful string utility functions, some of which are shown in the image. My “Q” interpolator is also included in that library.