Functional Programming, Simplified — currently 5-star rated on Gumroad.com, 4.5-star rated on Amazon, and one of the all-time best-selling books on functional programming — is currently on sale in three formats (prices shown in USD):
|
PDF Format
|
Paperback Book
|
Kindle eBook
|
NOV., 2022: My new book, Learn Functional Programming The Fast Way, is currently an Amazon Java and functional programming #1 new release. The book is now available in three formats:
|
PDF Format
|
Paperback
|
Kindle
|
I’ve been slowly working on a series of new Scala programming books, and today I’m proud to announce the first of these:
Starting today you can buy the PDF version of Learn Scala 3 The Fast Way! for just ten dollars — $10 (USD) — at this Gumroad.com URL.
As a brief note today, I just released the first version of a new, free book/booklet that I’ve titled Learning Recursion.
Since I’ve written two functional programming (FP) books, I thought it might help to provide a comparison of them.
The short story is that both FP books have “limited technical jargon,” and as shown, The Little FP Book essentially has one purpose, which is to help Java/Kotlin/OOP developers learn functional programming as fast as possible, using a technique that I “discovered” over the last few years.
Conversely, The Big FP Book covers many topics in great detail.
If you’re interested in more details, here are links to the two books:
Some of the computer programming books on the right side of this image are amazing, and I would never discourage anyone from reading the great ones.
But if you’re an object-oriented programming (OOP) developer who wants to start understanding functional programming (FP) over a weekend or a few nights of reading, that’s the goal of the new little book on the left: Learn Functional Programming The Fast Way. It takes you from Java/OOP to functional programming in the simplest possible step-by-step learning process.
I taught Java and OOP for many years, and have used other OOP languages like Kotlin, Python, and Flutter/Dart, so I understand both OOP and FP, and I think that helped to make this a simple book for learning FP.
I also wrote the FP book in the middle — Functional Programming, Simplified — and it’s about three times larger than the little book on the left. I based it on most of the FP books on the right, and it goes into many details that the book on the left doesn’t go into. It’s big, but it’s still easier than reading all the books on the right.
When you get started with functional programming (FP) a common question you’ll have is, “What is an effect in functional programming?” You’ll hear advanced functional programmers use the words effects and effectful, but it can be hard to find a definition of what these terms mean.
A first step in the process of understanding effects is to say that they’re related to monads, so you have to know just a wee bit about monads to understand effects.
But fear not, this is surprisingly simple. As I write in my book, Functional Programming, Simplified, a slight simplification is to say that in Scala, a monad is any class that implements the map and flatMap methods. Because of the way Scala for-expressions work, implementing those two methods lets instances of that class be chained together in for-expressions (i.e., for/yield expressions).
April, 2024 Update: This ZIO cheatsheet is currently being updated to ZIO 2.x, but it’s still a work in progress.
If you want a good cheat sheet right now, see this one on github. I’m creating my own as I learn ZIO and read the ZIOnomicon book. During the learning process I find that it’s much better to create your own by hand, that way you get something that’s meaningful to you.
Note that almost all of these initial examples come from the ZIOnomicon book and the video that I link to later.
Here’s a link to the ZIO Scaladoc. That’s for the companion object, and this link is for the companion trait.
As I work more with ZIO 2, I also find myself thinking a lot about the ZIO 2 mental model, by which I partially mean “a way of thinking about your code” and also “ZIO 2 best practices.”
Here are my initial notes. Also, I hope that most of this code is mine, but several snippets are from other sources that I don’t remember, including the official ZIO 2 docs.
This page provides a comprehensive overview of error-handling strategies in ZIO 2. My hope is that you can use this decision tree to determine good/best approaches for handling errors in your ZIO effects. Each section includes a use case (question/answer), brief explanation, and ZIO 2 example.
As a brief note, I have ensured that the following examples compile, but at some point I need to take the time to double-check my work.
If you’re interested in logging in a ZIO application, the following example shows a collection of different ways you can write log messages. I also show how to create your own custom log format, so the output logging from this application looks like this:
I’m starting to publish my next free video course, called ZIO HTTP + Caliban. You can find it at that website, and it’s free, thanks to the people at Ziverge.
Here’s a comprehensive guide to implementing retry logic in ZIO 2 applications, using various scheduling strategies.
Please note that I haven’t double-checked that all of these examples compile as-is, but I do demonstrate many of these in my free Scala and ZIO 2 training videos. (I also added a complete working example at the end.)
As a brief note today, here’s some skeleton code for a ZIO (ZIO 2) application that needs to run forever. It (a) does what it needs to do, then (b) sleeps for a minute, and then (c) goes back to Step A, doing whatever it needs to do, forever.
I wanted to share this code because I think it’s probably a very common pattern and need in the ZIO world — writing an application that needs to run forever, on a schedule.
Also note that the code is written using Scala 3, but the syntax can be changed to use Scala 2, if you need to. I also added a layer/ZLayer to the code to make it a little more “real world.”
All that being said, here’s the ZIO “run forever” code:
This statement from the book, Learning Concurrent Programming in Scala
As a brief note today, here is some source code for a ZIO ZLayer application using Scala 3. In this code I use the ZLayer framework to handle some dependency injection for a small application. (Note that I don’t like to use the word “simple” when writing about computer programming, but I have tried to make this as simple as I can.)
I’ve commented the code below as multiple “parts” so you can see the thought process of creating an application that uses ZLayer. Basically the idea is that your application needs some sort of service — which might be like a database connection pool, HTTP framework, etc. — and then you make that service available to your application with ZLayer’s provideLayer function (or one of its other functions).
Given that small introduction, here’s my ZIO ZLayer example, with many notes shown in the comments inside the code:
If you’d like to buy a signed copy of the Scala Cookbook, here’s a link to one I have on sale at ebay.
As I note on ebay, I only have seven copies of the Cookbook, and this is Book #4 out of 7.
As a quick note today, here’s a list of my currently-free books and online video courses about the Scala programming language and functional programming (as of October, 2024):
These books and courses are free thanks to the generosity of Ziverge. If you ever want to pay them back, check out their “on-demand team extension services.”
I just had a situation where I wanted to convert this Scala Map:
val userPrefs = Map(
"theme" -> "dark",
"lang" -> "en"
)
into a formatted String that looks like a collection of key/value pairs, like this:
"theme=dark;lang=en"
In short, I found this to be a good solution:
Server-side HTTP FAQ: When you're writing a server-side application, are cookies considered to be part of the header information?
Yes, cookies are part of the HTTP headers. Specifically: