Scala in practice

inPracticeScala
patric.fornasier@thoughtworks.com
marc.hofer@thoughtworks.com

2&/82..9+8$&+&"0+&/;0+2-3+0<10-*0+#7+
7=&"0=2>#50+2-3+;#(0?+
Optimising IT
Organisations
technology
Consulting
Testing
Build & Release
Management
Experience
Design

presentation Contains
code examples
Warning

Context
A bit of
about the project

Scala
FunctionalObject
Oriented
Statically
Typed
Scriptable
JVM-
based

List<String> features = Arrays.asList("noFeature", "featureC",
"featureB", "featureA");
for (String feature : features) {
System.out.println(feature);
}

List<String> javaFeatures = Arrays.asList("noFeature", "featureC",
for (String feature : javaFeatures) {
System.out.println(feature);
}
val scalaFeatures = List( "noFeature", "featureC",
"featureB", "featureA")
scalaFeatures foreach { println _ }

val currentFeatures = List("noFeature", "featureC", "featureB", "featureA")
Result: "featureA_toggle, featureB_toggle"
currentFeatures.filter { _.startsWith("feature") }
.mkString(", ")
.map { _ + "_toggle" }
.sorted
.take(2)

String result = "";
List<String> currentFeatures = Arrays.asList("noFeature", "featureC",
Collections.sort(currentFeatures);
int i = 0, j = 0, take = 2;

while(i < take && j < currentFeatures.size()) {
String feature = currentFeatures.get(j++);
if(feature.startsWith("feature")) {
result += feature + "_toggle" + ((i++ != take) ? ", " : "");
}
}

currentFeatures.filter { _.startsWith("feature") }
.mkString(", ")
.map { _ + "_toggle" }
.sorted
.take(2)

public class Property {
private final String key;
private final String value;
private final String defaultValue;
public Property(String key, String value, String defaultValue) {
this.key = key;
this.value = value;
this.defaultValue = defaultValue;
}
}

class Property(key: String, value: String, default: String) {}

// ...
public String getKey() {
return key;
}
public String getValue() {
return value;
}
public String getDefaultValue() {
return defaultValue;
}
}

class Property(val key: String, val value: String, val default: String) {}

// ...
public Property changeTo(String newValue) {
return new Property(key, value, newValue);
}
public Property reset() {
return new Property(key, value);
}
@Override
public String toString() {
return String.format("%s=%s", key, value);
}
}

class Property(val key: String, val value: String, val default: String) {
def changeTo(newValue: String) = new Property(key, newValue, default)
def reset = new Property(key, default)
override def toString = "%s=%s" format(key, value)
}

// ...
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Property))
return false;
Property other = (Property) obj;
return other.key.equals(key) && other.value.equals(value)
&& other.defaultValue.equals(defaultValue)
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + key;
result = 31 * result + value;
result = 31 * result + defaultValue;
return result;
}
}

case class Property(key: String, value: String, default: String) {
def changeTo(newValue: String) = Property(key, newValue, default)
def reset = Property(key, default)
}

this.key = key;
this.value = value;
}
return key;
}
return value;
}
}
}
}
@Override
}
@Override
return false;
}
@Override
int result = 17;
return result;
}
}

this.key = key;
this.value = value;
}
return key;
}
return value;
}
}
}
}
@Override
return false;
}
@Override
int result = 17;
return result;
}
@Override
}
}
case class Property(key: String, value: String, default: String) {
def changeTo(newValue: String) = Property(key, newValue, default)
def reset = Property(key, default)
}
45 vs 5
LOCs
* ignoring blank lines

Another Example:
{ Blocks }
“Less
Boilerplate”

val content = get("http://foo.com") { toString }
val statusCode = get("http://foo.com") { statusCode }
get("http://foo.com")
int statusCode = httpSupport.get("http://foo.com", new Block<Integer>() {
public Integer execute(HttpResponse response) {
return response.getStatusLine().getStatusCode());
}
});
String content = httpSupport.get("http://foo.com", new Block<String>() {
return EntityUtils.toString(response.getEntity());
}
});
httpSupport.get("http://foo.com", new VoidBlock() {
public void execute(HttpResponse response) {}
});

