This post is the introduction and overview to the Absolute Basics in Scala post series. Includes initial instructions for setting up your development environment
In this the first post on our series of the absolute basics in Scala, we look at values, variables and types - the initial building blocks to get familiar with
Discussion on expressions, one of the fundamental building blocks in Scala. Includes a look at relational operators and loops
No doubt you will have heard of functions from other programming languages, but in this post we introduce them in Scala
In this blog post we will explore stack and tail recursion in Scala, including examples of both methods. If you haven't seen recursion before this post should be of help to you!
This blog post looks at calling Scala functions either by name or by value and the difference between the two methods.
A detailed look at specifying default arguments in Scala functions, and naming arguments when calling functions. Includes examples of when you might use these techniques
In this final post of the series, we focus on some of the main operations used to manipulate strings in Scala. Some operations are borrowed from Java, whilst others are exclusive to Scala
This post is the introduction and overview to the Object Oriented Programming in Scala post series. Covers what you can expect to learn in this series of posts
We set the scene and start our look at objected oriented programming in Scala by exploring some of the basics in this post.
In Scala there are numerous method notations and shorthand ways of writing method calls, we will look at a few of them in this post
A deeper dive on objects in Scala, including how they can be used to replace the traditional "static" keyword from Java
See how to use inheritance and traits in Scala, including how to use constructors and access modifiers. The concept of inheritance is similar in Scala to other languages
In this post we will look at the concept of generics in Scala, and how we can use them on multiple (potentially unrelated) data types
Follow up your learnings of inheritance and traits in Scala with an in-depth look at Anonymous Classes. Includes how the compiler instantiates anonymous classes
Expand on the MyList application developed previously, turning it into a complete covariant generic list. This in-depth post covers a lot of ground previously seen in our journey up till now
Case classes are a small but very powerful feature of Scala. They are a way of defining light data structures with as little boilerplate code as possible, and with a lot of features.
Exceptions in Scala are inherited from the JVM, i.e. from Java. In this post, we will look at how to throw and catch exceptions, as well as defining our own custom ones
In this the final blog post on our series of Object Oriented Programming in Scala, we take a look at how packaging and imports both work
This post is the introduction and overview to the Functional Programming in Scala post series. Covers what you can expect to learn in this series of posts
In this the first post in our series on Function Programming in Scala, we take a deeper look at Functions and introduce Scala's Function Types
We already learned about anonymous classes in a previous blog post. In this post, we learn about anonymous functions in Scala
In this post we will look at higher order functions and curried functions in Scala. These are a critical concept for functional programming
Map, FlatMap and Filter are used extensively in functional programming and in Scala. This post will look at all three of them, as well as foreach comprehensions
A Sequence in Scala programming is a very general interface for data structures that has certain properties. We will explore them in this blog post
In this blog post we will explore the relationship between Tuples and Maps, and how they can assist us with functional programming in Scala
This post will explore the use of Options in Scala, and how they are used to guard against the dreaded null pointer exception that we so often see in programming