I also bought an iPad 2 as soon as it came out. I didn't buy it thinking it could replace my Kindle. I bought it because I thought I'd prefer using it over my Macbook for the times when I just want to consume web-content, instead of actually working on something. If I want to work on something, I use the Macbook. For entertainment, the iPad is more often used because of its superior form factor and ease of use. After a while, you sort of get spoiled by the iPad and its interface. I now expect to be able to use my fingers when I see a small screen without a keyboard attached to it. The auto-rotating screen has also become a must-have to me. The fact that I can quickly switch between apps, without being visually distracted by them, is something that I absolutely love. And I expect everything to just happen instantly whenever I trigger something.

Simply put: the iPad has spoiled me so much, that I now sort of dislike using my Kindle. I know the Kindle screen is easier on the eyes for long reading sessions. I know that reading in daylight is much better on the Kindle than on the iPad. I also know that I really dislike navigating using the Kindle controls. I hate switching between portrait and landscape mode on the Kindle. I hate that everything I do makes me wait, even if it's only half a second. And I really don't like the fact that I've caught myself switching between both devices to check Twitter or email. So a while ago, I installed the Kindle app on my iPad and tried it for a while. I haven't used my Kindle since. That's not to say that I no longer think that the Kindle is a good device. In fact, for its price I think it's a great device. But it really just loses a lot of its attraction once you're used to an iPad.

For Amazon's sake, I hope the rumors about the Kindle tablet are all true. I think they're going to need to go in the tablet direction if they want the Kindle brand to remain relevant over the next couple of years. I do wonder what that's going to mean for the future of e-ink though.

Note: I actually wrote this post on my iPad, using IA Writer. It's the first time I'm writing a post on the iPad, and it's unlikely to be the last.

Coming from the Microsoft world were SOAP services have for a long time been the norm in most projects, it's very interesting to see what REST is all about and how these Restful services are built. If you don't know anything about REST, you might want to check out this article by Martin Fowler first. Obviously, you don't need to read that before you can read the book but it might pique your interest. The first chapter does a great job of introducing to the architecture of the Web and how the REST architectural style fits within it. After that, you're introduced to the Restbucks example, which is used throughout the book to show you how Restful services can work.

The book then gradually starts diving deeper and deeper into the implementation of the Restful services for the Restbucks example. Everything is explained very clearly, and the authors continuously show both the requests and the responses that are going over the wire to illustrate what is going on at the HTTP level, which makes it even easier to understand everything that's being discussed. After the explanations and request/response examples, there's typically a code-based example in either Java or .NET to show how you can implement these systems. After a while i just started skipping these examples entirely because i thought they didn't really bring any added benefit. Though i'm sure some people will appreciate those examples being included as well.

Another great thing about this book is that it remains very clear and easy to follow, even though it covers a lot of ground. Here's a brief overview of the things you'll see implemented in the next couple of chapters:

• CRUD
• Hypermedia (the engine of application state transformations)
• Everything you need to know about caching
• Event-driven services with Atom
• Atom publishing
• Security: authentication as well as authorization

After that, there's a chapter on the semantic web and microformats, which i didn't find very interesting but others likely will. The final 2 chapters make for a great conclusion of the book. First, there's a pretty extensive comparison between the benefits and drawbacks of SOAP versus REST. And finally, the last chapter covers when it makes sense to use REST and when it doesn't and ends with a recap of the major selling points of using the Web as a central building block of your architecture.

I grok the REST architectural style now, and definitely like it. If you read this book with an open mind, i'd bet you'll like it a lot as well.

It is with that opinion in mind that i was at first hesitant to read Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman. But when i glanced over the table of contents, i couldn't help but think that this is the kind of stuff i wished was available when i first started my career. So i figured i had to give it a shot. And i'm glad i did. It's a very quick read (only 168 pages) but it does have a lot of great advice for people who want to become better developers. The only downside about this book is that you have to continuously read about the whole apprentice/journeyman/master thing. If the authors had left out the craftsmanship-fantasy and background, they probably could've gotten the exact same amount of great advice in just about 100 pages.

But again, despite the issues i have with the craftsmanship terminology, the actual content of this book is fantastic. I've been applying a lot of those patterns over the past couple of years and they've benefited me greatly. And there are a couple of them that i really want to incorporate in my 'routine' as well. By reading this book, you'll either learn a lot about how you can make yourself better or if you feel like you're already there, you'll at least know of a reference to pass to other people you want to assist on their journey of Continuous Improvement. I'm sorry, i meant their apprenticeship. It really is a blueprint to becoming a Jedi. I'm sorry, i meant master craftsman. Or just a very valuable and great developer.

The first chapter gives you a good overview on what exactly HTML5 and CSS3 will allow you to do, and also contains a helpful list of tags and attributes that will be deprecated in the HTML5 specification. After that, the book is split up in 3 larger parts:

1. Improving User Interfaces
2. New Sights And Sounds
3. Beyond HTML5

The first part consists of 4 chapters that cover how you can improve the things that you're already doing with HTML. You'll learn about new structural tags and attributes that help you avoid 'divitis', how you can create much better forms, and a bunch of new CSS selectors that'll make your CSS code much cleaner and easier. Finally, you'll learn more about how to make sure that your pages are accessible to people who require assistive technology to browse your site/webapp. What's really interesting about these chapters is that for each new thing that is discussed, fallback strategies for browsers that don't support the new features are covered as well.

The second part covers the features that most of the hype surrounding HTML5 is based on: drawing on the canvas, embedding audio and video in your pages and some very interesting eye candy features from CSS3 such as rouding corners, drop shadows, element rotation, gradients and the improved font features.

The final part covers some technologies that are often associated with HTML5 but aren't actually part of the specification. Things like client-side storage options, managing browser-history, cross-document messaging, web sockets and geolocation. Each of these are covered with clear examples. The final chapter covers some topics that are likely to change in the near future but it gives you a good idea on what to expect from CSS transitions, web workers, WebGL, IndexedDB, Drag & Drop and client-side validation.

