So, if the apocalypse does come, I really hope I'm not here to deal with it. Maybe I'll be off traveling while it happens or something. Yeah, that souSo, if the apocalypse does come, I really hope I'm not here to deal with it. Maybe I'll be off traveling while it happens or something. Yeah, that sounds good.
The thing is, the one thing Dartnell convinced me of, above all else, is that it's going to be a really hard road for civilization to crawl back out of that pit. Granted, there are a ton of shortcuts available -- for everything except maybe the organic chemistry that, as it turns out, plays a far greater role in our daily existence than most likely realize. But those even with those shortcuts, it's going to be a hard road forward. Forget what the preppers might tell you -- just packing a few years supply of canned goods and stockpile of guns and ammo isn't going to help much.
That being said, this book is a pretty great exploration of the landscape if you really want to understand what it will take to climb back up. If you read sci-fi or any of the post-apocalypse literature that's out there (and there is a log of it), this book is going to change the way you view it. Having recently read Lucifer's Hammer, I realize just how much most of these books miss. It's good to recognize that a book like this isn't going to be a cookbook for bringing society back, but it outlines the range of concerns and developments that will need to happen.
I was honestly tempted to give this one five stars, but I think it would have had to cover a bit more detail, provided about twenty times more illustrations, and likely been about ten times as long to fully satisfy my desire to understand what this book was trying to cover. Of course, I'll need about 5-10 years to give a thorough study if/when that book finally comes to be. ;~)...more
I remembered this book in the context of a conversation this morning and realized I needed to add it here. I'm disappointed to see what low marks it hI remembered this book in the context of a conversation this morning and realized I needed to add it here. I'm disappointed to see what low marks it has here on Goodreads, given how important this book was to me early(-ish) in my career. In terms of technology, this book is certainly VERY dated, but it is filled with important ideas and approaches, some of which we take for granted now and many of which have still not seen the light of day. I probably have the timeline wrong, but if I recall correctly, this book came out around the time that P2P networks seemed to be the next big thing. And yet, here were are at a time when a large percent of what the more radical uses of P2P have still not really taken hold. But there's no doubt there is still much value to be gained from them. If you ever want to get a snapshot-in-time view of what was considered fringe approaches to doing business collaboratively, you should read this book, but also go spend some time reading about the historical context around it: check out Ward Cunningham's Portland Pattern Repository (the original wiki); investigate the state of the P2P revolution that was supposedly taking place around the turn of the millenium (important search terms: Groove Networks & Ray Ozzie, gnutella, Napster, Freenet, SETI@Home, and of course BitTorrent (these P2P applications were indicators, if not direct precursors, to many of the so-called NoSQL technologies around today.
Read this, if you get a chance, but only do so if you have or can "retrieve" (through friends who were around or through your own studies) the historical context that surrounded it. ...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
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
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 help out. 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
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
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
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
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
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