Is Flash Dead?

That’s the question everybody is asking. As a company specialising in complex Flash and Flex applications, the death of Flash would of course be a major blow! At the centre of our industry however, the picture looks very different. The market is extremely buoyant, demand is as high as ever and good developers are hard to find.

So what is really going on? The surge to replace Flash is taking place under the banner of open standards but the extreme positions of various parties suggest that there are different motivations at play. Flash has been tremendously successful for over a decade and I see current events as the natural rhythm of development styles, power games and business interests.

Why is HTML5 significant?

HTML5 may not yet be ready for mass-market consumer deployment but the mobile arena is very different. On devices guaranteed to have compatible browsers, HTML5 is a life-saver. And not because it replaces Flash but because it replaces the need to develop mobile apps for different platforms. While HTML is accessible to many, Objective-C and Java are a different kettle of fish.

So perhaps we should be asking “Is HTML5 going to be the death of mobile apps?”. Less likely when you see who is holding the purse strings… But it is in mobile that the main focus will remain and in mobile that key developments and innovation in HTML5 will occur.

What should I learn next?

For individuals, it’s very straightforward: First, pick an area that you enjoy. If you create fantastic animations at night, there is no point in working in a cubicle during the daytime. Second, focus on core skills. Learn your craft. Solid foundations and a deep understanding will always be sought after and can be transferred to other industry branches very quickly.

For companies, my advice would sound a little different. Identify the core technologies that your business will require over the next year. Now is the time to start training your in-house team, for example in HTML5. Stay slightly ahead of the curve at all times. It keeps your staff happy but can also save you money because you’re not forced to rely on expensive freelancers due to lack of in-house skills.

Also bear in mind that everybody learns differently – we offer external or in-house training courses for example but also supplement that with written and video tutorials (some available for free on our blog and YouTube) and this mix of training techniques seems to work well.

We run a range of Actionscript and HTML5 training courses:

Our next course is:

HTML5 – The definitive Course- 20th/21st September.

Book now on :  training@dndigital.net or http://html5-september.eventbrite.com/

Price: £399 (student price £198)

Location: London/Shoreditch

Hello: 020 7749 3770

Who is the course for? http://dndigital.net/training/html5/

What can you expect? http://dndigital.net/training/html5/

WE KNOW WHAT YOU NEED.

Check out our new video for HTML 5 at: http://www.youtube.com/watch?v=hhTQPcqLWTI

You can find all our free video tutorials on our YouTube Channel. Feel free to subscribe to keep up-to-date with our future video releases!

http://www.youtube.com/DNDigital

Feel free to ask questions, leave comments or request further material.

Enjoy!

We’ve had a really successful summer, especially with our latest Advanced Actionscript 3 (OOP and design patterns) course.

Take a look at some of our feedback!

“Exactly what I had hoped for! Very pleased! Really liked the teaching style and the whole team have been very helpful, Thank you!” -  S.Perry

” Fantastic! It was great that the course was flexible to fit our skills, experience and needs. Relaxed fun environment with open frank discussions.” – R.Oliver

“A very good course. I would thoroughly recommend it.” – S.Hamilton

We would love for you to join us on our next upcoming course:

HTML 5 – The Definitive Course 20th & 21st September 2010

Book now on : training@dndigital.net or http://html5-september.eventbrite.com

Or call: 020 7749 3770

For everything you need to know about the course just visit: http://dndigital.net/training/html5/

Just a quick update to let you all know that we are now on MySpace.

Check out our new profile at:

http://www.myspace.com/547819857

Also! Make sure to keep checking our YouTube channel for more free online video tutorials!

http://www.youtube.com/dndigital

Look us up and find all the latest news and updates regarding our events, training courses and online tutorials.

Don’t forget!

You can still find all the information you need regarding our training courses at: http://dndigital.net/training/

For all our free online tutorials just visit our YouTube Channel: http://www.youtube.com/dndigital

We are running our new Advanced Actionscript 3 (Object Oriented Programming and Design Patterns) on the 25th, 26th and 27th August 2010.

Who is the course for?

