SimpleRemoting part 2

http://ledtechdesign.com/2009/02/tutorial-blazeds-simple-remoting-part-ii-flex/

Method A(acxtionscript method)

Steps in Flex

1) Add ActionScript “Beans” mirroring beans we created in Java application.

2) Create SportEventsManager ActionScript class which will retrieve Sport Events using blazeDS Object Remoting Service.

The structure has changed

The behaviour has changed and thier interaction has changed.

The STUCTURE came as a package

It was an unkown object

The zookeepers  made a composite structure

From the components

To make a single profile

Which they then deployed

The Behaviour

The interaction changed the gibbons mood State

Their activity changed

Their State of mind changed.

Their  Use case changed.

The Interaction

They sat on top to get an  Interaction overview of the others.

Their  Communication changed

And the Sequence of their communications changed.

wikipedia list of UML tools free and otherwise

used to amend (customize or decorate)existing classes and hides unwanted inheritance. functionality.

can mix and match at runtime.

safari :decorator pattern

class

extends  a component/class and and implemt an Abstract class (the decorator)that  implements methods to be amended(wrapper class)

extend from this the concrete class overriding the concerned methods

AS3DP is divided into several sections based on a basic categorization of design patterns. These categories have been defined previously in other important texts about design patterns, and I’m glad that the authors chose to stick with the precedent. They appear as follows.

1. Creational patterns
2. Structural patterns
3. Behavioral patterns
4. Multiple patterns (more than one pattern combined into one)

The section on Creational patterns starts with the Factory Method pattern. This pattern is explained very well with two interesting examples. The first example, a Print Shop, helped me understand the problem and solution very easily, and the second example, a shooter game, was a fun way to reinforce the knowledge. Next, the Singleton pattern is introduced. This pattern is an obvious choice, as one of the more common ones I’ve seen mentioned by ActionScript developers, and the section includes good material.

We go next into Structural patterns. I found the Decorator pattern, again, very easy to understand. The examples in this section illustrated the purpose well, but they didn’t quite catch my interest as the ones in previous chapters. Paper dolls probably won’t appeal to the average target reader of AS3DP. Decorating with “Deadly Sins and Heavenly Virtues” seemed weird too. I would have preferred the focus to have been closer to real-world projects as much as possible. The Adapter pattern is another well-explained pattern. The example of easily controlling a car in different ways (such as through code or the mouse) brought my interest back a bit. This section ends with the Composite pattern which is explained through the Flash display list (an excellent choice to help the reader’s understanding) and inverse kinematics, another interesting topic.

The third category of patterns features Behavioral patterns. We start with the Command pattern. One example implements undo, and another sets up controls for a podcast media player. Much to my annoyance, the authors decided to include the Observer pattern. Considering that they don’t have an exhaustive list of the classic patterns in this book as it is, I don’t understand why they decided this one is important to include. One of the native classes in Flash Player, EventDispatcher, already uses this pattern. To be blunt, very few developers will ever implement the Observer pattern in AS3. The Template Method pattern was easy to understand, and the examples summed it up well. Overall, he State pattern was introduced very well and I found it understandable. The video player example could have used a little more work, I think. I understand that simplicity is important for examples, but something felt strange about a video player that couldn’t go directly from a paused state to a stopped state. Behavioral patterns end with a look at the Strategy pattern.

The final category of design patterns introduced in AS3DP is the set of patterns that combine multiple patterns into one. The first is Model-View-Controller, or MVC for short. Along with Singleton, this is one of the most common patterns that seems to appear in ActionScript code. The examples for this one were generally interesting, and it was a good review for me. The finally pattern is Symmetric Proxy. It seemed to be explained pretty well, and the authors warned the reader that it has some minor changes from the traditional implementation which was thought-provoking, and I think it will act as a subtle suggestion to help readers explore design patterns a bit more. The requirement of Flash Media Server and its AS1-style code to create the example was a bit of a turn-off for me, though.

I found ActionScript 3.0 Design Patterns to be a book that I could read from start to finish. Often I will skip sections in books that cover material I already know, but design patterns are generally pretty flexible, and it was nice to see the authors’ perspectives on them. I also had motivation to continue on because there were several patterns I haven’t yet used in my projects, and I love to learn new things. Some examples were very good and kept me interested; others felt completely out of place. In general, all of them helped me to understand how the patterns should be implemented.

