The source content for blog.juliobiason.me
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

83 lines
3.8 KiB

+++
title = "Functional Python Programming - Create Succinct and Expressive Implementations with Python - Steven F. Lott"
date = 2020-08-27
[taxonomies]
tags = ["books", "review", "it", "steven f lott", "python", "functional",
"1 star", "2020 challenge"]
+++
[GoodReads Summary](https://www.goodreads.com/book/show/24925633-functional-python-programming---create-succinct-and-expressive-implement):
With Functional Python Programming by your side you’ll understand the core
concepts of function Python, its impact on the programming workflow, and how
to implement it in Python, giving you the ability to take your applications to
an even higher level.
<!-- more -->
{{ stars(stars=1) }}
Another book the proves my theory that the quality of a book is inversely
proportional to the amount of "as follows".
But functional programming in Python is generators.
That's it: Generators. Oh, generators and tuples.
There is a lot in this book, but mostly seems... wrong. For example, talking
about "tail call optimization", when Python does not have them. And then
talking how to optimize those -- which, again, it is plain "replace with a
generator".
Also, the case for tuples is that namedtuples is mentioned, but rarely used.
This makes code hard to read, except the author decided to create lambdas to
extract them, so you end up with a bunch of `xy_g = lambda p: p[0][1][0]`.
What the fuck is `0`, `1` and `0` again in this? Why not use name tuples and,
instead of this atrocity, go with `p.position.x`?
Other examples of wrong things:
- "extract the docstring function": Doctstrings are strings, not functions.
- "GNU Image Manipulation Program (GIMP) GNU General Public License (GPL) file
format": Neither GIMP not GPL is a file format; one is a photo editor and
the other is a license.
- "This is relatively simple implementation copied from the World Wide Web":
And we all know how things on the web are reliant.
- "We can use `((line.split() for line in file)` to create a sequence of ten
tuples": First of all, yes, the there is some unbalanced parenthesis
there; second, that thing won't generate ten tuples, it will generate as
many as the lines in the file -- which is never shown, by the way.
- Calling functions that return generators "higher-order functions". And no,
the function does not receive a function, it simply returns a generator.
- "perms = permutations(range(6)))))". Yup, there are 4 extra closing
parenthesis.
- Splitting a string with a path in it by `/`, then checking the first value
instead of, say, `path.startswith('expected_value')`.
- "We've created a Counter() function": Counter is a class, not a function.
- Lots of "not clear if this is helpful". Ok, showing some sort of code is ok,
but not explaining where if it is useful -- or if it is useful at all --
is plain... lazy.
- "We've shown the loop here to clarify that the server must, generally, be
crashed": It's the first time that I see that we expect a server to be
crashed.
- There is a convoluted aggregation grouping things in a dictionary with a key
and a count, and then using `Counter()` to check the number of times
something appear. Problem is, when `Counter()` process the dict, it will
get only the keys, so the whole process of generating the dictionary is
completely useless.
- By the end of the book, I'm not sure if things are being double
double-quoted (as in ""this is string"") or quadruple single-quote
(''''this is string'''') -- but neither format is valid Python.
Besides all that, there is a bunch of explanations that are very much akin to
> `a = a + 1`
>
> Adds 1 to `a`
Also, there are chapters for multiprocessing, which has absolutely nothing
functional about it and WSGI, which, again, has nothing functional about it.
The whole book feels rushed and badly reviewed -- if reviewed before
publishing at all.