Digital Primates

Michael Labriola named a 2012 MAX Master

DP in the News — Tue, 08 Nov 2011 23:01:19 +0000

Adobe named our own Michael Labriola a MAX Master for 2012, one of only nine external speakers to earn the title. The MAX Master award is given to presenters with the highest speaker rating based on audience surveys from MAX 2011. Nice work, Mike!

Funny, we always thought of him as more of a Blaster.

Talking Trash – An overview of Player GC

codeslinger — Tue, 11 Oct 2011 17:42:16 +0000

Okay, so, I have been a little behind schedule actually posting content. Here is my first attempt at reconcilliation. These are the slides from my garbage collection talk at flash and the city this year. They go into moderate depth about the internals of garbage collection on the Flash Player and AIR along with some speculation about where things may be going. The speculation is based off of commits happening on the tamarin project from our friends at Adobe.

Cheers, Labriola

Making a custom datagrid scrollbar? I hope the width=16…

strict-inequality — Wed, 02 Feb 2011 22:29:16 +0000

Flex has a lot of great facilities for styling and skinning, including custom scrollbars. Unfortunately, I’ve discovered that Flex really wants your vertical scrollbars to be 16 pixels wide. When it isn’t, Flex can make some strange layout decisions when first putting it on screen. for example, check out this (very fancy) datagrid: I made an 8-pixel wide vertical scrollbar, complete with a lovely red and purple coloring, and used it in my datagrid. Obviously, there’s a couple things wrong. First, there’s an ugly white gap between my content and my fancy scrollbar. Second, it looks like the content in my 2nd column has a different left padding than the content in my 1st column. Finally, the header area above the scrollbar didn’t render correctly. To see what kind of scrolling behavior it had, I clicked on my “down arrow”: A couple things sorted themselves out: the 8-pixel white gap is gone, the header looks right, and the content in the last row (Roger McBob) looks proper. As a final test, I sorted the 2nd column and got this: Now all the content looks properly placed. So what the heck is going on here? This bad behavior can be traced back to ScrollControlBase.as, in setScrollBarProperties() and createVScrollBar(). setScrollBarProperties() is going to be invoked from DataGrid’s updateDisplayList(). What we’re really interested in is whether the content area (for the first and last names) has changed size, which is tracked in the class variable scrollAreaChanged. If that scroll area has changed, then setScrollBarProperties() is going to call updateDisplayList(). What’s that? Aren’t we already in a call to updateDisplayList(), and isn’t that call going to re-execute DataGrid.updateDisplayList() and get us right back in here? Yes. Yes it will. The other thing that setScrollBarProperties() is doing is deciding whether or not it needs to create or destroy scrollbars. For the situation I’ve created, it will need to create a vertical scrollbar. And it does so with a call to createVScrollBar(). That new scrollbar, before its measure() can get called, is going to report a width of 16, which is the default. And that value will be used to determine not only the overall content area (c.f. that ugly white gap), but also how the content therein is placed (c.f. the 2nd column content being off a few pixels). It’s going to do all this before we can actually measure the scrollbar, even when we re-enter the method. It’s not until we start interacting with the control (scrolling, sorting) that we get back into setScrollBarProperties() after the scrollbar has finally been measured. As we can see, it then starts laying out properly. It’s great that the framework handles getting us back into that method, but I can’t help thinking that it would be better served through an invalidation cycle, rather than a recursive call. If that happened, we’d go through a proper measure cycle and the content area would be sized correctly without having to touch the control. Funnily enough, in createVScrollBar() (I’m looking at the Flex SDK 3.5 here), there’s this code:

//need verticalScrollBar.validateNow()?

Given the way the code is written now, I’d say the answer is yes. That would force a measure and our datagrid would render correctly the first time. Maybe that should have been explored more before simply commenting it out.

JSFL: fl.addEventListener() & fl.removeEventListener()

excessive-recursion — Tue, 02 Nov 2010 06:38:35 +0000

I’ve been experimenting with the Flash CS5 JSFL API lately and ran across these handy methods adding and removing event listeners to the fl object. However, I discovered that the functionality has changed from what the documentation states. After digging around the internet for some answers with no luck, I finally contacted Adobe about it and sure enough here is what they say.

fl.addEventListener now returns an eventID (valid across FLA files for that Flash session) when you add an event listener. When you remove the event listener, you have to specify the event type and the event id.

Example for adding: var evtID = fl.addEventListener("documentChanged", docChangedHandler); Example for removing: fl.removeEventListener("documentChanged", evtID); This affects Flash CS4 & Flash CS5. Hopefully this clears things up for people and hopefully the documentation will be updated soon. After experimenting with it while attempting to prevent duplicate event listeners from being added when working with a windowswf that has been opened and closed repeatedly, now you can derive a way to persist the id’s and keep your panel from adding duplicate listeners. Pretty handy I must say.

Lots of new prereleases from adobe

tapper — Mon, 25 Oct 2010 15:40:30 +0000

