Skip to content

Software Development Blogs: Programming, Software Testing, Agile Project Management

Methods & Tools

Subscribe to Methods & Tools
if you are not afraid to read more than one page to be a smarter software developer, software tester or project manager!

Feed aggregator

Productivity Books to Help You Know More, Be More, and Achieve More

I’ve put together a roundup of the best productivity books that have helped me get better results in work and life.  It contains many of the same books that I recommend to people and teams that I mentor.  Here is the list:

Productivity Books

It has a lot of books.  To be productive, it takes a lot of skills, and a lot of self-mastery.  And, you never know which book is going to do it for you.

I organize the productivity books in a scenario-based way:

  • Top 10 Best Productivity Books
  • Getting Started
  • Advanced Productivity
  • Action
  • Delegation
  • Drive, Energy, and Motivation
  • Focus
  • Goals
  • Learning and School
  • Procrastination
  • Teams and Organizations
  • To-Do Lists
  • Work-Life Balance

At the end of the list, I included all the books in a simple, flat A-Z list so you can quickly check against your own productivity book collection to see if I have mentioned books that you don’t have or don’t know about.

I’ve put this list of productivity books together to give you an unfair advantage.   Competition can be fierce.  Remember that the best person to always compete against is you—find ways to be better, faster, or cheaper, when it comes to making things happen.  It’s how you stay in the game, and it’s how you change your game.

In fact, productivity is a backbone for surviving and thriving.  Yeah, it’s a big deal.

Also, bear in mind that the big idea behind extreme productivity, or effective productivity is to focus on learning and growth.   If you have a growth mindset, you’ll win in the long-run, because you’ll get better over time, and you can compound your effort.  Also, learn to embrace the effort, and to love the work you do, or love the way you do it.  

Your work is the ultimate self-expression, and the legacy you leave behind, can be an inspiration for yourself, as well as for others.

My Productivity Books page will be a living catalog of the books I draw from, and it’s part of my bigger Great Books collection, where I share the world’s best books for insight and action on business, career, leadership, personal development, and more.

I know there are a lot of productivity books on my list.   If I can only recommend one, I start people off with Getting Results the Agile Way.   I wrote it specifically to help people get better results in work and life with a simple system I developed over time in extreme scenarios.   It integrates proven practices for personal productivity, as well as positive psychology, project management, sports science, and more in terms of achieving high-performance with flow.  And, it’s easy to get started (Here is the Agile Results QuickStart.)

I believe in the power of books to change lives.   Productivity is just one area, but it’s an area that impacts all the other major areas of our life.

If you can master productivity, you can know more, be more, and achieve more.

And, if you balance that with living your values, making an impact, and enjoying the journey, that is the key to living la vida buena.

Categories: Architecture, Programming

The Work/Life Balance

Software Requirements Blog - Seilevel.com - Fri, 12/26/2014 - 17:30
Back in the day when I was an intern, I worked for a large corporation that promoted this idea of a “Work/Life Balance.” Most of my fellow interns thought it was just a catchy buzz-phrase or a sales pitch, but I have always embraced the idea. As the child of two work-a-holics, I am VERY […]
Categories: Requirements

Five Problems That Impact Testing Effectiveness and Efficiency: #4 Capability

In order to participate you have to be capable.

In order to participate you have to be capable.

Testing effectiveness and efficiency will suffer if the organization or team does not have the capability to test well. Testing with the proper level of capability is akin to trying to drive from Cleveland, Ohio to Washington, DC in a car with four flat tires.  It could be done, but at what cost?  Capabilities include the number of testers, clarity of responsibilities, expertise, tools and environments.  Problems in any of these categories will affect the effectiveness and efficiency of testing.

  • The number of testers – There is no fixed ratio of testers to developers however too few testers will cause corners to be cut. The development methods used, amount of test automation available, application criticality and the ability of others in the organization to augment the ranks of testers will all impact the required staffing level. The business needs and test goals and strategy will also influence staffing levels for testers.
  • Clarity of responsibilities – The responsibilities for testing in teams can be easily delineated if the team is cross functional with a mix of developers and testers supporting a common delivery goal. Techniques, such as stand-up meetings, are useful for ensuring everyone knows the work they are responsible for completing. As the number of teams increase, ensuring testing responsibilities are understood become more problematic.  Techniques, such as SAFe’s release planning and the role of a release train engineer, can be leveraged as tools to coordinate responsibilities.
  • Expertise – Just drafting anyone to do testing is a recipe for using your clients to find your defects. The core of your testing capabilities needs to be comprised of experienced (both in testing and with the application being tested) and certified testers. The core testers should lead testing efforts, but also act as consultants to support others who also are acting as testers (think cross-functional).
  • Tools – Development frameworks like Agile work best when testing is performed early and often. Making testing a ubiquitous part of the development process requires test automation.  Automation is needed not only for executing tests, but for generating test data, generating code builds, and capturing defects. Good automation will lessen the testing effort burden and increase the effectiveness of testing.
  • Environments – A test environment is the combination of hardware, software and data required to run software tests. Test environments should closely emulate the environment that the software will run in when it is finally installed in production.  Problems in the test environment will generally mask problems that will not be recognized until production.  The expense to implement and maintain test environments often cause organizations to cut corners on the number or makeup of test environments.

A team’s or organization’s testing capabilities are critical factors in the equation of whether testing will be effective and efficient. Capabilities encompass a broad range of factors from people to computer environments.  Being good at one might compensate a bit for weaknesses in another, but in the long run an organization needs strength in all categories testing software


Categories: Process Management

Merry Christmas, 2014

Merry Christmas 2014

Merry Christmas 2014

Eric Sevareid, a CBS news journalist from 1939 to 1977, said, “Christmas is a necessity. There has to be at least one day of the year to remind us that we’re here for something else besides ourselves.” Whether in your day job you gather requirements, write or test code, facilitate teams or lead change Christmas represents a time to reflect on the larger world, reflect and make it better for someone other than yourself. NPR’s Morning Edition on December 24 included a segment discussing research that suggests that generosity is a hardwired human attribute.  The research by Dr. Lara Aknin is an Assistant Professor of Psychology at Simon Fraser University suggests that people feel better about themselves and the world around them when they are generous to others. Christmas is a day of celebration but also a reminder that to feel good about ourselves we need to give of ourselves to others.

Regardless of whether you celebrate Christmas, take the few minutes you would spend reading this blog and reach out to a family member you have lost track of, a co-worker that might be alone on this day or to a friend you have only talked to only on Facebook and say hello. Whether, like Fred in the Dicken’s Christmas Carol, invite your Uncle Scrooge to dinner or just spend a few minutes on the phone reaching out to another fellow human.


Categories: Process Management

Blame Yourself First

Making the Complex Simple - John Sonmez - Thu, 12/25/2014 - 16:00

In this video, I talk about why it is important to take responsibility for things that happen to you instead of blaming others and circumstances. When you choose to blame others and “bad luck” or make excuses for yourself, you give your power away to make a positive change in your situation.

