1. Create an array with the first 100 natural numbers

First we will create a NumPy array of the numbers 1 – 100 with the arange function.

a = numpy.arange(101)

2. Sum the squares of the numbers

Second we will sum the squares of the numbers with the sum function.

sum_squares = numpy.sum(a ** 2)

3. Square the sum of the numbers

The NumPy ndarray class has a sum method, that we can use to sum the numbers in our array. After that calculate the square of the sum.

square_sum = a.sum() ** 2

Below is the complete solution.

print square_sum - sum_squares

import numpy
 
#The sum of the squares of the first ten natural numbers is,
#1 ** 2 + 2 ** 2 + ... + 10 ** 2 = 385
 
#The square of the sum of the first ten natural numbers is,
#(1 + 2 + ... + 10) ** 2 = 55 ** 2 = 3025
 
#Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 - 385 = 2640.
 
#Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
 
# 1. Create an array with the first 100 natural numbers
a = numpy.arange(101)
 
# 2. Sum the squares of the numbers
sum_squares = numpy.sum(a ** 2) 
 
# 3. Square the sum of the numbers
square_sum = a.sum() ** 2
 
# Calculate the difference
print square_sum - sum_squares

If you liked this post and are interested in NumPy check out NumPy Beginner’s Guide by yours truly.

Chapter Structure

Each chapter starts with an introductory example. Each section within a chapter ends with practice problems and exercises. Worked out examples with solutions are given too. As you would expect from a Linear Algebra book, there are lots of theorems and numerical notes.

1. Systems of Linear Equations

The first chapter gives some examples of linear systems. The row reduction algorithm is explained. I remember having to solve these kind of problems by hand for weeks. As is usual in mathematics, we learn to work out something with paper and pencil the hard way and then we figure out how to do it faster by writing a computer program. If you are into Python, please check out NumPy.

2. Vector and Matrix Equations

Chapter 2 starts with a number of examples as well. We learn about the fundamental idea of representing a linear combination of vectors as a product of a matrix and a vector. This leads to this famous equation:

3. Matrix Algebra

Chapter 3 teaches about matrix operations such as matrix multiplication, matrix inversion and transposing matrices. The chapter ends with the Leontief Input Output Model from economics and applications to computer graphics.

4. Determinants

The introductory example in this chapter is about determinants in analytic geometry. Properties of determinants are mentioned as well as calculation methods.

5. Vector Spaces

I don’t know if it has anything to do with the chapter title, but the first example of this chapter is about space flight and control systems. In my opinion this chapter is more theoretical than the preceding chapters. The chapter ends with applications to difference equations and Markov Chains.

6. Eigenvalues and Eigenvectors

Dynamical systems and spotted owls are the topic of the introductory example of chapter 6. This chapter covers amongst others the characteristic equation, diagonalization and iterative algorithms to estimate eigenvalues.

7. Orthogonality and Least Squares

Chapter 7 begins with a short text about the North American Datum. After that we continue with sections on:

• orthogonality
• orthogonal sets
• orthogonal projections
• the Gram-Schmidt process
• least square problems
• inner product spaces

8. Symmetric Matrices and Quadratic Forms

A story about multi channel image processing is the introduction of chapter 8. This chapter has sections on quadratic forms and singular value decomposition.

The book is very readable and entertaining. The diverse list of examples are already reason enough to recommend “Linear Algebra and Its Applications”. I give this book 5 stars out of 5.

1. Create a divisors array

First we will create a divisors array. We only need to divide by the numbers 11 – 20.

divisors = numpy.arange(11, 21)

2. Check for 0 remainder

Second make sure that all the divisions of a number by the divisors produce a 0 remainder. We can check for that with the NumPy all function.

numpy.all((i % divisors) == 0)

3. Test the solution

Eventually we will get an answer. We need to check whether this is the correct answer. Use the assert_equal function from the numpy.testing module to confirm the result.

numpy.testing.assert_equal(numpy.zeros(19), i % numpy.arange(2, 21))

Below is the complete code solution.

import numpy
 
#2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
 
#What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
 
# 1. Create a divisors array
divisors = numpy.arange(11, 21)
 
for i in xrange(2520, 10 ** 9, 2520):
        # 2. Check for 0 remainder
        if numpy.all((i % divisors) == 0):
                print i
                # 3. Test the solution
                numpy.testing.assert_equal(numpy.zeros(19), i % numpy.arange(2, 21))
                break

