I finally took the time to read Rework by Jason Fried & David Heinemeier Hansson from 37signals so as a memo, I'm sharing there the best parts I found:

"Workaholics aren't heroes. They don't save the day, they just use it up. The real hero is already home because she figured out a faster way to get things done."

"You want your customers to say, “This makes my life better.” You want to feel that if you stopped doing what you do, people would notice."

"The most important thing is to begin. So get a camera, hit Record, and start shooting."

"[...] keep in mind why you're doing what you're doing. Great businesses have a point of view, not just a product or sevice."

"Whenever you can, swap “Let's think about it” for “Let's decide on it.” Commit to making decisions. Don't wait for the perfect solution. Decide and move forward."

"When things aren't working, the natural inclination is to throw more at the problem. More people, time, and money. All that ends up doing is making the problem bigger. The right way to gi is the opposite direction: Cut back."

"The core of your business should be built around things that won't change. Things that people are going to want today and ten years from now."

"Interruption is the enemy of productivity"

"Meeting are toxic [...] set a timer. When it rings, meeting's over. Period."

"Make tiny decisions [...] When you make tiny decisions, you can't make big mistakes. These small decisions mean you can afford to change. There's no big penalty if you mess up. You just fix it."

"[...] you can't beat something who's making the rules. You need to redefine the rules, not just build something slightly better."

"[...] build an audience. Speak, write, blog, tweet, make videos [...]. Share information that's valuable and you'll [...] build a loyal audience."

"As a business owner, you should share everything you know [...]."

"Marketing is not a department [...]" everything you do (email, support, in-app error messages, phone calls, ...) is marketing.

Mastering JavaScript Design Patterns (MJDP) is another book Packt graciously sent me. This book is divided in two parts. The first part is about Gang Of Four (GoF) classical Design Patterns the other part is about other well know patterns.

TL;DR: Overall the book is good enough and will be perfect for developers with little experience in software development.

However be careful with the following points below:

• UML diagrams are not descriptive as they should be, "memberName" should not be written multiple times as class attributes
• The part where the author said that singleton could not be created in JavaScript in a OOP way is plain wrong
• In the Functional Programming chapter, JavaScript examples could have been written better. Using a for loop instead of map (IE9+) is disappointing (to say the least!)
• The MV* chapter does not follow the Separation of Concerns principle well enough
• View initialization and rendering are done inside the constructor (they should not be)
• Model attributes are too often manipulated inside the controller
• State information is duplicated (e.g. IsValid in ValidationResult)
• A dispose (or release) method is missing for clean life-cycle management
• bind (IE9+) should be used instead of the old _this workaround

Once again Packt graciously sent me AngularJS UI Development book for reviewing and I am grateful for that.
But I will be brief. It's one of the worst written "technical" book I've ever read.

• silly chapter ordering and subject choices
• chapter subjects are glanced over, chapters feel like unfinished copy/pasted tutorials
• code samples should have never been approved during the review
• separation of concerns is not respected most of the time
• and by most of the time I mean 95% of the time, not 60%
• there are so much state in these examples, everywhere
• this book does not even talk about routing and state management
• ... well, unless you wait until chapter 10 and consider a one-route single page application (SPA) good enough.
• In a book about UI Development, view state management is essential so in my humble opinion the book should have started with it. 

When we think about AngularJS UI Development, the first library that come to mind is ui-router. Instead we have a chapter 3 about google maps integration, chapter 5 about ng-animate, chapter 6 about charts integration and so on...

Okay, let's stop there and just say that I won't recommend this book to anyone, ever.

If you are new to AngularJS and are looking for a serious book on that matter consider MEAN Web Development, at least this one is well written.

After my review of Getting Started With Grunt and Lodash essentials this time Packt Publishing contacted me to review MEAN Web Development. Since Redsmin was first built over the ME(A)N stack and a lot of our applications at Bringr are built using NodeJS/AngularJS I happily accepted the offer, below is the review I posted on amazon.

Chapter 1 Introduction to MEAN

This chapter begins with a brief introduction to the MEAN stack and is then a deep step by step guide on how to install and run MongoDB, NodeJS, NPM both on Windows, Mac OS X and Linux. It's the perfect starting point for newcomers. I will simply add that it's a better practice ? to install NodeJS using Node Version Manager (nvm) that with the official installation software.

Chapter 2 - Getting Started with NodeJS