The post Blame Yourself First appeared first on Simple Programmer.

Categories: Programming

Five Problems That Impact Testing Effectiveness and Efficiency: #3 Organizational Management

Expectations and environment affect behavior.

Expectations and environment affect behavior.

When I was a manager of QA (testing), my manager more than once shared the expectation that testing should have found all of the defects in a piece of software before it was put into production. I actually think that expectation found its way into my annual objectives just prior to my changing jobs. Not only is it not possible to find all defects, the responsibility for defect removal must be shared by developers and testers alike. Organizational management can impact test efficiency and effectiveness in many ways, however three are fairly common.

  1. Unrealistic expectations – One of the principles of testing is that exhaustive testing is impossible.  The over-emphasis of removing all defects or perhaps slightly less dangerous – all significant defects – takes the focus away reducing risks. Testers and test managers must use testing and other techniques (reviews, for example) to focus the available time and effort they have on what is important and risky. Developing an understanding of potential impact and possibility of problems (risk) is needed to target testing resources. That is impossible when trying to find all possible problems.
  2. Undervaluing /Underfunding testing – One the indicators of how an organization values test (and testers) is funding. Funding includes people, tools and other resources. Organizations can have enough testers and but not the proper logistics to test effectively or efficiently.  Another common indication that testing is considered a commodity or not a core function is when an organization outsources testing.
  3. Failure to pursue root causes of defects – Testing shows that defects exist (another principle of testing). Testing does not create defects; said another way defects come from somewhere else. The only way to stem the tide of defects is to change how the software is developed by improving the development process (inclusive of people, process and tools) by finding the root cause of defects and then improving the process. If process improvement does not include the development process the rate of defects production will not change. Ignoring the lessons from defects found in testing dooms the organization to repeating the mistakes that led to those defects.

Organizational management can have a direct impact on the effectiveness and efficiency of testing.  The actions that are taken are very rarely because they want buggy software, but rather because they are unsure of the role, scope and goal of testing in the development and maintenance of software.  As a general rule, the role of testing whether through reviews requirements, design and code or by executing cases is to find defects. Software is complex enough that exhaustive testing is either not possible or not cost effective, therefore the goal of testing is to reduce the risk to the users of the software (and to the organization) that defects that will be delivered. The organization has the responsibility to provide the resources and tools needed to meet the goals and strategy of the testing that is needed to meet the organization’s goals.


Categories: Process Management

Quote of the Day - Do It Right the First Time (Update)

Herding Cats - Glen Alleman - Wed, 12/24/2014 - 19:12

Screen Shot 2014-12-23 at 1.17.48 PM

This quote has two interpretations:

  • New ideas from beginners provide many more opportunities for good results than from experts.
  • Experts understand the consequences of untested, unproven, ill conceived ideas on the probability of success for mission critical, high value at risk projects.

I want to thank Tom Peters @tom_peters for stimulating this clarity.

In parallel with this notion of novices know better and experts have limited possibilities is the conjecture that: 

Do it Right the First Time is the dumbest statement ever uttered by a human being

In the absence of a domain and context in that domain, that statement is of little value - a nice platitude with no actionable outcomes.

Here's an example from personal experience. 

Mars Science Laboratory represents the first use of a "soft landing" technique called the Sky Crane maneuver. The sheer mass of Mars Science Laboratory prevented engineers from using the familiar airbags to deliver their rover safely to the martian surface. As rovers become more capable and carry more instruments, they become larger. So, in order to accommodate this advanced mission, engineers designed a sky-crane method that will lower the rover to the surface.

This mission was built and tested by the same people who built and flew most of the other Mars missions, right here in town. The decent shield, engines and other processes had to work the first time as a system and could not be tested as a system, since the final testing could only take place on Mars.

"Courisity relies on untried Sky Crane for Mars descent" 

So in this case (domain) it has to work the first time, or the mission is lost.

The consequences failing for the first time to reach your audience and gets a round of applause at a conference on a new topic may mean not being invited back.

So when we read all those posts about agreeing with the do it right is the worst things that ever happened, ask if those posters have ever worked on a mission critical must work project where billions are at risk? Maybe lives aren't a risk on Mars lander, but Nuke Power start ups, weapons plants cleanups with loose plutonium laying on the floor, off shore unattended gas platforms, ABM intercept missiles, and the like are actually in the domain of do it right the first time.

Those who use the terms fail often may not have experienced these high value at risk conditions, where failure is actually not an option. Lovell's comment to his ground partner during their joint talk at a PMI conference was Gene says Failure was not an option. I'd have to say Success was our only option.

Gene Kranz Glen Kevin and Lovell

Succeeding on the first try is mandated in many domains. Doesn't mean you haven't prepared in depth for that first try. But it is naive at best to think that failure is to be tolerated in the absence of a domain and context that assesses the consequences of that failure.

Those who suggest  fail often and you'll learn more in the absence of a domain, context, and Value at Risk are just repeating a platitude in the absence of witnessing the BBR aftermath of failure. 

Our past experiences informs our current world view, mine is from mission critical - literally  do or die - experiences. So I'm jaded on making over generalized statements in the absence of domain and context.

A good example of this do it right the first time can be found in the history of RFETS, where the consequences of failure were very high. One of the brilliant strategies of the first CEO was to hire Navy ship and submarine Captains who understood those consequences and behaved accordingly when faced with a high value at risk situation.

Making the impossible possible from Glen Alleman

So when you hear I've tried this, maybe you should try it as well. Or just try it, when you've failed you'll be better for it. Ask if that speaker has any experience outside his own anecdotal domain to make a credible assessment of the applicability of his suggestion?

From https://blog.slideshare.net/2014/12/12/entrepreneurial-expertise-guy-kawasakis-3-must-see-decks/

Related articles What is Governance? Complex Project Management Is Programming the Same as Software Engineering? The Myth and Half-Truths of "Myths and Half-Truths"
Categories: Project Management

Santa Lands on a Virgin Atlantic Plane with 4D Technology

Microsoft and Virgin help land Santa on top of a plane at 30,000 feet.  If you’ve been wondering where Santa’s been, he landed on top of a Virgin Atlantic plane and did a photo shoot with the passengers.

Microsoft teamed up with Richard Branson and Virgin Atlantic to bring the magic of Christmas to life.  In the world’s first 4D experience in flight, Santa Claus appears to land on top of a Virgin Atlantic plane at 30,000 feet. 

How’s that for some fancy flying with modern technology?!

Each passenger was also given a Windows tablet so they could track Father Christmas and chat with him during the flight.

Here’s the video of Santa landing on top of the plane and visiting with the passengers:

Video: Santa Lands on Top of a Virgin Atlantic Plane at 30,000 Feet

Here are a few scenes that show Santa in action …

Here’s one of Santa’s reindeer peering down into the cabin from on top of the plane:

image

Here’s Santa peering down into the cabin from above the plane before he goes inside:

image

Santa sees somebody he recognizes:

image

Santa boards the plane and walks the cabin:

image

The kids are excited to see Santa:

image

image

 

