**spoiler alert** I find myself constantly going back and flipping through this book. Dawes is full of great ideas and interesting thoughts on creativ**spoiler alert** I find myself constantly going back and flipping through this book. Dawes is full of great ideas and interesting thoughts on creativity and ways to find inspiration. ...more
I have this not so secret wish to be an embedded systems developer. I also like to know what's going on inside the devices I'm developing for. This boI have this not so secret wish to be an embedded systems developer. I also like to know what's going on inside the devices I'm developing for. This book gave me a lot of insight into that and made me at least believe that if I put the effort into it, I could probably design a simple embedded device. It's also full of tips that would likely be useful to any electronics hobbiest. ...more
Good, if somewhat flawed, introduction to "advanced" systems/application programming in Linux. You should definitely have at least some background inGood, if somewhat flawed, introduction to "advanced" systems/application programming in Linux. You should definitely have at least some background in C development before trying to tackle this book. That said, it's not really that advanced, despite the name. However, it does collect a lot of good information into one place that would otherwise require tracking down lots of how-tos, tutorials, manpages, etc. to get the full picture. Not to say it presents the full picture -- but for the concise size of the book, it does a pretty good job....more
I've only just started reading this one, but I've skimmed quite a bit of it for useful tidbits. It's definitely the first good solid book on Vim thatI've only just started reading this one, but I've skimmed quite a bit of it for useful tidbits. It's definitely the first good solid book on Vim that I've found. If you're a die hard Unix-head, you should definitely pick this up unless you already know Vim inside and out....more
Note: this review is based on a pre-release copy of the book.
When I first encountered RDF years ago, I wrote it off. It seemed unlikely that it wouldNote: this review is based on a pre-release copy of the book.
When I first encountered RDF years ago, I wrote it off. It seemed unlikely that it would get much use. But the recent arrival of collections of so-called 'semantic' data via organizations like Freebase, has made me rethink that position. Of course, figuring out how to make use of this data is another proposition, but Programming the Semantic Web serves as a solid introduction and survey of the tools and techniques necessary to make it into something worth your effort.
I can say that after reading this book, I finally get the concept of semantic data and the relationships it defines. The book begins by walking through the building of a basic triple-store (that is, a data store full of triples -- if you don't know what they are, you should read the book). This and the ensuing discussion of the graph structures built from these triples leads into an introduction to RDF. In this context, it really starts to make sense.
The examples in this book are quite useful and not too abstract. For instance, one of the examples shows how to take legacy data from an RDBMS and generate an RDF graph, going from implicit to explicit semantics. Another uses a programmatic version of the popular 'Six Degrees of Kevin Bacon' trivia game to show how you can use a semantic database of movie data to find the shortest path between two given actors (one, clearly, being the ever-popular Kevin Bacon). The final example in the book shows in brief how you might build a system for managing job listings for various companies. The example is thorough and reasonably complex, but still manages to cover a lot of ground, including integration with libraries for visualizing the data. The majority of the examples in the book are written in Python, though Java makes an appearance in the toolkit chapter, which covers various libraries available for working with RDF.
One item of note is that in the conclusion, the authors do stress caution about this technology or at least particular approaches or tools. It's important to sort out the hype from the real deal and it takes a realists perspective to understand that semantic web tools have been considered the 'next great thing' by various pundits for much of the last decade -- clearly it's not what some envisioned back when the ideas were first brought forth.
I can't say that I'm going to be rushing out and building next great application after having read this book, nor will I be looking at bring RDF into each system I build. But I do have an appreciation for what semantic data and RDF can bring to aspects of future projects I might work on. I would have enjoyed seeing more details about using external, non-semantic data source and using that data in a semantic graph, but given the range of material to cover, I can understand that this could be an entire book of it's own. ...more
Just to be clear I read the prerelease "rough cut" of this book from O'Reilly. I haven't read it in detail, but as near as I can tell, it handily beatJust to be clear I read the prerelease "rough cut" of this book from O'Reilly. I haven't read it in detail, but as near as I can tell, it handily beats the other Scala books out. ...more
This is just a quick write up for now -- I plan to write a more thorough review of this later. While I do have some quibbles about some of the thingsThis is just a quick write up for now -- I plan to write a more thorough review of this later. While I do have some quibbles about some of the things Burke did not cover in this book or that he glossed over, I would say that this is a must read for anyone working with webservices in the Java world. It is far more complete and comprehensive than any of the tutorials available on JAX-RS and made me aware of a lot of capabilities I had failed to uncover in previous investigations....more
It helps that you can easily read through the majority of this book in a couple hours. But it's also one to keep around and flip through every so often when you need a refresher....more
The first read of this was largely in its pre-release state. I'm currently on my seconding reading.
Overall I came away feeling strongly that this wasThe first read of this was largely in its pre-release state. I'm currently on my seconding reading.
Overall I came away feeling strongly that this was the best book to read after you've had some exposure to Scala and want to go a bit deeper (ok, perhaps a LOT deeper, in some areas). Josh clearly knows his stuff and is enthusiastic to share it. He covers a broad-range of Scala's more complex features, but makes them approachable and understandable. I suspect this will be a book I'll be referencing time and time again.
There are some weaknesses in the book. A few areas I, in particular, I felt could have used a bit more clarity. But my biggest gripe is just the poor editing -- there are a lot of typos and in some cases these are in the code examples. This unfortunately can make it harder to understand what's being explained....more
Full disclosure: I was the technical proofreader for this book. Before you yell at me for anything I missed, please know that I was called on at the vFull disclosure: I was the technical proofreader for this book. Before you yell at me for anything I missed, please know that I was called on at the very last minute to provide this service to them. Nonetheless, I did the best I could in the time provided, hand-entering most of the examples directly to make sure they worked as expected. Also, while I will be getting compensated for my proofreading of this book, my earnings are not dependent on its success or failure.
Having said all that, I highly recommend this book if you're looking for an introduction to the Play Framework from a Scala perspective (there is also a Java-based book with a similar purpose being published by Manning later this year). There are certainly things it leaves out, such as testing (a big oversight, as Debasish has pointed out in a recent tweet), embedding in existing SBT projects, etc. But for a mostly comprehensive understanding of the core functionality, this book is very useful. It's also well-written, providing clear explanations where things might not be entirely obvious. It does assume some familiarity with Scala and having exposure to Akka, which Play uses for various purposes and provides as a utility for the user of the framework, would be helpful, but one does not need to be an expert in either to find this book useful....more
This book should be required reading for anyone wanting to really learn and understand Scala. It's not that the book will necessarily give you masteryThis book should be required reading for anyone wanting to really learn and understand Scala. It's not that the book will necessarily give you mastery of the language -- only time and experience gained through writing lots of code can do that, though they help by giving the reader lots of good exercises. But it will alter your view of the language and very likely teach you a new way of approaching problems. The authors are both expert Scala engineers with deep understanding of the principles of functional programming. Their approach is illuminating, in particular, in showing how you can apply the type system and referential transparency to solve problems using very generalizable patterns.
Addendum to my earlier posting of this, initially very brief, review:
First, it's worth noting that this book in no way requires you to learn or use Scalaz, though both authors are contributors to that library. It will teach you what you need to better understand Scalaz, but it also leaves a lot out. For example, the current pre-release draft of the book doesn't even mention type classes. In my opinion, this is a good thing. There are other books, such as Joshua Suereth's fantastic Scala in Depth, that do a very good job of this already. And covering this material here would only take away from the core of what this book attempts to teach.
Finally, I should note that I was both a technical reviewer of earlier drafts and did the final technical proofreading. So hold me responsible for any errors that slipped through!! Well, not really! ;~) I was (well, will be) compensated for both of these (a free book in the first case and a small monetary amount in the second), but I can tell you truthfully that in no way did this influence my review of this book. If anything, my experience proofreading this gave me an interesting insight into the book. Having tech reviewed and proofread many other books, I was floored by how few technical errors (remember, I was not reviewing their language or grammar) I was able to find. I personally believe this may demonstrate something interesting about the diligent effort the authors put into this book.
This book is a good one to work through with others, particularly given the exercise driven nature of it. At Janrain, where I am currently employed, we started a study group to work through it. We initially planned a week per chapter, but found even this was overly aggressive at times. It's best to find the rate that works for the group and adjust as needed.
As I mention in one of my comments below to my friend and coworker Sean, this is probably nto the best book to use as an introduction to Scala. The authors do a good job of introducing the features you need to work through the book (though I did see a few places where they leave the reader to find more on her own), it won't give you the breadth you really need to become proficient. That said, if you do choose to pick up a book, such as Scala for the Impatient, you can certainly work through both in tandem if you're really in a hurry. ...more
Interesting, but not hugely insightful into the PhD process (not to imply that was the author's intent). It was mostly worthwhile read, but primarilyInteresting, but not hugely insightful into the PhD process (not to imply that was the author's intent). It was mostly worthwhile read, but primarily just as a memoir....more