After a brief history of why Ryan Dahl created NodeJS the author dives into explaining event-driven programming. You will learn how work an event loop and how a webserver with a non-blocking event-loop (nginx) differs from a blocking web-server (apache) in terms of concurrent access performance and memory consumption. Then you'll take a look at closures and why they are useful in callbacks. Finally you'll learn how to write your first NodeJS http server along with your first connect middleware.

Chapter 3 - Building an Express Web App

Time to go to the next step : writing your first Express application, managing sessions, using a template engine (EJS) and a routing scheme. This chapter takes the reader by the hand and is really descriptive on how to organize your application folder architecture and write your first application.
However instead of using configuration files by environments (e.g. production, staging and development) I would recommend the reader to use environment variables (using a module like common-env + autoenv) since it's a way more flexible approach. Another missing point is to warn the reader to add a "private:true" inside its package.json file otherwise it could publish its application on npm by mistake.

Chapter 4 - Introduction to Mongodb

Even if this chapter explains to new comers what MongoDB is, the author is clearly using too much superlative about MongoDB. It's important to recall that MongoDB is not a replacement for relational storage and that it must be used with care.

Chapter 5 - Introduction to Mongoose

Just like the previous chapter, this one is also well written. It explains each Mongoose features starting with schema, validation, virtuals, getter/setter and even DbRef. I would simply note that some conditionals in the code examples could be greatly simplified.

Chapter 6 - Managing User Auth Using Passport

Learn how to handle user creation/connection with PassportJS, using local auth or Facebook/Twitter/Google OAuth. The OAuth user creation mechanism described in the book does not allow a user to connect via multiple OAuth provider and is thus limited. The access_token refreshing mechanism, even if it's not implemented, should be at least given as an exercise for the reader.

Chapter 7 - Introduction AngularJS

Another really well written chapter, this time about AngularJS. From the history to the state of the art, you'll learn everything you need to know to build your first application with AngularJS from routing to services. Note that the authentication service code example does not respect the Inversion Of Control principle and should be rewritten to ask for $window.

Chapter 8 - Creating a MEAN CRUD Module

In this chapter, learn how to set CRUD (Create-Retrieve-Update-Delete) modules up from back (using mongoose) to front (using angularjs $ressource). The middleware approach to retrieve an article is subject to race-conditions. I will just add that a much more powerful alternative than ngressource is Restangular. Also I would advise the reader to prefer ui-router (built over a finite-state-machine with support for sub-views) over angular own router module.

Chapter 9 - Adding Real-time func. Using Socket.io

Next, learn how to communicate in real-time between the browser and the server using websocket. In order to do that you'll learn how to set socket.io up. Be careful about the socket.io session configuration example, the error management should really be improved.

Chapter 10 - Testing MEAN apps

Nice overview of what unit-testing and end-to-end (E2E) testing is about. You'll learn how to unit-test a MEAN application with Mocha and Karma using Jasmine as well as E2E testing with protactor.

Chapter 11 - Automating & Debugging MEAN Apps

The last chapter demonstrates how to configure grunt to automate code quality checking and testing. You will learn grunt, node-inspector (for nodejs debugging) and batarang (a browser extension for angularjs debugging).

Conclusion

MEAN Web Web Development is clearly a well written book that will be the perfect match for beginners in AngularJS and NodeJS!

Context

When Packt contacted me to review this book it was fairly natural to me to accept the offer. We are huge fan of Grunt* at Bringr and Redsmin and use it a lot in our everyday workflow.


This book was really quick and easy to read (about a day). While reading it, I discovered that it was primarily written for beginners in mind so I personnally did not learned a lot of new things but that's fine since it will be a great book for them.

[Review #grunt] Received it yesterday, was (too) easy to read (junior js dev level), review is on its way! pic.twitter.com/5jRflWgNnZ
— François-G. Ribreau (@FGRibreau) April 27, 2014

Review

Getting Started with Grunt is the perfect book for anyone who wants to improve their workflow with Grunt while building JavaScript applications.

With only 112 pages the book is really short and easy to read, it took me about one day to read it all. It was written for javascript beginners but contains however some tips for advanced developers.

Chapters are written gradually, from building your directory setup to writing your first Gruntfile followed by an introduction on how to write multi and asynchronous grunt tasks.

Broader subjects are explored like: why you would want to use static analysis tools like JSLint or JsHint in your project; what are NodeJS and NPM; how NPM dependencies management works; what is transcompilation and how to configure grunt to transcompile CoffeeScript, Jade and Stylus files; etc.…

I would recommend this book to anyone who doesn't know very much about Grunt, or anyone who just wants a reference for it.


* we are planning to move on Gulp.