If you liked this post and are interested in NumPy check out NumPy Beginner’s Guide by yours truly. The NumPy Christmas Book Giveaway has officially ended. Winners will be contacted by the publisher. A new review of the book was added on Amazon.

I tried dividing the first list in some sublists for the purpose of this review.

Career

As expected the book contains a number of general career insights.

• Be Noticed – do your work and make sure you’re noticed.
• Consulting – tips on avoiding doing grunt work, setting your rates, growing your skillset and finding new projects.
• Decisions – we make so many decisions in our working life, that we need to review where we are heading at least once a year.
• Hairy Arm – leave an obvious flaw in your design or proposal. People want to have something to fix before accepting your idea.
• I don’t Know – it’s hard to say that you don’t know something, but it is the best thing to do.
• Lateral Thinking – a different way to solve problems.
• Line Versus Service – work where the money is, line organizations.

Product Marketing

Surprisingly, the book also has advice on product marketing.

• Betting On Instinct – most companies do extensive market analysis, however eventually decisions are made not based on numbers, but intuition.
• By The You-Know-Whats – this one doesn’t require any explanation.

Technical Management

Technical management pitfalls are also discussed in the book.

• Breaking Owsie Chains – owsie chains are bad. You need to find a way to break them.
• Consent of the Governed – managers do not have a Divine Right to rule.
• Credit Theory of Management – this theory compares management to credit banking.
• Fear – you cannot innovate if you live in fear.
• Gearing up – shifting from mediocrity to superiority.
• Hiring – a list of hiring techniques is given.
• It’s not What you do – do not expect other people to work in the same way or at the same level as you do.

Writing and Documentation

The author is a former technical editor with years of experience writing documentation.

• Conceptual Maps – needed for documentation. I wonder if mind maps are meant here.
• Learn to Write – writing can be learned. You need to read and practice a lot. There are two stages. First, aim for simplicity. In the last stage you try to perfect your style. For a technical writer content is more important than style.
• Writing Memos, Letters – use a pyramidlike approach, put concepts at the top and details at the bottom. Use contractions and keep the text simple.

Programmer or Engineer

The writer seems to make a distinction between programmers and hardware engineers.

• Design Reviews – reviews are needed to find errors early.
• Engineering Notebook – you should have one, preferably a paper notebook.
• Expecting Too Much – you don’t expect your code to work the first time you run it, do you? Why would it be different in real life?
• Invest 30 minutes a Day – set time aside each day to keep current.
• Pat Yourself on the Back – as you become more senior you will get less and less kudos from management. Know your worth.
• Product Track Record – make sure you have some successes.

Job Search Tips

At the end of the book we find hints and observations about job hunting.

• Catching a Horse – finding a job is easier, while you have one.
• Contacting People – hints on contacting managers and recruiters.
• Do It In Parallel – search in parallel fashion.

Technical Career Navigator contains many hidden gems. It’s a book you will be reading again and again. I give this book 5 stars out of 5.

1. Create a 3-digit numbers array

We will create an array to hold 3-digit numbers from 100 to 999 using our favorite NumPy function arange. Check the first and last element of the array with the assert_equal function from the numpy.testing package.

a = numpy.arange(100, 1000)
numpy.testing.assert_equal(100, a[0])
numpy.testing.assert_equal(999, a[-1])

2. Create the products array

Now we will create an array to hold all the possible products of the elements of the 3-digits array with itself. We can accomplish this with the outer function. The resulting array needs to be flattened with ravel, to be able to easily iterate over it. Call the sort method on the array to make sure the array is properly sorted. After that we can do some sanity checks.

numbers = numpy.outer(a, a)
numbers = numpy.ravel(numbers)
numbers.sort()
numpy.testing.assert_equal(810000, len(numbers))
numpy.testing.assert_equal(10000, numbers[0])
numpy.testing.assert_equal(998001, numbers[-1])

3. Find the largest palindromic number

At this point I decided to continue with standard Python. We can probably do something fancy with NumPy, but it looked like reversing string representations of the numbers, and comparing them to the originals would be simpler.

for i in xrange(-1, -1 * len(numbers), -1):
   s = str(numbers[i])
 
   if s == s[::-1]:
      print s
      break

Below is the complete program.

import numpy
import numpy.testing
 
#A palindromic number reads the same both ways.
#The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 x 99.
 
#Find the largest palindrome made from the product of two 3-digit numbers.
 
