Profile for R. Friesel Jr. > Reviews

Browse

R. Friesel Jr.'s Profile

Customer Reviews: 196
Top Reviewer Ranking: 13,026
Helpful Votes: 1062




Community Features
Review Discussion Boards
Top Reviewers

Guidelines: Learn more about the ins and outs of Your Profile.

Reviews Written by
R. Friesel Jr. "found_drama" RSS Feed (Burlington, VT USA)
(REAL NAME)   

Show:  
Page: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11-20
pixel
Client-Server Web Apps with JavaScript and Java
Client-Server Web Apps with JavaScript and Java
by Simon St.Laurent
Edition: Paperback
Price: $29.72
42 used & new from $22.07

6 of 6 people found the following review helpful
4.0 out of 5 stars good survey of "modern" architecture and tools for building modern web apps, April 29, 2014
Having just wrapped up "Client-Server Web Apps with JavaScript and Java" by Casimir Saternos (O'Reilly, 2014), I'd say that I _mostly_ got out of it what I wanted, and that it serves as a good jumping-off point for developers that want to build "modern" web applications on top of the JVM. More than anything else, Saternos' book is a thumbnail sketch of the architecture and tools needed to build those kind of apps, but it does not go particularly deep on any one of those items. As it says in the preface, it's probably best suited for developers who primarily work in Java and want to build a scalable web application with modern technologies -- not that front-end developers don't stand to gain something as well, but they may have more catching up to do (more on this in a moment...).

Saternos' basic approach here is to describe "modern" web applications as RESTful, API-based back-ends that primarily serve JSON to a rich front-end that is built around something like AngularJS. However, he doesn't limit himself to just the API and front-end layers here. Even a glance at the table of contents will reveal that he goes for breadth in his discussion: there are chapters on REST fundamentals and API design, API implementation with tools like Jersey, testing strategies with JUnit and Jasmine, build and deployment tooling, virtualization strategies, and more. The book's coverage is fairly shallow, but Saternos provides many references to other sources for richer coverage, and he also provides sample code with example implementations for each relevant chapter.

Was there anything missing? Yes and no... Again: the book is a shallow survey of these technologies, and as such it elegantly fulfills its main mission: to give an overview of the technologies that you would use when constructing a modern web application in the JVM. And again: there are plenty of references to solid foundational texts for those instances where you need to go deeper on some particular subject. But there are also seem to be some gaps.

First, some front-end developers may feel a bit lost coming into this; working in the JVM can be a bit daunting to the new-comer, and piling dynamic languages on top of this can be a bit eyebrow-raising. Part of me thinks that this is absolutely the right move -- I know a lot of front-end developers that are right at home in Ruby or Python, and so using JRuby or Jython as the introduction to the JVM makes sense. But there are also esoteric complications that come along with that which are not really addressed in the book. Not that a survey such as this is the right place to cover that kind of edge-case trivia, but a footnote to that effect may have been useful.

Second, the chapter on "Packaging and Deployment" focused exclusively on the server side of the web application with no substantive mention of how to package the front-end assets. Where was the discussion of minification and concatenation? Considering the depth of the discussion on REST and HTTP earlier in the book, I would have expected to loop back around on that here for a discussion of CDNs or Expires headers. This seemed like a lost opportunity to me.

In the grand scheme of what Saternos set out to do however, those critiques are pretty minor. That he assumes the reader has more familiarity with the JVM than with front-end technologies is evident, but not a detriment. The book is a good look into what technologies and techniques make up a "modern" web application, and though there is plenty of room for disagreement about some of his recommendations, it is also a great "conversation-starter" for your project, and chances are that you'll learn about a thing or two that you'll want to chase down further.


Data Structures and Algorithms with JavaScript
Data Structures and Algorithms with JavaScript
Price: $18.35

15 of 15 people found the following review helpful
4.0 out of 5 stars like CS 101 with JS, March 30, 2014
Mike McMillan's "Data Structures and Algorithms with JavaScript" uses JavaScript as a vehicle for introducing a number of fundamental computer science concepts. It reminds me a little bit of Tom Stuart's "Understanding Computation" -- that is, it's a book about CS topics that targets people without a CS background. One might consider both books to be a gentle introduction to computer science, or "computer science for the layperson".

At a high level, McMillan walks us through some of these different data structures (e.g., sets, binary trees) and algorithms (binary search, quick sort). These are topics that we might have encountered in introductory computer science courses (had we made it all the way through our introductory computer science courses) -- he just happens to have chosen JavaScript as the illustrative language here. And there are some good reasons for choosing JavaScript: it is fairly ubiquitous, and it's comparatively easy to start programming with JavaScript as opposed to many other languages. There's also this latent assertion that there are many people who are doing professional software development (with JavaScript) who otherwise do not have CS backgrounds.

To this point, McMillan is largely successful. He is able to demonstrate *how* to implement these data structures and algorithms using JavaScript, even if it isn't always clear *why* you would use JavaScript. He clearly articulates the traditional use-cases for each of the data structures and algorithms, but sometimes we're still left wondering why we would use JavaScript to solve this problem (e.g., as opposed to a language that already has sets built in). Also, some of his implementations appear to duplicate built-in objects (e.g., his `HashMap` arguably overlaps with JavaScript's built-in `Object`) or else they're implemented... strangely? (e.g., his `Dictionary` implementation uses an `Array` under the hood for no good reason)

That being said, McMillan does a great job of explaining each data structure, what shape they are, why you would want to use one over another, and how they align with certain types of problems. (Same goes for his discussion of search and sort algorithms.) However, despite how strong these discussions are, it also seems to go against the current trend in JavaScript development. As I read through many of these chapters, I thought to myself: "Wouldn't you just use a function for that?" Granted, the OO approach gives us those functions (as methods) just beneath the façade of the object itself -- but still, those thoughts were there: "Wouldn't you just use a function?" and "Why do this in JavaScript when there are other languages that have first-class support for this?"

Overall, I enjoyed McMillan's book. I found it was a good introductory level instructional text for some of these CS concepts (even if the choice of JavaScript is a bit of a novelty) -- but I wouldn't consider it a practical manual of what to do "in the field". If you're doing software development in JavaScript and you're trying to fill in the gaps of your computer science background, I would recommend this.
Comment Comment (1) | Permalink | Most recent comment: May 5, 2014 5:31 PM PDT


Practical Data Analysis
Practical Data Analysis
by Hector Cuesta
Edition: Paperback
Price: $44.99
20 used & new from $40.99

4 of 4 people found the following review helpful
4.0 out of 5 stars good intro to data analysis, great if you have something to compare it to, December 9, 2013
I just finished up reading "Practical Data Analysis" by Hector Cuesta (Packt Publishing, 2013) and overall, it was a pretty good overview and recommends some good tools. I would say that the book is a good place for someone to get started if they have no real experience performing these kinds of analyses, and though Cuesta doesn't go deep into the math behind it all, he isn't afraid to use the technical names for different formulae, which should make it easy for you to do your own follow-up research.

Jeff Leek's Data Analysis on Coursera provides the lens through which I read this book. That being said, I found myself doing a lot of comparing and contrasting between the two. For example, they both use practical, reasonably small "real world" sample problems to highlight specific analytical techniques and/or features of their chosen toolkits. However, whereas Leek's course focused exclusively on using R, Cuesta assembles his own all-star team of tools using Python and D3.js. Perhaps it goes without saying, but there are pros and cons to each approach (e.g., Leek's "pure R" vs. Cuesta's "Python plus D3.js"), and I felt that it was best to consider them together.

Cuesta's approach with this book is to present a sample scenario in each chapter that introduces a class of problem, a solution to that problem, and his recommended toolkit. For example, chapter six creates a stock price simulation, introducing simple simulation problems (especially for apparently stochastic data), time series data and Monte Carlo methods, and then how to simulate the data using Python and visualizing it in D3.js. Although the book is not strictly a "cookbook", the chapters very much feel like macro-level "recipes". There's quite a bit of code and some decent discussion around the concepts that govern the analytical model, and (true to the "practical" in the title) the emphasis is on the "how" and not the "why".

While I did not read the entire book cover-to-cover, I would definitely recommend it to anyone that wants an introduction to some basic data analysis techniques and tools. You'll get more out of this book if you have some base to compare it to -- e.g., some experience in R (academic or otherwise); and you'll get the most out of this book if you also have a solid foundation in the mathematics and/or statistics that underlie these analytical approaches.

DISCLOSURE: I was given an electronic copy of this book from the publisher in exchange for writing a review.


High Performance Browser Networking: What every web developer should know about networking and web performance
High Performance Browser Networking: What every web developer should know about networking and web performance
by Ilya Grigorik
Edition: Paperback
Price: $36.66
56 used & new from $21.49

2 of 2 people found the following review helpful
5.0 out of 5 stars required reading for folks working in the web stack, December 1, 2013
I just wrapped up "High Performance Browser Networking" by Ilya Grigorik (O'Reilly, 2013) and it just may be the best technical book I read in 2013. I first encountered Grigorik and his work about a year ago when I was researching web performance and HAR tools in particular; it wasn't long after that that I heard he was working on this book. I looked forward to it ever since, and I wasn't let down.

If you are working where the web is your deployment platform, then HPBN has strong coverage of the protocols, networks, and APIs that you're using every day. Grigorik asserts that latency is the true performance problem of the web, and goes on to tell a compelling end-to-end story, looking at TCP, UDP, and TLS, then then different kinds of wireless networks between you and your users, and finally going deep on HTTP, XHR, SSE, WebSockets, and WebRTC. He presents some great data to back up his statements, and the book winds up feeling like a comprehensive report on the fundamental building blocks of networked applications. Whether you work primarily in the back- or front-end of the web stack, HPBN is essential reading and will provide you with a strong foundation in how to perform performance profiles of your applications and how to optimize for different scenarios (and the trade-offs you may be forced to make).

I learned a great deal from this book, and I suspect I'll be re-reading it to pick up what I missed the first time. I would highly recommend HPBN -- it's a great reference, and should be considered required reading for anyone deploying applications to the web. I don't know of any other books quite like this one.

DISCLOSURE: I received an electronic copy from the publisher in exchange for writing a review.


Jasmine JavaScript Testing
Jasmine JavaScript Testing
by Paulo Ragonha
Edition: Paperback
Price: $30.59
19 used & new from $26.59

2 of 2 people found the following review helpful
4.0 out of 5 stars a book about good code (using testing as a measure of success), September 26, 2013
Packt Publishing recently released Jasmine JavaScript Testing by Paulo Ragonha (@pirelenito), and I just wrapped up reading it this morning. I've read a few books on JavaScript unit testing and at least one other that was dedicated to Jasmine, and this one is a strong entry.

If you're unfamiliar with Jasmine, Ragonha will give you a solid foundation of the testing framework by the end of the second chapter. Less than 40 pages in and you'll understand Jasmine's approach to testing, as well as how to stand up a basic test suite. His coverage of the core functions and the collection of built-in matchers is concise and accurate. He builds on this foundation by demonstrating Jasmine's abilities in testing everything from asynchronous code to MVC components to AMD modules.

Despite the title, Jasmine JavaScript Testing isn't merely about the testing framework, or even just about testing. What Ragonha gives us is a book about how to write better code, using testability as the measurement of success. What is strongest about this book is how he uses a refactoring project as a frame-of-reference for telling the testability story. He's not just talking about using Jasmine for writing tests; he's talking about how to use it alongside the other tools and patterns that will make you a better front-end developer.

If you're just getting started with testing JavaScript for the front-end, or if you want to see some good real-world examples, then I would definitely recommend this one.

Disclosure: I received an electronic copy of this book from the publisher in exchange for writing this review.


Understanding Computation: From Simple Machines to Impossible Programs
Understanding Computation: From Simple Machines to Impossible Programs
by Tom Stuart
Edition: Paperback
Price: $26.17
63 used & new from $16.99

32 of 36 people found the following review helpful
4.0 out of 5 stars the computer science book for non-computer science software engineers, July 6, 2013
Despite the fact that there's no _real_ reason to be apologetic, I also haven't yet reached the point in my career as a software developer where I've stopped apologizing for the fact that I have no "real" Computer Science Background. And/but that's exactly what draws me to books like "Understanding Computation" by Tom Stuart (O'Reilly, 2013). Stuart describes the books as for:

"...programmers who are curious about programming languages and the theory of computation, especially those who don't have a formal background in mathematics or computer science."

In other words, people like me. The people that Eric Miraglia described as the "liberal arts majors drafted into web-developer service during the dotcom boom". (source: Professional JavaScript for Web Developers 2nd ed.) Yes: the liberal artsy non-computer science degree holders that wound up doing computer sciencey type software work just the same. Smart people that nevertheless are exploring some of these concepts for the first time.

For a taste of what I mean, observe the following quote:

"In the end, syntax is only concerned with the surface appearance of programs, not with their meanings."

If that made you smile just a little bit, because you want to peel the onion layers away and get at the semantic questions underneath... then this book is for you.

Now before we go any further -- a couple words on what this book is **not**. This is _not_ a book about software engineering. "Big O notation" does not make an appearance here in the text, not once. It isn't that we aren't concerned with "clean code" or efficiency or scalability or any of that -- but those are just implementation details that are not particularly interesting when you're otherwise diving into language semantics and finite automata.

Instead, the kind of questions this book poses are more like:

- What _is_ a computer?
- How do you create one?
- How does a computer _compute_?
- How would you go about designing a language?
- Are there limits to computation? What are they?

These are fascinating questions, and reading this book was one of the first times where I really understood what separates "computer science" from "software engineering". The book is a fascinating read, even if it occasionally lapses into sentences like this:

"The NFA class automatically takes account of free moves -- we can see that when our NFA is started in state 3, it's already possible for it to be in state 2 or 3 before it has read any input -- so we won't need to do anything special in NFASimulation to support them."

_Awesome_, but a little opaque. And/but, there's quite a bit of this; for a "simple" book about foundational computer science thinking, there's a lot of complicated material. ("But this is why you're here, right? To dip your toes into this particular pool?") It's often challenging, but also rewarding. (And there's plenty of humor along the way, if you're paying attention.)

A year from now, when I'm settling in to re-read this one, I probably won't remember the details about pushdown automata or what formalisms define a "universal Turing machine". However, I'm going to remember the in-depth discussions of static typing vs. dynamism and the trade-offs between them. I'll remember that we went through some engrossing exercises where we built up integers and arithmetic operators from scratch (even if I don't remember the details). I'll remember the flirtatious foray into language design. I'll remember The Halting Problem and most of the gory details around the limits of computation. And another thing I'll remember, statements like this:

"The purpose of an expression is to be evaluated to produce another expression; a statement, on the other hand, is evaluated to make some change to the state of the abstract machine."

If you're "doing software" and you don't have a degree in computer science, I'm going to urge you to read this book. Even if you can't follow everything, you'll walk away with a lot of insight. (I'm particularly fond of the first and last thirds.) And if you _do_ have a CS degree... Well, it's still worth skimming.


Functional JavaScript: Introducing Functional Programming with Underscore.js
Functional JavaScript: Introducing Functional Programming with Underscore.js
Price: $9.99

27 of 28 people found the following review helpful
5.0 out of 5 stars just might change how you approach problems with JS, June 19, 2013
My name is on the back cover, and that blurb probably says it all but...

I had the privilege of reading some early drafts of this book and seeing it take shape. Fogus has written an outstanding book here and one that I could see joining the ranks of canonical JS texts like JavaScript: The Good Parts, Professional JavaScript for Web Developers, and JavaScript: The Definitive Guide (aka "el Rhino Diablo"). Just like Underscore is a surprisingly-small-yet-surprisingly-powerful library, so this book is surprisingly dense. This probably shouldn't be your first JavaScript book, but if you're familiar with the language already, then this is an excellent introduction to the functional programming paradigm, as well as how to apply those concepts to JavaScript. I'm particularly impressed with how accessible he makes some of these concepts (e.g., pipelining, trampolines, protocols) which can sometimes seem a bit... obtuse and academic. Fogus really shows how these powerful techniques can be used with great effect in JavaScript, but also how JavaScript itself makes some of these concepts possible (and even trivial) to implement.

Seriously: JavaScript is everywhere, it's the lingua franca of the web, and as we do more powerful things in the browser, we're going to need more powerful programming paradigms. "Functional JavaScript" helps show the way.
Comment Comment (1) | Permalink | Most recent comment: Aug 5, 2013 1:34 PM PDT


Programming Grails
Programming Grails
by Burt Beckwith
Edition: Paperback
Price: $37.04
57 used & new from $20.00

3 of 3 people found the following review helpful
4.0 out of 5 stars a guided tour of the "magic" parts by a seasoned expert, May 13, 2013
This review is from: Programming Grails (Paperback)
If you've been programming in Grails for a year (give or take) and are ready to go deeper than the tutorials and docs usually take you, then this book is just what the doctor ordered. If asked to sum it up as a pithy one-liner, I'd describe it as a guided tour of the framework's guts by one of the field's seasoned experts. He goes beyond the basics, and dives headlong into those dark corners for (as he puts it) "developers who want to dig deeper into the architecture and understand more about how Grails works its magic".

Having worked in, with, around, over, under, and through Grails over the past couple of years, this book was exactly what I was looking for at this point in my relationship with the framework. Beckwith is specifically targeting developers that have gone past simply snapping together applications along the happy-path; this one is for the developers that find themselves regularly battling with some dark and thorny corner or rough edge of the framework. Beckwith does a fantastic job of introducing these "hidden" and "magical" parts of Grails, and breaking them down into easily-digestible sections. It's like a series of miniature epiphanies -- one right after the other. (The opening chapter on Groovy alone is worth the price of admission.)

There were a couple of things that could have made this one better. Most of them were small to the point of being ridiculous (e.g., I could have used a more specific definition for the _purpose_ behind `BootStrap.groovy`), while others were arguably out of scope (e.g., an in-depth discussion of Groovy's metaclasses is... probably more appropriate for a book dedicated to Groovy). Then there was the chapter on plugin development which -- although I learned something on almost every page -- I found myself wondering: (1) why not discuss how to run with inline plugins right from start? (2) why wait so long to mention `settings.groovy`? (3) why not a better example of CLI tests?

(As you can see: even my "legitimate gripes" are little more than nit-picks. But I suppose the nit-picks add up?)

Would I recommend this one? In heartbeat. I'll continue to recommend Grails in Action as the best place to start (with the caveat: "as soon as the second edition comes out..."), but "Programming Grails" is required reading for anyone with six months or more of non-trivial Grails development under their belt.

----

DISCLOSURE: I received an electronic copy of the book from the publisher in exchange for writing a review.


JavaScript Testing with Jasmine: JavaScript Behavior-Driven Development
JavaScript Testing with Jasmine: JavaScript Behavior-Driven Development
by Evan Hahn
Edition: Paperback
Price: $13.43
45 used & new from $8.48

2 of 2 people found the following review helpful
3.0 out of 5 stars a short "guided tour" of Jasmine, May 5, 2013
Evan Hahn did us a favor and slapped together this primer for us. It's short (around 50 pages), so you can burn through it in an afternoon, but he hits the high notes and (most importantly) provides a clear path for how to get started using Jasmine.

As a testing library, Jasmine itself is pretty approachable. It does not have a steep learning curve, and you can get some valuable results quickly just by diving in. But if you're looking for a kind of... "guided tour" to help orient you to the library (and JavaScript testing in a more general sense) then that is where this book comes in. Hahn has peppered the text with some discussion TDD and BDD, and in some chapters there is almost as much discussion of these general development philosophies than there is of Jasmine specifically.

The book's greatest strength (that it is so focused and concise) is also its greatest weakness -- you may reach the end and wonder: "OK, what next?" Its coverage, while broad, is not particularly deep. This isn't much of a criticism though -- how deep into the innards can you really get before you're just talking about the low-level source code? In addition to the "guided tour" approach taken by most of the book, I also appreciated the quick-and-dirty "Using Jasmine with Other Tools" chapter near the end, which is a series of overviews dedicated to the major integrations that exist. (That being said, the overviews of those integrations are just that: shallow overviews, and I would have liked to have seen at least one _really_ deep dive.)

By itself, Hahn's book is a good intro to the subject (Jasmine, and JavaScript testing), and works best if you're looking for a kind of "guided tour" to help you get started. And if you are just looking for something focused on Jasmine, then this is great; and/but if you are looking for a more thorough treatment of the subject (i.e., JavaScript testing) then you'll want to check out something like Mark Ethan Trostler's Testable JavaScript.

[FULL DISCLOSURE] I received an electronic copy of this book from the publisher in exchange for writing this review.


Doom Days
Doom Days
Price: $1.97

3 of 4 people found the following review helpful
3.0 out of 5 stars "Grasshopper Song" alone makes it worth the price, March 1, 2013
This review is from: Doom Days (Kindle Edition)
"Doom Days" is an anthology in the same spirit as Larry Niven's The Man-Kzin Wars series or Robert Lynn Asprin's Thieves' World [1] -- a "shared world" anthology conceived by one author, but the individual (and loosely-connected) stories written by several others besides. This particular set of stories is set in a post-apocalyptic United States [2] -- specifically the fictional town of Thorn Creek, North Carolina, a bit outside of Raleigh. The nature of the apocalypse ("the Collapse") is never really explored, and stories focus instead on the hard-scrabble lives of the characters scraping out their existence within the milieu. The stories are populated by a diverse cast of relatable, mostly "morally good" [3] protagonists against a largely invisible back-drop of scavengers, opportunists, bandits, slavers, and... intellectual terrorists? [4]

At their hearts, post-apocalyptic stories tend to be "what if?" fantasies that let the author(s) plant little utopian seeds in the midst of some of the most difficult and taxing periods they can imagine. (It's convenient, really.) They're fun to contemplate. "What if we got rid of all these modern trappings and went down to basics--would we wind up making the same mistakes?" They're fables, morality plays. They're easy because we get to have a simple-yet-familiar world in which to explore what feel like fundamental questions. But just because they're easy doesn't make them bad. They work. As Dale Bailey wrote:

"The truth is, almost all end-of-the-world stories are at some level Adam-and-Eve stories."

And the "Doom Days" anthology is no different. [5]

Overall, the stories are pretty good. "Grasshopper Song" alone makes the whole thing worth the $2.99 Kindle price.

----

Disclosure: I received a copy as a gift from the author in exchange for writing a review.

-----

[1] The former was the first one that came to mind for me; the latter was the one cited in the author's note.

[2] No real discussion of whether this "Collapse" affects the rest of the world. It's suggested that it does, but it's also suggested that places like Canada and Mexico are somehow "safe(r)". It doesn't totally add up, but given its local focus and the somewhat specifically narrow scope of the story, I don't think it matters that this isn't explored.

[3] "Morally good" being in the traditional Western more/less Judeo-Christian sense of the phrase here. Not Mega-Church Ultra-Right Family Values "Good", but a more (Western) universally palatable good vis-à-vis hard work, fairness, justice, etc.

[4] Not exactly a spoiler alert here but... A couple of the stories refer to "the University" in rather ominous terms. The University appears to be a town/commune built up around an abandoned college campus in Raleigh, NC. The narrative paints The University's inhabitants as an oligarchy of unscrupulous academics and engineers that have walled themselves off in this compound so that they can pursue a rigorous eugenics program while trying to fashion themselves into the post-apocalyptic world's first nuclear power. I was really hoping that there would be more to this -- that The University and the circumstances around it would be more nuanced... But instead it's almost cartoonishly flat and carries a latent anti-intellectualism that was my biggest disappointment with the anthology.

[5] Hell, it starts with what is basically a twisted cast-out-of-Eden retelling.


Page: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11-20