Index

A

• Abstract Syntax Tree (AST) / Using Play JSON
• activator templates
  • about / Learning from activator templates
  • reactive stocks / Reactive stocks
  • reactive real-time search / Reactive real-time search
  • Play-Akka-Angular-WebSocket template / The Play-Akka-Angular-WebSocket template
• actor-in-a-box / Understanding the Actor model
• Actor model
  • about / Understanding the Actor model
• ActorRef object / Understanding the Actor model
• Actor Room
  • about / Playing with Actor Room
• actors
  • about / Understanding the Actor model
  • supervising. to handle failure / Supervising actors to handle failure
• ActorSystem object / Understanding the Actor model
• actor systems
  • testing / Testing actor systems
• Akka
  • about / Getting started with Akka
  • Actor model / Understanding the Actor model
  • switching behavior / Switching behavior
  • actor systems, testing / Testing actor systems
  • documentation, URL / Exploring further with Akka
• akka.Main class / Switching behavior
• Algebird
  • about / Scratching the surface of Big Data
• anonymous functions / Filter and partition
• Anorm / A simple example using Anorm
• appendToFile() function / Timing code execution in the REPL
• apply method / Understanding Iteratees in Play
• assert statement / Converting between collection types
• AST (Abstract Syntax Tree) / Mocking with ScalaMock
• async() method / The Async library – SIP-22-Async
• Async library
  • about / The Async library – SIP-22-Async
  • web services combining, async{}/await{} used / Combining web services
  • web services combining, without await{} / Combining services without await
• async { <expression> } construct / The Async library – SIP-22-Async
• async{}/await{}
  • used, for combining web services / Combining web services
• async{}/await{} mechanism / The Async library – SIP-22-Async
• authentication
  • about / Playing with authentication
• await() method / The Async library – SIP-22-Async, Combining services without await
• await { <expression returning a Future> } construct / The Async library – SIP-22-Async

B

• Backus-Naur Form (BNF) / Tackling external DSLs through parser combinators
• BDD-style testing
  • about / BDD-style testing
• BookstoreSpec.scala class / Binding XML data in Scala

C

• Casbah
  • about / Entering Casbah
• Casbah Scala toolkit
  • URL / Exploring MongoDB
• case word / Explaining case classes
• classic Play distribution
  • URL, for downloading / Getting started with the classic Play distribution
  • about / Getting started with the classic Play distribution
• close() method / Timing code execution in the REPL
• coll collection / Entering Casbah
• collections
  • operations / Operations on collections
  • containing primitive types, transforming / Transforming collections containing primitive types
  • of complex objects / Collections of more complex objects
• collections, complex objects
  • about / Collections of more complex objects
  • filter and partition / Filter and partition
  • tuples / Dealing with tuples
  • map / Introducing Map
  • option construct / Introducing the Option construct
  • pattern matching / A glimpse at pattern matching
  • map method / The map method
  • String Interpolation / Looking at String Interpolation
  • groupBy method / The groupBy method
  • foldLeft method / The foldLeft method
• collection types / Converting between collection types
• companion / Declaring objects
• companion objects / Introducing companion objects
• Concurrency
  • about / The pillars of Concurrency
• controller, Play application
  • request, handling / Handling a request in the controller
• Converter.convert method / Testing with ScalaCheck
• copy and paste feature, REPL / Copying and pasting in the REPL
• copy method / Explaining case classes
• CustomerTest class / Making JPA available in Scala

D

• DAO (Data Access Object) class / Making JPA available in Scala
• database
  • existing database, REST API creating from / Creating a REST API from an existing database
  • sample database / The sample database
• Domain Specific Language (DSL)
  • about / Building with Simple Build Tool (SBT)
• drop method / Transforming collections containing primitive types
• DSLs
  • about / Introducing DSLs in Scala
  • internal DSLs / Observing internal DSLs
  • external DSLs, tackling through parser combinators / Tackling external DSLs through parser combinators

E

• Either class / The Async library – SIP-22-Async
• ElasticSearch
  • URL / Reactive real-time search
• ElasticSearchActor actor / Reactive real-time search
• Enumeratee
  • defining / Adapting Enumerator with Enumeratee
• Enumerator
  • about / Understanding Iteratees in Play
  • adapting, with Enumeratee / Adapting Enumerator with Enumeratee
• exceptions
  • handling / Handling exceptions
• expectMsg() method / Testing actor systems
• expects method / Mocking with ScalaMock
• external DSLs
  • tackling, through parser combinators / Tackling external DSLs through parser combinators