#1. Create  3-digits numbers array
a = numpy.arange(100, 1000)
numpy.testing.assert_equal(100, a[0])
numpy.testing.assert_equal(999, a[-1])
 
#2. Create products array
numbers = numpy.outer(a, a)
numbers = numpy.ravel(numbers)
numbers.sort()
numpy.testing.assert_equal(810000, len(numbers))
numpy.testing.assert_equal(10000, numbers[0])
numpy.testing.assert_equal(998001, numbers[-1])
 
#3. Find largest palindromic number
for i in xrange(-1, -1 * len(numbers), -1):
   s = str(numbers[i])
 
   if s == s[::-1]:
      print s
      break

Have a Go

Although I am pretty sure this is the right solution, it might be a good idea to check the result. Find out which two 3-digit numbers produce our palindromic number by modifying the code a bit. Try implementing the last step in a NumPy way.

If you liked this post and are interested in NumPy check out NumPy Beginner’s Guide by yours truly. I would like to make a few announcements. First, I was recently interviewed by floss4science about the book. Second, a gentle reminder that the Christmas NumPy Book Giveaway is going to end this month.

“Refactoring: Improving the Design of Existing Code” is focused on OO programming (lots of Java examples) and Agile practices. It is setup as a catalog of refactoring techniques. Each page dedicated to a refactoring is clearly marked, so that you can easily look up a refactoring.

The book was written a decade ago. At that time IDE’s did not support advanced refactorings. Most of the methods described are fully automated in modern IDE’s. This means that you don’t have to follow the text that closely any more.

1. Refactoring, a First Example

The first chapter starts with a simple example. Java code is used throughout the example as well as UML diagrams.

2. Principles in Refactoring

The Why and When of refactoring are discussed. Also we get instructions on what to tell our manager about refactoring. This seems a bit silly to me, since I have never had to explain refactoring to my managers.

3. Bad Smells in Code

“Code Smells” is a frequently used Agile phrase. A phrase I don’t care that much about. Code works or it doesn’t, it can be ugly or unreadable, but it doesn’t smell. The list of “smells” makes sense, however some of the names are downright confusing. For instance, would you be able to tell me what “Refused Bequest” means?

4. Building Tests

This chapter talks about JUnit at length. I am sure you are aware that there are many other unit testing frameworks for programming languages other than Java such as PyUnit. We are told that before you start refactoring, you need to have tests. I think it is more of a chicken/egg dilemma. Sometimes you need to refactor first in order to test. Unit tests and functional tests are mentioned. Integration tests, however are completely ignored. How would you know whether the performance and memory usage of your system remained the same? Clearly, this chapter was written by a software developer, and not by somebody who likes breaking applications, I mean testing applications.

5. Toward a Catalog of Refactorings

Chapter 5 describes the catalog of refactorings to follow. It is the catalog metada in a sense.

6. Composing methods

This chapter is the beginning of the catalog, which forms the “meat” of the book. I am just going to mention a few of the techniques listed in chapter 6.”Extract Method” is one of those refactorings I use on a daily basis. Sometimes things go wrong so we have to do the opposite refactoring “Inline Method”. The author starts using the term “temp” to mean temporary local variables.

7. Moving Features Between Objects

The author admits that he has trouble assigning responsibilities to objects. We are supposed to fix errors with “Move Method”, “Move Field”, “Extract Class” or other refactorings in this chapter.

8. Organizing Data

This chapter discusses a lot of different ways to simplify working with data. For instance, with these refactorings:

• Replace Data Value with Object
• Replace Array with Object

Also the refactoring “Replace Magic Number with Symbolic Constant” is explained a.k.a “Extract Constant”.

9. Simplifying Conditional Expressions

In my opinion the refactorings in this chapter need to be renamed. Apart from “Decompose Conditional”, which is clear enough. Although “Breaking up Conditional” might have been better.

10. Making Method Calls Simpler

Make method calls simpler by renaming them or replacing long parameter lists by objects. The latter technique could be a problem in concurrent programs. It is common to pass immutable values as parameters. You might not be able to replace them by immutable objects.

11. Dealing with Generalization

Generalization or in OO terms inheritance is a powerful mechanism, that tends to be overused a lot. You can push/pull a method or a field. Inheritance can be replaced by delegation and vice versa.

12. Big Refactorings

In this chapter starts what we can call the “dessert” part. No more simple refactoring recipes. Instead four refactorings that take a considerable amount of time.

