UP | HOME

Books
Books I read

☰
× logo-full-size.png

Home

Curriculum Vitae

Public Keys

GitHub

Books I read

SHA 256 Calculator

PLs & Tools

Blog

RSS Feed

Publications

Archive

Impressum

All lists, especially Boring, are incomplete.

1. Computer Stuff

  • The Pragmatic Programmer by David Thomas & Andrew Hunt
    • Also listended to the Audible audiobook. It is really fun!
  • Unix - A History and a Memoir by Brian Kernighan Interesting overview of the history of Unix at Bell Labs.

1.1. Programming Languages

  • Porgramming Erlang by Joe Armstrong
  • Programming Elixir >= 1.6 - Functional |> Concurrent |> Pragmatic |> Fun by Dave Thomas
    • Great book, though it inspired me to look at LFE rather than Elixir.
  • Programming Phoenix >= 1.4 by Chris McCord, Bruce Tate, and José Valim
    • Mmmh, I'm not a fan. I like to read these books basically twice. Once just front to back and once where I look at and re-implement the code. But I find the example hard to follow, continuously jumping between different files of the implementation. Maybe I'm just the wrong audience, I'm not really interested in front-ends and the whole approach makes it look like front- and back-end are tangled up. I know this is not the case because they use a MVC-architecture but continuously jump between the layers hides this really grossly. I think my way of thinking is just incompatible with the writing style which is sad because I can tell it is competently written.
  • Kotlin in Action by Dmitry Jemerov & Svetlana Isakova
    • I don't think Kotlin is a very interesting programming language. Many thinks seem arbitrary or surprising, for instance where a return in a lambda-function returns to depends on how it is instantiated. It's probably superior to Java, but let's not act like that's a high bar to pass. There DSL support through their receiver lambdas is nice though.
  • Racket Programming The Fun Way: From Strings to Turing Machines by James W. Stelly
    • A fun little book. It strikes an interesting balance between simple programming tutorial and actual computer science concepts. I can image it would feel right at home at in introductory computer science class at high school level. For someone with an already established background in computer science it is a fun little read now real ground is covered. (That's already established by the title anyway.) The most interesting thing was to see that is possible with Racket in ''as-is'' condition, really impressive. Racket really is batteries included.
  • The GO Programming Language by Alan A. A. Donovan & Brian W. Kernighan
    • Probably the best book-form introduction to Go I know of. It introduces all the major concept of Go with great examples through out. I would wish though that modules would be covered in ''Chapter 10: Packages and the Go tool''.
  • Programming Clojure, Third Edition by Alex Miller with Stuart Halloway & Aaron Bedra
  • Learning Perl: Making Easy Things Easy and Hard Things Possible by R. L. Schwartz, b d foy, and T. Phoenix
    • Fine introduction. The language looks a little I could randomly hit my keyboard and there would be a decent chance, that would be a legit program. Also, the language doesn't help you right correct programs at all. This could be a culture thing. Anyway, good introduction to a language I don't like.
  • Parallel and Concurrent Programming in Haskell by Simon Marlow
  • Programming in GO by Mark Summerfield
  • Erlang Programming by Fransesco Cesarini & Simon Thompson
  • The Little Schemer by Daniel P. Friedman & Matthias Felleisen
  • The Seasoned Schemer by Daniel P. Friedman & Matthias Felleisen
  • The Reasoned Schemer by Daniel P. Friedman, William E. Byrd, Oleg Kiselyov, and Jason hemann
  • The C Programming Language by Brian W. Kernighan & Dennis M. Ritchie
  • Programming Rust by Jim Blandy & Jason Orendorff
  • Building High Integrity Applications with Spark by John W. McCormick & Peter C. Chapin
  • Programming in Ada 2012 by John Barnes
  • R for Data Science by Hadley Wickham & Garret Grolemund
  • Practical Common Lisp by Peter Seibel
  • The Rust Programming Language by Steve Klabnik, Carol Nichols & Contributions from the Rust Community
  • Real World Haskell by Bryan O'Sullivan, John Goerzen & Don Stewart
  • Type-Driven Development with Idris by Edwin Brady
  • Verified Functional Programming in Agda by Aaron Stump

    • Great introduction to dependent types. Most examples that are implemented are founded in Computer Science and Mathematics. (eg. Kripke-Structures, Huffman-Encodings, Theorems about Boolean operations, etc.) If you are looking for a practical introduction to improve your programs, you might be better suited with Type-Driven Development with Idris by Edwin Brady. It also, as the title suggests, focuses more on a new development style compared to Verified Functional Programming in Agda by Aaron Stump. This is not to mean, that you can't use Type-Driven Development with Agda, it is just not focused on in this book. Most examples should be fairly straight forward to translate any program in either language in the other, their underlying constructs are very similar after all.

      What really annoyed me was not the content at all but the way it is printed. (Yes, I read the print version.) The right margin on the left page is to small. If you open book ''normally'' (like opening it on a flat surface) you can't read the whole page. A few letters in very line are hidden in the inner margin. This is just annoying because you could easily have in increased the right margin and decrease the left margin because the left margin is very big. Unnecessarily big even. That would be a easy fix to an annoying problem.

1.2. (Operating) Systems

  • Absolute FreeBSD by Michael W. Lucas
  • FreeBSD Mastery: Jails by Michael W. Lucas
  • FreeBSD Mastery: ZFS by Michael W. Lucas & Allan Jude
  • FreeBSD Mastery: Advanced ZFS by Michael W. Lucas & Allan Jude
  • FreeBSD Mastery: Storage Essentials by Michael W. Lucas
  • Understanding the Linux Kernel by Daniel P. Bovet & Marco Cesati
  • Distributed Systems - Principles and Paradigms by Andrew S. Tanenbaum & Maarten Van Steen
  • The Design and Implementation of the FreeBSD Operating System by Marshell Kirk McKusick, George V. Neville-Neil & Robert N. M. Watson

1.3. Tools

  • Autotools, 2nd Edition: A Practitioner's Guide to GNU Autoconf, Automake, and Libtool by John Calcote
    • Only skimmed to get an overview of how these tools work and to use them in a project. They seem mostly targetted towards C only. I suspect they can be used with other languages reasonably well too but that is not explained. If you have to use these tools and need(/want) an introduction in book form, this might be a good book. I strongly recommending reading the physical copy. The kindle edition is hard to read because the listings are broken sometimes, there is so view text on the screen that explainations of the listing is split through many kindle-pages and jumping back and forth is not really quick. I generally read these books on paper so I rarely comment on the kindle edition but this time I read it on the kindle and it was not fun.
  • Managing Projects with GNU Make by Robert Mecklenburg
  • Practical Vim by Drew Neil
  • Pro Git by Scott Chacon & Ben Straub
  • The Org Mode 8 Reference Manual by Carsten Dominik & others
  • gnuplot in Action by Philipp K. Janert
  • Learning GNU Emacs by Debra Cameron, James Elliott, Marc Loy, Eric Raymond & Bill Roseblatt
  • sed & awk: UNIX Power Tools (Nutshell Handbooks) by Arnold Robbins & Dale Dougherty
  • Forge Your Future with Open Source by VM (Vicky) Brasseur
    • Good book. Everything is explained in simple terms and is enjoyable to read. The complaint I have is that the answer to most questions is ''It depends.'' which even though true doesn't help a reader in that moment. ''It depends.'' is usually balanced with the place where the information can be looked up for a specific project. So it is not a total loss. To be clear, this is not the authors fault, it's just the state of affairs in FOSS. I would say this is a great book to get an overview of how to work in FOSS or how to approach a FOSS project. My personal favorite sentence: ''You don't inherently deserve to be in the center of the onion, you must earn it.'' (p. 125)
  • tmux 2 - Productive Mouse-Free Development by Brian P. Hogan
    • Establishes a good overview of tmux and how to use it in a practical fashion. It is short, 79 pages, but it is in the ''pragmatic express'' series of the publisher (''The Pragmatic Programmers''), so it is advertised as such. After reading it and toying around with tmux I feel comfortable enough to sit down at a tmux-session and get around. I won't use tmux on a daily basis because I live in emacs and that allows me to do most of what I would be doing with tmux. But if you want to get started with a more major terminal setup (maybe you code in vim and you want to run programs in split-screen in the same terminal), tmux is a fine choice. This book gets you there definitely. You won't be an expert but you will know enough to find all the information you need online and will be equipped to interpret them correctly. I especially liked the For Future Reference sections. They list all commands learned or mentioned in this chapter. Normally, I would keep such a list myself, but it is easier if they just but it in the book. It would be even better if they additionally but a complete list in the back or something. All in all, well worth a read if you are interested in tmux and since it is so short it isn't even a huge time investment to get started with the basics.
  • Modern Vim: Craft Your Development Environment with Vim 8 and Neovim by Drew Neil
    • Modern Vim introduces useful extensions to Vim and Neovim. The first four chapters focus on plugins to ease opening files (chap. three or navigating to errors (chap. four). It later also introduces built-in features like Session (chap. 6) that allow to quickly return to a previous state. Useful for everybody who wants to know how to bring their Vim setup to the next level. If you want an introduction, you should start with Practical Vim by the same author. The basics are prerequisites and not explained at all. Sadly, that is not clear from the title but anyone looking for such a book probably knows enough to first go for Practical Vim. It is a classic after all.

1.4. Mathematics

  • Communicating and Mobile Systems: The π-calculus by Robin Milner
  • Category Theory For Programmers by Bartosz Milewski
  • The Little Typer by Daniel P. Friedman & David Thrane Chstiansen
  • The Little Prover by Daniel P. Friedman & Carl Eastlund
    • Fun little book introducing how to prove theorems about programs. I suspect, it's not going to be applicable for big programs but it was a fun read for in between. Also, I couldn't get the prove assistant (JBob) to run, so I could not run the examples in the book.
  • Types and Programming Languages by Benjamin C. Pierce
  • Advanced Topics in Types and Programming Languages edited by Benjamin C. Pierce
    • This is a creat survey of different topics in this area. The writers' style resonated with me differently from chapter to chapter. That's probably the biggest reason why I enjoyed some chapters more than others. Since you are not really expected to read it cover to cover you can skip to the parts your are interested in and will be fine. I would expect that the people who read this have some familiarity with the material and are looking for specific piece of information or a reference, so it's fine. I really enjoyed it and took my time to work through some of the exercises. (Most of them have solutions in the back.) Definitely worth a read if you are looking to broaden your perspective about what Types can do for programming languages. Full Disclosure: This is more oriented towards research than the predecessor, their are no implementations in this book. I also found a few errors, nothing major but if something looks weird it may be worth to go to this page. It has resources and errata for the book.
  • Type Theory and Formal Proof by Rob Nederpelt & Herman Geuvers
  • The Art of Computer Programming - Volume 1 by Donald E. Knuth
  • The Art of Computer Programming - Volume 2 by Donald E. Knuth
  • Specifying System - The TLA+ Language and Tools for Hardware and Software Engineers by Leslie Lamport

    • This book describes the TLA+ Language(See below for a more detailed explanation) and a few tools that analyze it. It consists of four parts:

      1. Getting Started
      2. More Advanced Topics
      3. The Tools
      4. The TLA+ Language (Only skimmed)

      The First part introduces how to write basic specifications in TLA+. It introduces an intuitive semantic to explain most operators and should be sufficient for most people. The author and I agree in that respect. (See p. 3)

      The second part introduces advanced topics. Among these are Liveness, Fairness, and Real-time requirements, composition, and more advanced operators. I would have liked to see a more detailed description about composition. The composition in chapter ten mostly highlights the composition on a logical level. Using TLA+ on a larger scale requires are clear way to organize a large number of specification. At the moment, the tools described in this book don't help with this and I would have appreciated advice beyond ''Put all your Modules in one directory''. (The book is not current in terms of tools, consider The TLA+ Home Page for up-to-date information.)

      The third part introduces the syntax checker, the typesetter, and the model checker. The most interesting of those is the model checker (TLC).1 TLC enumerates possible behaviors 2 that satisfy the specification and checks that all invariants that the designer specified hold. TLC has some clear limits, for example, it can't find violations in infinite behaviors. (Technically behaviors are always infinite but that's not important here.) TLC's goal is to find errors in a specification by finding properties that don't hold. In general, it doesn't show freedom from errors because of aforementioned limits. In practice, it increases the confidence in the system modeled by the specification and can help to find the right system.

      The fourth book describes the TLA+ language and semantics in depth. I didn't read that part because it's more like a reference.

      TLA+ (or Temporal Logic of Actions) describes systems in form of logical expressions. State transitions are described in an action by relating the current state of a variable with the next state. We can (in principle) describe any system this ways. (This is true for Pnueli's temporal logic (see p. 2) and I think it still holds for TLA+.) It also allows reasoning about this systems. The problem I often have is that the implemented system and the TLA+ specification live in different worlds. Provided I have a specification of a system and a program that may implement this system, how do I verify if it's the case? The same problem arises when talking about hardware systems. This can't be done in general because it would solve Halting Problem. That doesn't mean it's worthless, it just means that verifying a specification and verifying a program are not both solved with TLA+. TLA+ can be used to describe the system in general and verify that it behaves as expected or wanted. It basically allows to check that you are building the right system before you start implementing it. This can be useful when TLA+ allows you to try things out more quickly than possible with a traditional implementation. It requires the user to use logic which can be hard to pick up for some.

      In conclusion, Specifying System - The TLA+ Language and Tools for Hardware and Software Engineers by Leslie Lamport is a good book for anyone interested in system specification. The logic used for system specification is described thoroughly and intuitive interpretation of most operators are provided. No prior knowledge about logic or system specification are required.

  • Purely Functional Data Structures by Chris Okasaki
    • Must-read for anyone you is serious about programming in functional languages. Even if not everything is understood on a first read-through, it is still a valuable reference.

1.5. Security

  • Security Engineering by Ross Anderson
    • Essentially a collection of anecdotes and ``it depends''.
  • Black Hat Go by Tom Steele, Chris Patten & Dan Kottmann

    • It's a fun read and a good introduction to Go in a pentesting context. My only problem with it was, it never actually explains why Go is the best tool for the job. I may have missed it but as it stands, it seems like a collection of tools implemented in Go. This doesn't have to be a bad thing, I assume it can be really useful as a starting block. It just isn't a general (as in abstract) introduction to the topic. There are a few errors in the text. For example, variable names in the Code don't match the ones in the text. Can't find an example, so maybe I imaged it. Also the Code Listing could have used some more work:

      • Some Code is oddly formatted. (eg. Listing 13 - 5) The comment that was added for the book is not indented correctly.
      • Some Code won't compile if copied from the book. (eg. Listing 14 - 2) Go won't compile code that uses '\' to extend the line. At least not in the argument list to a function and probably not anywhere else either. Luckily the code on Github is correct. It is a little annoying because simple removing the '\' makes the code compile. It may not be idiomatic Go but I really appreciate if code example compile if typed out verbatim.
      • The Listing scale horizontally in size with the code. (eg. Listing 11 - 5 compared to 5 - 6, picked at random) The same is true for the example shell commands. It is not a huge deal, but it annoys me every time. Just pick one size and format the code to fit it. I wouldn't even care if you picked the biggest size and it didn't match the margins of the text. It wouldn't look that aesthetically pleasing but at least it's consistent. This way, it's the worst out from both worlds.

      Non of those are major issues, they just annoyed me.

1.6. Science

  • Science Research Writing by Hilary Glasman-Deal

2. Thriller

  • Diener der Dunkelheit by Donato Carrisi
  • Der Nebelmann by Donato Carrisi

3. Pop-Science

  • Die Mathematik des Daseins by Rudolf Taschner
  • Die Zahl die aus der Kälte kam by Rudolf Taschner
  • what if? Was wäre wenn? by Randall Munroe
  • Der Aufstieg der Quandts: Eine Deutsche Unternehmerdynastie by Joachim Scholtyseck
    • Very detailed description about the Quandt-Family. It describes the history of the family starting with Emil Quandt in the late 1800s until Günther Quandt during the third reich. Günther Quandt's sons are described to a lesser degree. The focus is on the businesses Günther Quandt bought and developed. The very detailed descriptions appears to be a summerization of all sources Scholtyseck could find. The Quandt family allowed him to use their personal archives. This made it possible for him to look at the history from a number of angle and allowed him to stay impartial through out. A book for all who want to know how the Quandt family achieved their extra-ordinary wealth.
  • Selbstverliebt - aber richtig by Rainer Sachse
    • A book for a very entertaining evening. If read with the necessary self-reflection, everyone can find him-/herself in this book.
  • Simple Thinking. by Richard Gerver

4. Boring (Since Dec 2020)

  • Woran Glauben - 10 Angebote für den aufgeklärten Menschen by Rudolf Taschner
    • The title is very misleading. It talks about these things not in contrast to theism, instead they are painted as things you could also believe. As such, I find it pointless because you can believe in literally anything. For example, the Flying Spaghetti Monster. I would have expected that the books explains how the these believes are consistent with what we know as enlightened humans. When a flipped through the book and saw a chapter about God (I was about half-way through.), the last remaining pieces of hope for that went out of the window. I did give up in the chapter about the because I was very bored reading it.
  • Competing with Unicorns: How the World's Best Companies Ship Software and Work Differently by Jonathan Rasmusson Thoughts about this book

Footnotes:

1

The other two do exactly what the name suggest.

2

A sequence of states of a system