This course requires an intermediate to advanced knowledge of Actionscript 3. You should be comfortable writing and using your own custom classes, working with events (eg. addEventListener, removeEventListener, custom events) and working with the display list (eg. addChild, Sprite).

Although the course is based on Flash using an external code editor, it is also suitable for Flex developers.

Price: £420 incl VAT (student discount available)

For full details of the course please visit: http://dndigital.net/training/advanced-as3-oop-patterns/

Book directly at: http://advanc3-london-aug2010.eventbrite.com/

or call us on: 020 7749 3770 or email training@dndigital.net

We hope to see you there!

We have a new HTML5 course running on the 20th & 21st September 2010.

Who is the course for?

The course is aimed at web designers and web developers with a good understanding of HTML and CSS. A working knowledge of Javascript is useful for some parts of the course but not essential.

Price: £399 ( Students discount £198).

For all the information you need regarding the HTML5 course simply visit: http://dndigital.net/training/html5/

Book directly on :  http://html5-september.eventbrite.com or call us on : 020 7749 3770 or training@dndigital.net

We look forward to seeing you there!

We are running a course on the 18-19th August 2010 and only have a few places left.

Only £399 ( Students discount £198) incl. VAT.
Who is the course for?

The course is aimed at web designers and web developers with a good understanding of HTML and CSS. A working knowledge of Javascript is useful for some parts of the course but not essential.

You can find out more about the HTML5 course at: http://dndigital.net/training/html5/

Book directly on : http://dndigital.net/training/puremvc-introduction/ or call us on : 020 7749 3770 or training@dndigital.net

Don’t forget we also have free online tutorials! Just visit  http://www.youtube.com/dndigital

There are four positions open at the moment:

• Front end web developer (HTML, CSS, Javascript, WordPress, etc)
• Actionscript developers (Actionscript, Flex, backend-development experience a bonus)
• Marketing interns (excellent written and spoken English, social-media experience, innovative marketing ideas)
• PHP developers (good PHP5, MySQL experience)

I can only really provide a brief overview here – but we’ve got full details online at enternships.com. Please read them there and then get in touch if you are interested.

This just in: I’ve just been told we’re also keen to meet talented web designers, so if you’re pretty hot with Photoshop and interactive design, please get in touch with a CV and samples of work.

I’d love to hear about your own experiences in regards to object oriented programming in AS3 – please leave a comment!

The material in this blog post and in the video is an excerpt from our Advanced Actionscript 3 (Object Oriented Programming and Design Patterns) training course.

You can watch the video and read up on the details after the break.

Making Choices

The Abstract Factory Design Pattern is all about choice. Not any kind of choice mind you – but very specifically choosing which class to instantiate given certain conditions. Whether you realise it or not, you are probably making these choices numerous times in your own programming code. Here are some examples:

• Which type of menu to display based on the admin privileges of the current user
• Which type of skin to apply to your game characters, based on the selections made at the beginning of the game – and subsequently which types of weapons are available for that character
• Which type of button graphic to use based on the size of a banner
• Which type of XML parser to use based on the type of feed the user has loaded in

and so on. Once you’re dealing with object oriented programming, most of those choices are going to result in a class being instantiated and the trick is to choose the correct class based on a set of circumstances.

No problem, right? You just whack an if-statement in there:

1
2
3
4
5

if( user.isAdmin ){
    menu = new AdminMenu();
}else{
    menu = new NormalMenu();
}

Weeds Everywhere

Of course, using if-statements will work fine, however it spreads the choices throughout your application, like a weed taking a strong-hold in your garden, then your front lawn, then your walls…you get the picture. Suppose you introduce a third user privilege level? Time to revisit all those many if-statements (of course you’ll remember where they are!). The more complex your project, the more difficult, time-consuming and error prone such a change becomes.

Factory Pattern to the Rescue

It is in these cases that the Factory Design Pattern comes to your rescue, by moving the choice into a single, isolated piece of code. The resulting class that is instantiated – the factory – will then provide the application with the correct class instances. As a result, you only need to change the single point-of-choice and create a new factory class in order to make wide-ranging changes to your entire application.

