Buy and Download - LiveLessons Scala Fundamentals

2013
LiveLessons | informit.com
Dan Rosen
~5h
English

In Scala Fundamentals LiveLessons, developer and trainer Dan Rosen teaches the essentials of the Scala programming language. The video training covers:

Scala’s background and development history
The basic mechanics of writing and building Scala code using the sbt build tool and the Scala IDE plug-in for Eclipse
Fundamental control-flow structures and type inference
Scala’s approach to object-oriented programming and design
The basics of generic programming
The basic functional programming idiom and Scala’s collections API
"Real-world" considerations including Java interoperability and common pitfalls

Introduction
Lesson 1: Getting Started with Scala talks about Scala’s origins in both object-oriented and functional languages, and its development history and design goals. The lesson goes over the steps of setting up a development environment, including the sbt build tool, and the Eclipse IDE, and finally getting viewers comfortable navigating the standard Scala documentation.
Learning objectives
Understand Scala’s background
Set up sbt
Set up Eclipse
Navigate the Scala documentation
Lesson 2: Data and Control Flow covers the basics of declaring variables and evaluating expressions in the Scala interpreter. The lesson talks about type inference, which spares developers the burden of writing repetitive type signatures all over the code. The lesson helps viewers to understand how expressions compose cleanly into methods, as well as a new, powerful kind of expression called pattern matching, and it explores how most of the familiar control-flow structures such as “try-catch” blocks and even “for” loops can be treated as composable expressions. At the end of the lesson, Eclipse is used to implement a simple calculator application.
Learning objectives
Declare variables and evaluate expressions
Explore the type lattice and use type inference
Define methods
Explore pattern matching
Handle exceptions with patterns
Transform data with for-comprehensions
Implement a postfix calculator
Lesson 3: Object-Oriented Programming reviews some basic object-oriented concepts, but assumes viewers have seen the basics before and focuses more time on Scala’s newer features. The lesson covers singleton and companion objects, including special factory methods and integration with pattern matching. Viewers derive a very useful design pattern which combines two additional, new object-oriented features in Scala---case classes and sealed classes---to model data with a minimum of boilerplate. Viewers also see how mix-in traits provide a predictable mechanism for composition and code reuse. Finally, the lesson revisits the calculator, using Scala’s object-oriented features to improve its overall quality and readability and to expand its capabilities at the same time.
Learning objectives
Define classes
Define singleton objects
Implement apply and unapply methods
Eliminate boilerplate with case classes
Apply polymorphism and inheritance
Compose behavior with traits
Expand the calculator with object-oriented style
Lesson 4: Introduction to Generics covers the basics of how generic classes and methods are defined. The goal is to get viewers comfortable with the syntax of type bounds and variance annotations. Combined with everything viewers have learned to this point with generics in lesson four, viewers will finally be able to dive into functional programming in lesson five.
Learning objectives
Implement generic classes and methods
Understand variance annotations
Lesson 5: Functional Programming starts out by looking at first-class function objects, immutable lists and structural recursion. From there, the lesson generalizes to higher-order functions such as map, filter and fold, and has fun with some “functional gymnastics” using a technique called currying. Finally, the lesson revisits the calculator again, which really demonstrates how using these techniques can save developers time and energy resulting in much more elegant, readable and bulletproof code.
Learning objectives
Explore function objects and literals
Understand purely-functional lists and recursion
Capture common patterns with higher-order functions
Manipulate functions with currying
Refine the calculator with pure functional style
Lesson 6: Real-World Scala leads developers in the right direction for their future endeavors with Scala. The lesson covers some of the more intimidating aspecs of Scala including implicits and Java interoperability. The lesson also covers common “gotchas” in pattern matching and type inference and provides general advice for code readability.
Learning objectives
Use implicits and Java interoperability
Avoid common mistakes
Summary

http://www.informit.com/store/scala-fundamentals-livelessons-video-training-downloadable-9780321927743