Beginning Scala Programming

Set up eclipse for scala, create a scala project and worksheet, and use the scala interpreter to evaluate expressions and save results for later study.

Explore the Scala type hierarchy from any to nothing, noting that all values are objects and there are no primitives. Also learn unit and option to avoid null pointer errors.

Explore declaring variables in Scala with val and var, understand the memory model with no primitives, apply type inference, and use tuple patterns to return multiple values.

Explore the scala match expression and its powerful pattern-based cases, including wildcards and tuple patterns. See how match differs from switch, avoids fall through, and binds variables for results.

Learn to write recursive functions in Scala, from factorial to a pi estimate using random darts, and see how nested helpers and explicit return types shape recursion and stack usage.

Adopt a tail-recursive approach by introducing an accumulator to prevent stack overflow when estimating pi with many iterations. Observe how Scala's tailrec annotation guides optimization, turning recursion into a loop.

Explore sequences in Scala by creating and comparing array and list. Compare vector, buffer, and range while learning uniform indexing, immutability, cons, and performance implications.

Discover how to create large arrays and lists, and compare vectors and buffers with fill and tabulate in Scala, while exploring currying, pass by name, and lambda expressions.

Explore the Scala API and how implicit conversions apply arrays in collections. Learn why there are no static methods and how fill and tabulate build various dimensional arrays.

Explore sequences and common methods that work on arrays, lists, and vectors, emphasizing immutable, functional operations like ++, :+, drop, take, splitAt, and slice.

Explore higher-order methods like flat map, exists, for all, and reduce left. Compare map with flat map, understand fold versus reduce, and use take and take while for collection operations.

Learn how the Scala find method uses the option type to return some value or none, and explore map, filter, getOrElse, and other higher-order methods on option.

Explore how to use pattern matching with collections in Scala, including arrays and lists, and leverage case classes to bind values and enable class-level pattern matching.

Create a Scala IO source from a file and iterate over its lines, skip header data, and prepare to map remaining lines into a case class array for structured data.

Parse the San Antonio weather data file using a Scala source and iterator, map lines to a case class with day, year, precipitation, and temperatures, and extract the maximum values.

Explore loops in Scala, starting with while and do-while, then mastering for loops, until ranges, and for comprehensions with yield to produce values from collections.

Explore advanced for comprehensions in Scala: multiple generators yield tuples, use variables and guards, and understand map, flatMap, filter, foreach, and parallel collection execution.

Discover partial functions in Scala, contrast them with complete functions, and learn their syntax using braces and cases, including type declarations and exception behavior for undefined inputs.

Explore object orientation in Scala by building a simple application and a multi-user text environment. See how singleton objects replace static methods within an inheritance hierarchy.

Explore an imperative text adventure in Scala, focusing on mutable design, companion objects and apply, and how traits, abstract members, and overriding shape a player class.

Explore imperative programming in Scala by building a text adventure: manage rooms, items, and player state through an input-driven loop, options, and companion objects for commands.

This lecture demonstrates a fully functional text adventure in Scala, using immutable data, recursion, and tail recursion to replace loops, returning new player and room maps instead of mutating state.

Explore special methods in Scala, including apply and operator-style names on a 3d vector and a complex number class. Learn how precedence follows the first character and how infix notation.

Examine how Scala handles special methods and names, including private balance access and require checks. Demonstrate how balance_ = and update enable assignment and indexing with apply.

Explore implicit conversions and implicit arguments in Scala, learn how to define and import them, and see how they enable operations like scalar times a vector and complex number arithmetic.

Discover how Scala trait linearization resolves method calls in multiple inheritance, using right-to-left resolution with buffers and binary formats in a printer scenario.

Explore self types in Scala to enforce dependencies between writer user and its right method via traits, and learn how trait mixing and linearization shape printing, buffering, and binary formats.

Learn to set up scala test in Eclipse by installing the scala test plug-in and adding its jar to the build path, then run tests to see a green bar.

Learn to read and parse XML data using Skala's ex-MIL, load files, search with backslash, and map XML nodes to room and item objects by accessing attributes such as name.

Learn how to build and write XML using Scala's XML literals, embedding Scala values with curly braces, and serialize a player with name, room, and items to an ex-MIL file.

Explore how Scala wraps Java regular expressions for powerful pattern matching, using raw strings and dot r syntax to extract area codes with find all match in and groups.

Learn how parser combinators extend regular expressions to parse context-free grammars in Scala, converting an expression grammar with plus, minus, multiply, divide, numbers, variables, and parentheses using Java token parsers.

Explore building a composite parse tree from a math expression using parser combinators in Scala, enabling efficient evaluation of expressions by prebuilding a sealed expression tree (numbers, identifiers, operations).

Demonstrate parser combinators for a text adventure by adding a single parser to the player that handles get, drop, and look commands, including look at objects and look in directions.

Explore parallelism in Scala through parallel collections and the par API, illustrate race conditions with a mutable var, and show how yield enables safer, ordered results with Fibonacci-style computations.

Explore actor parallelism in Scala using Akka to scale applications up and out by sending messages to actors, ensuring no two threads process the same actor and avoiding race conditions.

Two Akka actors exchange immutable messages to count down from 10, printing each value each second and shutting down at zero. The lesson highlights immutable messages and careful sender handling.

Explore the ask pattern with futures in the actor model, learning non-blocking message exchanges, how to use onSuccess with execution contexts, and considerations for distributed systems.