Code and Conquer with Globe Labs, October 27, 2012

Globe Corporate Showroom
October 27, 2012

Copyright (c) 2012 Job and Esther Technologies, Inc.

Major mobile platforms


Major platforms (mobile + desktop)


Mobile platform market shares

(IDC)


Mobile platform market shares (2015)


Technical things that must be considered

● Programming language
● APIs and libraries
● Different versions of the operating system
● User interface design
● User interface implementation
● Development tools


Programming language


Programming language

Apple iOS
Apple iOS 17% Objective C
17% Objective C

Windows Phone 20% C#
Windows Phone 20% C#

Android
Android 44% Java
44% Java

BlackBerry
BlackBerry 13% C/C++
13% C/C++


“NATIVE” vs “NON-NATIVE”

“NATIVE” is something that does not need an
interpreter

The primary language of any platform is “NATIVE” to
the platform.

All other languages on that platform are “NON-
NATIVE”.


APIs and libraries
Android iOS Windows Phone

User interface Android API Cocoa Touch / UIKit Silverlight
framework

Graphical rendering Immediate Immediate Retained
model

Networking API Standard Java Standard Posix / .NET
CFNetwork
Memory management Garbage collection Reference counting / Garbage collection
manual

Library format .jar .a / .so .dll

Web browser WebKit WebKit Internet Explorer
component


Example: Connecting a socket
IOS / Objective C

CFSocketRef socket = CFSocketCreate(NULL, PF_INET, SOCK_STREAM, IPPROTO_TCP,
kCFSocketConnectCallBack, (CFSocketCallBack)ConnectCallBack, &CTX);
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_len = sizeof(addr); addr.sin_family = AF_INET;
addr.sin_port = htons(PORT); addr.sin_addr.s_addr = INADDR_ANY;
CFDataRef connectAddr = CFDataCreate(NULL, (unsigned char *)&addr, sizeof(addr));
CFSocketConnectToAddress(socket, connectAddr, −1);

ANDROID / JAVA WINDOWS PHONE / C#

try { IPEndPoint endpoint =
InetAddress serverAddr = new IPEndPoint(ipAddress, PORT);
InetAddress.getByName(serverIpAddress); Socket socket =
Socket socket = new Socket(serverAddr, new Socket(AddressFamily.InterNetwork,
serverPort); SocketType.Stream,
} ProtocolType.Tcp);
catch (UnknownHostException e1) {
}
catch (IOException e1) {
}


Different versions of the operating system

(As of June 2012; source Chitika)


User interface design

Windows Phone Android iOS


User interface implementation
XAML (Windows Phone) Layout (Android) Storyboard (iOS)

<phone:PhoneApplicationPage <?xml version="1.0" <?xml version="1.0"
x:Class="eqela.samples.squar encoding="utf-8"?> encoding="UTF-8"
e.MainPage" <LinearLayout standalone="no"?>
xmlns="http://schemas.micros xmlns:android="http://sche <document
oft.com/winfx/2006/xaml/prese
mas.android.com/apk/res/a type="com.apple.InterfaceBu
ntation"
xmlns:x="http://schemas.micro ndroid" ilder3.CocoaTouch.Storyboa
soft.com/winfx/2006/xaml" android:layout_width="fill_p rd.XIB" version="2.0"
xmlns:phone="clr- arent" toolsVersion="2837"
namespace:Microsoft.Phone.C android:layout_height="fill_p systemVersion="12A269"
ontrols;assembly=Microsoft.Ph arent" targetRuntime="iOS.CocoaT
one" xmlns:shell="clr- android:orientation="vertical ouch"
namespace:Microsoft.Phone.S " ><TextView propertyAccessControl="non
hell;assembly=Microsoft.Phon android:id="@+id/text" e" useAutolayout="YES"
e" android:layout_width="wrap initialViewController="4">
xmlns:d="http://schemas.micro _content" <dependencies>
soft.com/expression/blend/200
8"
android:layout_height="wra <plugIn
xmlns:mc="http://schemas.ope p_content" identifier="com.apple.Interfac
nxmlformats.org/markup- android:text="Hello, I am a eBuilder.IBCocoaTouchPlugi
compatibility/2006" TextView" /><Button n" version="1921"/>
android:id="@+id/button" </dependencies>


Development tools

Microsoft Visual Studio – Windows Phone

Eclipse - Android

Apple Xcode - iOS


Bottom line

While targeting only the most popular
mobile platforms, you will need to work
with 10-20 different operating system
platforms/versions, at least 3-4
different programming languages,
each with different API libraries.


How to make this work?