Overall, the quality of writing is excellent, the examples are very clear and despite being a quick read at 231 pages (not counting the appendices) it covers quite a lot of interesting things, most of which you can indeed start using today. This book won't make you an expert on any of the topics it covers though, nor is that its intention. It is a great way to get started with these new features and technologies though, and encourages you to dig deeper.

I'm not going to go over everything that's covered in the book (just check out the table of content here), but i can't imagine you'll have any questions left about jQuery after finishing this book. Everything is explained very clearly and thoroughly and the authors do an admirable job of avoiding boring parts. The only times where it's (predictably) less interesting (though, i wouldn't call that boring) is when you're presented with lots of reference-like documentation. In most cases, it's only a few pages but sometimes it's just a little bit too much. That's pretty much the only bad thing that can be said about this book.

One thing that i would like to point out is that, in my opinion, previous experience with or knowledge of JavaScript isn't really a requisite before reading this book. The little JavaScript-specific knowledge that you need to be productive with jQuery (a testament to jQuery's elegance, clarity and overall quality) is covered in an appendix which will most likely be sufficient for most people, at least to those who're somewhat used to looking at other programming languages from time to time. That's not to say that it's not worth learning more about JavaScript (some of the next books i'll read are specifically focused on JavaScript actually), i just don't think you need in-depth JavaScript knowledge to use jQuery effectively.

• JQuery In Action, Second Edition
• HTML5 and CSS3: Develop with Tomorrow's Standards Today
• HTML5 Up And Running
• CSS Cookbook, Third Edition

I haven't bought the following books yet, but probably will once i've gone through the books listed above:

• JavaScript: The Good Parts
• JavaScript Patterns

If anyone has any other good books on web-development they can recommend, please let me know

1. Choosing Your Market
2. Investing In Your Product
3. Executing
4. Marketing... Not Just For Suits
5. Maintaining Your Edge

In these 5 parts, Chad offers a truckload of solid advice on things like figuring out which technologies to focus on, expanding your skill-set to more than just coding, improving yourself continuously, being as effective as you can be, getting the word out on how good you are, and making sure you keep improving as your career progresses.

Each part consists of multiple short chapters, each of which is kinda blog-post like in focus and length. Again, it's a very quick and easy read. And the electronic version is only $15. The advice you get from this book is a lot more valuable than the time and money you'll put into it

As the title says, it's a cookbook. It consists of a bunch of recipes for a very large variety of NHibernate-related tasks. These kind of books are usually pretty low on theory, but this one does a good job of backing up most of the recipes' practical steps with just enough of the background theory that you do need to use NHibernate effectively. I still prefer the approach used in NHibernate In Action, which is more heavy on theory, but that book unfortunately targets NHibernate 1.2. This one covers a lot of the new things that have been introduced in NHibernate 2, 2.1 and the upcoming 3.0 version and as such, is the most suitable NHibernate book available right now.

I'm not gonna go over each chapter like i usually do, so if you want to get a a glimpse of what the book covers, just click here. And as you can see, it covers quite a lot. As usual with NHibernate books, i'd like to see a bit more pages being spent on querying, but this task only becomes harder as NHibernate keeps adding more querying API's. Yes, both QueryOver and the LINQ Provider are covered. Unfortunately, the whole chapter that deals with querying covers HQL, Criteria, QueryOver and LINQ in a mere 44 pages. And while there are some examples of each, none of them are really covered in depth. That's probably not the goal of this book, and it would indeed be hard for any book to cover all of those querying API's in depth while not boring the hell out of your readers, but it is something that a lot of readers are going to need to look into a bit more if they're going to use NHibernate in real applications.

But don't let my nitpicking on the querying chapter fool you. This book is very useful to people who are new to NHibernate, and a lot of people who already have experience with it will learn a few new useful tricks or learn some things they didn't know yet. And while it contains a lot of useful information, it also manages to be a pretty quick read. And if you need any more convincing, just take a look at the price of the electronic version of this book

The book consists of 10 chapters, each of which deals with a coarse-grained topic like progress, productivity, competitors, hiring, evolution, culture, etc. Each chapter consists of a set of 'posts' (think 'blog posts') about the topic at hand. Most of them are pretty short, yet they all contain a lot of wisdom. You might be very surprised by some of the advice they offer, or you might find yourself nodding in agreement from time to time. Or even often, depending from person to person obviously. They don't have all the answers, and in some cases they will tell you to avoid certain things while not telling you how you should do it instead. But as they make clear in the beginning: it's actually a good thing to just go with the flow, see how things play out and deal with problems as they present themselves, and not before that. Read their advice, stick to it, and you just might be able to prevent the otherwise inevitable slope to mediocrity that looms for pretty much every other company which sticks to mostly conventional ways of doing things.

So, is this book useful for you? If you're an entrepreneurial type, and you still don't know the answer to this question, then you really shouldn't be running your own business. I'd also recommend this book to anyone who is working as an employee for the following two reasons: it'll either improve the way you do parts of your job depending on what your responsibilities are, or you'll figure out whether or not your current employers are worth working for in the long term . That's a win-win situation if you ask me. The only people who won't really get any value out of this are people who are already 'institutionalized'... those who have been working in big companies for a while now and wouldn't be able to adapt to life without them.

I can imagine that quite a few people who read this review will still be skeptical (hi Ben!). That is of course your prerogative but keep in mind that these guys do have a proven track record that few can match. Read the book, and you'll understand why. If you're still skeptical after reading the book, go out and prove them wrong. These guys would love it if you did.

The first chapter is an introduction to the importance of everyone involved with a project speaking the same language and DSLs in general, including a good listing of the benefits and drawbacks of implementing a DSL. If you've already done any kind of DSL implementation, there's nothing new for you in this chapter, though it is a very good introduction to people who are new at it and want to learn more about it.

