Changing layout when the device orientation change is so common in many mobile apps that one might think it is automatic.But unfortunately it isnt.

Given Adobe FLEX multiplatform nature it is wrong to listen to device OrientationChange but you should listen to resize Events.

First step , Add this code snippet to your view :

   1: import mx.events.ResizeEvent;

   2:             

   3:             protected function application1_resizeHandler(event:ResizeEvent):void

   4:             {

   5:                 if (width>height)

   6:                     this.currentState="landscape";

   7:                 else this.currentState="portrait";

   8:             }

Of course you need to listen to call this method every time the view changes its size.You do this by adding resize Listener to your View declaration

   1: <s:View ..... resize="application1_resizeHandler(event)" >

Then we need to add two states that we can use to dynamically modify our orientation

   1: <s:states>

   2:         <s:State name="portrait"/>

   3:         <s:State name="landscape"/>

   4: </s:states>

Then we should use either the Design mode in Flash Builder or manually do the orientation Change.For Example i tell the TileLayout to lay its content in columns if in landscape or in row if in portrait:

   1: <s:TileLayout id="Tiles" orientation.landscape="columns" orientation.portrait="rows" horizontalGap="0" verticalGap="0"/>

So thats it and this was my first blog. Over.

Retrospectives are a tricky thing, you get a mix of people who have varying personalities and qualities and now they need to look objectively at the previous iteration, focussing on the performance of the team and interact, giving ideas and finding ways to improving the team practices for the next iteration.

In the ones I have been involved in, you get an array of people, some like to dominate the conversation while others would rather not say anything. Getting a balanced participation and a focus from the team on the purpose of the retrospective is both challenging and critical for the team to improve.

One of the tricks of a retrospective is to get everyone in the team to say something within the first few minutes of the retrospective. Generally it is found that if everyone says something within those first few minutes, the participation level of the team for the rest of the retrospective is higher. I have tried a range of different ways of achieving this and recently stumbled on a really nice way to get the team to focus on the purpose of the retrospective as well as getting everyone say something quickly, I have called it the goal analysis card game.

What you will need

• cards that you can print one, preferably playing card size (one for each team member attending the retrospective)
• goals from previous retrospective / team contracts or general agile principles
• table where the retrospective will be held

Before Retrospective Preparation

Before the retrospective you need to prepare the cards. Take the goals from the last retrospective typically you would have a handful of these (4 or 5 at tops setting SMART goals will be another posting if I get around to it). Print each goal on a card. You want one card per person attending the retrospective - if you do not have enough goals to cover each team member, go through team contracts / agreements and add them to the card pile. Thats all the prep work you need.

Playing the Game

Get everyone to sit around a table. Place the cards face down on the table and randomly order them in front of the team (its important that the team knows the cards are randomly ordered so that they do not feel that they are individually being targeted).

Explain to the team that to start the retrospective we are going to play a game. Each person will have a turn

For a turn, the team member chooses a card from the table (without knowing whats on it) they read the card to the team, then express to the team whether in their opinion this goal/contract/principle was met in the last retrospective. If they feel it was met they need to give one concrete example of when. If they feel it was not met, they need give a reason in their opinion why not. Once they have done this, if anyone else in the team feels they need to add to that, they can do so.

You then work your way around the table, each person going. Be careful to keep the focus on the items and not let the conversation derail. If you think it is derailing, ask if we can park the issue and move on to the next card.

The Results

I found this game to be a nice way to get a team to focus on the retrospective, and to get everyone to participate. In particular, it helps when you have one or two individuals on the team who have been on the quiet side to feel more included in the team and the opinions heard. I would love to get feedback from others if anyone tries this approach or any variant of it.