Adults are happy, too:

image

image

Santa has time for some photo shoots:

image

image

Santa leaves to get back to his sleigh on top of the plane:

image

Virgin Atlantic and Microsoft wish everybody a very, merry Christmas:

image

Here’s Richard Branson’s post on the story:

Santa Lands on Virgin Atlantic Plane at 30,000 Feet

Merry Christmas to all and to all a good night.

JD

You Might Also Like

10 Big Ideas from a Christmas Carol

25 Holiday Classic Movies and Lessons Learned

Microsoft Cloud Case Studies at a Glance

Categories: Architecture, Programming

Five Problems That Impact Testing Effectiveness and Efficiency: #2 Involvement

 

Riding a horse requires the involvement of the horse!

Riding a horse requires the involvement of the horse!

Effective testing scenarios require a tester to work with users, product owners, business analysts, developers and others to determine whether a deliverable is what it is supposed to be, whether it meets the definition of done and standards of quality. Testing is a collaborative enterprise. Testing is less effective when the right people are not involved in testing. In order to meet the basic level of collaborative involvement for effective testing, testers need interaction with the broad stakeholder community in three broad categories of activity. They are:

  1. Developing requirements – Requirements, whether written as user stories, use cases or paragraphs of text, are a critical input into the testing process. Requirements become the basis of comparison to determine if what is being developed is what the the business wants. Business and technical stakeholders provide the input that becomes the requirements. Testing provides feedback to challenge the assumptions of the stakeholders and development teams as the requirements are formed, groomed and transformed into functional code.
  2. Defining realistic acceptance tests and criteria – A well-formed user story includes not only the story itself, but a set of acceptance criteria. Acceptance criteria provide the development team both with a deeper understanding of how to interpret the story and with a tool to understand when development is complete. Business and technical stakeholders provide the diversity of knowledge to develop relevant acceptance tests and criteria. When testing is a silo’ed task the development team will have to make assumptions that will need to be validated later in the process (later is never better than sooner when it comes to validation). Agile roles such as the product owner and techniques like the Three Amigos are tools to codify involvement.
  3. Participating in reviews, discussions, demonstrations and acceptance testing – I have written a few lines of code, managed a few projects and teams and tested a few projects in my career. In most of those cases a business facing product owner and/or user(s) where involved in validating and verifying the work as it progressed toward completion. I can’t count the number of defects or poor assumptions that were caught and fixed along the way. In those scenarios where real stakeholders did not participate in reviewing, refining and testing the product, the quality was generally lower. Colleagues over the years have expressed similar observations.

When you look in a cube and see a developer or tester reading a user story or use case while typing out a test or perhaps even executing a specific test, it might seem that testing is a solitary event. But you would probably be wrong. What you would have missed is the interaction between developers, testers, product owners that preceded those events, in which knowledge and perspectives were shared. You would have also missed the involvement of users, product owners, developers and stakeholders to review the results so that what gets delivered is not only technically correct, but also has business value. Without involvement, testing provides far less value than possible.


Categories: Process Management

Speaking computers for more fun !

I didn't try it on mono, but it should also work with some tweaking, see details here

Xmas is a good time to surprise kids, and what's more fun than a talking computer ?!

Hello world !

Nothing's easier, and this kind of Hello World will appeal them to programming in a flash :

#r "System.Speech"
open System.Speech.Synthesis

let synt = new SpeechSynthesizer()
let say s = synt.Speak(s: string)

say "Hello world !" 

Of course, if you're french like me, it'll say this with an awful french accent - something like hélo ouorld !

But you can select a different voice if available by providing hints:

open System.Globalization
let english = CultureInfo.GetCultureInfo("en-US")

synt.SelectVoiceByHints(VoiceGender.NotSet, VoiceAge.NotSet, 1, english)
say "Hello world !"

Far better !

Can you beat it ?

Now, a talking fizz buzz, up to 100 ! Can you beat it ?

[1 .. 100]
|> List.map (fun n -> 
    match n%3, n%5 with
    | 0, 0 -> "FizzBuzz"
    | 0, _ -> "Fizz"
    | _, 0 -> "Buzz"
    | _ -> string n )
|> List.iter say
Even harder !

Now with a recognizer, we can wait for voice user input.

The problem with the Grammar API is that it's totally mutable and not really DSL oriented. Let's correct that :

open System.Speech.Recognition

type Grammar =
    | Phrase of text:string * result: string
    | Lst of Grammar list
    | Alt of Grammar list
    | Repeat of min: int * max: int * Grammar


let rec build = function
    | Phrase (text, result) -> 
        // Just build the a single phrase
        GrammarBuilder(SemanticResultValue(text,result))

    | Lst grammars -> 
        // Append parts of grammars one after the other
        let builder = GrammarBuilder()
        grammars
        |> List.map build
        |> List.iter builder.Append
        builder

    | Alt alternatives -> 
        // Create alternatives
        let choices =
            alternatives
            |> List.map build 
            |> List.toArray
        GrammarBuilder(Choices())

    | Repeat(min, max, grammar) -> 
        // Repeat a part of the grammar
        GrammarBuilder(build grammar, min, max)

This is not a full DSL for speach recognition, you can look at all the GrammarBuilder methods to add more possibilities.. Even here, I'll use only Phrase and Alt.

Now, we need a recognizer and wire the grammar with functions that will be called when a part of the grammar is recognized or rejected. It is mandatory to set grammar's culture to the recognizer's culture. There's usually a single recognizer installed by default on your system and it uses installed system's culture. In my case, it'll be french.

let recog = new SpeechRecognizer()

let recognize grammar recognized rejected  = 
    let builder = build grammar
    builder.Culture <- recog.RecognizerInfo.Culture
    printfn "%A" recog.RecognizerInfo.Culture
    recog.LoadGrammar(Grammar builder)
    
    recog.SpeechRecognized |> Event.add (fun e -> recognized e.Result.Text (string e.Result.Semantics.Value))
    recog.SpeechRecognitionRejected |> Event.add (fun e -> rejected ())
    recog.Enabled

We can then use this to create a little Christmass quizz thanks to the FSharp.Data FreeBase Type Provider !

We'll use free base to find a list of Actors who plaid Santa in movies.

For this, install the FSharp.Data NuGet:

nuget install FSharp.Data -o packages -x

The dll should be in .\packages\FSharp.Data\lib\net40\FSharp.Data.dll

#r @"packages\FSharp.Data\lib\net40\FSharp.Data.dll"
open FSharp.Data

let fb =FreebaseData.GetDataContext()

Let's build the grammar

let santaActorsFilms =
    fb.``Arts and Entertainment``
      .Film
      .``Film characters``
      .IndividualsAZ.S
      .``Santa Claus``
      .``Portrayed in films``
    |> Seq.map (fun c -> c.Actor.Name, c.Film.Name)
    |> Seq.toList

let santaActorsGrammar =
    santaActorsFilms
    |> List.map (fun (actor,film) -> Phrase(actor, film))
    |> Alt

Here is the function to call when an actor is recognized.

