Agile Metrics in Action: A good how-to guide to getting better performance measurements – #programming #bookreview

Agile Metrics in Action

Christopher W. H. Davis

Manningpaperback

In the rapidly changing world of software development, metrics “represent the data you can get from your application lifecycle as it applies to the performance of software development teams,” Christopher W. H. Davis writes in his well-written, well-structured new book, Agile Metrics in Action.

“A metric can come from a single data source or it can be a combination of data from multiple data sources. Any data point that you track eventually becomes a metric that you can use to measure your team’s performance.”

The goals of agile metrics include collecting and analyzing data from almost every useful and accessible point in the software development life cycle, so team and individual performances can be measured and improved, and processes can be streamlined.

A key aspect of the data collection and analysis process is distributing the resulting information “across the organization in such a way that everyone can get the data they care about at a glance,” Davis says. He explains how and highlights some “traps” that teams can “fall into when they start publishing metrics,” such as “[s]ending all the data to all stakeholders,” many of whom won’t know what to do with most of it.

Metrics remain a controversial topic for many software developers, Davis emphasizes. So any business leader planning to rush his or her company into adopting agile metrics will need to proceed cautiously, instead. It is vital to get buy-in first from developers and their managers, he says.

“There will likely be people in your group who want nothing to do with measuring their work,” he explains. “Usually this stems from the fear of the unknown, fear of Big Brother, or a lack of control. The whole point here is that teams should measure themselves, not have some external person or system tell them what’s good and bad. And who doesn’t want to get better? No one is perfect—we all have a lot to learn and we can always improve.”

The concept of continuous development is a key topic in this book. “In today’s digital world consumers expect the software they interact with every day to continuously improve,” Davis states. “Mobile devices and web interfaces are ubiquitous and are evolving so rapidly that the average consumer of data expects interfaces to continually be updated and improved. To be able to provide your consumers the most competitive products, the development world has adapted by designing deployment systems that continuously integrate, test, and deploy changes. When used to their full potential, continuous practices allow development teams to hone their consumer’s experience multiple times per day.”

Of course, continuous development produces continuous data to measure and manage, as well, using agile metrics techniques.

Many different topics are addressed effectively in this book. And the practices the author presents are organized to work with any development process or tool stack. However, the software tools Davis favors for this book’s code-based examples include Grails, Groovy and MongoDB.

Agile Metrics in Action is structured and written to serve as a how-to book for virtually anyone associated with a software development team that relies on agile metrics. You may not understand all of the text. But if you take your time with this well-illustrated book, you can at least gain a better comprehension of what agile metrics means, how the process works, and why it is important to your employer, your group and your paycheck.

Si Dunn

Advertisements

BIG DATA: A well-written look at principles & best practices of scalable real-time data systems – #bookreview

 

 

Big Data

Principles and best practices of scalable real-time data systems

Nathan Marz, with James Warren

Manning – paperback

Get this book, whether you are new to working with Big Data or now an old hand at dealing with Big Data’s seemingly never-ending (and steadily expanding) complexities.

You may not agree with all that the authors offer or contend in this well-written “theory” text. But Nathan Marz’s Lambda Architecture is well worth serious consideration, especially if you are now trying to come up with more reliable and more efficient approaches to processing and mining Big Data. The writers’ explanations of some of the power, problems, and possibilities of Big Data are among the clearest and best I have read.

“More than 30,000 gigabytes of data are generated every second, and the rate of data creation is only accelerating,” Marz and Warren point out.

Thus, previous “solutions” for working with Big Data are now getting overwhelmed, not only by the sheer volume of information pouring in but by greater system complexities and failures of overworked hardware that now plague many outmoded systems.

The authors have structured their book to show “how to approach building a solution to any Big Data problem. The principles you’ll learn hold true regardless of the tooling in the current landscape, and you can use these principles to rigorously choose what tools are appropriate for your application.” In other words, they write, you will “learn how to fish, not just how to use a particular fishing rod.”

Marz’s Lambda Architecture also is at the heart of Big Data, the book. It is, the two authors explain, “an architecture that takes advantage of clustered hardware along with new tools designed specifically to capture and analyze web-scale data. It describes a scalable, easy-to-understand approach to Big Data systems that can be built and run by a small team.”

The Lambda Architecture has three layers: the batch layer, the serving layer, and the speed layer.