13. Refactoring, Reuse and Reality

This chapter is an essay on Refactoring by William Opdyke.

14. Refactoring Tools

IDE’s have come a long way since this book was written. Most of the issues in this chapter are no longer valid.

15. Putting It All Together

This final chapter by Kent Beck is a bit mystical and vague. Those are his own words by the way. Some of the points make sense, but the chapter is written too much in a master talking to an apprentice style.

The book has a list of soundbites at the end. Literally. The fun thing is that you probably have heard or are going to hear a lot of these soundbites. “Refactoring” is a very useful book, albeit too focused on Java. Most recipes would work for another Object Oriented language. I give this book 5 stars out of 5.

   N = c * d  = (a + b) (a - b) = a ** 2 - b ** 2

We can apply the factorization recursively, until we get the required prime factors.

1. Create array of trial values

The algorithm requires us to try a number of trial values for a. It makes sense to create a NumPy array and eliminate the need for loops. However, you should be careful to not create an array that is too big. On my system an array of a million elements seems to be just the right size.

   a = numpy.ceil(numpy.sqrt(n))
   lim = min(n, LIM)
   a = numpy.arange(a, a + lim)
   b2 = a ** 2 - n

2. Get the fractional part of the b array

We are now supposed to check whether b is a square. Use the NumPy modf function to get the fractional part of the b array.

   fractions = numpy.modf(numpy.sqrt(b2))[0]

3. Find 0 fractions

Call the NumPy where function to find the indices of 0 fractions.

   indices = numpy.where(fractions == 0)

4. Find the first occurrence of a 0 fraction

Actually we only need the first occurrence of a 0 fraction. First, call the NumPy take function with the indices array from the previous step to get the a values of 0 fractions. Now we need to “flatten” this array with the NumPy ravel function.

   a = numpy.ravel(numpy.take(a, indices))[0]

Below is the entire code needed to solve the problem.

import numpy
 
#The prime factors of 13195 are 5, 7, 13 and 29.
 
#What is the largest prime factor of the number 600851475143 ?
 
N = 600851475143
LIM = 10 ** 6
 
def factor(n):
   #1. Create array of trial values
   a = numpy.ceil(numpy.sqrt(n))
   lim = min(n, LIM)
   a = numpy.arange(a, a + lim)
   b2 = a ** 2 - n
 
   #2. Check whether b is a square
   fractions = numpy.modf(numpy.sqrt(b2))[0]
 
   #3. Find 0 fractions
   indices = numpy.where(fractions == 0)
 
   #4. Find the first occurrence of a 0 fraction
   a = numpy.ravel(numpy.take(a, indices))[0]
   a = int(a)
   b = numpy.sqrt(a ** 2 - n)
   b = int(b)
   c = a + b
   d = a - b
 
   if c == 1 or d == 1:
      return
 
   print c, d
   factor(c)
   factor(d)
 
factor(N)

The code prints the following output:

1234169 486847
1471 839
6857 71

Have a go

I would suggest writing an unit test to check the outcome. Use for example trial division. To get you started here is some of the code of a possible test function. Please fill in the dots.

def is_prime(n):
   a = numpy.arange(2, n)
   return len(a[...]) == 0

Also maybe you should try finetuning the size of the trial values array, but be careful.

If you liked this post and are interested in NumPy check out NumPy Beginner’s Guide by yours truly.

1. Interactive Computer Graphics: A Top-Down Approach With Opengl

This is an introductory book about OpenGL. We had an optional course on OpenGL in University and this book was required reading for this course.

Chapter 1 introduces some basic concepts, such as camera models and ray tracing.

Chapter 2 gets us started wih the OpenGL API.

Chapter 3 discusses input devices, the client-server perspective and menus.

Chapter 4 starts with a bit of geometry and linear algebra. This is followed by an OpenGL example. The chapter ends with transformations supported by OpenGL.

Chapter 5 deals with projections and perspective.

Chapter 6 is about light, light sources, reflection and ray tracing.

Chapter 7 involves studying implementation algorithms for geometric transformations, clipping and rasterization.

Modeling the real world is the topic of Chapter 8. This includes physical models based on elementary Newtonian mechanics.

Chapter 9 teaches us about curves and splines.

Chapter 10 mentions texture mapping, bit and pixel operations, composition techniques, sampling and aliasing.

