By Brad Green, Shyam Seshadri
Publisher: O’Reilly Media
Released: April 2013
Pages: 196

I approached this book knowing that there was a new world of web development out there that I knew little about. I decided to start with the AngularJS framework and I’m glad I did. Expecting a simple framework that was going to make things easy for me I found myself on a journey that took me to the command line (node.js, npm, yeoman, grunt, and bower), to flexible DOM manipulation with directives, and to modules, services, promises, controllers, and scope.

This new world of web apps is not trivial. In this book real software terms are mentioned: Model-View-Controller (‘the model is the truth’), factories, dependency injection, the Law of Demeter, and testing (karma and jasmine). Software Engineering meets traditional web practice – at last.

So don’t expect to read this book and be immediately productive. If you are new to web apps then you have some ground to make up – and this book will help you. As you would expect it goes through the fundamentals of angular and does this well. A criticism: some of the explanations e.g. node and npm are not as clear as they could be. (I had to do a bit of digging to get the web server running for the sample app in chapter 4, but it was worth it and I now know more about webs apps and node).

Perhaps the book’s biggest strength is what others have concluded is its biggest weakness. Others have voiced criticism because of the initial emphasis on project management, on setting up the environment, and on testing – but this is serious development, and it is therefore worth doing things properly.

If you’re new to this whole area of webApps then I’d suggest combining this book with the Angular documentation and the growing list of resources that are appearing on the web. This book will help to get you started.

Disclosure: I’m writing this post as part of O’Reilly’s blogger review program.

I review for the O'Reilly Blogger Review Program

Developing with Couchbase Server

Developing with Couchbase Server
Building Scalable, Flexible Database-Based Applications; O’Reilly Media;
By MC Brown

This is a short book of 88 pages that serves as a good introduction to the world of Couchbase Server Development and NoSQL Databases. As the author states:

‘In this guide, I’ve combined some basic background information on Couchbase Server and how it operates behind the scenes, with the information you need to start building applications. The methods for storing information and querying that data, and how you can organize and format your data to get the best performance and operation from your Couchbase Cluster’.

The book begins with an explanation of how to install the server and describes it as an easy process – it was. It took 5 minutes on my macBook.

The explanations of the various technologies that make up the world of NoSQL are extremely clear and to the point. To explain how to develop with Couchbase the author uses the Couchbase example of food recipes, explains how the data is best structured (JSON), and then describes how to perform the basic CRUD operations. The explanation is primarily made up of php code snippets with some Ruby. I would have liked more Java or Python but the Couchbase documentation provides examples for the various languages so this is not really a quibble.

The book finishes with a more detailed explanation of searching the example database with a good explanation of Map/Reduce and Views and best practice on how to use them.

This is a short introduction that is understandable, gets you started, and serves as a precursor to delving into the Couchbase documentation. A side benefit is that it also serves as an introduction to the world of NoSQL data storage. Take a look at the Couchbase documentation and if you find it confusing then this book should work for you. What is noticeable about this book? The clarity of the various explanations.

Disclosure: I’m writing this post as part of O’Reilly’s blogger review program.

I review for the O'Reilly Blogger Review Program

Programming Android Review By Zigurd Mednieks, Laird Dornin, Blake Meike, Masumi Nakamura

Programming Android
Java Programming for the New Generation of Mobile Devices
By Zigurd Mednieks, Laird Dornin, Blake Meike, Masumi Nakamura

At over 500 pages this book covers a lot of material. The authors have extensive experience and provide good examples that you can download from the companion web site – if you want a book to work through to learn programming in Android that you can have confidence in this could be the one.

Even though the authors expect you to have some programming experience the early chapters provide a good explanation of Object Theory and the Java Programming Language and a very good explanation of Threading.

It is in Part 3 that we really start to get going with a skeleton application that you can use as a template for your own projects. Here the authors are very good at explaining the ‘gotchas’ that can catch you out e.g.

‘The approach we take in this chapter enables you to visualize and understand the component life cycle before you know you need it. Retrofitting life cycle handling to an application that was written without understanding life cycles, or with the expectation that life cycle handling won’t be needed, is one of the easiest ways to create an Android application that fails unexpectedly, in ways that are hard to reproduce consistently, and that has persistent bugs that can remain undiscovered across multiple attempts to eradicate them. In other words, it’s best to learn this before it bites you in the ass.’
There is a lot of code, good explanations, and good examples e.g. visualising the Activity Life cycle to enable you to see Memory Management in action. The latter part of this book contains Advanced topics such as REST, Google Search, Location and Maps, Audio and Video, Sensors, Speech and Accessibility.