Not surprisingly, the book likewise is divided into three parts, each focusing on one of the layers:

  • In Part 1, chapters 4 through 9 deal with various aspects of the batch layer, such as building a batch layer from end to end and implementing an example batch layer.
  • Part 2 has two chapters that zero in on the serving layer. “The serving layer consists of databases that index and serve the results of the batch layer,” the writers explain. “Part 2 is short because databases that don’t require random writes are extraordinarily simple.”
  • In Part 3, chapters 12 through 17 explore and explain the Lambda Architecture’s speed layer, which “compensates for the high latency of the batch layer to enable up-to-date results for queries.”

Marz and Warren contend that “[t]he benefits of data systems built using the Lambda Architecture go beyond just scaling. Because your system will be able to handle much larger amounts of data, you’ll be able to collect even more data and get more value out of it. Increasing the amount and types of data you store will lead to more opportunities to mine your data, produce analytics, and build new applications.”

This book requires no previous experience with large-scale data analysis, nor with NoSQL tools. However, it helps to be somewhat familiar with traditional databases. Nathan Marz is the creator of Apache Storm and originator of the Lambda Architecture. James Warren is an analytics architect with a background in machine learning and scientific computing.

If you think the Big Data world already is too much with us, just stick around a while. Soon, it may involve almost every aspect of our lives.

Si Dunn

JavaScript Application Design: A book you likely need if you are working with, or still learning, JavaScript – #programming #bookreview

JavaScript Application Design

A Build First Approach

Nicolas Bevacqua

Manning – paperback

 

I didn’t know how much I needed this book until I started reading it and exploring its code examples.

Many of us who have worked with JavaScript started our connections to the language in very haphazard fashions. We learned some of it on the job, under deadline pressure to fix or update somebody else’s code. Or we took an introductory class or two and then started picking up whatever else we could on the fly, including the bad habits of others around us who seemed to know a bit more about JavaScript than we knew at the moment.

Unfortunately, JavaScript is a big, messy programming language, and it offers numerous opportunities to crash and burn if you really don’t know what you are doing.

In his new book, JavaScript Application Design, Nicolas Bevacqua makes a compelling case for using “the Build First philosophy of designing for clean, well-structured, and testable applications before you write a single line of code.”

He writes: “You’ll learn about process automation, which will mitigate the odds of human error…. Build First is the foundation that will empower you to design clean, well-structured, and testable applications, which are easy to maintain and refactor. Those are the two fundamental aspects of Build First: process automation and design.”

In his well-written text, he argues: “Front-end development requires as much dedication to architecture planning and design as back-end development does. Long gone are the days when we’d copy a few snippets of code off the internet, paste them in our page, and call it a day. Mashing together JavaScript code as an afterthought no longer holds up to modern standards. JavaScript is now front and center.”

He continues: “We have many frameworks and libraries to choose from, which can help you organize your code by allowing you to write small components rather than a monolithic application. Maintainability isn’t something you can tack onto a code base whenever you’d like; it’s something you have to build into the application, and the philosophy under which the application is designed, from the beginning. Writing an application that isn’t designed to be maintainable translates into stacking feature after feature in an ever-so-slightly tilting Jenga tower.”

Bevacqua divides his nine-chapter book into just two parts: build processes and managing complexity. Here is how the chapters are organized:

  • PART 1: BUILD PROCESSES
    1 – Introduction to Build First
    2 – Composing build tasks and flows
    3 – Mastering environments and the development workflow
    4 – Release, deployment, and monitoring
  • PART 2: MANAGING COMPLEXITY
  • 5 – Embracing modularity and dependency management
    6 – Understanding asynchronous flow control methods in JavaScript
    7 – Leveraging the Model-View-Controller
    8 – Testing JavaScript components
    9 – REST API design and layered service architectures

Bevaqua notes that “Linting is often referred to as the first test you should set up when writing JavaScript. Where linters fail, unit tests come in.” He strongly pushes testing and automation right from the start.

Linting soon leads to Grunt, which Bevaqua uses as a task runner and key build tool (with selected modules) in this book. “Grunt is a tool that allows you to write, configure, and automate tasks–such as minifying a JavaScript file or compiling a LESS style sheet–for your application,” he states. (It also works well on Windows machines, which I find handy.)

Grunt leads to running a bit of Node.js on the command line. And if you’ve never worked with Node.js, Bevacqua takes the reader smoothly through the process of installing it and using it in linting exercises. Indeed, he devotes an entire appendix (B) to installing and running Grunt and picking the right plugins for the right tasks and targets.

One of the best parts of this book, to me, is how the author uses short code examples to introduce a concept, and  then builds upon the examples with helpful descriptions and more short but expanded code samples.