F

• f(param) function / Timing code execution in the REPL
• filter method / Filter and partition, A glimpse at pattern matching
• filterNot method / Filter and partition
• find method / Entering Casbah
• findOne{} method / Entering Casbah
• flatMap / Summary
• foldLeft method / The foldLeft method, Understanding Iteratees in Play
• foldRight method / Understanding Iteratees in Play
• for comprehension construct / Scala's for comprehension
• forURL method / Learning about Slick
• framework stack, Play application
  • visualizing / Visualizing the framework stack
• functional testing
  • about / Functional testing
• Futures and Promises
  • URL / The pillars of Concurrency
• future{} method / The Async library – SIP-22-Async

G

• getByName method / Making JPA available in Scala
• GoldCustomer class / Scala traits as enhanced Java interfaces
• greetPrinter / Understanding the Actor model
• groupBy method / The groupBy method
• Groupon service / Working with HTTP

H

• H2-browser database
  • visualizing / Visualizing the database in the H2browser
• HDFS
  • about / Scratching the surface of Big Data
• HelloAkkaScala object / Understanding the Actor model
• help() function / Timing code execution in the REPL
• hot swapped / Visualizing the framework stack
• HQL (Hibernate Query Language) / Replacing ORM
• HTTP
  • about / Working with HTTP
  • for comprehension / Scala's for comprehension

I

• implicit c parameter / A simple example using Anorm
• Inbox object / Understanding the Actor model
• index() method / Exploring the request-response lifecycle
• index method / Playing with authentication
• Input.Empty
  • about / Understanding Iteratees in Play
• Input.EOF
  • about / Understanding Iteratees in Play
• Input[E]
  • about / Understanding Iteratees in Play
• insert command / Entering Casbah
• IntelliJ
  • about / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans
• internal DSLs / Observing internal DSLs
• Iteratees
  • about / Understanding Iteratees in Play, Experimenting with WebSockets and Iteratees in Play

J

• Java
  • unit testing, adding / Adding a unit test in Java
  • and Scala code, in style differences / Differences in style between Java and Scala code
  • code layout, adjusting / Adjusting the code layout
  • naming conventions / Naming conventions
• JavaBean-style properties / JavaBean-style properties
• Java IDEs
  • about / Inheriting Java Integrated Development Environments (IDEs)
• Java Maven project
  • Scala, setting up / Setting up Scala within a Java Maven project
• Jfokus / Summary
• JPA
  • URL / Making JPA available in Scala
• JPA-annotated Scala
  • URL / Making JPA available in Scala
• JPA entities
  • creating / Creating JPA entities and REST web services
• JPQL (Java Persistence Query Language) / Replacing ORM
• JsArray / Using Play JSON
• JsBoolean / Using Play JSON
• JsError object / Calling web services from Play
• JsNull / Using Play JSON
• JsNumber / Using Play JSON
• JsObject / Using Play JSON
• JSON
  • manipulating / Manipulating JSON
  • Play requests, handling with / Handling Play requests with XML and JSON
  • Play responses, mocking with / Mocking Play responses with JSON
• JSPs (JavaServer Pages) / Rendering the view
• JsString / Using Play JSON
• JsValue type / Using Play JSON
• JUnit / Adding a unit test in Java

L

• lambdas / More concise and expressive
• Language entity / Making JPA available in Scala
• Location field / Better fit for asynchronous and concurrent code
• LogEntryProducerActor actor / Reactive real-time search
• LoggingReceive call / Playing with Actor Room
• LoggingReceive object / Switching behavior
• login method / Playing with authentication

M

• Macros / Mocking with ScalaMock
• main() method / Introducing Scala.js
• MainSearchActor actor / Reactive real-time search
• map
  • about / Introducing Map
• map method
  • about / The map method
• MapReduce / Scala's for comprehension
• MapReduce jobs
  • URL / Scratching the surface of Big Data
• MapReduce transformations
  • applying / Applying MapReduce transformations
• Maven project
  • setting up / Setting up a Maven project
• mocking
  • with ScalaMock / Mocking with ScalaMock
• MongoDB
  • exploring / Exploring MongoDB
  • URL / Exploring MongoDB
  • Casbah / Entering Casbah
  • MapReduce transformations, applying / Applying MapReduce transformations
• mongod daemon / Entering Casbah

N

• naming conventions / Naming conventions
• nbsbt plugin / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans
• NEScala / Summary
• not only SQL (NoSQL) / Exploring MongoDB

O

• onComplete() method / The Async library – SIP-22-Async
• option construct
  • about / Introducing the Option construct