Chapter 2 wastes no time in showing you how you can start building your own DSL. The first example is done in Java, but is quickly superseded by a Groovy implementation which is far more expressive than its Java counterpart. The author then covers some DSL implementation patterns for both internal and external DSLs, and then discusses some of the factors you need to keep in mind when deciding to go with an internal DSL (running within the context of a host language) or an external DSL (stands on its own without having to run inside a host language). Chapter 3 covers some of the topics that you'll definitely need to be aware of when implementing a DSL, such as patterns for integration of your DSL with the actual application that you're building (both in the context of internal as well as external DSLs), dealing with errors and exceptions, and finally, some performance related factors worth keeping in mind.

The next 3 chapters cover internal DSLs exclusively. Chapter 4 discusses a set of implementation patterns for internal DSLs, such as leaning on meta-programming techniques, taking advantage of typed-abstractions, runtime generation, and macros for compile time code generation. Obviously, the applicability of these techniques depends on which language you're using, and are nicely illustrated with examples in Ruby, Groovy and Scala. Chapter 5 covers the implementation of a DSL in each of the following languages: Ruby, Groovy and Clojure. Again, the examples do a nice job of highlighting each language's strong points and what kind of results you can get from them. To conclude the chapter, a nice list of common pitfalls that you need to avoid is discussed. The next chapter covers the implementation of a DSL in Scala. It's very heavy on the Scala usage (obviously) and was IMO, one of the two most difficult chapters of the book. If you're familiar with Scala, it'll probably be much easier to get through though but a lot of interesting stuff is covered, even if you don't quite understand all of the syntax. And the resulting examples of the implemented DSLs are the most expressive ones in the entire book, at least as far as internal DSLs are concerned.

After this extensive look at implementing internal DSLs, the next 2 chapters shift their focus to the implementation of external DSLs. I was very curious to see how this would turn out because up until now, i'd never bothered to look into the creation of external DSLs because i thought it would be far too complex. After reading those 2 chaptes, i'm glad to say that while it's no trivial task, it's not exactly rocket science either. You'll see examples of how to define the grammar of your language using EBNF notation, and how you can leverage the power of libraries like ANTLR to make the whole task of parsing your DSL much easier. You'll also see some interesting examples using XText which is more of a DSL workbench. Chapter 8 takes you back to the Scala world to show you can use Parser Combinators in Scala to write an external DSL. This chapter is once again very complex, but very interesting at the same time. The book then concludes with a short final chapter where the author looks forward to the future of DSL based development.

All in all, there is a lot of very interesting and useful information in this book. You'll learn a lot of the things that you'll need to know about to make an informed decision as to which approaches you should following when implementing a DSL. You'll also learn a lot of cool tricks to make your DSLs as expressive as they can be. I can't think of a better book to get you started with DSL development. The only thing that prevents me from labeling this as a Highly Recommended book is that it doesn't cover some of the topics you need to learn about to make sure your success with a DSL is sustainable in the long term. Things like testing your DSL, backwards compatibility, versioning, etc are not covered and it is somewhat missed.

One of the results of my recent Kindle purchase is that my craving for new books and knowledge has grown to a level that i haven't quite experienced before. It's gotten so bad that i'm starting to feel like Johnny 5, the malfunctioning robot with a strong addiction to continuous processing of new data from the terrible 80's movie Short Circuit (sidenote: while reading that wikipedia entry i was shocked to read that they plan on releasing a remake of that movie in 2011... you have been warned!).

I've got a bunch of technical books on my reading list, but my thirst for knowledge can't be satisfied solely by expanding my technical knowledge. I need more. Luckily for me, i learned the value of seeking other kinds of knowledge and understanding earlier this year and after a random browsing session through the Amazon store i quickly accumulated a rather large list of books that i'd love to read. Listed below are the 15 books i plan on reading first. I either include a small snippet from the Product Description or a featured review on Amazon, or my own reasons for wanting to read it.

1. Guns, Germs And Steel: The Fates Of Human Societies

   Most of this work deals with non-Europeans, but Diamond's thesis sheds light on why Western civilization became hegemonic: "History followed different courses for different peoples because of differences among peoples' environments, not because of biological differences among peoples themselves." Those who domesticated plants and animals early got a head start on developing writing, government, technology, weapons of war, and immunity to deadly germs.

   As if that isn't compelling enough, it was recommended to me by the one and only Mark Meyers, which means that at the very least it should be very interesting. I'm currently about one third of the way through this, and it is indeed very interesting

2. ReWork

   This book will make you uncomfortable. Depending on what you do all day, it might make you extremely uncomfortable. That's a very good thing, because you deserve it. We all do. Jason and David have broken all the rules and won. Again and again they've demonstrated that the regular way isn't necessarily the right way. They just don't say it, they do it. And they do it better than just about anyone has any right to expect.

   A book from people who've broken the rules and won? I'd be lying if i said i could resist that.

3. Made To Stick

   Drawing extensively on psychosocial studies on memory, emotion and motivation, their study is couched in terms of "stickiness"—that is, the art of making ideas unforgettable.

4. Leadership and Self-Deception: Getting out of the Box

   Learning how the process of self-deception works--and how to avoid it and stay in touch with our innate sense of what's right--is at the heart of the book. We follow Tom, an old-school, by-the-book kind of guy who is a newly hired executive at Zagrum Corporation, as two senior executives show him the many ways he's "in the box," how that limits him as a leader in ways he's not aware of, and of course how to get out. This is as much a book about personal transformation as it is about leadership per se. The authors use examples from the characters' private as well as professional lives to show how self-deception skews our view of ourselves and the world and ruins our interactions with people, despite what we sincerely believe are our best intentions.

