dependency injection, notifications, type safe commands and actionscript gripes

1. Dawn
standing on the shoulders of giants

2. What is Dawn
• Dependency Injection library inspired by
Google Guice
• Notification system based on types
• Simple type safe command pattern

3. Why?
• Unhappy with my options
• Small issues that have large consequences
• Flash and Flex
• Small (~12K)
• A new breed of project

4. What its not
• MVC, MVP ... you structure your app
• Plugin architecture
• Aiming to take over the world

5. Some Design Principles
• Testing is vital
• Play to language strengths
• Type safety is winfull
• Configuration is no fun (keep it DRY)
• Static state is bad
• Types are better than strings

6. Dependency Injection
a lot of fuss about nothing

7. TheDoctor

8. TheDoctor
Tardis

9. TheDoctor
Assistant Tardis

10. TheDoctor
Assistant Tardis Mission

11. TheDoctor
IAssistant Tardis IMission

12. TheDoctor
IAssistant Tardis IMission
RoseTyler
DonnaNoble

13. TheDoctor
IAssistant Tardis IMission
RoseTyler Cybermen
DonnaNoble Daleks

14. Object graph of
TheDoctor
TheDoctor
IAssistant Tardis IMission
RoseTyler Cybermen
DonnaNoble Daleks

15. Creating The Doctor
• Construct dependencies within the class
• Service locator
• Factories
• DI By hand

16. Doing it by hand
class TheDoctor{
public var mission:IMission;
public var assistant:IAssistant;
public var tardis:Tardis;
}

17. Doing it by hand
var doctor:TheDoctor = new TheDoctor();

18. Doing it by hand
var tardis:Tardis = new Tardis();
var doctor:TheDoctor = new TheDoctor();
doctor.tardis = tardis;

19. Doing it by hand
var assistant:IAssistant = new RoseTyler();
var tardis:Tardis = new Tardis();
var doctor:TheDoctor = new TheDoctor();
doctor.tardis = tardis;
doctor.assistant = assistant;

20. Doing it by hand
var mission:IMission = new Daleks();
var assistant:IAssistant = new RoseTyler();
var tardis:Tardis = new Tardis();
var doctor:TheDoctor = new TheDoctor();
doctor.tardis = tardis;
doctor.assistant = assistant;
doctor.mission = mission;

21. Doing it by hand
• Thats a lot of code to create a Doctor
• More code to maintain
• Fragile to change
• Client of TheDoctor must know inner workings
(encapsulation fail)
• Construction followed simple patterns

22. Dependency Injection
is all about creating
object graphs!

23. Dawn DI
• How can object creation be automated and easy?
• Meets design principles
• Thank you Google Guice!

24. Configure the Doctor

25. Configure the Doctor
1. Indicate the dependencies

26. Configure the Doctor
1. Indicate the dependencies
2. Chose an assistant

27. Configure the Doctor
1. Indicate the dependencies
2. Chose an assistant
3. Chose a mission

28. Configure the Doctor
class TheDoctor{
public var mission:IMission;
public var assistant:IAssistant;
public var tardis:Tardis;
}

29. Configure the Doctor
class TheDoctor{
[Inject] public var mission:IMission;
[Inject] public var assistant:IAssistant;
[Inject] public var tardis:Tardis;
}

30. Configure the Doctor
class Config implements IConfig{
public function create(mapper:IMapper):void{
mapper.map(IAssistant).toClass(RoseTyler);
mapper.map(IMission).toClass(Daleks);
}
}

31. Create the Doc
var mission:IMission = new Daleks();
var assistant:IAssistant = new RoseTyler();
var tardis:Tardis = new Tardis();
var doctor:TheDoctor = new TheDoctor();
doctor.tardis = tardis;
doctor.assistant = assistant;
doctor.mission = mission;

32. Create the Doc

33. Create the Doc
builder.getObject(TheDoctor)

34. Create the Doc
var doctor:TheDoctor;
var builder:IBuilder = new Builder(new Config());
doctor = builder.getObject(TheDoctor) as TheDoctor;

35. Dawn DI
• You write less code (no XML)
• Configuration is ActionScript (and small)
• Classes are compiled into final swf
• Agile code, refactor structure fast and easily
• Testing is easy, second nature
• DI helps you write better code!
• Dawn makes DI easy!

36. Dawn DI
• Scopes - Singleton or Transient
• Map toFactory/toInstance for construction control
• Modular configuration
• Name injections
• Inject properties like strings or arrays
• Optional injections
• Inject via mutators or properties

37. FP-183

38. [Inject] Dawn DI
• Simple
• Light
• Type safe
• Test friendly
• Terse

39. Notifications
decoupling without the compromise

40. Dawn Notifications
• Type based
• Closure friendly
• Static free

41. The Problem

42. The Problem
View
View
View
View

