Introduction to Eqela development

Copyright © 2012 Job and Esther Technologies, Inc.
(1) INTRODUCTION
Industry overview
Cross platform development
Introduction to Eqela
Eqela syntax / language features

Our world
(.. And all platforms come in various versions)

From an application development perspective ..
While targeting only the most popular
target platforms, a developer will need to
work with 10-20 different operating system
platforms/versions, at least 3-5 different
programming languages, each with
different API libraries.

Big problem in the industry
All software developers need to
deal with this one way or the
other

HOW?

Usual solutions
(1) Work only on one platform
(2) Create the same application several
times (once per platform)
(3) Do “cross platform development”

Traditional ways to do cross platform development
(1) The “scripted” approach
(Adobe Air / Flex, Appcelerator, Corona, RhoMobile, ..)
(2) The “bytecode” approach
(MoSync, Mono)
(3) The “C++” approach
(Marmalade, Qt, WxWidgets, Unity)
(4) The “embed a web browser” approach
(PhoneGap)
(5) HTML5

Five different cross
platform development
approaches

#1: The “scripted” approach
Source code
In a scripting
language
Development
tool
Unmodified
Source code
+
Interpreter /
Virtual machine
For iOS
Unmodified
Source code
+
Interpreter /
Virtual machine
For Android
Run in
browser
Android
application
iOS
application
(JavaScript,(JavaScript,
Lua, Ruby, ..)Lua, Ruby, ..)
(Adobe Air / Flex, Appcelerator, Corona, RhoMobile, ..)
Runtime /
Virtual
machine

The “scripted” approach: Architecture
Operating system
Language interpreter / runtime
APIs and libraries Application code

The “scripted” approach: Architecture
Operating system
Language interpreter / runtime
APIs and libraries Application code Makes application
Installers much bigger
Increases memory
usage
Reduces runtime
Performance
Due to this approach being very popular, many consider
cross platform development to be slow, high in memory use,
and producing bigger installers.
Applications can only
Access selected
Parts of the native API

#2: The “bytecode” approach
Source
code
Bytecode
Compiler
Android
application
Run in
browser
Class
Library
(MoSync, Mono)
iOS
application
Windows
Phone
application
Very similar to the “scripted” approach,
with the added bytecode compilation step.
Bytecode
Development
Tool
Runtime /
Virtual
machine

The “bytecode” approach: Architecture
Operating system
Bytecode interpreter / runtime
APIs and libraries Application code Makes application
Installers much bigger
Increases memory
usage
Reduces runtime
Performance
Due to its similarity with the “interpreted” approach, the
benefits and disadvantages are very similar
Applications can only
Access selected
Parts of the native API

#3: The “C++” approach
Source code
In a specific
Language
SDK /
compiler
Run in
browser
Android
application
iOS
application
(C++)(C++)
Cross
Platform
Class library
In the specific
language
(C++)(C++)
(Marmalade, Qt, WxWidgets, Unity)
BlackBerry
application
Windows
Phone
application
+ Truly native (100%)
+ High performance
- Limited platform support
(not really cross platform)

#4: The “embed a web browser” approach
Source
Code in
HTML, CSS,
JavaScript
The
tool
Libraries C source code
That opens a
Browser and
Displays the
program
Java source code
That opens a
Browser and
Displays the
program
Android
SDK
Android
application
iOS
SDK
iOS
application
Run in
browser
(PhoneGap, AppGyver)
- Very poor performance
- Suitable for only “web-style” apps
- Limited access to platform APIs
- Application source code can be easily retrieved
+ Easy way to convert existing websites to
“native apps”

#5: HTML5
+ Commonly known skillset (HTML, CSS, JavaScript)
+ Very popular, many Internet resources available
- Unfinished standard
- Fragmented, non-compatible implementations
- Extremely poor performance on mobile
- The language is poorly suited for large programs
- Applications are inherently “open source”

Common issues
Large installer size
Excessive memory use
Low performance
Limited API access

Cross platform development tool ..
.. Based on programming language conversion
technology

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

