[E-Dev-Day-US-2015][9/9] High Level Application Development with Elua (Daniel Kolesa) at Enlightenment Developers Day North America 2015 https://phab.enlightenment.org/w/events/enlightenment_developer_day_us_2015/

1. High Level Application Development
with Elua
... or what happens when C sucks too much
Daniel Kolesa
Samsung Open Source Group
d.kolesa@samsung.com
@octaforge
EFL Developer Day US 2015

2. The Problem
What are we dealing with?

3. Overview

4. Overview
Sick and tired of writing apps in C

5. Overview
Sick and tired of writing apps in C
There has to be a better way

6. Overview
Sick and tired of writing apps in C
There has to be a better way
Scripting languages?

7. Overview
Sick and tired of writing apps in C
There has to be a better way
Scripting languages?
They mostly suck

8. Why do most scripting languages suck?

9. Why do most scripting languages suck?
Slow

10. Why do most scripting languages suck?
Slow
Lack of a proper type system

11. Why do most scripting languages suck?
Slow
Lack of a proper type system
Tons of useless bloat we don’t need

12. Why do most scripting languages suck?
Slow
Lack of a proper type system
Tons of useless bloat we don’t need
Inherently sucky to bind

13. Why do most scripting languages suck?
Slow
Lack of a proper type system
Tons of useless bloat we don’t need
Inherently sucky to bind
Resource heavy

14. Why do most scripting languages suck?
Slow
Lack of a proper type system
Tons of useless bloat we don’t need
Inherently sucky to bind
Resource heavy
Battery eating

15. Why do most scripting languages suck?
Slow
Lack of a proper type system
Tons of useless bloat we don’t need
Inherently sucky to bind
Resource heavy
Battery eating
Let’s still give them a shot

16. Scripting language overview

17. Python

18. Python
An obvious choice at first

19. Python
An obvious choice at first
Tons of problems

20. Python
An obvious choice at first
Tons of problems
Slooooow

21. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated

22. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated
No decent unified API

23. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed

24. Python
An obvious choice at first
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed
Language design issues

25. Ruby

26. Ruby
A not so obvious choice

27. Ruby
A not so obvious choice
Tons of problems

28. Ruby
A not so obvious choice
Tons of problems
Slooooow

29. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated

30. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated
No decent unified API

31. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed

32. Ruby
A not so obvious choice
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to embed
Language design issues

33. Perl

34. Perl
You serious?

35. Perl
You serious?
Tons of problems

36. Perl
You serious?
Tons of problems
Slooooow

37. Perl
You serious?
Tons of problems
Slooooow
Bloated

38. Perl
You serious?
Tons of problems
Slooooow
Bloated
No decent unified API

39. Perl
You serious?
Tons of problems
Slooooow
Bloated
No decent unified API
Hard to... ok, that’s enough, see the pattern?

40. JavaScript

41. JavaScript
Popular these days

42. JavaScript
Popular these days
Fairly decent quality JIT implementations

43. JavaScript
Popular these days
Fairly decent quality JIT implementations
Weird APIs

44. JavaScript
Popular these days
Fairly decent quality JIT implementations
Weird APIs
Language is pretty bad

45. JavaScript
Popular these days
Fairly decent quality JIT implementations
Weird APIs
Language is pretty bad
But probably a better choice than the above

46. Io, Self, Squirrel etc.

47. Io, Self, Squirrel etc.
Many different choices

48. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters

49. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent-ish languages

50. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent-ish languages
Mostly fairly light on resources

51. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent-ish languages
Mostly fairly light on resources
Not good enough

52. Io, Self, Squirrel etc.
Many different choices
Mostly slow interpreters
Some are decent-ish languages
Mostly fairly light on resources
Not good enough
People would look at us weird

53. Lua

54. Lua
A popular scripting language

55. Lua
A popular scripting language
Fairly good language with a few quirks

56. Lua
A popular scripting language
Fairly good language with a few quirks
Light on resources

57. Lua
A popular scripting language
Fairly good language with a few quirks
Light on resources
Great embedding API