• ORM
  • about / Integrating an existing ORM – Hibernate and JPA
  • replacing / Replacing ORM

P

• -paste command / Combining web services
• param argument / Timing code execution in the REPL
• parser combinators
  • URL / Tackling external DSLs through parser combinators
• partition method / A glimpse at pattern matching
• pattern matching
  • about / A glimpse at pattern matching
• Play
  • web services, calling from / Calling web services from Play
• Play-Akka-Angular-WebSocket template
  • about / The Play-Akka-Angular-WebSocket template
• play-json library / Calling web services from Play
• Play application
  • architecture / Architecture of a Play application
  • framework stack, visualizing / Visualizing the framework stack
  • request-response lifecycle, exploring / Exploring the request-response lifecycle
  • controller request, handling / Handling a request in the controller
  • view, rendering / Rendering the view
• Play application, scaffolding
  • about / Scaffolding a Play application
  • test data, importing / Importing test data
  • H2-browser database, visualizing / Visualizing the database in the H2browser
  • app generation code, exploring / Exploring the code behind the app generation
  • playcrud utility, limitations / Limitations of the playcrud utility
• playcrud utility
  • limitations / Limitations of the playcrud utility
• Play Framework
  • using, tips / Practical tips when using Play
  • debugging / Debugging with Play
  • version control / Dealing with version control
  • persistence / Dealing with persistence in the Play Framework
  • example, Anorm used / A simple example using Anorm
• Play JSON
  • about / Using Play JSON
• Play requests
  • handling, with XML / Handling Play requests with XML and JSON
  • handling, with JSON / Handling Play requests with XML and JSON
• Play responses
  • mocking, with JSON / Mocking Play responses with JSON
• Play responses
  • mocking, with JSON / Mocking Play responses with JSON
• publish-local command / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans

R

• reactive applications
  • about / Describing reactive applications
• Reactive Manifesto
  • URL / Describing reactive applications
• ReactiveMongo project
  • URL / Applying MapReduce transformations
• reactive real-time search
  • about / Reactive real-time search
• reactive stocks
  • about / Reactive stocks
• react to events
  • about / Describing reactive applications
• react to failure
  • about / Describing reactive applications
• react to load
  • about / Describing reactive applications
• react to users
  • about / Describing reactive applications
• receive() method / Understanding the Actor model, Supervising actors to handle failure
• Receiver actor / Playing with Actor Room
• reduce method / Naming conventions
• remove{} method / Entering Casbah
• REPL / Better fit for asynchronous and concurrent code
  • as scripting engine / The REPL as a scripting engine
  • copy and paste feature / Copying and pasting in the REPL
  • timing code execution / Timing code execution in the REPL
• request-response lifecycle, Play application
  • exploring / Exploring the request-response lifecycle
• require() assertion / Switching behavior
• REST API
  • creating, from existing database / Creating a REST API from an existing database
  • sample database / The sample database
  • Maven project, setting up / Setting up a Maven project
  • JPA entities, creating / Creating JPA entities and REST web services
  • REST web service, creating / Creating JPA entities and REST web services
  • project, testing / Running and testing the project
  • project, running / Running and testing the project
• REST web service
  • creating / Creating JPA entities and REST web services
• ResultSet object / A simple example using Anorm
• run method / Understanding Iteratees in Play

S

• @ sign / Rendering the view
• SBT
  • about / Building with Simple Build Tool (SBT)
  • sample project, creating / Creating a sample project
  • Eclipse project, importing / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans
  • IntelliJ / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans
  • web application, creating / Creating a web application that runs on a servlet container
  • single .jar archive building, sbt-assembly used / Using sbt-assembly to build a single .jar archive
  • code, formatting with Scalariform / Formatting code with Scalariform
• sbt-assembly
  • using, to build single .jar archive / Using sbt-assembly to build a single .jar archive
• sbt-idea plugin / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans
• sbteclipse plugin / Importing the project in Eclipse, IntelliJ IDEA, and NetBeans, Writing tests with ScalaTest, Binding XML data in Scala
• Scala
  • learning, through REPL / Learning Scala through the REPL
  • test, adding / Adding a test in Scala
  • setting up, within Java Maven project / Setting up Scala within a Java Maven project
  • JPA availability / Making JPA available in Scala
  • XML data, binding / Binding XML data in Scala
  • DSLs / Introducing DSLs in Scala
• Scala.io / Summary
• Scala.js
  • about / Introducing Scala.js