How it works
Source
Code
(Eqela)
Eqela
Compiler
Libraries C
source
code
Java
source
code
Javascript
code
Android
SDK
Android
application
iOS
SDK
iOS
application
Run in
browser

The technical benefits ..
Small installer size
Optimal memory use
Native performance
No API access limitations

How it works: A sample application
class Main : LayerWidget
{
public void initialize() {
base.initialize();
add(LabelWidget.instance().set_text(“Hello World”));
}
}
Main.eq
Eqela
Compiler
LayerWidget,
LabelWidget
Main.java,
LayerWidget.java,
LabelWidget.java
Android
SDK
Android
application

100% native
Main.eq
Eqela
Compiler
LayerWidget,
LabelWidget
Main.java,
LayerWidget.java,
LabelWidget.java
Android
SDK
Android
application
Only native code → “100% native”
No virtual machine added
No interpreter added

Main.eq → Main.java
class Main : LayerWidget
{
base.initialize();
add(LabelWidget.instance().set_text(“Hello World”));
}
}
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() {
}
}
(EQELA)
(JAVA)

Eqela is many things ..

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

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

Eqela is ..
(3) An application framework
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
A powerful graphics rendering API for
development of custom controls
Works the same way across all
platforms (mobile, desktop, web)

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

Eqela is ..
Programming language
Compiler
Application framework
GUI toolkit
Development tool / environment

How can it be used?

ONLINE / WEB DOWNLOAD / INSTALL
EQELA LIVE
Target Android / HMTL5
Free of charge
No installation required
EQELA “FULL VERSION”
All supported platforms
Payment per platform
Installed per workstation
The different editions

Supported platforms
Android, BlackBerry 10, BlackBerry 5/6/7, HTML5,
Apple iOS, J2ME, Linux, Mac OS X, Symbian,
Windows, Windows Phone

Source files and modules
Eqela source file extension: “.eq”
Generally file is named after the class, eg. “Main.eq”
for class “Main” (convention only, not enforced)
Usually one class per file (also convention)
Directory name names the module and acts as the
“application id”

The Eqela syntax
Belongs to the “C” syntax family:
C, C++, Objective-C, Java, C#, PHP, ..

Eqela syntax / language features

Eqela is a fully object oriented,
class based programming
language

Class declarations
[modifiers] class [classname] : [basetypes]
{
[implementation]
}
public class MySampleClass : SuperClass
{
public void do_something() {
// more code here
}
}
The base class and interfaces may be mixed in the [basetypes]
section of the class declaration in any order.

Class declarations

Class declarations can include these components:
1.Modifiers: public, private (default) or fundamental.

public – the class will be exported in the module's API

private – the class is only available for use internally
within the module

fundamental – the class will not have any base class
2.The class name, by convention in CamelCase
3.The base class (superclass) and a comma-separated list of
interfaces implemented by the class may be mixed in the
[basetypes] section of the class declaration in any order.
4.The class body surrounded by braces, { }.

Automatic base classing
class MyClass
{
// field, constructor, and
// method declarations
}
class MyClass : Object
{
}
=
fundamental class MyClass
{
}
!=

There can be no program
without a class
(no standalone functions)

Comments
// This is a valid comment
/* This is also a valid comment */
/* This
* comment
* spans
* multiple
* lines.
*/
Comments are described in a way familiar with
many languages, using either the "//" notation or
the "/*" .. "*/" method.

Data types
Different kinds of data types:
Primitive types
Object types
(Strings)

Primitive types
● Built in to the language as basic building blocks, and
cannot be extended by the programmer. Passed by
value in method calls.
● strptr, ptr, void, double, bool, int, long, byte
strptr var_name = “abc”.to_strptr();
ptr var_name = null;
double var_name = 123.45;
bool var_name = true;
int var_name = 100000;
long var_name = 100000;
byte var_name = 100;
void //refers to no data type at all

Object types
Objects = Instances of classes
Passed by reference in method calls
class MyClass
{
public int method() {
return(10);
}
}
var o = new MyClass();