58. Lua
A popular scripting language
Fairly good language with a few quirks
Light on resources
Great embedding API
Interpreted... :(

59. Lua
A popular scripting language
Fairly good language with a few quirks
Light on resources
Great embedding API
Interpreted... :(
LuaJIT saves the day

60. Why is LuaJIT awesome?

61. Why is LuaJIT awesome?
One of the fastest JIT compilers around

62. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources

63. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios

64. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!

65. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!
API and ABI compatible with Lua 5.1

66. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!
API and ABI compatible with Lua 5.1
Portable bytecode

67. Why is LuaJIT awesome?
One of the fastest JIT compilers around
Very light on resources
Performance close to C for real world scenarios
The exact same API as Lua!
API and ABI compatible with Lua 5.1
Portable bytecode
We have a winner

68. Why LuaJIT sucks

69. Why LuaJIT sucks
VM written in assembly - only a handful of architectures

70. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough

71. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed

72. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed
A handful of other things not JITed

73. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed
A handful of other things not JITed
No multithreading support

74. Why LuaJIT sucks
VM written in assembly - only a handful of architectures
OTOH, it’s good enough
Classic Lua C API is not JITed
A handful of other things not JITed
No multithreading support
LuaJIT 2.1 significantly improves the situation

75. Elua

76. What is it?

77. What is it?
An application runtime

78. What is it?
An application runtime
Ships with the EFL

79. What is it?
An application runtime
Ships with the EFL
Lightweight

80. What is it?
An application runtime
Ships with the EFL
Lightweight
Reusable

81. What is it supposed to achieve?

82. What is it supposed to achieve?
Rapid application development

83. What is it supposed to achieve?
Rapid application development
Clean, high level code

84. What is it supposed to achieve?
Rapid application development
Clean, high level code
Lightweight, good performance

85. What is it supposed to achieve?
Rapid application development
Clean, high level code
Lightweight, good performance
Easier app distribution (app store model)

86. What is it supposed to achieve?
Rapid application development
Clean, high level code
Lightweight, good performance
Easier app distribution (app store model)
More safety (memory etc.)

87. How does it work?

88. How does it work?
Elua library and binary

89. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state

90. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state
Binary is a minimal application launcher

91. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state
Binary is a minimal application launcher
Together they set up Lua state + ecore main loop

92. How does it work?
Elua library and binary
Library provides Elua-related C utilities for the Lua state
Binary is a minimal application launcher
Together they set up Lua state + ecore main loop
Most of Elua is written in Lua itself

93. Bindings

94. Bindings
Any decent application runtime needs APIs

95. Bindings
Any decent application runtime needs APIs
Writing bindings is a pain in the ass

96. Bindings
Any decent application runtime needs APIs
Writing bindings is a pain in the ass
Maintaining bindings is a bigger pain in the ass

97. Bindings
Any decent application runtime needs APIs
Writing bindings is a pain in the ass
Maintaining bindings is a bigger pain in the ass
What do?

98. Eolian

99. Eolian
Eolian parses our API definitions

100. Eolian
Eolian parses our API definitions
We can reuse Eolian data to generate correct Lua bindings

101. Eolian
Eolian parses our API definitions
We can reuse Eolian data to generate correct Lua bindings
No maintenance burden except the generator itself

102. Lualian

103. Lualian
Lualian is the Elua binding generator

104. Lualian
Lualian is the Elua binding generator
Itself a Lua application powered by Elua

105. Lualian
Lualian is the Elua binding generator
Itself a Lua application powered by Elua
Easy to maintain and high level

106. Lualian
Lualian is the Elua binding generator
Itself a Lua application powered by Elua
Easy to maintain and high level
Bindings generated at EFL build time

107. How do our bindings work?

108. How do our bindings work?
LuaJIT provides a FFI interface

109. How do our bindings work?
LuaJIT provides a FFI interface
This allows us to directly access C APIs

110. How do our bindings work?
LuaJIT provides a FFI interface
This allows us to directly access C APIs
Lualian generates a FFI-powered binding layer

111. Eo

112. Eo
We have a Lua Eo layer

113. Eo
We have a Lua Eo layer
This provides a native-feeling Eo Lua core

114. Eo
We have a Lua Eo layer
This provides a native-feeling Eo Lua core
Handles callbacks, method resolution and other things

115. Eo
We have a Lua Eo layer
This provides a native-feeling Eo Lua core
Handles callbacks, method resolution and other things
Generated bindings properly register bound classes with this

116. Eo
We have a Lua Eo layer
This provides a native-feeling Eo Lua core
Handles callbacks, method resolution and other things
Generated bindings properly register bound classes with this
Native-feeling APIs!

117. Other Elua APIs

118. Other Elua APIs
Elua also provides a collection of Lua utilities

119. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system

120. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components

121. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components
Used by bindings

122. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components
Used by bindings
Eo interacts with our Lua-side object system

123. Other Elua APIs
Elua also provides a collection of Lua utilities
This includes a Lua-side object system
Also bindings to most relevant Eina components
Used by bindings
Eo interacts with our Lua-side object system
Completely transparent

124. Distribution

125. Distribution
Bundled with EFL → always available

126. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps

127. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps

128. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps
Closely matching EFL APIs → free documentation

129. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps
Closely matching EFL APIs → free documentation
Needs self-contained package format (use eet?)

130. Distribution
Bundled with EFL → always available
App store to promote development and distribution of apps
Well supported - encouraging people to write apps
Closely matching EFL APIs → free documentation
Needs self-contained package format (use eet?)
Make it possible to run Elua apps on Tizen?

131. Status

132. Where are we?

133. Where are we?
Working, solid base

134. Where are we?
Working, solid base
Binding generator needs some work

135. Where are we?
Working, solid base
Binding generator needs some work
Elua library needs a lot of work

136. Where are we?
Working, solid base
Binding generator needs some work
Elua library needs a lot of work
EFL interfaces

137. EFL interfaces

138. EFL interfaces
A linked project

139. EFL interfaces
A linked project
Design and implement EFL 2.0 APIs

140. EFL interfaces
A linked project
Design and implement EFL 2.0 APIs
Eo based

141. EFL interfaces
A linked project
Design and implement EFL 2.0 APIs
Eo based
Why is this relevant to bindings?

142. Eo files

143. Eo files
Our current Eo files are not complete

144. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.

145. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.
Complete Eo files → validation is possible

146. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.
Complete Eo files → validation is possible
Guaranteed definitions for types etc.

147. Eo files
Our current Eo files are not complete
Missing enum definitions, structs etc.
Complete Eo files → validation is possible
Guaranteed definitions for types etc.
Allows for proper binding generation

148. What does this all mean?

149. What does this all mean?
Our bindings are currently not fully functional

150. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions

151. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions
Dependencies are not correctly handled

152. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions
Dependencies are not correctly handled
Elementary is not handled at all

153. What does this all mean?
Our bindings are currently not fully functional
Many will fail to load because of missing type definitions
Dependencies are not correctly handled
Elementary is not handled at all
Our demos work with what we have + manually adjusted
bindings

154. Other issues

155. Other issues
Internationalization and localization

156. Other issues
Internationalization and localization
Loading files from VFS/Eet and seamless API for that

157. Other issues
Internationalization and localization
Loading files from VFS/Eet and seamless API for that
Sandboxing

158. Other issues
Internationalization and localization
Loading files from VFS/Eet and seamless API for that
Sandboxing
Startup time minimization

159. Other issues
Internationalization and localization
Loading files from VFS/Eet and seamless API for that
Sandboxing
Startup time minimization
Portable bytecode loading

160. Roadmap

161. EFL 1.14

162. EFL 1.14
Steady progress on Eo files

163. EFL 1.14
Steady progress on Eo files
Basic interfaces done

164. EFL 1.14
Steady progress on Eo files
Basic interfaces done
Design issues resolved

165. EFL 1.15

166. EFL 1.15
Correctly working bindings without manual modifications

167. EFL 1.15
Correctly working bindings without manual modifications
Maybe just wishful thinking

168. EFL 1.15
Correctly working bindings without manual modifications
Maybe just wishful thinking
Gotta get as close as possible

169. EFL 1.15
Correctly working bindings without manual modifications
Maybe just wishful thinking
Gotta get as close as possible
EFL interfaces should be mostly designed

170. EFL 1.15
Correctly working bindings without manual modifications
Maybe just wishful thinking
Gotta get as close as possible
EFL interfaces should be mostly designed
Properly validating Eo files

171. EFL 1.16

172. EFL 1.16
Initial proof-of-concept implementation of Bob

173. EFL 1.16
Initial proof-of-concept implementation of Bob
Further stabilized Lua bindings

174. EFL 1.16
Initial proof-of-concept implementation of Bob
Further stabilized Lua bindings
Eoifying further EFL libraries

175. EFL 1.16
Initial proof-of-concept implementation of Bob
Further stabilized Lua bindings
Eoifying further EFL libraries
Production-ready bindings

176. EFL 1.17

177. EFL 1.17
Further Bob work

178. EFL 1.17
Further Bob work
Bob should start matching Edje in functionality

179. EFL 1.17
Further Bob work
Bob should start matching Edje in functionality
Deprecation of non-luajit EFL builds

180. EFL 1.17
Further Bob work
Bob should start matching Edje in functionality
Deprecation of non-luajit EFL builds
Wider testing of Elua/Bob

181. EFL 1.17
Further Bob work
Bob should start matching Edje in functionality
Deprecation of non-luajit EFL builds
Wider testing of Elua/Bob
Initial Elua based applications!

182. EFL 2.0

183. EFL 2.0
Will take a while (several 1.x releases before that)

184. EFL 2.0
Will take a while (several 1.x releases before that)
Things have to be rock solid by then

185. EFL 2.0
Will take a while (several 1.x releases before that)
Things have to be rock solid by then
A lot of work

186. EFL 2.0
Will take a while (several 1.x releases before that)
Things have to be rock solid by then
A lot of work
Bob will be a thing

187. EFL 2.0
Will take a while (several 1.x releases before that)
Things have to be rock solid by then
A lot of work
Bob will be a thing
Deprecation of Edje

188. Code breakdown

189. Entry point

190. Entry point
Everything starts in the Elua launcher

191. Entry point
Everything starts in the Elua launcher
Lua state gets initialized

192. Entry point
Everything starts in the Elua launcher
Lua state gets initialized
Elua supports application lookup path

193. Entry point
Everything starts in the Elua launcher
Lua state gets initialized
Elua supports application lookup path
Apps get executed

194. Entry point
Everything starts in the Elua launcher
Lua state gets initialized
Elua supports application lookup path
Apps get executed
Ecore main loop is started

195. Module system

196. Module system
Elua provides a custom module system that works outside of
Lua’s

197. Module system
Elua provides a custom module system that works outside of
Lua’s
Seamless (replaces require)

198. Module system
Elua provides a custom module system that works outside of
Lua’s
Seamless (replaces require)
Modules support init/shutdown callbacks

199. Module system
Elua provides a custom module system that works outside of
Lua’s
Seamless (replaces require)
Modules support init/shutdown callbacks
Those take care of opening and closing the appropriate libs

200. Library system

201. Library system
C libraries are opened and initialized as necessary

202. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted

203. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted
Eolian-generated bindings use this

204. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted
Eolian-generated bindings use this
Symbols are retrieved and bound using C FFI

205. Library system
C libraries are opened and initialized as necessary
Opened C libraries are cached and reference counted
Eolian-generated bindings use this
Symbols are retrieved and bound using C FFI
This is wrapped in high level API (no FFI exposed to apps)

206. Eina bindings

207. Eina bindings
Elua provides hand-bound APIs from Eina

208. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only

209. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only
Provides APIs to convert them to Lua values

210. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only
Provides APIs to convert them to Lua values
Various modules like accessor, iterator, list, log, file etc.

211. Eina bindings
Elua provides hand-bound APIs from Eina
Containers are read only
Provides APIs to convert them to Lua values
Various modules like accessor, iterator, list, log, file etc.
Will be further expanded as necessary

212. Other modules

213. Other modules
Elua includes a benchmarking module in core

214. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser

215. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser
Lualian is included

216. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser
Lualian is included
A custom module system implementation

217. Other modules
Elua includes a benchmarking module in core
Also features a powerful command line argument parser
Lualian is included
A custom module system implementation
Util module provides an object system, library system, string
buffer implementation and other utils

218. Conclusion

219. Conclusion
Still largely incomplete

220. Conclusion
Still largely incomplete
Getting there

221. Conclusion
Still largely incomplete
Getting there
Eo files need work

222. Conclusion
Still largely incomplete
Getting there
Eo files need work
Eolian validator needs to be fully enabled

223. Conclusion
Still largely incomplete
Getting there
Eo files need work
Eolian validator needs to be fully enabled
Lua APIs need plenty of work

224. Thank you.
Daniel Kolesa
Samsung Open Source Group
d.kolesa@samsung.com
@octaforge
EFL Developer Day US 2015