I really love the LINQ language extension in dot net programming and Im really glad it was added to a language I love (C#).

My background, however, has a lot of C++ in it and I still do some coding in C++ sometimes for fun and sometimes to put back into practice things I should have know for years, but are just now being recognized by my ever-widening eyes. A lot of that new vision comes from seeing C# and LINQ and, of course, practicing all forms of programming MOJO on programming forums, like DaniWeb.com.

One particular post I saw there was in the C++ forum, where a user posted a question about two-dimensional arrays and how to search for a particular pattern of digits based on array boundaries. The user posted a block of digits like this:
2,2,9,8,7,3,4,
0,0,0,0,0,0,0,
3,4,5,7,8,9,6,
0,0,0,0,0,0,0,
1,3,4,5,5,5,5

The question asked was how to return a 2d array of the rows that did not contain all zero values. Most programmers can imagine a series of loops and boolean settings based on boundaries to eliminate the bad rows.

I immediately thought Use a WHERE clause on it. then I remembered I was in the C++ forum and, given the experience of the developer, might need a more traditional approach. I gave a suggestion about looping then began to make some examples for myself one full solution the (traditional) hard way, one solution in C# with LINQ and then curiosity took hold and I convinced myself it would not be too hard to do it with C++ (CLI) and LINQ. I underestimated the complexity, but consider it good practice.

Here is the C# code:

using System.Collections.Generic;
using System.Linq;
//
namespace DW_409646_CS_CON
{
   class Program
   {
      public static int[,] matrix2d = new int[5, 7]
      {
         {2,2,9,8,7,3,4},
         {0,0,0,0,0,0,0},
         {3,4,5,7,8,9,6},
         {0,0,0,0,0,0,0},
         {1,3,4,5,5,5,5}
      };

      static void Main(string[] args)
      {
         List<int> lst_int = matrix2d.OfType<int>().ToList();
         //
         int intHeight = (matrix2d.GetUpperBound(0) + 1);
         int intWidth = (matrix2d.GetUpperBound(1) + 1);

         // Method one
         int[][] arr =
         (
            from i in Enumerable.Range(0, intHeight)
            let lst_intEachRow = lst_int.GetRange(i * intWidth, intWidth)
            where !lst_intEachRow.All(ix => ix.Equals(0))
            select lst_intEachRow.ToArray()
         ).ToArray();

         // Method two
         int[][] arr2 =
            Enumerable.Range(0, intHeight)
               .Select(i => lst_int.GetRange(i * intWidth, intWidth)
                  .ToArray()).Where(xa => !xa.All(ix => ix.Equals(0)))
                     .ToArray();
      }
   }
}

The C++ conversion was a little more complex, but can be done. The tricky part was getting the return value from the Enumerable based on the height of the array:

   1:  #include "stdafx.h"

   2:  using namespace System;

   3:  using namespace System::Collections::Generic;

   4:  using namespace System::Linq;

   5:  //

   6:  public ref class CArrayHelper

   7:  {

   8:  public:

   9:     static array<int,2>^ matrix2d;

  10:  

  11:     CArrayHelper(array<int,2>^ matrix)

  12:     {

  13:        matrix2d = matrix;

  14:     }

  15:  

  16:     static Func<int, String^>^ intToString =

  17:        gcnew Func<int, String^>(IntToString);

  18:     

  19:     static Func<int, bool>^ isZero =

  20:        gcnew Func<int, bool>(IsZero);

  21:  

  22:     static Func<array<int>^, bool>^ notAllZeroes =

  23:        gcnew Func<array<int>^, bool>(AllZeroes);

  24:  

  25:     static Func<int, int, array<int>^>^ getArrFromArr =

  26:        gcnew Func<int, int, array<int>^>(GetArrFromArr);

  27:  

  28:     static array<array<int>^>^ OutputArrayNonZeroes()

  29:     {

  30:        return

  31:           Enumerable::ToArray

  32:              (Enumerable::Where

  33:                 (Enumerable::Select

  34:                    (Enumerable::Range(0, matrix2d->GetUpperBound(0) + 1),

  35:                       getArrFromArr), notAllZeroes));

  36:     }

  37:  

  38:  private:

  39:     static String^ IntToString(int i)

  40:     {

  41:        return i.ToString();

  42:     }

  43:  

  44:     static bool IsZero(int i)

  45:     {

  46:        return i.Equals(0);

  47:     }

  48:  

  49:     static bool AllZeroes(array<int>^ arr)

  50:     {

  51:        return !Enumerable::All<int>(arr, isZero);

  52:  



					

					

					Home