• scala.util.Try class / Handling exceptions
• Scala and Java collaboration
  • about / Scala and Java collaboration
  • collection types / Converting between collection types
  • JavaBean-style properties / JavaBean-style properties
  • object orientation / Scala and Java object orientation
  • enhanced Java interfaces / Scala traits as enhanced Java interfaces
  • objects, declaring / Declaring objects
  • companion objects / Introducing companion objects
  • exceptions, handling / Handling exceptions
• ScalaCheck
  • testing with / Testing with ScalaCheck
• Scaladays / Summary
• Scala dispatch library
  • URL / Working with HTTP
• Scala events / Summary
• Scala eXchange / Summary
• Scala for Java projects
  • advantages / Advantages of using Scala for Java projects, More concise and expressive, Increased productivity, Better fit for asynchronous and concurrent code
• Scala Improvement Process (SIP) / The pillars of Concurrency
• ScalaMock
  • mocking with / Mocking with ScalaMock
  • URL / Mocking with ScalaMock
• Scala REPL (Read-Eval-Print-Loop) / Better fit for asynchronous and concurrent code
  • about / Learning Scala through the REPL
  • var variables, declaring / Declaring val/var variables
  • val variables, declaring / Declaring val/var variables
  • classes, defining / Defining classes
  • case classes / Explaining case classes
• Scalariform
  • code, formatting with / Formatting code with Scalariform
• ScalaTest
  • about / Writing tests with ScalaTest
  • BDD-style testing / BDD-style testing
  • functional testing / Functional testing
• ScalaTest class / Writing tests with ScalaTest
• Scala Worksheets
  • about / Experimenting with Scala Worksheets
• scalaxb
  • running, from SOAP web service / Running scalaxb from a SOAP web service
• scalaxb library / Binding XML data in Scala
• Selenium tool
  • URL / Functional testing
• Server Side Events (SSE) / Reactive real-time search
• Simple Build Tool (SBT) / Setting up Scala within a Java Maven project
• single .jar archive
  • building, sbt-assembly used / Using sbt-assembly to build a single .jar archive
• singleOpt method / A simple example using Anorm
• Slick framework
  • benefits / Replacing ORM
  • about / Learning about Slick
• SOAP web service
  • scalaxb, running from / Running scalaxb from a SOAP web service
• social security number (ssn) / Declaring val/var variables
• Spark
  • about / Scratching the surface of Big Data
• Spring
  • URL / Making JPA available in Scala
• square() method / Introducing Scala.js
• static keyword / Declaring objects
• StockActor
  • about / Reactive stocks
• streams
  • handling / Handling streams reactively
• String Interpolation
  • about / Looking at String Interpolation
• StringSpecification test / Testing with ScalaCheck
• SummingBird
  • about / Scratching the surface of Big Data
• system.actorOf() method / Understanding the Actor model

T

• TAB completion / Defining classes
• test
  • adding / Adding a test in Scala
• test-only command / Writing tests with ScalaTest
• testing
  • BDD-style testing / BDD-style testing
  • functional testing / Functional testing
• timeAndLogged() function / Timing code execution in the REPL
• timedAndLogged() function / Timing code execution in the REPL
• timedAndLogged() method / Timing code execution in the REPL
• timing code execution, REPL / Timing code execution in the REPL
• TravelAgent object / Switching behavior
• tuples / Dealing with tuples
• Type Inference / Declaring val/var variables
• Typesafe Activator
  • about / Taking advantage of Typesafe Activator, Getting started with the Typesafe Activator
  • application creating, based on activator templates / Creating an application based on activator templates
• Typesafe page
  • URL / Better fit for asynchronous and concurrent code

U

• unit test
  • adding, in Java / Adding a unit test in Java
• using() function / Timing code execution in the REPL
• using() method / Timing code execution in the REPL

V

• view, Play application
  • rendering / Rendering the view
• VIPCustomer class / Scala traits as enhanced Java interfaces

W

• -wrap() method / Timing code execution in the REPL
• web application
  • creating / Creating a web application that runs on a servlet container
• web services
  • calling, from Play / Calling web services from Play
• Web Services Description Language (WSDL) / Running scalaxb from a SOAP web service
• WebSocket.async[JsValue] method / The Play-Akka-Angular-WebSocket template
• WebSockets
  • about / Experimenting with WebSockets and Iteratees in Play
• with keyword / Scala traits as enhanced Java interfaces

X

• XML
  • manipulating / Manipulating XML
  • Play requests, handling with / Handling Play requests with XML and JSON
• XML data
  • binding / Binding XML data in Scala