5. God Hates You, Hate Him Back: Making Sense of The Bible

   God Hates You, Hate Him Back makes the ultimate case for the claim that the God of the Bible is the most wicked character in the pages of history. With a wit as dry as a martini, and the cross examination techniques of a seasoned lawyer, CJ Werleman lays out all sixty-six chapters of the Bible to present an irrefutable argument that indeed God hates us all. If you have never read or never fully understood The Bible then you will do no better than this unique, comedic, 21st century summary of the greatest story ever sold, or in Werleman’s own words ‘never read’. God Hates You, Hate Him Back provides you with an arsenal of Biblical facts, stories, mythology and assertions to ensure you victory in your next religious debate.

   If any of my Christian readers are offended by this, please try to keep in mind that while i have my own views and beliefs, i respect and appreciate the fact that yours might be different from mine. So don't start bitching about religion in the comments, plskthx.

6. Linchpin

   By Seth’s definition, an artist is not just some person who messes around with paint and brushes, an artist is somebody who does (and I LOVE this term) “emotional work.” Work that you put your heart and soul into. Work that matters. Work that you gladly sacrifice all other alternatives for. As a working artist and cartoonist myself, I know exactly what he means. It’s not what you do, it’s the way that you do it. The only people who have a hope of becoming linchpins in any organization, who have any hope of changing anything for the better in real terms, are those who have the capacity to do “emotional work” at a high level—to be true artists at whatever they set their minds on doing. The guys who just plod around the office corridors, just turning up for their paycheck.... Well, those guys don’t have a prayer, poor things. The world is just too interesting and competitive now.

7. Making Ideas Happen

   Though creation always begins with an idea, ideas don't always lead to creation; examining why that's so, online entrepreneur Belsky finds that, no matter how unique or radically different ideas may be, the individuals and teams who carry those ideas to fruition share a number of common traits, such as engaging peers and leveraging communal forces. In this guide to realizing ideas, Belsky examines those traits in detail.

8. Talk Less, Say More: Three Habits to Influence Others and Make Things Happen

   Communication is the single greatest challenge in business today. It takes just 3 habits to conquer it. Talk Less, Say More will help you achieve more with less. Less wordiness. Less tune-out. Less frustration. You'll gain more time. More positive outcomes. More rewarding relationships.

9. Influencer: The Power To Change Anything

   An influencer motivates others to change, An influencer replaces bad behaviors with powerful new skills. An influencer makes things happen. This is what it takes to be an influencer. Whether you're a CEO, a parent, or merely a person who wants to make a difference, you probably wish you had more influence with the people in your life. But most of us stop trying to make change happen because we believe it is too difficult, if not impossible. We develop complicated coping strategies when we should be learning the tools and techniques of the world's most influential people. But this is about to change. From the bestselling authors who taught the world how to have Crucial Conversations comes Influencer, a thought-provoking book that combines the remarkable insights of behavioral scientists and business leaders with the astonishing stories of high-powered influencers from all walks of life.

10. Power: Why Some People Have It, And Others Don't

    Political skill, not just talent, is central to success in every field. In Power, this leading scholar comes down to earth with practical, even contrarian, tactics for mastering the power game.

11. 5 Minds For The Future

    Gardner uses a variety of explanatory models, from developmental psychology to group dynamics, demonstrating their utility not just for individual development, but for tangible success in a full range of human endeavors, including education, business, science, art, politics and engineering. A tall order for a single work, Gardner avoids overly-technical arguments as well as breezy generalizations, putting to fine use his twenty years experience as a cognitive science researcher, author and educator, and proving his world-class reputation well-earned. Though specialists might wish Gardner dug a bit more into the research, most readers will find the book lively and engaging, like the fascinating lectures of a seasoned, beloved prof.

12. UnMarketing: Stop Marketing, Start Engaging

    Marketing expert Scott Stratten focuses on a Pull & Stay method (pulling your market towards you and staying/engaging with them, leading them to naturally choose you for their needs) rather than Push & Pray

13. The Moral Landscape: How Science Can Determine Human Values

    In this explosive new book, Sam Harris tears down the wall between scientific facts and human values, arguing that most people are simply mistaken about the relationship between morality and the rest of human knowledge. Harris urges us to think about morality in terms of human and animal well-being, viewing the experiences of conscious creatures as peaks and valleys on a "moral landscape." Because there are definite facts to be known about where we fall on this landscape, Harris foresees a time when science will no longer limit itself to merely describing what people do in the name of "morality"; in principle, science should be able to tell us what we ought to do to live the best lives possible. Bringing a fresh perspective to age-old questions of right and wrong and good and evil, Harris demonstrates that we already know enough about the human brain and its relationship to events in the world to say that there are right and wrong answers to the most pressing questions of human life. Because such answers exist, moral relativism is simply false—and comes at increasing cost to humanity. And the intrusions of religion into the sphere of human values can be finally repelled: for just as there is no such thing as Christian physics or Muslim algebra, there can be no Christian or Muslim morality.

14. The Winner's Brain

    In The Winner-s Brain, Drs. Jeffrey Brown and Mark J. Fenske use cutting-edge neuroscience to identify the secrets of those who succeed no matter what-and demonstrate how little it has to do with IQ or upbringing. Through simple everyday practices, Brown and Fenske explain how to unlock the brain-s hidden potential

15. Different: Escaping The competitive Herd

    If there is one strain of conventional wisdom pervading every company in every industry, it’s the absolute importance of “competing like crazy.” Youngme Moon’s message is simply “Get off this treadmill that’s taking you nowhere. Going tit for tat and adding features, augmentations, and gimmicks to beat the competition has the perverse result of making you like everyone else.” Different provides a highly original perspective on what it means to offer something that is meaningfully different—different in a manner that is both fundamental and comprehensive.

That's it :p. I have no idea how long it'll take me to read those books, but i suspect that it'll at least take me a year. And after that, i can start working on the other 40+ titles on my wish list

This book covers a lot of ground. It starts off with a short introduction to the Dynamic Language Runtime and IronRuby and follows that up with some basic coverage of the Ruby language. If you already know Ruby, you can obviously skip this part since there won't be anything new for you here. If you're not familiar with Ruby yet and just want to learn about Ruby and how to use it together with .NET, you'll definitely appreciate this part, though i would recommend picking up The Ruby Programming Language to learn it more thoroughly.