Nicolas Bevacqua offers his readers plenty of helpful how-to and why information. Using his book, I have begun applying the Build First approach to some new projects and learning to how test and automate more of my work. I feel as if I now have a good shot at getting a lot better at JavaScript.

There is one small but important glitch to note: At two points in my preview copy of the book from Manning, Bevacqua shows what he calls a simple way to create bare-minimum JSON manifest files. For example, echo “{}” > package.json. Creating a blank, starting-point manifest file did not work this way for me. Instead, I had to use echo {“name: ” “project-name”} > package.json. The empty package.json issue apparently is somehow related to certain versions of Node’s npm.

Si Dunn 

SOFT SKILLS: A very useful ‘life manual’ for software developers – #programming #bookreview

Soft Skills

The Software Developer’s Life Manual

John Z. Sonmez

Manning paperback

I really wish I had had this book when I started a 14-year career in software development and testing. I was hired back in the days when you could get a software job by having a college degree (in anything), a couple of positive references and some decent writing skills. If you could also turn on a computer and bring up the DOS prompt, so much the better.

No matter how many skills you actually had, you were going to spend a couple of months learning your new environment and your new job, while also attending free, company-sponsored training classes (during working hours). Meanwhile, if you had any questions, you could just go ask the C guru down the hall or dour Mister Assembler, who lived in the big, corner cubicle and seemed to have no other life.

I am retired now from the corporate world of software. And when, out of curiosity, I look at today’s help-wanted postings for developers and testers, I am stunned by how much knowledge, training and verifiable skills one person is expected to bring to the table. At least ten jobs, it seems, have been rolled into one.

For that reason and more, I highly recommend Soft Skills by John Z. Sonmez. He believes, he says, in taking “a holistic approach to software development. This means that I think that if you want to be a better software developer—a better anything, really—you need to focus on the entire person, not just one or two areas of your life.”

Sonmez offers up a wealth of how-to information and useful advice covering everything from “hacking” a job interview to developing a personal brand and staying physically fit in a job that requires long hours sitting on one’s butt. He also offers tips for learning new things quickly, staying productive (using a modified version of the Pomodoro Technique)–and investing part of your paycheck so you can retire early or at least have a comfortable cushion if you get laid off and decide to become an independent consultant.

Yes, there is a lot of common advice sense in Soft Skills–the kind of advice you likely have heard before but ignored. Still, Sonmez’s book makes clear, compelling cases for why you really do have to watch out for–and take care of–yourself these days. You seemingly can’t count on an employer to do much of anything anymore, except view you as a unit of cost to be reduced or eliminated as soon as possible.

“Most software developers starting out in their careers make a few huge mistakes,” Sonmez writes. “The biggest of those mistakes, by far, is not treating their software development career as a business. Don’t be fooled; when you set out into the world to write code for a living, you’re no different than the blacksmith of old times setting up shop in a medieval town. Times may have changed, and most of us work for a company, but our skills and our trade belong to us and we can always choose to set up shop somewhere else. This kind of mindset is crucial to managing your career, because when you start to think of yourself as a business, you start to make good business decisions.”

This is a mindset I wish I had acquired and expanded when I got my first job in software and then began to surf the periodic waves of layoffs. If you are new at working in software development or still trying to get your foot in the door, you can get some very good information and guidance from this book. The same goes if your career currently is floundering and needs a reboot. Don’t just hit CTRL-ALT-DEL and go storming out the door. Try reading some of Sonmez’s chapters first–and at least have your resume reworked by experts who can help you boost your personal “brand.”

Si Dunn

 

NODE.js IN PRACTICE – A well-focused guide to understanding & using this powerful web development platform – #programming #bookreview

 

Node.js in Practice

Alex Young and Marc Harter

Manning – paperback

I have had a long-term, love-ignore relationship with Node.js. I have taken Node classes, read Node books, and tinkered with Node programming both on Windows and Linux machines. Sometimes I have loved working with Node.js. Other times, I have ignored it for months at a stretch while I rush around trying out other choices and development distractions: Clojure, Erlang, Grails, Hadoop, and Ember.js, for example — the list goes on and on.

Node.js in Practice is aimed at intermediate Node.js programmers and even advanced Node.js programmers. There is some awareness that beginners also may be reading this book. So the authors start by explaining Node from the standpoint of “what it is, how it works, and why it’s something you can’t live without.” Then they quickly recommend that Node newcomers should stop for now and read another good, but more basic, how-to book first: Node.js in Action.