This book places you in a comfort zone, in the hands of experienced developers, provides you with good examples, and highlights the places where you can easily fall over.

Disclosure: I’m writing this post as part of O’Reilly’s blogger review program.

I review for the O'Reilly Blogger Review Program

Selectors, Specificity, and the Cascade Applying CSS3 to Documents By Eric A. Meyer Publisher: O’Reilly Media

This chapter from the upcoming fourth edition of Eric Meyer’s CSS: The Definitive Guide contains good explanations and examples of selectors and a clear explanation of specificity, inheritance, and the cascade.

As you would expect from a chapter on selectors there are good examples of the basics. Meyer then includes very good descriptions and examples of the more difficult attribute selectors, pseudo-class selectors, and pseudo-element selectors. You get the impression that it is all here.

The parts I liked: there is a very clear section on chaining attribute selectors together to select elements based on the presence of more than one attribute, a very good example explaining the parent-child relationship and the document tree, and the description of pseudo-classes as ‘a sort of “phantom class”‘.

If you are new to CSS you may find this book heavy going. One option would be to choose an introductory text. In time you would probably end up here though so a thorough reading of this and some time spent working with and modifying the examples should prove a good investment. This book is the one that should be on your shelf and will probably be the one you reach for when you are getting surprising results from your style sheet and can’t understand why.

Disclosure: I’m writing this post as part of O’Reilly’s blogger review program.

I review for the O'Reilly Blogger Review Program

“Shipping Greatness: Practical lessons on building and launching outstanding software, learned on the job at Google and Amazon” by Chris Vander Mey; O’Reilly Media

I like this book; it is based on experience. As the author states in his introduction:

“The tools and tips herein are blunt and directional; it’s up to you to sharpen them and make them your own”.

These tools and tips are good: use them as is, or modify them.

Part I contains the author’s process for shipping software: defining the vision at the start of the project, choosing and working with a team, handling management, knowing enough technically, interacting with the UX team, testing, and launching the project. There are good tips. e.g. create a FAQ at the start of a project as a way of imagining the end result.

There are detailed examples usually followed by a good summary of the principles behind the practices. e.g. make sure the software you ship does not embarrass you: insist on test-driven development, build a testing team around a great test lead, review your test plan and test cases personally, automate testing, make the team use the software that they’ve built, arrange a big bug bash, triage your bugs diligently, and establish trusted testers as a last line of defence. The author includes his own project management spreadsheet (downloadable from the book’s website) as a bonus.

Part II contains techniques, best practices, and skills that the author has found successful and is based on the premise that you can always increase efficiency. There are sections on team building, understanding technology, and communication. His view on how to handle the product development process? Know the four S’s: servers, services, speed, and scaling, and – know how to say no to feature creep. Why? because “every line of code decreases the probability of shipping”.

His definition of success: find the right balance between shipping, quality and impact of the software, and your team’s health – deliver a quality product that people want and finish the project with a team still intact.

The book gives an interesting insight into the way large software companies manage projects. And the principles here are scalable; they would work in a small business or a startup. Would the book help me to create a minimum viable product and ship it? Yes, but with my eyes open. As the author says “…shipping great software is damn hard and crazy stressful. It’s also incredibly rewarding”.

I review for the O'Reilly Blogger Review Program

What you teach is what you get good at

What you teach is what you get good at; what you get good at is what you teach.

Perhaps it is imperative that a Lecturer has an ongoing project that includes as many elements of the content that he/she teaches e.g. the creation of a software/web company that includes the elements of Business Model Generation, Lean Startup, php/mySQL, HCI, programming, testing, and project management.

Continuous Integration

Continuous Integration

How can you keep up with, and teach, a subject that develops so quickly? Perhaps the Agile principle of Continuous Integration can help.

The delivery of a lesson can be seen as similar to a release of software: as a pattern of test (the assessment or learning objectives are already known), development (the preparation of the lesson), and release (the delivery of the lesson). Only if a lesson passes the test i.e. there is good feedback from the students and that formative assessment has shown that the students have learnt will the lesson remain unchanged on a course.

Some questions arise: what is the best timeframe to use? Lessons/lectures, days, weeks, or half termly sprints, or any other sprint length? Perhaps the best timeframe is the one that allows lectures to reinforce each other and create a unified course rather than a series of separate, disjointed modules?

Lesson diagram from an Agile Lean perspective

  • Reading/Code (Self Development)
  • Lesson/VLE Preparation (preparation of tests, creation of product)
  • Deliver lesson (software release)
  • Reflection, feedback from students? (Lean pivot opportunity)

Question: What is the essence of the principle of Continuous Integration?