Things get more interesting after this part, with a chapter dedicated to the fundamentals of interoperability between .NET and Ruby, more specifically: how .NET types and concepts can be used from Ruby code. The chapter after that takes a close look at how you can write Ruby classes that inherit from .NET classes. The next couple of chapters focus mostly on writing Ruby code that takes advantage of some .NET specific technologies, like ADO.NET, Windows Forms, WPF, ASP.NET MVC (there's also a chapter on Ruby On Rails btw) and Silverlight. Some of those chapters spend a little too much time explaining concepts that are related to the actual .NET technology that's being discussed instead of focusing more closely on writing Ruby code that takes advantage of those .NET pieces, but generally speaking they do a great job of covering many of the possibilities that you have with IronRuby.

You'll then learn about some of the options you have for writing automated tests in Ruby (either to test your .NET code, or to just test your Ruby code that runs on .NET). This chapter also contains introductions to 2 of the frameworks that the .NET world continuously tries to emulate: RSpec and Cucumber. After that, you (finally) get to the topic that interests me the most: using Ruby code from C#. This is a topic that never gets enough attention IMO. I wish you could find more information about this online, but it seems that few people who're using IronRuby are interested in consuming Ruby code from .NET instead of going the other way around (consuming .NET from Ruby). Anyways, it's good that this book covers some of the essentials of doing this. The book then concludes with a chapter on extending IronRuby with 'native' .NET extensions. This is interesting as well, though it's important to realize when (and when not) to use this.

It's not the greatest book on programming you'll ever read, as some of the examples could've been better IMO, or more extensive. Then again, it's the only available book on IronRuby at the moment, and it definitely covers a lot of stuff. It's easy to follow, and you'll definitely get a good view on all of your options with regards to combining Ruby and .NET. In short: if you're interested in combining Ruby with .NET, this book is definitely worth buying.

As you may have noticed from this picture (click on it to see it in its full size), the screen is really the killer feature of the Kindle. Text is crystal-clear, and remains that way even if you change your viewing angle:

Even when looking at it from the side, the text is still as clear as it would be on actual paper:

Most importantly, the impact of direct light on the screen is minimal. In the following picture, the camera flash was directed straight at the screen and IMO, the impact of it is minimal:

No matter what kind of light exposure you're dealing with while reading, tilting the Kindle slightly always leads to a fantastic reading experience. That is, as long as there is some kind of light. The screen itself doesn't emit any light so you can forget about reading in the dark. The clearness of the text and the fact that the screen doesn't emit any light are probably the 2 most important reasons why i like reading on the Kindle so much. You can simply keep reading for hours without your eyes getting tired. I had one stint where i read continuously for 5 hours and didn't notice any discomfort whatsoever. My eyes still felt great after those 5 hours, and because of its form factor, i could sit or lie on the couch in whatever manner i wanted to without the physical shape of the book constraining me in any way, sometimes simply by balancing the device with just one finger.

The only thing i'm not thrilled about when it comes to the form factor of the device is the location of the next/previous page buttons. They're located on both sides of the device, and while that is indeed useful depending on how you're holding it and what kind of position you're in at the time, it also caused me to press those buttons accidentally quite frequently in my first few hours of reading. By now, i'm used to avoiding those buttons unless i actually want to switch to another page, but in the beginning it was a bit frustrating though. Obviously, this is just a very minor complaint and for those who also have difficulty with this in the beginning, it'll only be for a few hours.

The battery also appears to be great... I've only used the device for 4 days, and even though i've used it a lot, i still have over 75% of battery life left out of a single charge. Obviously, the wonderful e-ink screen is the reason for this since it only consumes power while you're switching pages but once a page is displayed, it uses no more power whatsoever. Your battery usage will obviously vary on how often you use the wireless connection, or the 3G connectivity for those who've bought that edition.

So far for the great things about the device... now it's time to focus on some of the things that aren't quite great. First of all, reading PDF's really is a hit-or-miss experience from file to file. I only tried about 10 different PDF books, and none of them were displayed good enough to read them in portrait mode. In landscape mode, some of them looked good enough to read, while others are just acceptable. In those cases, i'm quite sure i can't keep reading them for hours and hours like i can with books in the native Kindle format. Converting them to MOBI format or having Amazon convert them to Kindle format leads to mixed results. While the actual text was then displayed almost as good as native Kindle books, you lose quite a bit of the formatting which is especially detrimental for programming books... code samples will lose most, if not all, of their indentation and become a pain to read.

As for technical books in the Kindle format, i haven't bought any of those yet, but i did try a few sample chapters of a few technical books, including ones that were listed as optimized for the larger Kindle DX screen. I found every sample to be of high quality (visually speaking) and am looking forward to reading all of my technical books on the Kindle from now on. In fact, i'm not really looking forward to finishing a few physical books i bought recently before ordering the Kindle. It would be cool if Amazon would offer free Kindle editions of physical books you've bought with them, but i don't see that happening since that would mostly be of major benefit to the consumer and publishers don't really seem to care about that.

Which brings me to my next complaint: why on earth is the price difference between Kindle editions of books and physical editions so small? In many cases, the difference is merely a few dollars. While i assume that Amazon takes a nice share of the profit for every electronic book purchase, i can't for the life of me imagine that that amount is comparable to the extra cost of producing and shipping physical books. The price difference should be bigger, given the fact that the cost of distributing electronic books can never even come close to the cost of producing and shipping physical books and let's not forget the positive impact on the environment of not having to waste all that extra paper. Surely, that ought to be worth something?

Another thing that's worth nothing is that the software of the Kindle feels very dated, and is somewhat clumsy to use. It's certainly not a big issue since the reading experience more than makes up for it, but every time i have to interact with the software i feel like i'm back in the 90's. Navigating the menu items or options with the '5-way' control, or navigating in the Kindle store is far from a great experience and it does occasionally make me sigh. Flipping through a bunch of pages is also a weird experience because it often makes me think "is it waiting for me to do something or am i still waiting for it to do something?". Finally, the included keyboard is so small that i doubt that you'll make heavy use of the annotations feature with this device. For me that's not an issue since the annotations feature doesn't interest me, but i can imagine that it would disappoint people who've bought it with the intention of making great use of that feature.

Now, despite some of the negative things i just mentioned, i'm still very impressed with this device, and i look forward to watching it improve in the editions that we'll hopefully see in the next couple of years. The reading experience more than makes up for any other shortcoming that you might find with it, and you can't argue with the price either. Amazon charged me 158 euros for it (which included shipping costs plus customs fees) which i think is a fantastic deal (well apart from the customs fees obviously, which i've always considered to be a rip-off). I was at an electronics store yesterday and strolled by their selection of e-readers from a variety of brands, and none of them impressed me after having used this. Even worse, pretty much every single device that i saw in that store was more expensive, looked more clumsy and had a screen that wasn't nearly as impressive as the Kindle's.