The usual solution (#1)
● Only work with one operating system
“I will only make applications for Android”
●

● “I am an iOS DEVELOPER!”

● The upside:
Easy to do. You only need to learn one language and
●

API, and write your program using the matching tools.
● The downside:
● You limit the potential of your application (you cannot
reach all users).
● Your future is tied to the target platform. (Eg. If Apple
removes your app from the AppStore, it's over)

How to expand? : PORTING

● Wikipedia: “Porting is the process of adapting
software so that an executable program can be
created for a computing environment that is
different from the one on which it was originally
designed.”
● Wikipedia: “Software is portable when the cost of
porting it to a new platform is less than the cost of
writing it from scratch.”
● → Traditional native applications (Android apps,
iOS apps, etc.) are not portable.


The usual solution (#2)
● Make several versions of your program, one for each
platform
● Write the same program multiple times; first in Java, then Objective-
C, then C# (often called “porting”)
● The upside:
● You will not limit the potential of your application, as you can now
reach all your users.
● The downside:
● Massive amount of work in rewriting the same program over and
over again. Very expensive if done professionally. Also not very
rewarding for a programmer (doing the same work repeatedly).
● You end up with multiple codebases of the same program. Very
tedious to maintain and develop further.


The third way:

CROSS PLATFORM DEVELOPMENT


Cross platform development
● Producing portable applications for multiple platforms
using a single codebase
● Write a program only once, but use it on several platforms
● Depending on the cross platform development
method, the applications may be native (not requiring
interpretation) or non-native (interpreted in some
manner)
● Especially the non-native approach has issues in
performance, memory use and application size,
which has caused many to abandon even the idea of
cross platform development.


The Eqela video

http://www.youtube.com/watch?v=WcWf7SXGBv0


Our solution: EQELA

● Eqela reads source code written in the
Eqela programming language / API, and
translates it to various other languages,
targeting different APIs / platforms

Eqela is .. (#1)
A modern, object oriented
programming language
● Powerful, object oriented, easy
to use, efficient to program
● Designed to fit the needs of the
different target platforms
● Part of the C syntax family
● Instantly familiar to anyone with
experience in C, C++, Java, C#,
JavaScript


A sample program
● A cross-platform graphical “Hello world” application:

class Main : LayerWidget
{
public void initialize() {
base.initialize();
add(LabelWidget.instance().set_text(“Hello World”));
}
}

● Works exactly the same way on all supported
operating systems / devices


Eqela is .. (#2)
An advanced compiler /
programming language translator
● Converts a source programming
language (Eqela) to other
programming languages (Java,
C#, C, JavaScript, ..)
● Generates project files / directory
structures to be used by the
development tools of the various
target platforms
● Pulls in libraries to link with the
application

Eqela is .. (#3)
A cross platform development
API
● A cross-platform API that works
across programming languages
● All common functionalities, such
as file I/O, networking,
threading, data structures, ..
● Same API on any language and
operating system


Eqela is .. (#4)
A cross platform graphical user
interface (GUI) API
● A rich set of user interface
components and controls
● The controls are available and
the GUI works across all
platforms
● Mobile devices
● Desktop
● Web / HTML5
● Develop your own controls

Some GUI components


Automatic scaling of user interfaces


Eqela is .. (#5)
A development tool / environment


How it works

Eqela C
iOS iOS
Libraries source
SDK application
code

Java
Eqela Android Android
Eqela source
Source SDK application
Compiler code
Code

Javascript Run in
code browser


How it works : Sample application
{
base.initialize();
}
}

Main.java, Android
Eqela
Main.eq LayerWidget.java,
Compiler SDK
LabelWidget.java

LayerWidget, Android
LabelWidget application


100% native

Only native code → “100% native”
No virtual machine added
No interpreter added

Main.java, Android
Eqela
Main.eq LayerWidget.java,
Compiler SDK
LabelWidget.java

LayerWidget, Android
LabelWidget application


Main.eq → Main.java
{
(EQELA)
base.initialize();
}
}

package mk.test;
public class Main extends eq.gui.LayerWidget
{
@Override
super.initialize();
((eq.gui.ContainerWidget)this).add(((eq.gui.Widget)eq.widget.LabelWidge
t.eq_widget_LabelWidget_instance().set_text(eq.api.StringStatic.eq_api_
StringStatic_for_strptr("Hello world"))));
}

public Main() {
}
} (JAVA)

Also type code in the native language

class AndroidHTTPGet
{
public static bool execute(String url) {
embed “java” {{{
org.apache.http.client.methods.HttpUriRequest hur =
new org.apache.http.client.methods.HttpGet(url.to_strptr());
android.net.http.AndroidHttpClient hc =
android.net.http.AndroidHttpClient.newInstance(“testing”);
org.apache.http.HttpResponse resp = hc.execute(hur);
if(resp == null) {
return(false);
}
}}}
return(true);
}
}
→ All platform specific features / APIs
are accessible from Eqela code

Is this the only way to do cross platform
development?


Cross platform development approach (#1)

The “scripted” approach
Unmodified
iOS iOS
Source code
SDK application
+
Interpreter /
Virtual machine
For iOS

Source code Competing Android
In a scripting Development application
language tool Unmodified
Source code
(JavaScript, +
Lua, Ruby, ..) Interpreter / Android
Virtual machine SDK
For Android
Run in
browser
(Adobe Air / Flex, Appcelerator, Mono / Unity,
Corona, RhoMobile, ..)


The “scripted approach” architecture

APIs and libraries Application code

Language interpreter / runtime

Operating system

(Adobe Air / Flex, Appcelerator, Mono / Unity,
Corona, RhoMobile, ..)


The “scripted approach” architecture

Increases memory APIs and libraries Application code Makes application
usage
Installers much bigger

Language interpreter / runtime

Applications can only
Reduces runtime Operating system Access selected
Performance Parts of the native API

Due to this approach being very popular, many consider
cross platform development to be slow, high in memory use,
and producing bigger installers. This is wrong.


The Mono / Android architecture

(Source: http://docs.xamarin.com/Android/Guides/Advanced_Topics/Architecture)


Unity (includes Mono) on Android

C++ code



The “MoSync” approach

Runtime / iOS
C++ class Proprietary Virtual application
Library / header bytecode machine
Files

Android
The GNU C application
Compiler
(GCC) Secondary
Compiler
C++ source (MoSync)
code Windows
Phone
application

Very similar to the “scripted” approach, Run in
only somewhat more complicated browser
(MoSync)



The “C++” approach
iOS
Cross
application
Plaftorm
Class library
In the specific
language
(Usually C++) BlackBerry
Playbook
SDK / application
Source code compiler
In a specific
Language
(Usually C++)
Android
application

Windows
+ Truly native (100%) Run in Phone
+ High performance browser application
- Limited platform support
(not really cross platform) (Marmalade, Qt, WxWidgets)



The “embed a web browser” approach

Run in C source code
browser Libraries
That opens a
Browser and
Displays the
program iOS iOS
SDK application
Source
Code in
HTML, CSS, “Compiler”
JavaScript Android Android
SDK application
Java source code
That opens a
Browser and
- Very poor performance Displays the
- Suitable for only “web-style” apps program
- Limited access to platform APIs
+ Easy way to convert existing websites to
“native apps” (PhoneGap)



The “source code conversion” approach

Libraries C
iOS iOS
source
SDK application
code

Java
Android Android
Source source
Compiler SDK application
Code code

+ Truly native (100%) on any platform Javascript Run in
+ High performance code browser
+ Optimized memory use
+ Small installer size
+ Unrestricted API access


Comparison : “Hello world” application

● The “scripted” approach:
● Appcelerator Titanium: 8MB
● Mono: 4MB
● The “embed a web browser” approach:
● PhoneGap: ~300KB
● The “source code conversion” approach
● Eqela: 96KB


How to learn more about Eqela?


Sign up and learn more details

● Free registration at
http://www.eqela.com/register
● Browse through the documentation,
tutorials, sample programs and
technical information


Try it out for yourself

● Once registered, try Eqela programming
at http://www.eqela.com/try
● Make short programs and compile to
different platforms
● Get familiar to the language and see
Eqela in action


Get one

● Choose any of the supported platforms
where you wish for your application to
work
● Install the Eqela compiler on your
computer; no internet connection
required
● Place your order at
http://www.eqela.com/buy


Supported platforms
PLATFORM TOOLS AVAILABLE EQELA LIVE SUBSCRIPTION
Microsoft Windows Yes Yes
Mac OS X Yes Yes
Linux Yes Yes
Igellle Yes Yes
Android Yes Yes
HTML5 / JavaScript Yes Yes
Apple iOS Yes
BlackBerry / Java Yes
BlackBerry / QNX Yes
Windows CE Yes
Windows Mobile Yes
Windows Phone Yes
Symbian OS Yes
Meego / Jolla Coming soon
Firefox OS Coming soon


Licensing cost

USD150
/ platform
/ programmer
/ year


Thank you


Code and Conquer with Globe Labs, October 27, 2012

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Code and Conquer with Globe Labs, October 27, 2012

Similaire à Code and Conquer with Globe Labs, October 27, 2012 (20)

Plus de jobandesther

Plus de jobandesther (6)

Dernier

Dernier (20)

Code and Conquer with Globe Labs, October 27, 2012