In practice, it looks something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// isolated choice code (eg. after user logs in)
if( user.isAdmin )
{
    factory = new AdminUserFactory();
}else{
    factory = new NormalUserFactory();
}
 
// and in the AdminUserFactory class:
function getMenu():Menu
{
    return new AdminMenu();
}
 
// and in the NormalUserFactory class:
function getMenu():Menu
{
    return new NormalMenu();
}
 
// much later, in a remote location in your code-tree
menu = factory.getMenu();

Can you see how you would add a third user level – and how much more manageable it has become compared to the previous example?

Let’s follow the example code through to its logical conclusion. Say we have 10 user levels. Then we’ll end up with 10 different factory classes (AdminUserFactory, NormalUserFactory, SuperUserFactory, etc). So far so good. But how does the code that is actually using the factory to retrieve the menu know how to deal with all those 10 different classes without using another if-statement? Surely that will lead to type-errors if we don’t know the exact data-type?

Interfacing with the Factory

In order to allow code throughout your application to use different factory classes, we’re going to use an interface to define what methods a factory class provides. This interface will be used as the data-type when passing the factory around to other pieces of code. So in practice it doesn’t matter which factory class is used behind the scenes and dependencies within your code are reduced to a single interface class, which is what we like to see!

Our user-menu example seems to use factory to create its user-interface elements, so let’s create an interface called IUIFactory. We start with just a single function – we can always add to it later on:

1
2
3
4

// in the IUIFactory.as file
public interface IUIFactory {
    function getMenu():Menu;
}

As a rule, you’d start with your interface first, then create your first factory class and then create your choice code – otherwise you’ll end up in a bit of a pickle.

Here is the sample code from earlier, with the interface thrown in.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// we start with an interface
var factory:IUIFactory;
if( user.isAdmin )
{
    factory = new AdminUserFactory();
}else{
    factory = new NormalUserFactory();
}
 
// and in the AdminUserFactory class - which implements IUIFactory
public function getMenu():Menu
{
    return new AdminMenu();
}
 
// and in the NormalUserFactory class - which also implements IUIFactory
public function getMenu():Menu
{
    return new NormalMenu();
}
 
// much later, in a remote location in your code-tree
var factory:IUIFactory;
menu = factory.getMenu();

Splendid.

Another beneficial side-effect of using an interface in this way comes into play when adding new features to your factory. Any new feature requires a new method in your factory interface. That new method will immediately result in compiler errors because none of your factory classes has implemented it yet. You have no option but to implement the new method in every single factory class – hence automatically making sure that your code is properly maintained.

Doesn’t that sound better than finding a long-lost if-statement deep down in the murky depths of your code-tree that your colleague forgot to change when they added a new user-group?

YouTube Tutorial and Source Code

The YouTube tutorial steps through a different example of coding a user-interface that can change depending on the age-group of the viewer.

You can download the source-code as a FlashBuilder 4 project so that you can follow the tutorial and experiment further. There are a couple of extra images in the assets folder so you can produce a third factory class. Copyright / licensing info is included in each file, all images used are publicly available via sxc.hu.

Further Thoughts – Factory Pattern and Dependency Injection

The Factory Design Pattern’s strengths come from isolating choices in a single location. Furthermore, each factory class also encapsulates a very simple set of actions – it knows how to create the correct instances but doesn’t require knowledge of the surrounding application to do so – so we are adhering to the  ’one class – one responsibility’ concept.

Of course you still need to pass the actual factory instance around to the classes that require them and there are various ways of managing these dependencies. In the YouTube tutorial, I simply pass the factory instance to the view classes via their constructor and this is a perfectly valid way of handling it.

There are of course other options – and Dependency Injection (DI) is especially helpful when working with the factory pattern.

Since DI hinges in principal around matching interface data-types to concrete classes, switching factory classes becomes a doddle. You simply specify the appropriate factory class to be used when the DI container encounters the factory interface and your project can be dramatically changed by essentially touching only a single line of code. This is especially true when there is a fixed, pre-determined choice of factory class, for example when repurposing an entire project for a different market or target audience.

I’d love to hear your own experiences of the Factory Pattern and OOP in general – leave a note in the comments below.