I shared a couple of my first impressions reading the Functional Reactive Programming book, and I am back with more after going a bit further with the book. I am spending this weekend in beautiful Queenstown, New Zealand for the Queenstown Winter Festival so this post is shorter than usual.
This book is not a ‘cookbook’ – it is not a collection of code recipes you can read and then easily apply in your code.
This book is not a ‘For Dummies’ or ‘Learn xyz in 24 Hours’ book – it is not partitioned into bite-sized chapters that are equally spaced out.
I would place this book in the intersection between a textbook and a reference book. It is trying to evangelise new concepts and frameworks via large examples, like a textbook. It is also organised in a way that makes it easy to jump back at a later stage to refresh one’s memory, as the core concepts are contained within a single chapter (the previously-mentioned dense Chapter 2).
The chapters themselves interchange between theoretical chapters and coding example chapters. The note in Chapter 4 summarises my thoughts perfectly:
“This chapter is quite dense, and we think it will repay any effort you spend on it, but there is no reason why you have to study it all closely now. If it fits your learning style, feel free to read parts of it briefly then carry on with the book and come back to it later.”
I think this note is equally applicable to the entire book. I wish to clarify that this is not necessarily a negative aspect – the big concepts in life sometimes need a few read throughs to be able to grasp. Do I wish that it was easier to learn? Yes.
Pro Tip: A lecturer friend of mine once shared his secret to quickly reading lots of academic papers. He scans the executive summary at the front, then jumps to the conclusion at the back to pick out the main gist of the paper. He then reads the main content if he decides there is something worthwhile about it. This tip is very much relevant here. There have been many times that I found the concepts easier to comprehend once I scanned the summary.
Think of it as a journey: the introduction describes the destination, while the chapter summary describes the journey you were on. Reading these two parts first make the journey itself more enjoyable as your eyes are peeled to spot the landmarks coming up.
Thankfully, this is not a dry text. The writing style is quite conversational at times, as if you are reading a series of blog posts. There is also friendly jabbing between the co-authors, almost like the editor’s notes in newspaper articles. Jokes are strewn sparingly around – some clever and some cringey. It definitely helps lighten the mood.
On the downside, jokes sometimes distract from the learning at hand. Here’s an example from Chapter 2. A note after the explanation of the map primitive said:
“When my co-author says “more generally” he is invariably trying to trick you into learning functional programming. Don’t fall for it. You can ignore these parts and focus on the examples.”
Here I was in a serious headspace trying to digest all these new concepts of cells and streams, how streams are like events (but not exactly), how the map primitive transforms streams… and suddenly here’s a jibe about ignoring parts of what I just read. It broke the flow – and I certainly wasn’t laughing. A good joke is as much about timing as it is about the punchline.
Pro Tip: Most of the notes in this book are meta. I would recommend ignoring them on your first read through.
This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.