Late last night adobe released several new betas on the labs.adobe.com site, including: • 64 bit Flash Player (Code Named “Square”) • Flex 4.5 SDK (Code Named “Hero”) • Flash Builder Next (Code Named “Burrito”) • Flash Catalyst Next (Coe Named “Panini”) Square is obviously very interesting, as more and more end users now have 64 bit machines, it is great that the flash player will now be able to leverage the full power of the underlying operating system. It seems that 64 bit players are now available for Windows, Mac and Linux. Hero is another great release, with Adobe continuing to move the flex sdk forward. In this release, many of the components which were not migrated to the spark architecture in the 4.0 release have now been completed, including the DataGrid, Form, and Image components. Even more interesting is the rework done to make to make Flex applications run well on mobile devices. Having done a few AIR for Android applications using AS3 without the flex framework, I look forward the increased productivity I can realize by leveraging flex on these devices as well. Burrito and Panini are both improved tools to allow developers and designers increased productivity with the new SDK. In addition to supporting the latest SDK, Burrito also includes a workflow to ease development of mobile applications, a series of coding improvements, such as the introduction of templates, metadata code hinting and more. All told, these new releases promise to push the flash platform forward, and increase the world of possibilities for those of us who develop for the platform.

Catching up

codeslinger — Thu, 23 Sep 2010 19:23:02 +0000

360|Flex is officially over and my slides are finally available. It was another great conference but I am officially wiped out. Three full days of content and wonderfully geeky discussion have left me looking forward to the weekend.

For any who asked for my slides, they are included below. Thanks so much for the great feedback and being a wonderful audience. I really enjoy doing these deep-dive style talks and so long as 360|Flex keeps inviting me back and all of you keep attending, I promise to try to keep them fresh and interesting.

Flex 4 components from the firehose

View more presentations from michael.labriola.

P.S. If you didn’t get a chance, check out my featured opening over at http://www.weheartdoug.org for Nate’s masterful prank.

Cheers,
Labriola

What’s under your skin

tapper — Tue, 21 Sep 2010 13:52:42 +0000

At 360|Flex DC yesterday, I presented my “Whats under your skin” presentation, all about architecting components with skins and layouts. I had a great audience, who was very engaged and asked lots of pertinent questions.

For anyone interested, here are the slides. The code for the ShoppingList component can be found below from the download link. The code for the Clocks are proprietary, and can not be shared. Sorry. Download

Wanted: Technical Writers with Free Time and an Altruistic Spirit

codeslinger — Thu, 08 Jul 2010 13:07:00 +0000

As many of you know, I am the project lead for FlexUnit 4.x. The technical side of the project is in great shape with new features, releases and tests forthcoming, however, the place we are really lagging is good documentation.

Right now the FlexUnit team is quite small and 120% of our time is occupied with development and user support. Unfortunately this means that the best engineered plans for good documentation seem to get farther behind as the days go on.

We are looking for a few people who would be willing to own large chunks of the documentation. We would arrange conference calls as needed with the developers of key sections to talk through approach, technical details and future plans. The goal would be to ensure you have a full understanding and access to anyone you need when writing. Ultimately, it would also give you a few things.

First, you would have unlimited access to learn FlexUnit at a very, very deep level. Second, you could help create a volume of work (I am hoping we can produce both wiki content and eventually a comprehensive PDF book) which will continue to be attributed to you. Third, that attribution plus future recommendations from myself and others on the team and in this industry are guaranteed (and very helpful for future interviews).

Anyone who is seriously interested should leave a comment on this post and I will reach out to you immediately.

If you want to take a look at our current efforts, head over to docs.flexunit.org

Thanks,
Labriola

FlexUnit 4.1 Beta 1 Now Available

codeslinger — Mon, 07 Jun 2010 13:06:00 +0000

For months now the core FlexUnit team and contributors have been working diligently to move the next release of FlexUnit forward. The 4.0 release was a success but we always knew there were many optimization and enhancement still to come. Today, we are happy to announce some of those are available as the 4.1 public beta begins. You can download the latest bits from the flexunit.org download site. Here are a few feature descriptions and bullet points of some of the new features in the FlexUnit 4.1 world.

Parameterized Testing

There are times when you need to repeat a test across a series of data points. Imagine a class that does a complex calculation based on input values. It is likely that you would want to test hundreds or thousands of different input values, checking each of their expected outputs to feel comfortable that this class was behaving properly. Or, perhaps you have a whole series of components which implement an interface and you wish to verify that setting the ‘x’ property on each of those objects dispatches and expected event or updates a given property. These are both cases where Parameterized testing can simplify your life. Parameterized testing in FlexUnit works by allowing you to specify arguments to be passed to a constructor (we call it JUnit style), or arguments which will be passed to a method (TestNG Style). Here is a quick sample of the approach:

Constructor (JUnit Style):

 [Parameters]
public static function data2():Array {
return [ [ 3, 6 ], [ 4, 8 ], [ 5, 10 ], [ 6, 12 ] ];
}

private var _input:int;
private var _expected:int;

public function TestParameterized( param1:int, param2:int ) {
_input = param1;
_expected = param2;
}

[Test]
public function doubleTest():void {
assertEquals(_expected, _input*2);
}