Strings
String literal = "This is a string literal";
var str = "Another string literal";
if(str is String) {
; // This is true
}
Eqela API provides a “String” class that offers a
string implementation as an object (object type).
String literals are automatically assigned as
instances of the “String” object, not as “strptr”
variables.

String operations
// assignment
var str1 = "String 1";
// concatenation
var str2 = str1.append(" + More stuff");
// console output
Log.message(str2); // prints out "String 1 + More stuff"
// comparison
if(str1.equals(str2)) {
; // not true
}
// comparison with a literal
if("String 1".equals(str1)) {
; // true
}

Constructing strings
var sb = StringBuffer.create().
sb.append("First");
sb.append_c(' ');
sb.append("Second");
Log.message(sb.to_string()); // prints "First Second"
Normal String objects are immutable
StringBuffer class is provided as part of the API
to efficiently construct strings

Class constructor
What is a “constructor”?


A method with the same name as the class name

Has no return type

A class can only have one constructor function, and the
constructor is not allowed to have any parameters.
public MyClass
{
public MyClass() {
; // implementation
}
}
Class constructor

Supplying object parameters upon creation
public MyClass
{
private int variable = 0;
public MyClass() {
}
public static MyClass create(int value) {
var v = new MyClass();
v.variable = value;
return(v);
}
}
var o = MyClass.create(10);
(1) By using static creation methods

public MyClass
{
property int variable = 0;
public MyClass() {
}
}
var o = new MyClass().set_variable(10);
Supplying object parameters upon creation
(2) By using properties

Class destructor
What is a “destructor”?

public MyClass
{
~Myclass() {
; // actions here
}
}
As is usual in all modern languages with
automatic memory management, it is highly
discouraged to use destructors in Eqela
applications. Generally the only well-known
acceptable use for a destructor is to deallocate
resources allocated manually.
Class destructor

Member variables
[modifiers] [type] [variablename] = [initializer];
class MyClass
{
int number = 10;
public static MyClass second;
private MyClass third = null;
}
Modifiers : "private", "public", "static"
Initializer is optional

Declaring methods
public int SomeMethod(int int_value, bool bool_value) {
// method body
return(10);
}
modifiers return
type
method
name
parameter
list
If the return type is NOT void, the method must
end in a “return” line

Virtual methods and overriding
class BaseClass
{
public virtual void hello() {
Log.message("hello 1");
}
}
class DerivedClass : BaseClass
{
public override void hello() {
Log.message("Hello enhanced!");
}
}
If a method is declared with modifier "virtual", it becomes
a virtual function.
To override a method in a subclass, it should be declared
using the "override" modifier

Method hiding
Eqela does NOT allow method hiding
If a method is declared in a base class, and it is not virtual, no
method of the same name may be declared in any of the
subclasses, even if the parameters would differ.

Static methods
class MyClass
{
public static void hello() {
Log.message("MyClass hello");
}
}
class SecondClass
{
public void method() {
var mc = new MyClass();
mc.hello(); // not right
MyClass.hello(); // the correct way
}
}
Called by the name of the class they are
associated with, not through an object instance

Abstract methods
What is an “abstract method”?

 Methods that have a method signature but no
implementation
 Declared using the modifier "abstract“
 If no "abstract" modifier is present, but method body is missing,
the "abstract" keyword is automatically assumed
 No "override" keyword is required to override abstract methods
interface MyInterface
{
public void first_method();
public abstract void second_method();
}
Abstract methods

What is an interface?

Interface
interface MyInterface
{
public void method1();
public int method2();
}
A group of related methods with empty bodies
Defines a standard and public way of specifying
the behavior of the class (defines a contract)
Declared using the interface keyword

Interfaces

To use an interface, you must implement that interface in
a class

Implementing an interface

Implement multiple interfaces
class MyClass : MyInterface
{
// class body
}
class MyClass : MyInterface, MyOtherInterface
{
// class body
}

Prerequisites
In Eqela, an interface may not "inherit" another
interface, but it may instead have "prerequisites",
through which roughly the same functionality is
achieved