In short: if you're looking to buy an e-reader: get this Kindle. Odds are that you'll love it as well, and in the small chance that you don't: you'll have no problem selling it off to someone else who will.

As you can imagine, some of the concepts that you'll have to learn about to apply metaprogramming techniques effectively are somewhat advanced (or at least, they appear to be at first). Paolo does an extraordinary job of explaining all of this in a very easy to grasp manner. The writing style is clear and very easy to follow. There are some parts that you might need to read twice (or thrice) before you get it, but that's more due to your mental conditioning from static languages than it is because of Paolo's writing.

The book is divided in 2 parts (well, 3 if you count the appendices). In the first part, you'll learn everything there is to know about metaprogramming. You're going to learn all about how objects and classes (which are really just objects) work in Ruby, and you'll explore a variety of ways of changing or extending existing classes and objects. You'll get a full grasp on Ruby's object model and you'll see how you can use that knowledge to your advantage.

In the second part, you'll see how metaprogramming is used in various Rails libraries. But don't worry, you don't need to know Rails to get value out of this part. It just shows a lot of real-world examples of the tricks and techniques you learned in the first part of the book and it very well might fill your head with ideas of stuff that you want to do as well (i know it did for me). You'll also find some good advice on how to apply metaprogramming safely. There's a lot of power in metaprogramming, and you're going to feel the pain if you go overboard with it. Follow some of Paolo's advice and you might avoid or at least minimize that pain

The second part closes with a redefinition of the metaprogramming concept. Paolo does a good job of making clear that metaprogramming really is just, well, programming. It's different from 'regular' programming, but it's still just programming. It's the kind of programming that truly leads to less repetitive programming.

If i had to describe this book in one word, i'd go with 'fascinating'. It's eye-opening, highly informative and fun to read. It'll inspire you to change the way you write your code and the perspective you'll gain on OO topics that you already thought you knew well is just invaluable.

At over 800 pages, this book is obviously big and heavy. That in itself is not necessarily a problem, but i wasn't happy with the actual binding of the pages. Flipping through them just doesn't feel right and i often felt that i had to be somewhat careful with a page if i didn't want it to be torn out of the book by accident. And it really wouldn't take that much effort for that to happen. If there is one book that's an ideal test case to make you seriously consider switching to an iPad/Kindle for your reading, then this is probably it.

Luckily, the content of the book does make up for the shoddy physical reading experience. This book covers a lot of topics, which is not only a great way to introduce the beginning Ruby programmer to a variety of possibilities, but also a welcome reference to keep on your desk if you quickly need to look up how to do something. It starts off with a short review of the Ruby language, and then works its way through a variety of topics, most of which are covered very thoroughly. You really will learn everything there is to know about strings, regular expressions, numeric types, symbols, ranges, dates and times and enumerable types (arrays, hashes, sets, ...). At this point, you're about 320 pages into the book with another 450 or so to go. Those first 9 chapters are probably also the only part of the book that will at one point be read by everyone who bought this book, either while reading cover-to-cover or when you're looking for something specific later on.

The next topic that is covered is that of IO and Data Storage. Again, this is covered pretty extensively because you'll learn all about typical file management operations, as well as how to do marshaling of objects. There's also a brief part on dealing with databases but it's so short that it really would've been better left out altogether. You'll see how to connect and interact with a few of the well known databases in a pretty low-level manner, but really though, hardly anyone still deals with databases in that way. It probably would've been better to point to some higher-level data access frameworks, since the people who are going to deal with a database in such a low-level manner are probably more than capable of figuring out how to do so without referring to a book that only briefly lists a few things that you can do for basic stuff, but nothing important.

The next chapter covers Ruby's OOP and Dynamic features/capabilities and it's a good 80 pages long. It goes through some of the topics a bit too quickly for my taste, but that's alright since the next book on my reading list is Metaprogramming Ruby which is sure to whet my appetite for dynamic goodness. It does again cover quite a lot, but if you've read The Ruby Programming Language already, you won't really find anything new here.

Next up is an overview of some of the graphical toolkits that you can use with Ruby. This is a chapter that ultimately doesn't bring any value since coverage of a single toolkit is probably enough to fill an entire book already. The examples shown for each of the toolkits in this chapter are obviously short and offer no more than a quick look at how you'd interact with a certain toolkit. Well, in my case it inspired me to come up with a decent event syntax for Ruby, but that's about it. It probably would've been better to leave this chapter out, and just refer to these toolkits in an appendix or something.

The book then switches to a topic that i'd been looking forward to: Threading. While Ruby does offer some constructs to deal with threading, it's a far cry from what you might be used to in .NET. I was also surprised with the lack of attention paid to asynchronous operations, but then again, there just might not be that much interest in asynchronous programming in the Ruby world. This is definitely something i need to look into more as i continue on my Ruby journey . Another downside to this chapter is that some of the examples are a bit simplistic, and in some cases, aren't quite thread-safe. If you read this chapter, focus on the discussion of what you can do with Ruby from a threading point of view, but please don't reuse any of the code in your own code because you will end up chasing race conditions because of it.