43. The Problem
View
View
Data
View
View

44. The Problem
View
View
Data
Data
View
View

45. The Problem
View
View
Data
Data
Data
View
View

46. The Problem
View
View
Data
Data
Data
Data
View
View

47. The Problem
View
View
Data
Data
Data
Data
View
View

48. The Problem
View
View
Data
Data
Data
Data
View
View

49. The Problem
View
View
Data
Data
Data
Data
View
View

50. The Problem
View
View
Data
Data
Data
Data
View
View

51. The Problem
View
View
Data
Data
Data
Data
View
View

52. The Problem
View
View
Data
Data
Data
Data
View
View

53. The Problem
View
View
Data
Data
Data
Data
View
View

54. The Problem
View
View
Data
Data
Data
Data
View
View

55. The Problem
View
View
Data
Data
Data
Data
View
View

56. The Problem
Gets a little confusing?
View
View
Data
Data
Data
Data
View
View

57. Decouple and Scale

58. Decouple and Scale
View
View
View
View

59. Decouple and Scale
View
View
Data
Data
Data
Data
View
View

60. Decouple and Scale
Notification System
View
View
Data
Data
Data
Data
View
View

61. Decouple and Scale
Notification System
View
View
Data
Data
Data
Data
View
View

62. Decouple and Scale
Notification System
View
View
Data
Data
Data
Data
View
View

63. Type based

64. Type based
addEventListener(type:String,closure:Function...)

65. Type based
addEventListener(type:String,closure:Function...)
addCallback(type:Class,closure:Function);

66. Why Types

67. Why Types
• Make full use of polymorphism
IEventType, BaseRpcEvent, com.wibble.Woo

68. Why Types
• Make full use of polymorphism
IEventType, BaseRpcEvent, com.wibble.Woo
• Avoids meaningless statics
FinishedBaconEvent.FINISHED_BACON

69. Why Types
• Make full use of polymorphism
IEventType, BaseRpcEvent, com.wibble.Woo
• Avoids meaningless statics
FinishedBaconEvent.FINISHED_BACON
• No hidden collisions
MyEvent.CLOSE == Event.CLOSE == FAIL

70. Why Types
• Make full use of polymorphism
IEventType, BaseRpcEvent, com.wibble.Woo
• Avoids meaningless statics
FinishedBaconEvent.FINISHED_BACON
• No hidden collisions
MyEvent.CLOSE == Event.CLOSE == FAIL
• No switch statements
switch( notification.getName() )

71. Closure unfriendly
addEventListener(Event.ADDED,
function(event:Event):void{
trace(“haha, Try removing me”)
});

72. Closure friendly!

73. Closure friendly!
var listener:IListenerRegistration =
bus.addCallback(ILogAction,
function(note:ILogAction):void{
}
);

74. Closure friendly!
var listener:IListenerRegistration =
bus.addCallback(ILogAction,
function(note:ILogAction):void{
}
);
listener.remove();

75. Triggering
class TadPole{
[Inject] public var bus:INotificationBus;
[DependenciesInjected]
public function init():void{
bus.trigger(new TadPoleCreated());
}
}

76. Dawn Notifications
• Simple API
• Use the language, closures are good!
• Types are smarter then strings (Duh!)
• Reduce the complexity of application structure

77. Commands
simple tools are easy to build with

78. Commands
• easy to maintain stateless goodies
• central point for lots of easy wins
• queueing
• cacheing
• handle errors
• etc etc.

79. Commands
• ICommand interfaces force casting
• execute(param:Object):void
• How to access other application objects
• Model.getInstance();
• Mapping Strings to Commands is fiddly
(more developer discipline)
• registerCommand(Notify.GET_THING, GetThingCommand);

80. Dawn Commands
• Injectable
• Type safe
• Type based DRY configuration

81. Dawn Commands
class MakeHayCommand{
[Inject] public var barn:Barn;
[Execute] public function execute(note:MakeHay):void{
barn.makeHay(note.howMuchHay);
}
}

82. Dawn Commands
class MakeHayCommand{
[Inject] public var barn:Barn;
[Execute] public function execute(note:MakeHay):void{
barn.makeHay(note.howMuchHay);
}
}

83. Dawn Commands
class MakeHayCommand{
[Inject] public var barn:Barn;
[Execute] public function execute(note:MakeHay):void{
barn.makeHay(note.howMuchHay);
}
}

84. Dawn Commands
class MakeHayCommand{
[Inject] public var barn:Barn;
[Execute] public function execute(note:MakeHay):void{
barn.makeHay(note.howMuchHay);
}
}

85. Dawn Commands
addCommand(MakeHayCommand);

86. Dawn
• Dependency Injection
• Notifications
• Commands

88. http://github.com/
sammyt/dawn

89. Questions etc?