Multiple inheritance
Multiple inheritance is not allowed – but
implementing multiple interfaces IS allowed

Legal interface usage
interface First
{
}
interface Second : First
{
}
class MyClass : Second, First
{
public void method1() {
}
}
}

Illegal interface usage
interface First
{
}
interface Second : First
{
}
class MyClass : Second
{
}
}
}

Other language features ..

Operators and expressions
Group Operator
Unary -, !, ++, --
Logical binary ||, &&
Comparative binary ==, !=, <, <=, >, >=, is
Operative binary +, -, *, /, %
int a = 10 + 5;
int b = a / 10;
If(a == 15 || b == 7) {
}
if(a == 15 && b == 7) {
}
if(a != b) {
}

Type casting
What is the meaning of “type casting”?

Type casting
Static type casting
One data type can be cast into another in a fairly liberal
manner by using the "(typename)" notation.
(Fast but may lead to runtime errors)
Dynamic type casting
Uses the “as” operator to cast one data type to another.
(Slightly slower than static type casting, due to extra checking involved, but a much safer
way)
double n = 100.43;
int ni = (int)n;
var x = new MyClass();
var y = (MyOtherClass)x;
var x = new MyClass();
var y = x as MyOtherClass; // will be null if not a subclass of MyOtherClass

Control structures
If .. Else
While
Do .. While
For
Foreach
Switch

If .. Else
if(condition) {
; // execute if condition is true
}
else {
; // execute if condition is false
}

While
while(condition) {
; // execute while condition is true
}
while(condition) {
if(want_to_stop) {
break;
}
continue;
; // will not reach here
}
While blocks can be interrupted
with the "break" statement or
restarted with the "continue"
statement

Do .. While
do
{
; // execute here
}
while(condition);

For
for(initializer; condition; execute_after) {
; // actions here
}

Foreach
foreach(var variablename in collection) {
; // actions here
}
foreach(String variablename in collection) {
; // actions here
}
The data type of the loop
variable may be dynamically
assigned as above ("var"), or
it can be explicitly set by the
user.

Switch
switch(expression) {
case value1: {
; // statements
}
case value2: {
; // statements
}
default: {
; // statements
}
}
•All "case" blocks must be
enclosed in curly braces "{"
and "}".
•Only one "case" statement is
allowed per block.
•No break statements are
required to terminate the case
blocks.

Properties
class MyClass
{
property int myproperty;
}
class MyClass
{
int myproperty;
public MyClass set_myproperty(int v) {
myproperty = v;
return(this);
}
public int get_myproperty() {
return(myproperty);
}
}

class MyClass
{
property int myproperty;
}
class AnotherClass
{
public void method() {
MyClass cl = new MyClass().set_myproperty(10);
}
}
Using properties

Default parameters
public void my_method(int n = 0) {
// (method implementation code here)
}
obj.my_method(10);
obj.my_method();
Automatically supply parameter values where
no parameters are given

Embedding other languages

Embedding code
The dictionary definition of “embed” is to make
something an integral part of
In Eqela programming language, “embedding” refers
to adding other programming languages into blocks
within the Eqela code

Embed: Syntax
embed “(language name)” {{{
// code in other language
}}}
Languages: c, c++, objc, java, js, cs, ..
int n;
embed “c” {{{
char* str = “Hello World”;
n = strlen(str);
}}}
Log.message(“Length = %d”.printf().add(n));

Embed: Example
class Main
{
embed "c" {{{
#include <stdio.h>
}}}
public static void print() {
embed "c" {{{
printf("Hello worldn");
}}}
embed "java" {{{
System.out.println("Hello world");
}}}
}
embed "c" {{{
int main(int c, char** v) {
hello_Main_print();
return(0);
}
}}}
embed "java" {{{
public static void main(String[] args) {
hello_Main_print();
}
}}}
}

Thank you

Introduction to Eqela development

More Related Content

What's hot

Similar to Introduction to Eqela development

Recently uploaded

Introduction to Eqela development