In Node.js in Practice, the learning curve can start getting steep fairly quickly, especially for those of us who have worked somewhat superficially with Node in web projects that also involve other software (such as the MEAN stack: MongoDB, Express and AngularJS, plus Node). Fortunately, the authors, Alex Young and Marc Harter, take a very focused, three-part approach that keeps Node.js centered in the spotlight and promotes deeper understanding.

Part One focuses on “Node’s core fundamentals” and “what’s possible using only Node’s core modules (no third-party modules).” Part Two moves into “real-world development recipes” and shows how to “master four highly applicable skills—testing, web development, debugging, and running Node in production.” Some third-party modules also are introduced. Part Three, meanwhile, emphasizes “creating your own Node modules in a straightforward manner that ties in all kinds of ways to use npm commands for packaging, running, testing, benchmarking, and sharing modules. It also includes helpful tips on versioning projects effectively.”

The book offers “115 techniques…each module covering a specific Node.js topic or task, and each divided into practical Problem/Solution/Discussion sections.” I really like this approach, and the illustrated discussions that accompany each short code example are especially helpful.

For me, it has been a pleasure to upgrade to the latest version of Node.js and reconnect with it using this new book. Despite my previous experience with Node.js, I see a lot to learn! My thanks to Manning for providing a review copy of Node.js in Practice.

 

GIT IN PRACTICE: A fine how-to guide, with 66 techniques for greater effectiveness in individual & team settings – #programming #bookreview

 

 

Git in Practice

Mike McQuaid

Manning Books – paperback

 

I have taken Git how-to classes and read several how-to books on the Git distributed version control system. But I don’t use Git every day. Therefore, I tend to forget how to do certain tasks when I once again start bumbling around with my various local and remote Git repositories.

Git in Practice is exactly the book I have been needing at my computer. Git in Practice gives clear how-to steps, plus descriptions of ways to be more efficient and effective with Git in individual and team settings. And the well-written book even provides interesting background on how Git came to be–and be the way that it is.

For Git newcomers (and for those like me who tend to get rusty fairly quickly), the book’s appendices include how install Git, how to create a GitHub account and repository and how to benefit from the author’s heavily commented Git configuration files. There also is a handy index of Git methods for those times when you think you remember a particular command-line entry but aren’t sure exactly what is supposed to happen and what options, if any, may appear.

It matters not if you are new to Git, or someone who uses Git sporadically, or someone who uses Git daily as part of a software development or software test team. Git in Practice is a fine and useful book to keep within reach.

 

– Si Dunn

Advanced Software Testing, Vol. 2, 2nd Edition – Study guide for ISTQB Advanced Test Manager – #bookreview

Advanced Software Testing, Volume 2, 2nd Edition

Guide to the ISTQB Advanced Certification as an Advanced Test Manager

Rex Black

(Rocky Nook – paperback)

 

Software testing is a complex and constantly evolving field. And having some well-recognized certifications is a good way to help encourage  your continued employability as a software tester and manager of software test teams.

Advanced Software Testing, Volume 2, 2nd Edition, focuses on showing you how to obtain an International Software Testing Qualifications Board (ISTQB) certification as an advanced test manager. The 519-page book is well-written and lays out what test managers should know to gain advanced skills in test estimation, test planning, test monitoring, and test control.

It also emphasizes  knowing how to define overall testing goals and strategies for the systems you and your team are testing. And it gives you strategies for preparing for and passing the 65-question Advanced Test Manager qualification test that is administered by ISTQB member boards and exam providers.

This second edition has been updated to reflect the ISTQB’s Advanced Test Manager 2012 Syllabus.  Advanced Software Testing, Volume 2, 2nd Edition takes a hands-on, exercise-rich approach, and it provides experience with essential how-tos for planning, scheduling, and tracking important tasks.

The updated book focuses on a variety of key processes that a software test manager must be able to handle, including describing and organizing the activities necessary to select, find and assign the right number of resources for testing tasks. You also must learn how to organize and lead testing teams, and how to manage the communications among testing teams’ members and between testing teams and all the other stakeholders. And you will need to know how to justify your testing decisions and report necessary information both to your superiors and members of your teams.

As for taking the complicated qualifications test, the author urges: “Don’t panic! Remember, the exam is meant to test your achievement of the learning objectives in the Advanced  Test Manager syllabus.” In other words, you cannot simply skim this book and take the exam. You must spend significant time on the learning exercises, sample questions and ISTQB glossary.

Si Dunn

***

Get the book here: Advanced Software Testing, Volume 2, 2nd Edition

***