I tried to pass a discriminated union as a value, but even if the API uses an object, the documentation states that it has to be a bool, an int or a string. I used only strings here.

let recognized text value =
    say (sprintf "True ! %s was Santa in %s" text value)

Here is the function when the speech could not be matched with the grammar.

It is also possible to get the audio of the text in this case. I decided to ignore it due to time constraints.

let rejected () = say "No, Not a Santa !"

Now, let's run it !!

recognize santaActorsGrammar recognized rejected

At this point the speech recognition configuration should appear if it's the first time you use it.

Once done you should be able to try the quizz !

If your OS culture is not english, don't hesitate to use a local accent for actor's name !

Conlusion

I hope you had fun with this API, and that you'll want to tweak it for your own demo !

The full code - using FSharp.Formatting - is on my gist

Happy Christmass !

namespace System namespace System.Speech namespace System.Speech.Synthesis val synt : SpeechSynthesizer

Full name: XMas fun.synt Multiple items
type SpeechSynthesizer =
  new : unit -> SpeechSynthesizer
  member AddLexicon : uri:Uri * mediaType:string -> unit
  member Dispose : unit -> unit
  member GetCurrentlySpokenPrompt : unit -> Prompt
  member GetInstalledVoices : unit -> ReadOnlyCollection<InstalledVoice> + 1 overload
  member Pause : unit -> unit
  member Rate : int with get, set
  member RemoveLexicon : uri:Uri -> unit
  member Resume : unit -> unit
  member SelectVoice : name:string -> unit
  ...

Full name: System.Speech.Synthesis.SpeechSynthesizer

--------------------
SpeechSynthesizer() : unit val say : s:string -> unit

Full name: XMas fun.say val s : string SpeechSynthesizer.Speak(promptBuilder: PromptBuilder) : unit
SpeechSynthesizer.Speak(prompt: Prompt) : unit
SpeechSynthesizer.Speak(textToSpeak: string) : unit Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string namespace System.Globalization val english : CultureInfo

Full name: XMas fun.english Multiple items
type CultureInfo =
  new : name:string -> CultureInfo + 3 overloads
  member Calendar : Calendar
  member ClearCachedData : unit -> unit
  member Clone : unit -> obj
  member CompareInfo : CompareInfo
  member CultureTypes : CultureTypes
  member DateTimeFormat : DateTimeFormatInfo with get, set
  member DisplayName : string
  member EnglishName : string
  member Equals : value:obj -> bool
  ...

Full name: System.Globalization.CultureInfo

--------------------
CultureInfo(name: string) : unit
CultureInfo(culture: int) : unit
CultureInfo(name: string, useUserOverride: bool) : unit
CultureInfo(culture: int, useUserOverride: bool) : unit CultureInfo.GetCultureInfo(name: string) : CultureInfo
CultureInfo.GetCultureInfo(culture: int) : CultureInfo
CultureInfo.GetCultureInfo(name: string, altName: string) : CultureInfo SpeechSynthesizer.SelectVoiceByHints(gender: VoiceGender) : unit
SpeechSynthesizer.SelectVoiceByHints(gender: VoiceGender, age: VoiceAge) : unit
SpeechSynthesizer.SelectVoiceByHints(gender: VoiceGender, age: VoiceAge, voiceAlternate: int) : unit
SpeechSynthesizer.SelectVoiceByHints(gender: VoiceGender, age: VoiceAge, voiceAlternate: int, culture: CultureInfo) : unit type VoiceGender =
  | NotSet = 0
  | Male = 1
  | Female = 2
  | Neutral = 3

Full name: System.Speech.Synthesis.VoiceGender field VoiceGender.NotSet = 0 type VoiceAge =
  | NotSet = 0
  | Child = 10
  | Teen = 15
  | Adult = 30
  | Senior = 65

Full name: System.Speech.Synthesis.VoiceAge field VoiceAge.NotSet = 0 Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
  interface IEnumerable
  interface IEnumerable<'T>
  member Head : 'T
  member IsEmpty : bool
  member Item : index:int -> 'T with get
  member Length : int
  member Tail : 'T list
  static member Cons : head:'T * tail:'T list -> 'T list
  static member Empty : 'T list

Full name: Microsoft.FSharp.Collections.List<_> val map : mapping:('T -> 'U) -> list:'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map val n : int val iter : action:('T -> unit) -> list:'T list -> unit

Full name: Microsoft.FSharp.Collections.List.iter namespace System.Speech.Recognition type Grammar =
  | Phrase of text: string * result: string
  | Lst of Grammar list
  | Alt of Grammar list
  | Repeat of min: int * max: int * Grammar

Full name: XMas fun.Grammar union case Grammar.Phrase: text: string * result: string -> Grammar union case Grammar.Lst: Grammar list -> Grammar type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_> union case Grammar.Alt: Grammar list -> Grammar union case Grammar.Repeat: min: int * max: int * Grammar -> Grammar val min : e1:'T -> e2:'T -> 'T (requires comparison)

Full name: Microsoft.FSharp.Core.Operators.min Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_> val max : e1:'T -> e2:'T -> 'T (requires comparison)

Full name: Microsoft.FSharp.Core.Operators.max val build : _arg1:Grammar -> GrammarBuilder

Full name: XMas fun.build val text : string val result : string Multiple items
type GrammarBuilder =
  new : unit -> GrammarBuilder + 7 overloads
  member Append : phrase:string -> unit + 7 overloads
  member AppendDictation : unit -> unit + 1 overload
  member AppendRuleReference : path:string -> unit + 1 overload
  member AppendWildcard : unit -> unit
  member Culture : CultureInfo with get, set
  member DebugShowPhrases : string
  static member Add : phrase:string * builder:GrammarBuilder -> GrammarBuilder + 4 overloads

Full name: System.Speech.Recognition.GrammarBuilder

--------------------
GrammarBuilder() : unit
GrammarBuilder(phrase: string) : unit
GrammarBuilder(alternateChoices: Choices) : unit
GrammarBuilder(key: SemanticResultKey) : unit
GrammarBuilder(value: SemanticResultValue) : unit
GrammarBuilder(phrase: string, subsetMatchingCriteria: SubsetMatchingMode) : unit
GrammarBuilder(phrase: string, minRepeat: int, maxRepeat: int) : unit
GrammarBuilder(builder: GrammarBuilder, minRepeat: int, maxRepeat: int) : unit Multiple items
type SemanticResultValue =
  new : value:obj -> SemanticResultValue + 2 overloads
  member ToGrammarBuilder : unit -> GrammarBuilder

Full name: System.Speech.Recognition.SemanticResultValue