The chapter titles could have been a bit longer and more descriptive. The book goes over some mathematics and theory. However, it never gets very challenging. I would not buy the book for that. There are lots of OpenGL examples. This is the strength of the book. Although the book has color plates and a nice hard cover, the code does not have syntax highlighting. You might say that I am too used to IDE’s, but I have seen syntax highlighting in at least one book, so it should be possible. I give this book 3 stars out of 5.

2. Computer Graphics: Principles and Practice in C (2nd Edition)

Computer Graphics is about computer graphics and principles. This book has four authors, who are experts in their field. It has a hardcover, is richly illustrated with color plates and lots of figures. If the code had syntax highlighting, then it would have been even better.

Chapter 1 covers the basics. Chapter 2 is about SGRP (Simple Raster Graphics Package). Chapter 3 presents basic raster graphics algorithms for drawing 2D primitives.

Chapter 4 describes graphics hardware. Chapter 5 introduces geometrical transformations. Chapter 6 discusses viewing in 3D, projections and perspective.

Chapter 7 is dedicated to SPHIGS (Simple Programmer’s Hierarchical Interactive Graphics System). Chapter 8 is the first of three chapters on GUI’s. These three chapters are low on mathematics and code. Dialogue design is the title of Chapter 9. Chapter 10 examines user interface software.

Chapter 11 is about representing curves and surfaces. Finally, we get back to some code and mathematics. Chapter 12 builds on the previous chapter and continues with solid modeling. Sadly, no code in this chapter. Achromatic and colored light is the subject of chapter 13. This is a fun chapter, however, the lack of color usage in this chapter about color seems paradoxical to me.

In Chapter 14 we embark on a quest for visual realism. Chapter 15 is about visible-surface determination. Chapter 16 discusses illumination and shading.

Chapter 17 explores image manipulation and storage. Chapter 18 discusses advanced raster graphics architecture. Chapter 19 describes advanced geometric and raster algorithms.

Chapter 20 concentrates on advanced modeling techniques. Chapter 21 brings to life animation.

As I said above, this book is written by four authors. Obviously, this means that the writing style differs between chapters. Some chapters have no code or mathematics. Some chapters have one or the other. These are not my favorite chapters. The code examples are written in C or sometimes in pseudocode that looks a lot like C, so you need to have some knowledge of C.

The book is quite thorough and seems pedagogically sound. It is considered a “classic” for many reasons. Personally, I learned a lot about computer graphics algorithms. I give this book 4 stars out of 5.

I read that the Project Euler problems are some sort of katas. Katas are what martial artist call exercises, preparing you for real-life fighting situations. For instance, imagine that your house is on fire and that your family is surrounded by heavily armed thugs. What do you do? In this case your secret weapon is NumPy, which is like the Dim Mak death touch. If you master that like me, then you don’t even need to bother with katas.

1. Calculate the golden ratio

When the bad ninja guys are walking towards you, the first thing to do, is calculate the golden ratio, also called the golden section. This part of the kata is called Moro Ashi Dachi.

1
2

phi = (1 + numpy.sqrt(5))/2
print "Phi", phi

This prints the golden mean.

1

Phi 1.61803398875

2. Find the index below 4 million

Next in the kata we need to find the index below 4 million. A formula for this is given in the Wikipedia page. All we need to do is convert log bases. We don’t need to round the result down to the closest integer. This is automatically done for us in the next step of the kata.

1
2

n = numpy.log(4 * 10 ** 6 * numpy.sqrt(5) + 0.5)/numpy.log(phi)
print n

We get the result 33.2629480359. You can double check this yourself from the Wikipedia article.

3. Create an array of 1-n

No, you say. Not the arange function again. We know about it already, when are we going to learn about the Jyutping. Patience, let’s first master the basics.

1

n = numpy.arange(1, n)

4. Compute Fibonacci numbers

There is a convenient formula we can use to calculate the Fibonacci numbers. We will need the golden ratio and the array from the previous step in the kata as input parameters. Print the first 9 Fibonaci numbers to check the result. I could have made an unit test instead of a print statement. This variation of the kata is left as an exercise for the reader.

1
2

fib = (phi**n - (-1/phi)**n)/numpy.sqrt(5)
print "First 9 Fibonacci Numbers", fib[:9]

The output is below. You can plug this right into an unit test, if you want.

1

First 9 Fibonacci Numbers [  1.   1.   2.   3.   5.   8.  13.  21.  34.]

5. Convert to integers