Method (TestNG Style):

 public static function dataThree():Array {
return [ [ 0, 1, 1 ], [ 1, 2, 3 ], [ 2, 4, 6 ] ];
}

[Test(dataProvider="dataThree")]
public function addTwoValuesTest( value1:int, value2:int, result:int ):void {
  assertEquals( value1 + value2, result );
}

Parameters are defined by static properties containing arrays of arrays. The framework iterates through the array, calling your methods with the parameters of each inner array. Parameterized testing can be combined with the asynchronous testing for very complex testing. At first glance, those of you familiar with theories might see a lot of similarities to parameterized testing; they also allow a developer to create methods and a constructor that accept parameters. A theory is different in how the data is defined and in the way a test fails. A theory is akin to a mathematical theory wherein any failure means the whole theory is bad. Further, theories are often reversible. For instance, a valid theory might entail testing a math class by first multiplying two numbers and then dividing the product by the first number. If your code is valid, you should get the second number back. Testing this across a potentially infinite number of values is the real of a theory. Whereas theories see all of the datapoints as input to a single test, which passes or fails as a whole, parameterized testing expands your set of parameters to individual tests allowing you to understand which cases fail and succeed individually. Parameterized tests are more useful in cases where you have a fixed data set with known specific values which represent a valid outcome.

External Data for Parameterized Testing and Theories

Executing tests across large data sets necessarily involves maintaining that data. FlexUnit 4.1 allows the data for Theories and Parameterized tests to be loaded from an external source.


public static var dataRetriever1:IExternalDependencyLoader = new ParamDataHelper( "PurelyFakeExample.xml" );
[Parameters(loader="dataRetriever1")]
public static var someData:Array;

The IExternalDependencyLoader interface works with the Theory and Parameterized test runners to facilitate asynchronous loading of data points before testing begins.

Rules Implementation

When creating large suites of unit tests, you could find yourself duplicating complex setup code many times. Rules offer the ability to factor this code into a separate class and specify logic that will be invoked before or after each test method call, allowing you to alter how a method is called, perform additional setup or even examine and change the result of a test runner.

 [Rule]
public var rule1:IMethodRule = new SomeRule();
[Test]
public function test1():void {
}

This feature can be used to create new types of test runners through composition instead of inheritance, allowing more flexibility, less code to maintain and the ability to reuse the rule across many types of runners. The first application of this technology was the auto-creation and verification of Mocks for test cases, however, the next application is a Rule to inject dependencies into cases.

Directory Scanning and Test Loading

Using the FlexUnit Ant tasks, you can point FlexUnit at a directory, which it will recursively scan for tests, build a temporary suite and execute on your behalf, removing the need to maintain static lists of tests in many cases.


 haltonfailure="false" verbose="true" localTrusted="true">

Performance Improvements

FlexUnit 4.1 now executes FlexUnit 4.x style metadata tests approximately 60% faster than before. New logic that directly monitors the progress of tests throughout the Flash Player frame allows the framework to better utilize the available time, resulting in an additional significant performance boost. Collectively these improvements can halve the execution time on very large suites over previous versions.

UIImpersonator for AS or Flex

Flex developers have had the ability to use the UIImpersonator classes to allow components to interact with the display list since version 4.0. Version 4.1 extends that coverage and allows ActionScript only projects the same access. A new property on FlexUnitCore allows developers to indicate the visual display root of the application, thereby allowing this access.

 var core:FlexUnitCore = new FlexUnitCore();
core.visualDisplayRoot = this;

Asynchronous Functionality now Available in Parameterized Testing and Theories

The ability to test asynchronously is imperative in Flash, where operations are often broken across frames. FlexUnit Asynchronous methods are now available in Theories and Parameterized Tests.

Package level assertions

You may have noticed that throughout these examples, we have simply said assertTrue() instead of Assert.assertTrue() Package level assertions now exist for all assertion methods, minimizing typing and porting from previous versions of FlexUnit or Fluint.

Timing information during test run

Timing information is gathered internal to the framework during test run, allowing for more accurate measurements of test execution time. Now, go download the latest bits from the flexunit.org download site and give us some feedback.

VectorCollection

codeslinger — Tue, 18 May 2010 09:05:00 +0000

First, let me say I am sorry. A year or so ago, I wrote these VectorCollection classes. They are not spectacular works of art, they are very basic implementations required to use Vector inside of Flex components which are looking for IList and ICollectionView for their dataProviders. Vector has some performance advantages in some cases (for more details, take a look here. ) but overall, the big advantage to me is type safety. I know what should be in the Vector and flash knows if I mess that up. On the whole, these are simple implementations that don’t solve every problem I would love to solve if I had the Flash Player source and some time, but they will allow you to use Vectors more directly in Flex. So, if you find them useful, then enjoy.

private var source:Vector.;
source = new Vector.;

private var vc:VectorListCollection;
vc = new VectorListCollection( source );

var sort:Sort = new Sort();
var field:SortField = new SortField( null, false, false, true );
sort.fields = [field];
vc.sort = sort;
vc.refresh();

File Available Here Cheers, Mike