--------------------
SemanticResultValue(value: obj) : unit
SemanticResultValue(phrase: string, value: obj) : unit
SemanticResultValue(builder: GrammarBuilder, value: obj) : unit val grammars : Grammar list val builder : GrammarBuilder GrammarBuilder.Append(value: SemanticResultValue) : unit
GrammarBuilder.Append(key: SemanticResultKey) : unit
GrammarBuilder.Append(alternateChoices: Choices) : unit
GrammarBuilder.Append(builder: GrammarBuilder) : unit
GrammarBuilder.Append(phrase: string) : unit
GrammarBuilder.Append(phrase: string, subsetMatchingCriteria: SubsetMatchingMode) : unit
GrammarBuilder.Append(builder: GrammarBuilder, minRepeat: int, maxRepeat: int) : unit
GrammarBuilder.Append(phrase: string, minRepeat: int, maxRepeat: int) : unit val alternatives : Grammar list val choices : GrammarBuilder [] val toArray : list:'T list -> 'T []

Full name: Microsoft.FSharp.Collections.List.toArray Multiple items
type Choices =
  new : unit -> Choices + 2 overloads
  member Add : params phrases:string[] -> unit + 1 overload
  member ToGrammarBuilder : unit -> GrammarBuilder

Full name: System.Speech.Recognition.Choices

--------------------
Choices() : unit
Choices(params phrases: string []) : unit
Choices(params alternateChoices: GrammarBuilder []) : unit val min : int val max : int val grammar : Grammar val recog : SpeechRecognizer

Full name: XMas fun.recog Multiple items
type SpeechRecognizer =
  new : unit -> SpeechRecognizer
  member AudioFormat : SpeechAudioFormatInfo
  member AudioLevel : int
  member AudioPosition : TimeSpan
  member AudioState : AudioState
  member Dispose : unit -> unit
  member EmulateRecognize : inputText:string -> RecognitionResult + 2 overloads
  member EmulateRecognizeAsync : inputText:string -> unit + 2 overloads
  member Enabled : bool with get, set
  member Grammars : ReadOnlyCollection<Grammar>
  ...

Full name: System.Speech.Recognition.SpeechRecognizer

--------------------
SpeechRecognizer() : unit val recognize : grammar:Grammar -> recognized:(string -> string -> unit) -> rejected:(unit -> unit) -> bool

Full name: XMas fun.recognize val recognized : (string -> string -> unit) val rejected : (unit -> unit) property GrammarBuilder.Culture: CultureInfo property SpeechRecognizer.RecognizerInfo: RecognizerInfo property RecognizerInfo.Culture: CultureInfo val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn SpeechRecognizer.LoadGrammar(grammar: Grammar) : unit event SpeechRecognizer.SpeechRecognized: IEvent<System.EventHandler<SpeechRecognizedEventArgs>,SpeechRecognizedEventArgs> Multiple items
module Event

from Microsoft.FSharp.Control

--------------------
type Event<'T> =
  new : unit -> Event<'T>
  member Trigger : arg:'T -> unit
  member Publish : IEvent<'T>

Full name: Microsoft.FSharp.Control.Event<_>

