Profile for Dennis D. Jensen > Reviews

Personal Profile

Content by Dennis D. Jensen
Top Reviewer Ranking: 677,922
Helpful Votes: 11

Learn more about Your Profile.

Reviews Written by
Dennis D. Jensen (Denmark)

Page: 1 | 2
Paper Airplane
Paper Airplane
Offered by MediaMine
Price: £4.59

5.0 out of 5 stars Another excellent album from Alison Krauss and Union Station, 27 Jan. 2013
Verified Purchase(What is this?)
This review is from: Paper Airplane (Audio CD)
Good production as always! Alison's voice, the lyrics, the music, and the Union Station band once again combines into a great, coherent whole. It's a joy to listen to.

97 Things Every Software Architect Should Know
97 Things Every Software Architect Should Know
by Richard Monson-Haefel
Edition: Paperback
Price: £22.97

2 of 3 people found the following review helpful
4.0 out of 5 stars A bunch of good blog entries or small essays, 19 July 2009
This book is a good collection of small blog entries or essays if you will. Nearly all of these are good reminders of what is essentially good thinking or practice for a software architect. They range from down to earth technical advices to overall process and collaboration and roles, to the philosophical guiding points of software architecture. Some of them may even seem or are self contradicting, but this only highlights the importance of taking context into account when you make decisions based on some of the condensed principles or learned knowledge of this book.

I find it particular interesting to be able to go back to a topic or subject in one of the essays and find the arguments for some considerations that's suddenly imperative for a decision you need to make now or communicate to somebody. The book is perfect for looking up or revisiting a subject when you need it. The titles of the essays are in most cases small soundbites or reminders of the subject in themselves, making it possible to quickly refresh a point made somewhere in a certain context.

I am a system/software developer, and some of the essays are a bit too philosophical to my taste, but fortunately those essays are in the extreme minority. I have enough experience to recognize a genuine experience or knowledge born out of practical expediency when I see it, and most of the essays in this book are of this kind.

Sure, I could just maintain a bunch of links to the relevant websites that substantiates the same essays, but having them collected in a book, easily accessible, is suitable for this kind of knowledge: These essays are nearly timeless in their advices and suggestions.

It's easy to go read a handful of the essays in 15 minutes or there about. I think some other reviewer suggested to do as he did, namely read a couple of essays every morning as quick reminder, because almost all these essays are truisms of the kind that you usually forget although you do know them.

I especially like the essays "Seek the Value in Requested Capabilities" by Einar Landre, "Everything will ultimately fail" by Michael Nygaard, "One Line of Working Code Is Worth 500 of Specification" by Allison Randal, "There Can Be More Than One" by Keith Braithwaite, "Simplicity Before Generality, Use Before Reuse" by Kevlin Henney, "Get the 1,000-Foot View" by Erikk Doernenburg, "It Is All About The Data" by Paul W. Homer, and many others. It's not really fair not to mention any more essays, but this review is getting long enough.

I give it 4 stars of 5, because the book is really good for software architects, technical project managers, software developers, etc. or people who aspire to be one of those, or maybe just a better one. It's not up there with the nearly immortal classics or epitomes that lives on for years, even decades, so 5 stars is out of the question as far as I am concerned. I especially liked that the book was kept short (less than 200 pages) and still managed to get alot of knowledge through, a hallmark of any good book. Maybe it really deserves 5 stars of 5, but let's wait 10 years and see.

Real World Haskell
Real World Haskell
by John Goerzen
Edition: Paperback
Price: £26.80

7 of 9 people found the following review helpful
5.0 out of 5 stars Excellent introduction to practical use of Haskell, 29 April 2009
This review is from: Real World Haskell (Paperback)
I am no newcomer to functional programming languages, having spent a few years with Lisp and a little with ML as well, but I never really got Haskell under my skin, because of the difficulty to really, fully understanding Monads, and monadic programming, and the very high level of abstractness Haskell encourages. Thanks to this book, and the references it contains to online material and articles, I now have much more familiarity with the idioms, the abstract level of code, and good programming style of Haskell as well as how better to think about problems in Haskell.

