NumPy Beginner’s Guide – Second Edition

I got a review copy of NumPy Beginner’s Guide – Second Edition from Packt Publishing. The book is relatively thick, a bit over 300 pages and packed with content.

As usual with Packt books, it starts by introducing the tools and giving detailed instructions on installing them, before diving into actual subject. The book starts easy, teaching how to create arrays and manipulate vectors. Soon more concepts are introduced starting from slicing and ending to SciPy. There is even a chapter about testing, which I found especially interesting to read.

I liked how there are pop quizes to help the reader to check if he understood what he just read. They aren’t really hard, but still quite fun. Layout of the book is clear and makes the books easy to read. There are plenty of examples and graphs in the book that help to explain the concepts.

The book is very suited for a person who is not familiar with NumPy and wants to learn it. It covers lot of ground in sufficient detail. I felt that reading this book was good investment of time and enjoyed it.

TeamCity 7 Continuous Integration Essentials

I got a review copy of TeamCity 7 Continuous Integration Essentials by Volodymyr Melymuka recently and I must say that it was pretty captivating to read (finished it in an evening and planning to read it again after digesting a bit). The book is about setting up TeamCity 7 for continuous integration (a subject close to my heart). While it does not go really deep into technical details, it serves as a good starting point for getting started with TeamCity 7.

The book starts by describing continuous integration and some other basic terms and concepts and continues into architecture of TeamCity and build lifecycle. These form the foundation for rest of the book as the author takes us through setting up the TeamCity and a sample project that is used to showcase how unit tests are handled and how code coverage metrics can be collected.

Setting up, configuring and maintaining the TeamCity server and build agents is described in sufficient detail and pointers are given to where to find more information. The end of the book is used to wrap up with more advanced techniques, like remote run, where TeamCity can be used to verify changes before committing them into source control.

I was really happy how down the earth the book is. The author does not feel need to make things complicated or complex, but explains them in a way that is easy to understand. This does not mean that he would be glossing over the details though. Everything is explained in sufficient detail.

The book is good purchase if you don’t have previous experience with setting up and administering TeamCity server. The book also covers TeamCity 7 from point of view of Windows, Linux and Macintosh, making it a good source of information regardless of the operating system in use. The book is relatively short, slightly over 100 pages, so reading through it will not take a long time.

NumPy Cookbook

Recently I got a copy of NumPy Cookbook to read and review from Packt Publishing and I must say that I was positively surprised. Focus is of course NumPy, but the book touches SciPy too.

The book is laid out nicely and is generally easy to read and digest. I really loved how instead of doing examples as Python programs or even interpreter commands, they chose to use IPython, which is like regular Python shell, but in steroids (as my colleague eloquently put it). IPython makes experimenting and sharing the experiments with others fun and easy.

My only experience with NumPy before was from time when I was writing a simple ray tracer with Python. I knew that the library had lot to offer besides simple things I was doing, but did not really have good way to dig in into it. This book has over 70 different ways of using NumPy, SciPy, PIL among other libraries that can be used to analyze and manipulate data. It also briefly touches subject of quality assurance, which of course is very close to my heart.

Focus is all the time in showing how to do things with brief examples. This suited very well for me, since I’m more about learning by doing than learning by reading type of person. While the book is relatively thin (around 200 pages + index), it has quite lot in it. For seasoned NumPy / SciPy user it probably does not offer that much new, but for a person not familiar with the libraries it offers a fast way getting started.

Working with NHibernate 3.0

I have been busy trying to catch up with a big pile of books on my nightstand and finished Working with NHibernate 3.0. I must admit that I was left with somewhat mixed feelings after finishing the book. There are lot of examples and author does good work showing different ways of accomplishing same result. At the same time, the book is rather short (only a bit over 200 pages) and leaves a feeling that some details had to be omitted in order to cover everything that was placed inside the book. I think the book works as an introduction to the subject, but anything more in-depth information has to be gathered from somewhere else.

Dependency Injection in .NET