The next 2 chapters deal with scripting, system administration and working with certain data formats (xml, rss, images, pdf). Depending on what you need or what you're working on, this could be pretty interesting to you. The book then switches to the topics of testing and debugging. This isn't really covered in-depth and as such, this too would've been better suited for an appendix with some links to online resources or dedicated books on these subjects. After that it gives another quick overview of packaging and distributing your code. This chapter also would've been better off being dropped since i had to package and distribute some Ruby code today and i found more useful and relevant information online than i did here.

The book then starts focusing on writing code again, but this time in the online world. First you'll learn about low-level network programming in a chapter that is dedicated to the topic. After that, there's a chapter about Ruby and webdevelopment and it kinda suffers from the same problems as the GUI toolkits chapter did. It lists a few of the options, of which at this point only Rails still seems to be popular but it can't really tell you anything in-depth about it. Once again, a summarized version of this chapter would've been better fit for an appendix. Finally, you'll learn about Distributed Ruby which is illustrated with an example.

The book then closes with 2 more chapters, one covering some Ruby development tools, and finally, some words on the Ruby community.

This is by far the longest book review i've ever written, but then again, this book is huge and i did have a lot to say about it. Its biggest flaw (apart from the shoddy physical reading experience) is that it tries to cover too much, and because of that, a lot of the stuff that is covered is basically pointless. Ideally, this book would've been limited to the first 11 chapters, followed by the chapters on threading and networking. The stuff about databases, web frameworks, GUI toolkits, etc... should've been covered in succinct appendices which should just point the reader in the right direction since there's no way one single book can cover all of it anyway.

I know this review might come over as hard on the author and the content, but i really did like half of the book a lot. The other half however prevents me from starting this post with 'Recommended Book' or 'Highly Recommended Book' instead of 'Book Review'. Hopefully, the upcoming 3rd edition (which should be out sometime next year) fixes some of these flaws so this book can reach the potential that it certainly does have. In the meantime, i will keep this book on my desk as a reference. About 500 of these 800 pages do contain a lot of great stuff that's gonna save me a lot of time after all.

Fast forward 8 years, and here i am: a developer who was once convinced of the virtues of static languages, but is increasingly frustrated by both the static nature of C# (regardless of the introduction of the dynamic keyword) because of the limits it places on my creativity, as well as the entire .NET world for a variety of reasons. So i figured it was time for me to learn exactly what was so good about these dynamic languages. At first, i doubted between going for Ruby and Python. I picked Ruby, mostly because it has more momentum than Python. And since i hate learning something new from some simple online tutorials, i wanted to get some good books on the subject to make sure i really learned what it was all about. The first book i ordered was The Ruby Programming Language which seems to be the definitive guide to the Ruby language. It ought to be, with that title

Books about programming languages are generally pretty boring. It's not the fault of the writers, or the language, it's just because so many boring details need to be covered when learning a new language. I was very happy to see that this book certainly minimizes those boring parts. The book starts off with a quick introduction to Ruby. It very quickly goes over some code with very brief explanations as to what the code is doing. Not sure if everyone will agree on this, but for me it was like the perfect appetizer. It really made me want to learn the language thoroughly.

The next 4 chapters aren't nearly as interesting as the introduction was. The 2nd chapter deals with the structure of Ruby code. Important, but not exactly thrilling to read. The 3rd chapter discusses some of the standard data types and you'll also learn more about how objects work in Ruby. The stuff about objects was very interesting, but the descriptions of the data types are, as they always are, pretty boring. The 4th chapter (Expressions and Operators) and the 5th one (Statements and Control Structures) are also quite boring. But then again, i can't possibly imagine how anyone could write about these kinds of topics in a way that is truly interesting, regardless of the programming language that is used. In fact, i'd say that these topics were dealt with in a manner that is at least less boring than how they're usually covered in programming books. And even though those parts are not the most interesting to read, it is great reference material if you quickly need to figure out something or need to refresh your memory while working with the language.

The next 3 chapters however were (IMO) immensely interesting. Chapter 6 tells you everything you need to know about Methods, Procs, Lambdas and Closures. You might be thinking "how could that possibly be immensely interesting?", but trust me, it is. I also think that this chapter will either strongly increase your appreciation of the Ruby language, or might be a little off putting, depending on how you generally feel about the importance of static typing vs dynamic. Most developers will see the possible dangers here and you'll either feel fear for what people can do in a method, or you'll love the power and flexibility while still recognizing the dangers (with an increased appreciation for automated tests, hopefully).

Chapter 7 deals with everything there is to know about classes and modules, and it's an absolute joy to read. At this point, i really started to feel stupid for not having learned about this years ago. Lots of interesting stuff here, and the ideas it planted in my head are surely gonna hurt me frequently while coding in C# at work. Chapter 8 was even worse in this regard... it discusses Ruby's reflection capabilities and the whole metaprogramming thing. It made my head spin, in the good way. I know i can really take serious advantage of those capabilities and i can't wait to actually experiment with it.

The 9th chapter discusses the Ruby Platform, which is basically a succinct run down of what you can do with a lot of the standard Ruby classes. I largely skipped this chapter since the next book on my reading-list (The Ruby Way) covers all of that and more, in depth. The final chapter covers the Ruby interpreter and the general Ruby environment. It's somewhat interesting, but nothing spectacular.

I generally approach programming language books as necessary reading (at least when you're learning a language) but a chore at the same time. While some of the chapters in this book suffer from a lot of the same problems that you'll find with other programming language books, it at least is less boring to read. Chapter 6 through 8 however are more than worth the cost of the book and could really change the way you think and feel about OO and if i could legally get away with it, i'd force every programmer to read those. It's certainly not going to convince everyone, but it could open a lot of people's eyes. This book is not only ideal to learn the Ruby language, it'll also be an invaluable reference resource to keep on your desk as you keep taking more steps in your Ruby journey.

I already know it's gonna take a long while before this book moves from my desk to my bookshelf.

Then about 2 months ago someone recommended Robert Greene's The 48 Laws Of Power. If you've got certain goals in your life but are not quite sure how to achieve them, then i would certainly recommend it. Hell, i'd recommend it to anyone because it's just that good and valuable. If i had read that book back when i was stuck in Enterprise Hell, i would've gotten through that period with a lot less friction and a lot more results. And for the record, that book isn't necessarily about how you should use the power that you have, or how to put yourself in a position of power, but it's a good guide on how to protect yourself against people who have power or are trying to gain power at your (or other people's) expense.