Through out the book, the focus is constantly on how best to use Haskell, in particular to give the reader a good feeling for what constitutes good programming style, and why in each case.

In the context of a subject I've not often found the ending of a subject to leave me missing an explanation for why things are done this way, or why things were done in a certain way. In the the few cases this happened things were quickly cleared up by just reading (or in a single case jumping) forward. I haven't left a topic unsatisfied with the depth, width, or any lack of detail.

The book may be an introduction, but fortunately it doesn't shy away from advanced concepts like Monad Transformers, and why they are more essential than Monads themselves when talking about the Monad programming style. Over all GUI, concurrent and parallel programming, databases, network and web programming, system programming, error handling, profiling, and optimization, package installation, and many other earthly issues are among just some of the subjects presented in the book. There is enough to get everybody going. I can also recommend the book "The Fun of Programming" by Jeremy Gibbons, if you want more fun or odd examples, rather than the more real, smelly examples that you'll find in this book.

All the examples are thankfully not toy examples, but real world examples with enough complexity to be meaningful in a realistic context, and at the same time they incite to learn more, and inspire how to solve other problems of similar structure. There is plenty of code, but thanks to Haskell's conciseness, it never weighs down the content of the book, and actually allows meaty examples to be shown, all the while without ending up as just code listings without much explanation.

The book keeps walking this wonderful line between theory and practice, where every bit of theory is practical theory supporting real world work. In some ways it reminds me of the Bell Labs culture of excellence which also walked this edge. It's difficult to keep this equilibrium, but the book does a very good job in this respect as well, making it joy and pleasure to read. It never becomes dry, or dull to read. It dives into particular details when needed, and postpones complex topics dilligently, although in early examples it doesn't try to hide that more is going on, and gives forward references, but they never disturb the current reading flow, and it's safe to jump forward and then back again, if one just cannot wait.

One of the many things I was very happy about, was the very good explanation of how the non-strictness of the language makes it possible to introduce space leaks, if you blindly use idioms from strict languages. I was possitively surprised to find out that very often what is considered a naive solution in a strict language (like Lisp or ML) often is a very good, and efficient solution in Haskell, making the code even better, and beatiful to read and maintain.

I am deeply impressed with how much width and depth the authors managed to put into the barely 700 pages of the book. There's hardly any typing mistakes, and I've already used the index, and appendices on several occasions. I've been reading from the beginning, and actually picked up good bits and pieces from the beginner tutorial in the first chapters, even though I am no spring chicken, but very soon I found my self jumping to forward references without any trouble or bother. I expect the book will be very useful to look up forgotten things, or things you just want to freshen up on. I've already needed to do this in later chapters, when showing alternatives to earlier examples that I needed to refresh.

The authors of this book has managed with all the many reviewers and contributors to make this the flagship book for Haskell in the coming years, and a really impressive one at that. I am reminded of Peter Seibel's book "Practical Common Lisp" which does the same for Common Lisp.

And Haskell? I have become really enthusiastic about this language and especially its advanced type system. It takes a little while to get used to the very high level style, but in the end, it has raised the level of my unit tests to better, and more problem domain oriented levels, killed much boiler plate code, if not nearly all of it, and improved my thinking about the structure of programs and program design in ground breaking ways. I haven't tried this since I jumped on the Lisp and Prolog wagon some years back. Everything in Haskell seems to get on stereoids when you do it the Haskell way. Quickcheck unit testing was one of the things that impressed me.

Haskell is an unavoidable language, even if you don't end up using it in your day job. I am a better programmer for it.

One surprising use of Haskell which may seem odd to many, is that I've found Haskell really good for scripting. The conciseness of Haskell code, and the type system, and all the orthogonal features of Haskell have a synergetic effect which is really in itself beatiful, and suddenly turns such a boring drone task into a joy to do.

There are many good things in this book, and I feel like I've touched upon too few things to really give a detailed enough impression of the book, but I hope it is complete enough to be useful to others considering whether to buy this book.

Have fun!

Page: 1 | 2