Finished today Seeman’s excellent Dependency Injection in .NET. I have been doing poor man’s DI for a while in my game project (and I really love what it does for the code), so the concept wasn’t new to me. Details of the matter weren’t completely clear though and there the book cleared up quite a bit, even when the language is different than the one used in pyherc. I liked the fact that until end of part 3, everything was more or less doable even without dedicated DI-container. In my opinion, this put dependency injection and not the tools in focus and that was a good thing.

The book was enjoyable to read and sprinkled with small examples that showcase what the text is talking about. At the very end of the book there’s section where 6 different DI-containers are covered briefly. The section isn’t very throughout, but gives enough information to select one and get started using it.

Vacation time reading

My vacation is starting soon and I was thinking of doing some old traditional reading in addition to listening to librivox audiobooks. So I got myself Working with NHibernate 3.0 by Benjamin Perkins and Dependency Injetction in .NET by Mark Seeman.

Especially the Dependency Injection book should be interesting to read. I have been doing somewhat similar things with my simple game, but without IOC-container. It will be interesting to compare differences in solutions due to difference in language and tools.

The NHibernate one I picked more or less blindly. It’s not very long book, only a bit over 200 pages. If it can give me the basic idea behind NHibernate, some sensible implementation models and warnings about most common pitfalls, I’m pretty happy. I’m not looking comprehensive guide book here, but a kickstarter that gets me going to correct direction.

Domain Specific Languages by Fowler

I finished reading Domain Specific Languages by Fowler some time ago. The reason I’m interested in DSLs in general is because I’m looking how to use them in testing. Adding a layer of abstraction on top of all those little gritty technical details helps to move focus to higher level, namely to problem domain. Instead of specifying that in order the test to pass, these two variables how to be equal, I can specify the same thing as an concept, using language that is more close to problem domain.

Book is pretty hefty and has quite lot of information inside of it. The focus is on the procedural languages, because Fowler feels that he does not have enough expertise on functional languages to write about them. Some of the ideas presented in the book work on the functional side and some can be adapted. Some are so specific to procedural languages though, that they aren’t useful on the functional side.

Book is divided in two sections. First section is about what DSLs are, how they are used and what kind of techniques can be used to contruct them. It constantly refers to second section, which lists all the patterns used in the book in short and clearly written format. In the beginning this referring back and forth was a bit annoying, but after patterns started sinking in, reading the first section was more enjoyable. In the end I liked the format though, since I can easily go back and check patterns, without having to hunt through the whole book for correct page.

Book was interesting to read, but left a feeling that there are so much more to write about DSLs. Also, it left a bit vague feeling in times, probably because the subject is so new to me. Good read in any case, and very good addition to me desk library.

Learning

It’s been busy week again and I have been cramming on information. I finished reading excellent How Google Tests Software and I must say that I’m impressed. It’s short, only a bit over 250 pages and full of interesting information not only about how they test the software, but also about how they ended up testing it like they do now.

I’m still slowly learning how to program in clojure and got a pile of links to get started with from a colleague:

https://github.com/functional-koans/clojure-koans
http://www.4clojure.com/
http://learn-clojure.com
http://clojure.org
http://clojuredocs.org

I haven’t touched anything else but the clojure-koans and 4clojure yet, but rest should be good too. Haven’t even had time to search for any books, since I still have pile on my nightstand to read first.

Interesting times and quite enlightening.

Even more reading

Since it’s 6 months until christmas and getting presents, I treated myself by getting some more interesting reading:

Growing Object-Oriented Software, Guided by Tests by Freeman and Pryce I have read before. However, I never owned the book, only borrowed it from a colleague, but because it is such an interesting book, I wanted to have my own copy. After I finish my thesis (or maybe even before that), I’m planning on taking that to sit on my office desk where rest of the team can borrow it.

How Google Tests Software by Whittaker, Arbon and Carollo sounded interesting and had gotten good reviews. Scale of the testing in such a huge company is probably something different from what I have learned to do and will most likely offer nice ideas and thoughts.

Domain-Specific Languages by Fowler and Parsons I ordered because of brief foray into DSL with my cutesy-platform (the one used in pyherc for behaviour driven testing).

So, the focus is on testing and things that can facilitate it. All this should be both interesting, useful and helpful for my thesis.