Exercises in Programming Style

I have not yet read the whole book, but I have greatly enjoyed the chapters on the following styles: Monolithic (chapter 3), Cookbook (4), Pipeline (5), Infinite Mirror (7), Kick Forward (8), The One (9), Quarantine (24), Map Reduce (30), Double Map Reduce (31). The author makes the code (in Python) available for free in a GitHub repository; it may be downloaded as a zip file using the "Download Zip" button in GitHub. Even though I am not a Python programmer, I was able to install Python and get the code running quickly. Note that the code is written in Python 2 (not Python 3), so you need to install a (free) Python 2 compiler to run it.The book is well written and edited. To the editorial reviews, I would add that the Historical Notes and Further Reading sections are excellent, and that the Commentary makes it possible to read the chapters in a non-sequential order, because of the good references to other chapters. For example, the commentary in chapter 5 ("Pipeline"), which is the chapter about the basic function composition style, refers to the Cookbook style (chapter 4), the Quarantine style (chapter 24, on Monadic IO), and the Map Reduce style (chapter 30).The author cautions that the book is not intended for beginners. I agree. As a Computer Science textbook, it could be used as a supplement in an upper division Concepts of Programming Languages course; this is how I am considering using it. It could be the basis for a Comparative Programming Languages course for beginning graduate students in Computer Science.

I loved the concept of the book: departing from a literature styles book to make another one about programming styles.It's nice to see a comparison between one's first code entitled "Good Old Times" and the other ones. Pipeline (Chapter 5) was the style that caught my attention the most.However, this book feels like it is more destined to those who are into theoretic computer science rather than concrete Software Engineering.

This book solves a simple problem in Python over and over again. Each time it uses a different style of programming, some of which are idiomatic, and some of which look downright odd. After each program there is an explanation of the style, when it is useful, and a brief history.Each program is only as long as needed, rarely more than a page, and illustrates the key points of the style. It's a little like hearing many different styles of music played on a piano.

An easily consumed, enjoyable read, and excellent review of the history of programming style, from older days of constrained memory and monolithic styles, through pipelining and object-oriented variants, to more recent patterns like model-view-controller (MVC), mapreduce, and representation state transfer (ReST). Along the way, each variant is described, along with its constraints, its history, and its context in systems design.

Very useful book

Very nice book! Excellent to be used as the basis for an advanced programing coarse!

This is a really great book for software engineers. If I were managing a group of developers (as I did earlier in my career) I would buy a copy for each engineer.The book is targeted to either old hacks like me, who enjoy reading about the history of different programming styles, or graduate-level students in computer science. Speaking as an old hack, I felt as though the book was having a conversation with my inner dialogue - things I have thought about to myself but rarely talk about - things like how do you explain to a bad programmer why their program is bad.The author uses one particular programming task: identifying the most common words in a text file and sorting them by frequency and shows 33 different ways of accomplishing the task in Python. She presents the 33 different styles mostly chronologically and notes their historical significance, which is one reason why this book is so much fun for the 62-year-old software engineer in 2014.As it happened, after spending the weekend reading most of this book I had occasion to write a similar file i/o utility in C, so it was very amusing for me to realize that my first stab at it was naturally "monolithic" (the most primitive style).Many many useful concepts. One of the few books I have ever read where it is important to read the preface. The author talks about the "constraints" in any programming project - some of these constraints can be self-imposed: I can remember at one point in my career, about 30 years ago, when I was programming in Pascal, deciding that I would not use any global variables - this would be an example of a self-imposed constraint - and over the years I often find myself deciding to adopt some particular style or "constraint" just to see what would happen.Over the years I have been paid to program in Assembler, "C", Pascal, horizontal microcode, Forth, C++, Java, Python and Javascript and have done coursework using PL/I and Lisp. One of my takeaways from this book is that I would like to learn Haskell.

It's a historical tour of programming techniques and the languages that realized them. The programming task is to solve the word frequency problem using techniques associated with particular programming languages and the style of programming they promote. Even though the examples are written in Python they are easy to follow whether or not you know the language.There's even a F# implementation of the techniques available on the web.

The book presents and describes several programming styles using a very interesting approach. The book is focused on style, but some styles' implementations have big running times with large input data (complexity issues).The use a Python as software language is adequate. Very much recommended.

Content is deep. This is not a book for the fainted heart.