extended observer Pattern

used to manage 1 to many relationships between classes.

// set up Pacman class to broadcast
Pacman extends EventDispatcher

// tell enemies to listen to pacman instance
pacman.addEventListener(Pacman.ATE_PELLET, enemy1.update);
pacman.addEventListener(Pacman.ATE_PELLET, enemy2.update);
pacman.addEventListener(Pacman.ATE_PELLET, enemy3.update);

// broadcast state change
pacman.dispatchEvent(new Event(Pacman.ATE_PELLET));
// enemies respond
enemyClass.update() {
// run away
}

Scrum Master (PM) : meeting, facilitation.

Developers/testers

Domain experts

team size upto several hundered.

————————

Functionalatity : product backlog

release planning  phase

identify features

prioritise

estimate work involved

use relative estimates i.e. bold vs italic functionality in a word prosesor (cheesits, points).

run the project se how far we get then estimate.

Steps

product Backlog

1) features are broken down into a series of releases.

2) Release are broken down into short duration milestones called sprints.

3) have from4 to 12 sprint backlogs

at the end of each sprint full subset  of the

burn down chart

average rate of producyivity can estimate .

a late finish of a sprint is a good indicator that the the project is behibnd schedule and something needs to be done.

monitor the progress of each sprint with a Burndown chart. a great product visibility chart. It provides a day by day measure of the amount of work that remains in sprint.

can calulate the slope of the chart to claculate the ‘Burn down velocity’ which the be used to calculate the entire amount of work remaining for the sprint or even the entire project.

What we van do is compare our actual burn-down velocity and actual completion date with the forecast, and give the team a view of what it needs to do and make the appropiate adjustments in order to finish on time

defect backlog

track all defects separately from features in their own process

deal with all  bugs in the backlog before finishing the sprint.

Standing Meetings

daily standard meetings.

plan one or two sprint to deal entirely with the defect backlog

videos

High Paced description of SCRUM development

The value of Agile vs Waterfall

<?xml version=”1.0″ encoding=”utf-8″?>
<s:Application
xmlns:fx=”http://ns.adobe.com/mxml/2009″
xmlns:s=”library://ns.adobe.com/flex/spark”
xmlns:mx=”library://ns.adobe.com/flex/halo”
creationComplete=”reflect()”  width=”800″ height=”800″
minWidth=”1024″ minHeight=”768″>
<s:layout>
<s:BasicLayout/>
</s:layout>
<mx:Image x=’200′  id=”gr1″  y=’75′ source=”../assets/a.jpg”/>
<s:Button x=”100″ y=”75″ click=”reflect();” />
<fx:Script>
<![CDATA[
import spark.core.SpriteVisualElement;
private function reflect():void
{
var angle:Number = 60;
var offset:Number = Math.tan(angle*Math.PI/180) * gr1.height
var bmd:BitmapData = new BitmapData(gr1.width+ offset,gr1.height,true,0x000000);
var m:Matrix =new Matrix()
m.scale(1,-1);
m.c = Math.tan(-1*angle*Math.PI/180);
m.translate(offset,gr1.height)

trace( Math.tan(angle*Math.PI/180) * gr1.height );

bmd.draw(gr1,m,null,null,null,true);

var s:SpriteVisualElement = new SpriteVisualElement();
s.graphics.beginBitmapFill(bmd);
s.graphics.drawRect(0, 0, gr1.width + offset, gr1.height);
s.graphics.endFill();

this.addElement(s)
s.x = gr1.x
s.y= gr1.y + (1* gr1.height) + 10;

//
//create mask
//
var mk:SpriteVisualElement = new SpriteVisualElement
m=new Matrix;
m.createGradientBox(gr1.width+ offset,gr1.height,Math.PI/180*90);
//mk.graphics.beginFill(0xff0000,1)
mk.graphics.beginGradientFill('linear',[0xffffff,0xffffff,0xffffff],[.7,.1,.01],[0,75,150],m)
mk.graphics.drawRect(0,0,gr1.width+ offset,gr1.height)

mk.graphics.endFill();
s.mask = mk;
s.cacheAsBitmap = true;
mk.cacheAsBitmap=true;
this.addElement(mk)
mk.x = gr1.x  ;
mk.y= gr1.y + (1* gr1.height) ;

}
]]>
</fx:Script>
</s:Application>

http://www.citysolutions.co.uk