--------------------
type Event<'Delegate,'Args (requires delegate and 'Delegate :> Delegate)> =
  new : unit -> Event<'Delegate,'Args>
  member Trigger : sender:obj * args:'Args -> unit
  member Publish : IEvent<'Delegate,'Args>

Full name: Microsoft.FSharp.Control.Event<_,_>

--------------------
new : unit -> Event<'T>

--------------------
new : unit -> Event<'Delegate,'Args> val add : callback:('T -> unit) -> sourceEvent:IEvent<'Del,'T> -> unit (requires delegate and 'Del :> System.Delegate)

Full name: Microsoft.FSharp.Control.Event.add val e : SpeechRecognizedEventArgs property RecognitionEventArgs.Result: RecognitionResult property RecognizedPhrase.Text: string property RecognizedPhrase.Semantics: SemanticValue property SemanticValue.Value: obj event SpeechRecognizer.SpeechRecognitionRejected: IEvent<System.EventHandler<SpeechRecognitionRejectedEventArgs>,SpeechRecognitionRejectedEventArgs> val e : SpeechRecognitionRejectedEventArgs property SpeechRecognizer.Enabled: bool namespace FSharp namespace FSharp.Data val fb : FreebaseData.ServiceTypes.FreebaseService

Full name: XMas fun.fb type FreebaseData =
  static member GetDataContext : unit -> FreebaseService
  nested type ServiceTypes

Full name: FSharp.Data.FreebaseData


<summary>Typed representation of Freebase data. See http://www.freebase.com for terms and conditions.</summary>
FreebaseData.GetDataContext() : FreebaseData.ServiceTypes.FreebaseService val santaActorsFilms : (string * string) list

Full name: XMas fun.santaActorsFilms property FreebaseData.ServiceTypes.Film.Film.Film_characterDataIndividualsAZ.S: FreebaseData.ServiceTypes.Film.Film.Film_characterDataIndividualsAZ.Film_characterDataIndividualsIndexedS


<summary>An indexing of specific named individuals of type &apos;Film character&apos; in the web data store</summary>
module Seq

from Microsoft.FSharp.Collections val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map val c : FreebaseData.ServiceTypes.Film.Film.PerformanceData property FreebaseData.ServiceTypes.Film.Film.PerformanceData.Actor: FreebaseData.ServiceTypes.Film.Film.ActorData


<summary></summary>
property Runtime.Freebase.IFreebaseObject.Name: string property FreebaseData.ServiceTypes.Film.Film.PerformanceData.Film: FreebaseData.ServiceTypes.Film.Film.FilmData


<summary></summary>
val toList : source:seq<'T> -> 'T list

Full name: Microsoft.FSharp.Collections.Seq.toList val santaActorsGrammar : Grammar

Full name: XMas fun.santaActorsGrammar val actor : string val film : string val recognized : text:string -> value:string -> unit

Full name: XMas fun.recognized val value : string val sprintf : format:Printf.StringFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf val rejected : unit -> unit

Full name: XMas fun.rejected
Categories: Architecture, Requirements

Making a performant watch face

Android Developers Blog - Tue, 12/23/2014 - 19:42

Posted by Hoi Lam, Developer Advocate, Android Wear

What’s a better holiday gift than great performance? You’ve got a great watch face idea -- now, you want to make sure the face you’re presenting to the world is one of care and attention to detail.

At the core of the watch face's process is an onDraw method for canvas operations. This allows maximum flexibility for your design, but also comes with a few performance caveats. In this blog post, we will mainly focus on performance using the real life journey of how we optimised the Santa Tracker watch face, more than doubling the number of fps (from 18 fps to 42 fps) and making the animation sub-pixel smooth.

Starting point - 18 fps

Our Santa watch face contains a number of overlapping bitmaps that are used to achieve our final image. Here's a list of them from bottom to top:

  1. Background (static)
  2. Clouds which move to the middle
  3. Tick marks (static)
  4. Santa figure and sledge (static)
  5. Santa’s hands - hours and minutes
  6. Santa’s head (static)

The journey begins with these images...

Large images kill performance (+14 fps)

Image size is critical to performance in a Wear application, especially if the images will be scaled and rotated. Wasted pixel space (like Santa’s arm here) is a common asset mistake:

Before: 584 x 584 = 341,056 pixelsAfter: 48*226 = 10,848 (97% reduction)

It's tempting to use bitmaps from the original mock up that have the exact location of watch arms and components in absolute space. Sadly, this creates problems, like in Santa's arm here. While the arm is in the correct position, even transparent pixels increase the size of the image, which can cause performance problems due to memory fetch. You'll want to work with your design team to extract padding and rotational information from the images, and rely on the system to apply the transformations on our behalf.

Since the original image covers the entire screen, even though the bitmap is mostly transparent, the system still needs to check every pixel to see if they have been impacted. Cutting down the area results in significant gains in performance. After correcting both of the arms, the Santa watch face frame rate increased by 10 fps to 28 fps (fps up 56%). We saved another 4 fps (fps up 22%) by cropping Santa’s face and figure layer. 14 fps gained, not bad!

Combine Bitmaps (+7 fps)

Although it would be ideal to have the watch tick marks on top of our clouds, it actually does not make much difference visually as the clouds themselves are transparent. Therefore there is an opportunity to combine the background with the ticks.

+

When we combined these two views together, it meant that the watch needed to spend less time doing alpha blending operations between them, saving precious CPU time. So, consider collapsing alpha blended resources wherever we can in order to increase performance. By combining two full screen bitmaps, we were able to gain another 7 fps (fps up 39%).

Anti-alias vs FilterBitmap flags - what should you use? (+2 fps)

Android Wear watches come in all shapes and sizes. As a result, it is sometimes necessary to resize a bitmap before drawing on the screen. However, it is not always clear what options developers should select to make sure that the bitmap comes out smoothly. With canvas.drawBitmap, developers need to feed in a Paint object. There are two important options to set - they are anti-alias and FilterBitmap. Here’s our advice:

  • Anti-alias does not do anything for bitmaps with transparent edges. We often switch on the anti-alias option by default as developers when we are creating a Paint object. However, this option only really makes sense for vector objects. For bitmaps, this is used to blend the rectangular edges if it is rotated or skewed and it has no impact if the edge pixels are transparent (as we would imagine most watch face arms would be). The hand on the left below has anti-alias switched on, the one on the right has it switched off. So turn off anti-aliasing for bitmaps to gain performance back. For our watch face, we gained another 2 fps (fps up 11%) by switching this option off.
  • Switch on FilterBitmap for all bitmap objects which are on top of other objects - this option smooths the edges when drawBitmap is called. This should not be confused with the filter option on Bitmap.createScaledBitmap for resizing bitmaps. We need both to be turned on. The bitmaps below are the magnified view of Santa’s hand. The one on the left has FilterBitmap switched off and the one on the right has FilterBitmap switched on.
Eliminate expensive calls in the onDraw loop (+3 fps)

onDraw is the most critical function call in watch faces. It's called for every drawable frame, and the actual painting process cannot move forward until it's finished. As such, our onDraw method should be as light and as performant as possible. Here's some common problems that developers run into that can be avoided:

  1. Do move heavy and common code to a precompute function - e.g. if we commonly grab R.array.cloudDegrees, try doing that in onCreate, and just referencing it in the onDraw loop.
  2. Don’t repeat the same image transform in onDraw - it’s common to resize bitmaps at runtime to fit the screen size but this is not available in onCreate. To avoid resizing the bitmap over and over again in onDraw, override onSurfaceChanged where width and height information are available and resize images there.
  3. Don't allocate objects in onDraw - this leads to high memory churn which will force garbage collection events to kick off, killing frame rates.
  4. Do analyze the CPU performance by using a tool such as the Android Device Monitor. It’s important that the onDraw execution time is short and occurs in a regular period.

Following these simple rules will improve rendering performance drastically.

In the first version, the Santa onDraw routine has a rogue line:

int[] cloudDegrees = 
    getResources().getIntArray(R.array.cloudDegrees);

This loads the int array on every call from resources which is expensive. By eliminating this, we gained another 3 fps (fps up 17%).

Sub-pixel smooth animation (-2 fps)

For those keeping count, we should be 44 fps, so why is the end product 42 fps? The reason is a limitation with canvas.drawBitmap. Although this command takes left and top positioning settings as a float, the API actually only deals with integers if it is purely translational for backwards compatibility reasons. As a result, the cloud can only move in increments of a whole pixel resulting in janky animations. In order to be sub-pixel smooth, we actually need to draw and then rotate rather than having pre-rotate clouds which moves towards Santa. This additional rotation costs us 2 fps. However, the effect is worthwhile as the animation is now sub-pixel smooth.

Before - fast but janky and wobbly

for (int i = 0; i < mCloudBitmaps.length; i++) {
    float r = centerX - (timeElapsed / mCloudSpeeds[i]) % centerX;
    float x = centerX + 
        -1 * (r * (float) Math.cos(Math.toRadians(cloudDegrees[i] + 90)));
    float y = centerY - 
        r * (float) Math.sin(Math.toRadians(cloudDegrees[i] + 90));
    mCloudFilterPaints[i].setAlpha((int) (r/centerX * 255));
    Bitmap cloud = mCloudBitmaps[i];
    canvas.drawBitmap(cloud,
        x - cloud.getWidth() / 2,
        y - cloud.getHeight() / 2,
        mCloudFilterPaints[i]);
}

After - slightly slower but sub-pixel smooth

for (int i = 0; i < mCloudBitmaps.length; i++) {
    canvas.save();
    canvas.rotate(mCloudDegrees[i], centerX, centerY);
    float r = centerX - (timeElapsed / (mCloudSpeeds[i])) % centerX;
    mCloudFilterPaints[i].setAlpha((int) (r / centerX * 255));
    canvas.drawBitmap(mCloudBitmaps[i], centerX, centerY - r,
        mCloudFilterPaints[i]);
    canvas.restore();
}

Before: Integer translation values create janky, wobbly animation. After: smooth sailing!

Quality on every wrist

The watch face is the most prominent UI element in Android Wear. As craftspeople, it is our responsibility to make it shine. Let’s put quality on every wrist!

Join the discussion on

+Android Developers
Categories: Programming

Sponsored Post: MemSQL, Campanja, Hypertable, Sprout Social, Scalyr, FoundationDB, AiScaler, Aerospike, AppDynamics, ManageEngine, Site24x7

Who's Hiring?
  • DevOps Engineer for Wikia. Wikia is the go-to place for fan content that is created entirely by fans! As a Quantcast Top 20 site with over 120 million monthly uniques we are tackling very interesting problems at a scale you won't find at many other places. We embrace a DevOps culture and are looking to expand our team with people that are excited about working with just about every piece of our stack. You'll also partner with our platform team as they break down the monolith and move towards service oriented architecture. Please apply here.

  • Engineer Manager - Platform. At Wikia we're tackling interesting problems at a scale you won't find at many other places. We're a Quantcast Top 20 site with over 120 million monthly uniques. 100% of the content on our 400,000+ communities is user generated. That combination of scale and UGC creates some pretty compelling challenges and on top of that we're working on moving away from a monolithic architecture and actively working on finding the best technologies to best suit each individual piece of our platform. We're currently in search of an experienced Engineer Manager to help drive this process. Please apply here.

  • Campanja is an Internet advertising optimization company born in the cloud and today we are one of the nordics bigger AWS consumers, the time has come for us to the embrace the next generation of cloud infrastructure. We believe in immutable infrastructure, container technology and micro services, we hope to use PaaS when we can get away with it but consume at the IaaS layer when we have to. Please apply here.

  • Performance and Scale EngineerSprout Social, will be like a physical trainer for the Sprout social media management platform: you will evaluate and make improvements to keep our large, diverse tech stack happy, healthy, and, most importantly, fast. You'll work up and down our back-end stack - from our RESTful API through to our myriad data systems and into the Java services and Hadoop clusters that feed them - searching for SPOFs, performance issues, and places where we can shore things up. Apply here.

  • UI EngineerAppDynamics, founded in 2008 and lead by proven innovators, is looking for a passionate UI Engineer to design, architect, and develop our their user interface using the latest web and mobile technologies. Make the impossible possible and the hard easy. Apply here.

  • Software Engineer - Infrastructure & Big DataAppDynamics, leader in next generation solutions for managing modern, distributed, and extremely complex applications residing in both the cloud and the data center, is looking for a Software Engineers (All-Levels) to design and develop scalable software written in Java and MySQL for backend component of software that manages application architectures. Apply here.
Fun and Informative Events
  • Sign Up for New Aerospike Training Courses.  Aerospike now offers two certified training courses; Aerospike for Developers and Aerospike for Administrators & Operators, to help you get the most out of your deployment.  Find a training course near you. http://www.aerospike.com/aerospike-training/
Cool Products and Services
  • MemSQL provides a distributed in-memory database for high value data. It's designed to handle extreme data ingest and store the data for real-time, streaming and historical analysis using SQL. MemSQL also cost effectively supports both application and ad-hoc queries concurrently across all data. Start a free 30 day trial here: http://www.memsql.com/

  • Aerospike Hits 1M writes per second with 6x Fewer Servers than Cassandra. A new Google Compute Engine benchmark demonstrates how the Aerospike database hit 1 million writes per second with just 50 nodes - compared to Cassandra's 300 nodes. Read the benchmark: http://www.aerospike.com/blog/1m-wps-6x-fewer-servers-than-cassandra/

  • Hypertable Inc. Announces New UpTime Support Subscription Packages. The developer of Hypertable, an open-source, high-performance, massively scalable database, announces three new UpTime support subscription packages – Premium 24/7, Enterprise 24/7 and Basic. 24/7/365 support packages start at just $1995 per month for a ten node cluster -- $49.95 per machine, per month thereafter. For more information visit us on the Web at http://www.hypertable.com/. Connect with Hypertable: @hypertable--Blog.

  • FoundationDB launches SQL Layer. SQL Layer is an ANSI SQL engine that stores its data in the FoundationDB Key-Value Store, inheriting its exceptional properties like automatic fault tolerance and scalability. It is best suited for operational (OLTP) applications with high concurrency. Users of the Key Value store will have free access to SQL Layer. SQL Layer is also open source, you can get started with it on GitHub as well.

  • Diagnose server issues from a single tab. The Scalyr log management tool replaces all your monitoring and analysis services with one, so you can pinpoint and resolve issues without juggling multiple tools and tabs. It's a universal tool for visibility into your production systems. Log aggregation, server metrics, monitoring, alerting, dashboards, and more. Not just “hosted grep” or “hosted graphs,” but enterprise-grade functionality with sane pricing and insane performance. Trusted by in-the-know companies like Codecademy – try it free!

  • aiScaler, aiProtect, aiMobile Application Delivery Controller with integrated Dynamic Site Acceleration, Denial of Service Protection and Mobile Content Management. Cloud deployable. Free instant trial, no sign-up required.  http://aiscaler.com/

  • ManageEngine Applications Manager : Monitor physical, virtual and Cloud Applications.

  • www.site24x7.com : Monitor End User Experience from a global monitoring network.

If any of these items interest you there's a full description of each sponsor below. Please click to read more...

Categories: Architecture

What is Governance?

Herding Cats - Glen Alleman - Tue, 12/23/2014 - 18:13

Magna-carta-014In the business management business and the management of spending other people's money to produce a product or provide a service, there is a distinct bright line between organizations that have governance or organizations that have no governance. 

Governance and the ideas of governance have been around for a long time. The signing of the Magna Carta 800 years ago set the stage for governance in political systems, which flowed to business systems, and down to the management of projects in both business and government.

Business Governance is ...

... the set of decisions that defines expectations, grants power, or verifies performance. It consists either of a separate process or of a specific part of management or leadership processes.

There are well developed business governance frameworks, starting with SOX. But I work primarily in the Program Governance  domain, guided by ITIL, CMMI, CMS (Center for Medicaid Services), and other internal paradigms.

Program and Project Governance is ...

... the framework which ensures the project has been correctly conceived and is being executed in accordance with best project management practice within the wider framework of the firms organizational governance process.

Effective project governance ensures projects deliver the value expected of them.  An appropriate governance framework ensures that all expenditure is appropriate for the risks being handled. 

Project governance is not about micro–management, it is about setting the terms of reference and operating framework, defining the boundaries and ensuring that planning and execution are carried out in a way which ensures that the project delivers benefits.

The difference between business governance and project governance is ...

  • Business Governance is the organization control of the business's ability to deliver value.
  • Project Governance is the oversight of the execution of the project's that produce that value.

Screen Shot 2014-12-23 at 9.11.12 AM

So What Does This Mean and Why Should We Care?

Let's start with the question what's the value at risk? † The literature, blog-sphere, and other outlets are full of examples of IT project failures. From the poor statistics of Standish, to the Root Cause Analysis reports at RAND and IDA, to research on processes and practices searching for solutions to the cost, schedule, and technical shortfalls - the common missing element is deciding what governance processes to apply in what manner to protect the Value At Risk.

When we hear of some new, untested, idea of how to improve the performance of a project, we need to start with:

  • Where have you seen this work in improving the probability of success?
  • What's the Value at Risk for the projects you want to apply this idea to?
  • What Governance processes are in place, that would be violated if we applied you clever idea?
  • What basic principles of business management would be violated in the presence of this idea?

These questions are governance questions? 

If you have no governance, then the answers to the questions are unimportant, proceed to spend your customer's money. 

When we encunter Dilbert-Isk situations in management, it is likley we are missing the Governance of Other Peoples Money factor, that is often used as the excuse for not doing good management. Here's a small sample of current conditions, and desired conditions from a recent engagement.

Screen Shot 2014-12-23 at 8.21.51 AM

A Test of Any New Idea

When we hear about the newest idea on managing other peoples money, ask how is this idea going to address the root cause of the current undesirable condition? 

Then ask how would we see tangible evidence that this new idea is applicable in out domain, for our "value at risk," within our governance model?

No answers? Just I'm not going to tell you how, I'm just going to tell you my experiences. 

Nothinghere

† "Using Value-at-Risk for IS/IT Project and Portfolio Appraisal and Risk Management," Stefan Koch Department of Information Business, Vienna University of Economics and BA, Austria

† Portfolio Optimization, using Value at Risk, http://www.doc.ic.ac.uk/~vk02/project 

Categories: Project Management

Isn’t Santa really just a Product Manager?

Software Requirements Blog - Seilevel.com - Tue, 12/23/2014 - 17:30
I used to do some fun holiday jingles requirements-style. I fell out of habit with it a few years ago, but luckily they are timeless and can just be reused! That said, I was trying to get in the holiday spirit to try again this year, and I found myself going down a different path. […]
Categories: Requirements

Five Problems That Impact Testing Effectiveness and Efficiency: #1 Planning

 

Forewarned is forearmed!

Forewarned is forearmed!

Testing is an important set of tools for influencing the quality of the functionality that gets delivered. The term testing can cover a wide range of activities ranging from reviews to user acceptance testing with a nearly infinite number of stops in between. Some organizations expend up to 60 – 70% of project effort just on testing (this is abnormally high), often with the intention of “testing in” quality. When the effectiveness and efficiency of testing has been derailed there are five typical root causes.

  • Planning
  • Involvement
  • Organizational Management
  • Capability
  • Process

Planning is the first of the root causes. Poor planning will yield poor results. Test planning defines the approach a project will use to verify and validate the deliverable they are creating. There are several inputs that impact and shape a test plan. The inputs are:

  1. Risk – Risk is a reflection of possibilities that might impact the project if they occur. Some projects will inherently have a bigger impact on the organization if things go wrong. Testing can be tuned to act as insurance that risks do not become issues. Agile projects use a wide range of techniques to incorporate risk into how testing is approached. Planning techniques include release planning, sprint planning, tools like the definition of done, techniques such as test first development (including test driven development) or classic test planning documentation.
  2. Test Goals – Test goals reflect an organization’s business strategy and needs. Test goals can be as simple as ensuring software is defect free (this is not only simple, but a simplistic) to improving the product’s delivered quality (as compared to a standard or a baseline).
  3. Test Policy – A policy defines a course of action that supports a long-term purpose. A test policy describes the type of behavior without defining the ends, means or approach. Good policies are aligned with the business strategy and the test goals. Test policies must be agreed upon (at least passively) by all of the stakeholders.  Policies that the involved parties don’t agree with will potentially generate poor behavior as stakeholders struggle against what they perceive as artificial constraints. For example a policy that requires all applications to be stress tested even if they are standalone, one person applications will not be perceived as fitting the environment.  The policy will be ignored when practitioners don’t think it applies which opens the door for failure if something is not stress tested that should be.
  4. Test Strategy – At an organizational level, a test strategy represents a broad outline that will orperationalize the test policy.At a project level, a test strategy will define the how the project will conform to the test policy and meet the test goals. The strategy operationalizes the testing goals and policies based on the business and project risks.

The typical image painted when discussing test planning is an omnibus document that defines how a project will approach testing, sometimes in mind-numbing detail. While that level of detail might be important in some scenarios, in most Agile projects the adoption of standard techniques provides the policy, strategy and guidance to ensure a good test planning. Agile techniques that improve planning include:

  1. Well-formed user stories (including acceptance criteria),
  2. Test first development (such as test driven development or acceptance test driven development), and
  3. A solid definition of done.

Planning is requirement for any activity development activity, testing included.  Good planning is a requirement for good testing.


Categories: Process Management

The Best Books I Read in 2014

I wrote a roundup of the best books I read in 2014.  

I read a lot of books, and not all of them are worth sharing.  I’m a believer that leaders are readers, and as Bill Gates says, “reading is how I learn best.”

Here are a few of the books that made my list:

  • All in Startup: Launching a New Idea When Everything is On the Line, by Diana Kander
  • Blind Ambition: How to Envision Your Limitless Potential and Achieve the Success You Want, by Patricia Walsh
  • Eat for Health, by Dr. Joel Fuhrman, M.D.
  • How to Fail at Almost Everything and Still Win Big: Kind of the Story of My Life, by Scott Adams
  • Leading Digital: Turning Technology into Business Transformation, by George Westerman, Didier Bonnet, and Andrew McAfee
  • The Undefeated Mind: On the Science of Constructing an Indestructible Self, by Alex Lickerman
  • Use Your Brain to Change Your Age: Secrets to Look, Feel, and Think Younger Every Day, by Daniel G. Amen, M.D

For the full list and some quick perspective on each book, you can read my post on the best books I read in 2014.

Categories: Architecture, Programming

Scalability as a Service

This is a guest post by Thierry Schellenbach, CEO GetStream.io and author of the open source Stream-Framework, which enables you to build scalable newsfeeds using Cassandra or Redis.

We first wrote about our newsfeed architecture on High Scalability in October 2013. Since then our open source Stream-Framework grew to be the most used package for building scalable newsfeeds. We’re very grateful to the High Scalability community for all the support.

In this article I want to highlight the current trend in our industry of moving  towards externally hosted components. We’re going to compare the hosted solutions for search, newsfeeds and realtime functionality to their open source alternative. This move towards hosted components means you can add scalable components to your app at a fraction of the effort it took just a few years ago.

1.) Search servers
Categories: Architecture

