I recently received some books to review around my favorite hobby, photography. I can't wait to get some time to go through all of them, but the first one that caught my attention was Creative Close-Ups: Digital Photography Tips and Techniques by Harold Davis. This is a book about Macro photography, which is a sub-hobby of my hobby. Macro photography is taking close-up photos of small subjects or higher detail of subjects.
When most people get a camera, they love taking pictures of flowers. To be honest, I have seen too many flower shots, mine and others, that I am not a flower guy anymore. However, if you can take an extreme close-up of the inner workings of a flower, I will enjoy. There is something about creation that makes we enjoy the fine details of things that from our prospective seem small. Some people are attracted to the universe and planets and how small the earth is compare to all of God's creation, but I love to see His work in the small details. This is a book for photographers like me who love the details.
Photography books come in many packages. Some just have photos, some are educational, and other are just editorial. This one is educational with enough examples to get you started. You quickly get that Harold likes water drops, the majority of these images are of water drops. If he revises this book, it would be great if he stretched past flowers and water drops on his extreme close ups. The book is great for anyone who has a DSLR and either no money and a lot of macro lenses and wanted to learn more. He covers the equipment needed, the techniques for focusing, how to light the subjects, and different ways of photographing subjects besides just getting them in focus.
When shooting macros, I typically pull out my NIKKOR 105mm f/2.8 VR lens for normal close ups or reverse mount my NIKKOR 50mm f/1.4 D lens on the front of the 105 and do a double reverse lens setup that gets me really really close. Here is a sample from today:
This image of the head of a Japanese Beetle (look like an orange ladybug) was taken at lunch today with the double reverse setup. I am able to get in there real close and still get a very sharp image of what you can not see with the naked eye. Because this book has some many samples and info attached to each images, I started to learn about extension tubes and close up filters. I have never messed with either of these, but because of the low cost to get started, I think I will ask for some for Christmas. Also the author loves to us his tripod and is able to get most of his shots in decent focus because he uses apertures of 22+ and low shutter speeds. This is only possible with a tripod and you will need an adjustable plate to get the fine movements you need to get the best focus. We are dealing with millimeters of depth-of-field in some of these images, so the more stable and smaller movements you can make, the quicker you are going to get a set of photos in focus. Most of the time you can't move the subject, you have to move the camera so his tips on how to do that are priceless. My bug was handheld only because I am missing the plate for my tripod to hook to my camera. This means i had to take it at 1/60 of a second with f/16 aperture and a lot of flash to make up for the light.
This book really showed me that there is much more to the world of Macro photography that I didn't know about and a lot more gear that one the cheap can extend my ability to capture shots while still retaining the sharpness of the images I like to have. Suggested readers would be any photographer who is looking to get into Macro photography. Take it from me, there is other information out there online, but it is hard to bring it together like this book does. If I would have known about it last year, I would have totally bought it right away.
Technorati Tags: Book Review, Wiley
The C# Programming Language, Fourth Edition by Anders Hejlsberg, Mads Torgersen, Scott Wiltamuth, and Peter Golde
Publisher: Addison Wesley (Special Annotated Edition for C# 4.0)
I can honestly say I have had a copy of this book for each edition it was published. I love this book and have always loved it. Ever since Microsoft stopped publishing the White Reference Guides we used to all have back in the day, Addison Wesley has became my reference book dealer. These White cover books with the most generic titles have filled my bookshelf since I started writing .NET. When it comes to pure reference, I choose these books.
I am not saying I don't have other books around, but typically they fit a different need than reference. Good example would be Steven Walther's (and friends) ASP.NET X.0 Unleashed. I always keep a copy of this book around, but not for reference, for examples and investigating how ASP.NET works and interacts with other portions of the Framework. You won't find this book fitting that need. This is a reference book that talks about C# as a language. It going through everything you could think of when it comes to the syntax of the language. You won't find information about ADO, ASP.NET, LINQ, etc in this C# book, you will find what makes the language tick.
One thing I enjoy about the book is the hard cover and ribbon place holder. I hand this book out the many developers that I work with consulting so it goes through the dirt and gets used. I am a fan of Google for finding answers, but I find when you look it up in a book and really read what it has to say about it, it sticks better. You won't typically find yourself going back to click search a week later when you have to work with events or arrays with a language if you look it up in a book before in my experience. I also really like the idea of a built in placeholder (the ribbon) with a book like this. Not because you would ever read this cover-to-cover. If you do, you probably should see stop reading this post and go outside and do something with a real human, only kidding. I do however suggest everyone who has been in C# and skipped between versions throughout the years to thumb through it page by page and stop when you see something interesting. I found just by spending a few minutes a time with this book that you will find something that will interest you that you didn't know about the language. This will only make you stronger as a developer. Imagine being a carpenter and getting on a project and you only had a standard screwdriver. You could get it done, but you would gain speed by keeping the head of the driver in the screw easier with a phillips-head screwdriver. Even today if you go through Home Depot or Lowes you will find new screwdriver heads designed to make the job go faster and strip less screws. Knowing what tools are available at the core is key. I don't know how many times I have ran into developers after 2.0 was released that did not know a thing about generics. They may have used them, but the mechanics behind them was foreign and they definitely didn't create their own logic using them. Making it a habit to refresh your knowledge about the core language will only make you stronger.
Since this book covers everything, we won't get into the details of the text in this book for this review, it is all there. However, one thing I truly enjoy about this book is the annotations provided by very smart people. These guys are mostly authors themselves and well known in the industry. Their annotations are great additions that go beyond what the authors had written and also add a level of humor to a technical book. Comments like "In all the time since I've been programming .NET (starting before the RTM of 1.0), I've never once found a need to write unsafe code. Not once" by Chris Sells in the beginning of the chapter on Unsafe Code just crack me up. I have never either found a need for unsafe code. I think I used it once for doing some image manipulation, but I didn't write the code, someone else did and I am sure the problem could have been solved without it. Another one by Bill Wagner says "These examples are not as compelling now that nullable types have been added to the language and the framework, Even so, I find that I still create struct types for holding instances of types when I create very large collections of data values" found in the section on Structs adds a little bit of insight to a language that has grown over time and has newer and better ways of doing things that you should consider. The annotations are definitely a favorite of mine when it comes to this book.
Who should have a copy of this book? Any developer who is moving into C# 4.0 and it should hold a prominent place on your bookshelf. They should also consider grabbing it before hitting search. There is something about the written word on paper that just helps for learning new concepts.
Technorati Tags: Book Review, C#, Addison Wesley
So we are at almost two weeks since I purchased the 11 inch MacBook Air and the question would be asked, would you buy it again now that you had one? The answer, absolutely. I am amazed at the speed. Engadget suggested that it was slow on their podcast, but I have to disagree. I only have the 2gb and 1.4ghz model as well, the only upgrade I was able to purchase at the store was the 128gb SSD. I would say it is fast enough for what I use it for. Blogging, Word, Outlook, Excel, surfing, music, video playback and other common tasks. This is not my development box, it will never run Parallels, Fusion, or Boot Camp for me. I won't even install XCode on here for messing around. I have the bigger, beefier box for that. This is my business machine. I will use this for the day-to-day tasks of co-running Geekswithblogs.net and AJI Software. When I am consulting though, I will wake up the MBP 17.
What is my favorite aspects of the MBA11? Size, hands down is number one. It is just big enough for comfortable typing and the resolution is high enough for comfortable editing. I am writing this post with it right now and I am not using any external devices besides the Magic Mouse. I am not a on-board trackpad kind of guy, so the Magic Mouse gives me the touch interface and movement of a mouse.
Next aspect I enjoy would have to be Instant On. Never have to wait or click anything to get this thing to come on. Open the lid and bam, it is on. Amazing how nice that is when you use your machine and a "got a few moments, lets get something done" box. Instant on should be adopted by all portable devices in the future.
Third and last all time favorite thing is the weight, it is a light box. It is comfortable on your lap. You never feel like you are going to drop it while carrying it. It won't add any noticeable difference to your bag. It doesn't make a thud when you sit it down.
So would I buy it again, Yes. Would I suggest it to a friend, if they have a need for portability and productivity. College Students, absolutely. Developers as a main box, no. Moms who have young kids, sure if the kids don't touch it. It is small which makes it fragile. This is not a desktop replacement, it is a productivity enhancement. Now if syncing technologies would be better and not require paid subscription, we would be golden, for a few days before needing something else :D.
So, does anyone else have one of these? What do you think?
Technorati Tags: Apple, MacBook Air, Review
We I first received this book, I was not sure what to expect. When it comes to development topics on debugging the spectrum is very wide. Most developers, including myself, only use basic techniques for day-to-day debugging. These get us through our problems quickly and they work well for 80% of the bugs we encounter. We forgot to close a connection, we didn't set a variable, we forgot to exit a loop, we fat fingered a variable name. All of these are daily errors we as developers face and fix with ease inside Visual Studio. The team in Redmond has done an awesome job at making our job easier for these tasks.
However, there are some bugs that are just hard to find. There are some bugs that are not ours and we have no influence over the correction, but we must know they exist and why so that we can reroute our logic to not run into them when possible. In today's developer economy, more and more is done by larger firms that just can not be moved quickly for repair unless you have the power and clout to make them move. We wait for a patch or sometimes the next version for these things to be fixed. These bugs and others that are more difficult to find and require much smarter tools that Response.Write/Console.Write, breakpoints, Stack Traces, or F10/F11 walkthrough to find. They require SDKs and obscure searches on Microsoft.com to find these tools. They are not the most friendly when it comes to UI's and some were just behind-the-scenes projects that make our lives easier from those who work at Microsoft. This book plays in this territory.
Flip open the cover of this book and you will find names that you know and titles that you wish you had writing praises about the author and his book. Most of these names come from Microsoft Corporation, so you get a sense of comfort knowing that "if they liked it, then I probably should too". A very cool feature of this book was a List of Code Listings, a ToC of code examples which quickly turns this book into a reference guide as well as a sit down and read book. I think other technical books could learn from this. Some people buy books to read, other buy books for reference, I think all dev books could use a list like this to fit in both spectrums.
The book does well at going into the details of the topics covered. I was refreshed when going through the CLR fundamentals chapter after years since reading about how the CLR worked. It didn't take long to have my passions arise about .NET from 2001 and 2002 when I couldn't get enough information about this new product that would change development (and it did). I also learned a lot more that I didn't know about the stack as well through this, how the Windows Loader works with files and loading .NET assemblies. Not something you deal with daily, but still interesting to know and helpful when you are looking into how it all works.
Once you dive through the introduction and layout outline of the book, you get right into the different tools for debugging. Some of them you know, some of them you wish you had known about before. Reading this chapter causes you to want to read more because there is something on this list the average developer wants to know more about. The next chapters are pretty deep and I would not suggest reading it if operating heavy machinery or driving a car. Definitely good stuff, but not for the faint of heart.
Chapter 3 may make you feel a little off when you read the title "BASIC DEBUGGING TASKS" and yet the information cover is not basic as all to the typical developer who does not debug at this level. This is an advanced book so the title should read "BASIC DEBUGGING TASKS FOR ADVANCED .NET DEBUGGING". Reading it this way will help create a level of comfort with the book. The topics discussed in this chapter set the stage for the remainder of the book so it is important to review and understand before moving on. This chapter concludes the Overview section of the book.
The next section of the book is Applied Debugging. This is where the author covers the specific types of debugging problems you face. The Assembly Loader, Managed Heap and Garbage Collection, Synchronization issues, and Interoperability. Though I didn't read these chapters with much detail, they contain a wealth of information I and I will be using this book when I run into issues now instead of trying to use the basic tools for daily debugging. The author truly shows his wealth of knowledge in this section.
The final section of this book covers "Advanced Topics" which is not as scary as it sounds. Postmortem Debugging (Dump Files and Windows Error Reporting) as covered in detail in Chapter 8, Power Tools in Chapter 9, and topics specific to CLR 4.0 in Chapter 10.
I enjoyed reading the chapter on Windows Error Reporting, cause I have always wondered when an obscure application crashes, does the vendor get this information or is it just for Microsoft to see how the applications are working with Windows. The author does a great job detailing out the enrollment process and showing you how to get those dumb files that were submitted. I will be looking into this for a current project I am on for use by the client.
Power Tools is your deep breath chapter. The author has done a great job up to this point of doing a brain dump on how to debug application dumps and you will feel a little bit like telling the author "TMI man!" But the Power Tools chapter shows you how you can interact with these debugging tools in your native developer environment better. Visual Studio integrations and topics covering the CLR Profiler are a must read for those going through this book.
The last chapter covers all the differences between CLR debugging in 3.x to 4.0 that have changed. It is a very short chapter, but important if you are moving to .NET 4.0 and are learning the differences. I really liked seeing this as a separate chapter instead of intermixed with the rest of the book since not every project is on the latest platform.
This book has definitely earned a spot on my bookshelf and will be suggested to other developers who are struggling with debugging topics. All developers owe it to themselves to at least review some of these tools for debugging their applications. This book is the High Dive at the pool however and a counterpart to the Low Dive should be written. .NET and Visual Studio have allowed us as developers to get through our days without the need of a book like this, however when the Red Lights are flashing and you have to get down and dirty with a bug, this should be used by someone on your team as a flashlight to help become familiar with techniques for digging deeper.
Technorati Tags: Book Review, .NET, Debugging