The future of Alloy and open source development at Appcelerator

1. 2.0
Leaner & Meaner

2. #HappyMothersDayFromTiConf

3. Text
Tony Lukasavage
@tonylukasavage
tlukasavage@appcelerator.com

4. MVC framework for
Titanium
Declarative UI via XML
Styling via TSS
Models & data bindings
Widgets
Embeds best practices and high performance
techniques aimed at delivering the most stable,
high quality Titaniums apps possible.

5. 3 types of people
Those who love Alloy
Those who have never used
Alloy
Those who have founded
Apperson Labs

6. Why Alloy Works
Community-driven effort
Feedback loop
Iterations & experience
Features based on need

7. How can we do better?
Vision & Transparency
Road map
Ownership

8. app development
Features, best practices, and stability
“If builders built buildings like programmers
wrote programs, then the first woodpecker
that came along would destroy civilization.”
— Gerald Weinberg

9. Write Once Mode

10. Parity Mode
Aims for a higher degree of a write once, run
anywhere experience
Parity where parity matters, but still provide native
experience
Large, integrated effort
Intelligently creating new normalized APIs

11. XML Templating

12. view modules
Same views you know and love
Compiled to separate modules
Promotes reuse and export
Possible to generate entirely new syntax
(i.e., hyperloop)

13. Titanium
iOS
Windows

14. How do you export your own controller definition?
How can you do true prototype inheritance on controllers?
How do you create a controller-specific model in code and
use it with view-model binding?
How do I get arguments in my controller without this hideous
syntax: var args = arguments[0] || {};
How do you skip time-consuming AST parsing on controllers
that don’t need it?
Controller Trivia

15. How do we solve all of that
with one fundamental
change?

16. Pure JS controllers

17. TSS.. more or LESS
Alternates forms of style syntax?
What about something like LESS?
Improvements to the core of TSS, driven by
external TSS pre-processor development

18. data models
Simpler and more focused
No more masking Backbone
Expose a programmatic interface for view-
model binding
Faster, more intelligent data binding

19. Existing format
exports.definition?
What happens to it?
Why separate
definition from models
and collections?
extendModel &
extendCollection…
WAT?!

20. Hey look, Backbone!
Use Backbone
conventions
Simpler, pure
CommonJS format
Unnecessary Cruft

21. nested collections
Very specific use cases: TableView & ListView
Efficiency and convention

22. bidirectional binding
Very specific use cases: TextField & TextArea
Convenience where it makes sense.

23. dev experience
faster, happier development
“I love it when a plan comes together”
— John “Hannibal” Smith

24. local installs
Have as many non-conflicting alloy installs as you
want.
Can be global or per-project
Allows you to take Alloy updates on a needed basis,
just like Titanium.
Alloy as a dependency

25. export widgets
Widgets in traditional Titanium apps
Fully functional
Native or plain CommonJS modules

26. scaffolding
robust generators for widgets, builtins, adapters,
commands, and generic commonjs modules
Configurable to your environment
Not just code structure, but ready for distribution

27. ridiculously fast compiles
No builtins
Pure JS controllers to handle inheritance
Separation between controller and views
There’s full runtime version of the Alloy library

28. No more AST parsing!!!
100x speed up with Alloy compiles
Leave the AST parsing to optional
pre-processors
LiveView, TiShadow, and RapidDev
just got extremely more powerful

29. parallel compiles
Android Blackberry iOS MobileWeb
$
alloy
compile
—platform
all

30. rock solid
with metrics
!
“What’s measured improves”
— Peter F. Drucker

31. unit testing

32. Travis CI for continuous
integration
Covers master, branches, and
even pull requests

33. test coverage

34. ti-mocha

35. contributing
made easy
“In open source… to really do
something well, you have to
get a lot of people involved.”
— Linus Torvalds

36. npm
70K+ modules, 1/4 billion downloads a month
distribution for all widgets, “builtins”, adapters,
commands, and anything we come up with.
It’ll just work with Ti.Next
require() will work like node.js
ti-commonjs in the meantime

37. ti-commonjs
Library and CLI hook that provides a node.js-style
commonjs implementation to ti.current
Using npm for package management just works
Initially supported on android and ios
Initially alloy, but could work for traditional titanium

38. VS
Undo incremental
growth and expansion
of repo
grok-ability
Externalize non-
essential modules
widgets
“builtins”
tools

39. git-style subcommands
Add arbitrary commands that can make use of Alloy
configuration data
Extensibility allowing for out-of-band contributions

40. module API
!
Use Alloy as a node.js module, not just a CLI
No more expensive, unreliable sub-processing
natural progression with git-style subcommands

41. get on board
migrating to the awesomeness
“If you want to make enemies,
try to change something.”
— Woodrow Wilson

42. 1.X -> 2.0
Migration will be a driving force behind the new features,
not an afterthought.
Old formats will be deprecated, but most will still work
New controllers, views, models, styles, widgets, and even
builtins will be able to be migrated through an
automation script.
You could very well be porting to 2.0 with no manual
intervention

43. wrap-up

44. try to keep up
http://bit.ly/alloy_2

45. Special Thanks
Fokke
Zandbergen
Mads Moller
Aaron
Saunders
Paul Egli
David Bankier
Tim Poulsen