java -cp "lib/*" com.springer.core.app.Casper
Scala library goes in here!

val java = new java.util.ArrayList[String]
val scala: Seq[String] = foo filter { ... }

val log = Logger.getLogger("com.foo")
log.debug("Hello!")

“Gentle
Learning Curve”
“Java without ;”
Library
re-use JVM

<PdfInfo hasAccess="false">
<DDSId>12345</DDSId>
<ContentType>Article</ContentType>
</PdfInfo>

val pdfInfo =

val contentType = (pdfInfo "ContentType").text
val hasAccess = (pdfInfo "@hasAccess").text.toBoolean

val pdfInfoList = <PdfInfoList>
<PdfInfo hasAccess="false">
<ContentType>Article</ContentType>
</PdfInfo>
<PdfInfo hasAccess="true">
<ContentType>Book</ContentType>
</PdfInfo>
</PdfInfoList>
case class PdfInfo(xml: NodeSeq) {
val ddsId = (xml "DDSId").head.text
val hasAccess = (xml "@hasAccess").head.text
val contentType = (xml "ContentType").head.text
}
(pdfInfoList "PdfInfo") map { PdfInfo(_) }

System
App2
App3
Functional
App1
Unit
DB
Integration
Levels of Testing

Unit Test DSL
class PropertyTest extends Spec with ShouldMatchers {
it("should render key and value separated with an equals sign") {
Property("shark", "fish").toString should equal ("shark=fish")
}
}

class ForgottenPasswordPageTests
extends FunctionalTestSpec with ForgottenPasswordSteps with Uris {
it("should validate user email") {
given(iNavigateTo(ForgottenPasswordPage))
when(iSubmitEmail("invalid@email.com"))
then(iShouldSeeInvalidEmailErrorMessage)
}
}
Functional Test DSL

Document Validation DSL
trait DDSValidationRules extends JournalXPaths with APlusPlusElements {
val journalRules = List(
No(JournalTitle) is Invalid,
MoreThanOneElementIn(JournalArticle) is Invalid,
BadLanguageIn(JournalArticleLanguage) is Invalid,
JournalIssue With No(JournalIssueCoverYear) is Invalid,
Bibliography With No(BibliographyHeading) is Invalid,
MarkupIn(JournalTitle) is Unsupported,
MarkupIn(JournalAuthor) is Unsupported
)
}

“Fun”
List<Integers> foo = new ArrayList<Integers>()
for (int i = 7; i <= 21; i++) {
foo.add(i);
}

“Fun”
def eat(food: String = "plankton")

“Fun”
public void eat(String food) {...}
public void eat() {
eat("plankton");
}

get("http://foo.com") { statusCode }
“Fun”

httpSupport.get("http://foo.com", new Block<Integer>() {
return response.getStatusLine().getStatusCode());
}
});
“Fun”

def ++ [B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]):That
Scala Collection Library

class JournalPageTests extends Spec with FunctionalTestSpec
with JournalPageSteps
with SearchResultsPageSteps
with LanguageSteps
with LanguageSupport
with JavascriptSupport
with Uris
with IssuePageSteps
with VolumesAndIssuesPageSteps
with CoverImageUrlBuilders
with FakeEntitlementSteps
with FullTextPageSteps
with CommonAbstractSteps
with GoogleAnalyticsSteps
with ActionSectionSteps { ... }
Traits Galore in our codebase...

disclaimer
use scala
at your own risk

Thanksfor
Listening
@patforna | @mhoeﬁ

Scala in practice

Recommended

Recommended

More Related Content

What's hot

What's hot (18)

Viewers also liked

Viewers also liked (20)

Similar to Scala in practice

Similar to Scala in practice (20)

Recently uploaded

Recently uploaded (20)

Scala in practice