Agile Analysis, Self-Selecting Teams, TDD & BDD in Methods & Tools Winter 2014 issue

From the Editor of Methods & Tools - Mon, 12/22/2014 - 15:22
Methods & Tools – the free e-magazine for software developers, testers and project managers – has just published its Winter 2014 issue that discusses Agile Analysis, Self-Selecting Teams,Collaborative Development of Domain-specific Languages, TDD with Mock Objects, BDDfire. Methods & Tools Winter 2014 contains the following articles: * Analysis on Analysts in Agile * Self-Selecting Teams – Why You Should Try Self-selection * Collaborative Development of Domain-specific Languages, Models and Generators * TDD with Mock Objects: Design Principles and Emergent Properties * BDDfire: Instant Ruby-Cucumber Framework 55 pages of software development knowledge that you can freely download from ...

It’s beginning to smell like the holiday season!

Software Requirements Blog - Seilevel.com - Mon, 12/22/2014 - 15:00
It’s about that time of year now when people are thinking of what to get others as gifts during the holiday season. Each year my family does a Yankee Swap (which may also be known as a White Elephant), which means that I need to get a gift which has one requirement: $20 or less. […]
Categories: Requirements

Is It Possible The Sony Hack Was Just A Publicity Stunt?

Making the Complex Simple - John Sonmez - Mon, 12/22/2014 - 14:00

What if Sony never was really hacked? Or worse yet, if Sony hacked themselves? I know this sounds a bit crazy–and I admit, I AM a bit crazy–but, indulge me for a few minutes of your time and perhaps I’ll convince you that it just might be possible that the whole thing was staged for a very specific purpose… Why ... Read More

The post Is It Possible The Sony Hack Was Just A Publicity Stunt? appeared first on Simple Programmer.

Categories: Programming