That book lead me to The 50th Law which is a collaborative effort between Robert Greene and 50 Cent. Now, if you're closed minded and don't want to read a book that has a gangsta rapper associated with it, be my guest, but rest assured that you're missing out on some very interesting and valuable stuff.

Next up on my reading list is The Prince and The Art Of War by Niccolò Machiavelli.

Now you might be wondering why i'm reading these kinds of books. Basically, because they really teach you a lot about how plenty of people think and react to things. That doesn't mean that you have to follow the advice or the guidelines in those books, but it does certainly help you put certain things in perspective and understand certain situations better. And after all, if we are about self-improvement on a technical level, then we certainly should be open-minded enough to read books that could help us improve our understanding of other things in life as well. And i can guarantee you that the stuff you read in those books can help you in your professional life as well.

I'd definitely be interested in any other kind of non-technical, non-fictional book that you can recommend for whatever reasons

The book is divided in 3 parts.  The chapters of the first part explain in depth what kind of debugging strategy you’ll need.  Discussed topics include:

• figuring out what you’re really looking for
• tips and tricks to come up with a reliable reproduction of the bug and the value of having that reproduction
• diagnosing the actual problem
• coming up with a true fix
• reflecting on why the bug ever got into the software
• making sure that the bug can’t come back and that we learn from the mistake

For some of you, most of this stuff will just be common sense.  For a lot of developers though, this part alone should be considered required reading.  It’s a complete process of how to deal with bugs efficiently in less than 80 pages!  Think about that for a second: 80 pages that will improve your efficiency at your job and will reduce the amount of time you spend doing something you probably don’t like doing.  How could you resist?

The second part is pretty short (only 2 chapters) but pretty interesting as well.  It mostly deals with organizational patterns and practices that a development shop should take into account.  It covers things such as:

• the importance of bug tracking
• what makes a good bug report
• effective communication with users and support staff
• giving priority to bugs as soon as they’re discovered
• the importance of pragmatic zero-tolerance for bugs
• ways to get out of a Quality Hole

Not all developers will like the second part, but it definitely contains some valuable information for technical managers, or for developers who need to convince their technical managers

The third part of the book deals with a lot of various strategies for a variety of specific situations.  While not everyone will get something out of every topic discussed in this part, odds are that quite a few of them will indeed be interesting for you.  You’ll find specific advice for quite a few special cases (performance, concurrency, backwards compatibility, third-party bugs, etc…).  You’ll also find the obligatory chapter on creating an ideal debugging environment with automated tests, a build system and continuous integration.  If you’re reading this blog, you’re hopefully already convinced of the values of such things so you might want to skip this chapter.  The final 2 chapters are again very interesting… They’ll show you how you can write software that will debug itself.  While not everyone will actually go out and do this, some ideas of that chapter should definitely be kept in mind by most of us.  The final chapter deals with some common (mostly organizational) anti-patterns for dealing with bugs.

All in all, there is just a lot of tremendously valuable information in this book.  And it’s only about 190 pages so it definitely won’t take you a long time to read it.  I’ve frequently been amazed at the inability of developers to efficiently debug issues when they occur.  And i’m not just talking about bad developers.  I’ve seen plenty of good or even great developers having trouble with debugging efficiently.  This book would definitely get them on the right track, with just a little bit effort.

Now, i'm not a project manager and have no intentions of becoming one in the future. But as a software developer, i do think it's important to have an understanding of what good (and bad) project management entails so i'd recommend this book to project managers as well as developers. As usual with books in this series, it's full of useful, real-world advice and common sense contributed by experienced and established project managers. Each piece of advice is again only 2 small pages, and no topic is ever discussed too in-depth. While not everyone will get something out of every bit of advice, there surely will be quite a few that'll make you think about improvements that can be made in your company.

While there is no structure in the order of the tips, the book does list each tip by topic in the beginning. Topics that are covered are agile methods, general software development, managing people and teams, dealing with distributed teams, improving communication, managing stakeholders, project processes, dealing with requirements, dealing with end-users and self-management. The book claims to be useful to project managers in general and not just for software projects, though i think non-software project managers will probably not get a lot of valuable information out of this book since the large majority of the tips are rather specific to software development.

Definitely worth reading.

• 97 Things Every Project Manager Should Know: i love the 97 Things series, and i think it's important to figure out how project managers think (just as it's important for men to figure out how women think) so i had to pick this one up. I am about halfway through at the moment.
• Debug It!: Too many developers have trouble figuring out where to look when something goes wrong. I'm proud not to be a part of that group (on most days), though i keep my eyes and ears open for any kind of debugging tips so i just had to pick this one up.
• Growing Object-Oriented Sofware, Guided By Tests: i never knew about this book, but i happened to glance over it in a list of recommended books based on another book that i was buying at the time. Once i spotted the "Kent Beck Signature Book"-series logo i clicked the "Add to shopping cart" button. That's right, i'm that big of a Kent Beck fanboy.
• Advanced .NET Debugging: This is the book i got suckered into buying today... why? because Tess Ferrandez recommended it. Yup, i'm that easy. Seriously though, how could it be bad?
• Writing Secure Code: 2nd Edition: I started reading this about 2 months ago. I'm currently at page 154. It's that boring.
• Enterprise Integration Patterns: As cool as i suspect this book to be, i still haven't made it past the first chapter. Which i started about 3 months ago. It's not that it's boring, i actually think that messaging is very cool... but for some reason i can't get myself to read this thoroughly when there are other things to do that are more relevant to what i need at work.