This step is optional. I think it’s nice to have an integer result at the end. It’s like the difference between Mawashi Geri and Mawashi Geri Koshi. The effect is almost the same, but one feels better than the other. OK, I actually wanted to show you the astype function.

1
2

fib = fib.astype(int)
print "Integers", fib

A long list of numbers is printed.

1
2
3

Integers [      1       1       2       3       5       8      13      21      34
  ... snip ... snip ...
  317811  514229  832040 1346269 2178309 3524578]

6. Select even-valued terms

The kata demands that we select the even valued terms now. This should be easy for you, if you followed the previous kata.

1
2

eventerms = fib[fib % 2 == 0]
print eventerms

There we go. Another opportunity to write unit tests.

1
2

[      2       8      34     144     610    2584   10946   46368  196418
  832040 3524578]

7. Sum the selected terms

This is the final step. Your enemies are lying on the ground helpless, unable to fight back. Finish the job, call the ndarray sum method.

1

print eventerms.sum()

For completeness, below is the complete code of this kata.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import numpy
 
#Each new term in the Fibonacci sequence is generated by adding the previous two terms. 
#By starting with 1 and 2, the first 10 terms will be:
 
#1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
 
#By considering the terms in the Fibonacci sequence whose values do not exceed four million, 
#find the sum of the even-valued terms.
 
#1. Calculate phi
phi = (1 + numpy.sqrt(5))/2
print "Phi", phi
 
#2. Find the index below 4 million
n = numpy.log(4 * 10 ** 6 * numpy.sqrt(5) + 0.5)/numpy.log(phi)
print n
 
#3. Create an array of 1-n
n = numpy.arange(1, n)
print n
 
#4. Compute Fibonacci numbers
fib = (phi**n - (-1/phi)**n)/numpy.sqrt(5)
print "First 9 Fibonacci Numbers", fib[:9]
 
#5. Convert to integers
# optional
fib = fib.astype(int)
print "Integers", fib
 
#6. Select even-valued terms
eventerms = fib[fib % 2 == 0]
print eventerms
 
#7. Sum the selected terms
print eventerms.sum()

That was quite a workout. More katas to come soon. Please stay tuned.

If you liked this post and are interested in NumPy check out NumPy Beginner’s Guide by yours truly. I would like to thank Christopher Felton and Gael Varoquaux for their recent reviews of my book.

1. TCP/IP Illustrated Volume 1

This is a fantastic textbook about different network protocols. The protocols are illustrated using the output of tcpdump and other utilities. Protocols discussed include:

• IP
• ARP
• RARP
• ICMP
• UDP
• IGMP
• TFTP
• BOOTP
• TCP
• SNMP
• FTP
• SMTP

Beside the protocols several diagnostic tools such as ping and traceroute are covered in detail. The book contains lots of diagrams, that illustrate the protocols even further. Each chapter ends with exercises. The solutions of some of those exercises can be found in the book as well. I give this book 4 stars out of 5.

2. Database System Concepts

This book teaches about the inner workings, the nuts and bolts of databases without requiring a lot of prior knowledge:

• Data Models
• Relational Databases
• Object Based Databases and XML
• Data Storage and Querying
• Transaction Management
• Database System Architecture

Personally I feel that some material doesn’t belong here, such as XML, but it seems to be a tradition to include it. I found the chapter on indices quite interesting.

At the end of the book there are several chapters on popular commercial databases. It seems that these chapters do not add any value. In any case the authors should have devoted at least one chapter to an open source database. In the real world you have as much chance to work with a commercial database as with an open source one.

My copy is quite outdated by now. New developments, for instance NoSQL databases, are not mentioned. I give this book 3 out of 5 stars.

3. Machine Learning

This is an introductory book on Machine Learning. There is quite a lot of mathematics and statistics in the book, which I like. A large number of methods and algorithms are introduced:

• Neural Networks
• Bayesian Learning
• Genetic Algorithms
• Reinforcement Learning

The material covered is very interesting and clearly explained. I find the presentation, however, a bit lacking. I think it has to do with the chosen fonts and lack of highlighting of important terms. Maybe it would have been better to have shorter paragraphs too.

If you are looking for an introductory book on machine learning right now, I would not recommend this book, because in recent years better books have been written on the subject. These are better obviously, because they include coverage of more modern techniques. I give this book 3 out of 5 stars.

Thanks for the NumPy 1.5 Beginner’s Guide review by Chris Fonnesbeck on the Strong Inference Blog.