Ecere Technologies
| |

The Ecere software technologies form a cross-platform development toolkit, to build applications running at maximum native performance satisfying the most demanding markets.

The solution allows the developers to write software in an intuitive and efficient way. It is well integrated, and a complete software development solution.

The Ecere Integrated Development Environment

The Ecere IDE is a complete development environment for editing code, designing graphical user interfaces, managing and building projects as well as debugging. Its aim is to fully support eC and C programming, but also supports including and building e.g. C++ modules as part of the projects.

The designer allows for visually editing objects (such as forms).
The property sheets and method sheets are also available to interactively modifying methods and properties (whether working in the designer or code editor).
Code and designer are automatically synchronized as modifications are made from one side or the other.
User APIs can include Designer functionality to integrate their own visual editors inside the designer

Code Editor
The Ecere IDE's code editor is a standard syntax highlighting text editor featuring contextual feedback for things like instance members, parameters, function prototypes as well as autocomplete support. It also facilitates overriding methods.

Project Management
The Ecere IDE supports multiple configurations (e.g. Debug and Release), specifying compiling and linking options and can build executables, static and shared libraries.
Building projects report errors to which one can easily jump to in the code. Resources can be integrated inside executables and are easily accessible using the Ecere file access system. The IDE has a Find in Files and Find in Project feature for quick searches through the code.

The debugger allows to step through code, view the call stack and jump to frames, view the threads and switch between them, settings breakpoint, inspecting the values of expressions.

The IDE debugging a sample 3D application

Ecere Runtime Components

The Ecere runtime components are what enables the cross platform aspect of the SDK. It offers the same functionality across the multiple platforms it supports, and therefore allows for platform independent application development and deployment.
Programmers can therefore spend their time working on the essence of their application.
They don't have to worry about maintaining multiple versions of their application for each platform on which it will be deployed.

Currently, Windows, Linux and Mac OS X (through X11) are supported.
It can be built for other UNIX systems, therefore if you are interested in a particular system please let us know.
A more native MacOS X support is planned for the future, and PDAs and game consoles are being considered as well.

The runtime component has a very small footprint. It can either take the form of a shared or static library. In its simplest form it can be bundled into a single application executable smaller than 1 megabyte on Windows.

Cross Platform Graphical User Interface
One of the most important feature of the runtime component is the custom cross platform GUI engine.
It is an alternative and is analogous to other GUI toolkits such as wxWindows, GTK or Qt.
It also offers a rich 2D text, graphics and image manipulation system supporting a variety of graphics file formats.

System Functionality
The runtime component covers many powerful general functinality covering advance file access, multithreading, time.
It also greatly simplifies socket programming (either through UDP or TCP/IP).

3D Graphics Engine
The runtime component contains a powerful and easy to use 3D graphics engine, introducing concepts of cameras, meshes, materials, lights and objects.
It currently supports loading models from the 3DS file format. Meshes can also be built dynamically through the API. The engine supports both Direct3D and OpenGL.

Component Object Model
The runtime component also enables the entire Ecere Component Object Model and its advanced features such as distributed objects, dynamic class hierarchy amalgamation, dynamic injection and ejection of modules and their components as well as automatic data type management.

Ecere 3D Chess Game (Simple Ai, Networking Functionality)

Download and try it out for yourself:
Ecere Chess for Windows / Ecere Chess for Linux

The eC Language

eC is an object oriented language fully compatible with C.
It is compiled and runs natively on the target platforms ensuring maximum performance.
It enables powerful object oriented features similar to those found in C# and Java.
Standard C programming can be used anywhere inside eC modules, and other object modules can be linked to eC code as if it was a standard C module.

The language has been designed keeping C performance in mind.
All the Ecere technologies, including the Ecere compilers and Ecere IDE are built using eC and are running in a cross platform manner with the Ecere runtime component.

Simple eC Form Application using the Ecere GUI

import "ecere"

class Form1 : Window
   text = "Form1";
   background = white;
   borderStyle = sizable;
   hasMaximize = true;
   hasMinimize = true;
   hasClose = true;
   size = { 640, 480 };

   Button button1
      this, text = "button1", position = { 280, 176 };

      bool NotifyClicked(Button button, int x, int y, Modifiers m)
         return true;

Form1 form1 {};

No more header files, prototypes, forward declarations
eC removed the need for header files: other source files or "modules" packaged as shared library are "imported".
All public classes, functions and members will automatically be accessible.
eC offers better control over what is visible when building an API library.
Library developers don't need to worry about the private content of the class definition being seen by the end user, only what is declared public will be visible
The IDE will automatically be able to use the defined modules functionality (e.g. property and method sheets)
Class specific visual editors can be packaged right inside libraries to fully integrate with the IDE
eC also removes the need for forward declarations (prototypes).

Powerful Component Object Model Framework
Object oriented code written in eC is built around the Ecere Component Object Model Framework.
All required information about the programming interfaces is readily and dynamically available.
Classes can be instanciated and methods can be called using textual names.
This also makes it ideal for automatically generating binding to other languages completely automatically
The unique features of the language offers a solid foundation on which to build a uniform Application Programming Interface using eC that will scale nicely to other languages, since eC was invented as a framework to easily build, publish and maintain classes.
This powerful model can also be used in a distributed manner: it supports using objects across a network the same way as if they were local objects.

eC includes properties, a way to indirectly access data encapsulated in classes.
Modifying a property can cause code to be executed
Properties are totally transparent and can be used like regular data members
They typically replace constructor parameters and Set/Get methods in C++
They can be edited from the IDE property sheet

Classes and Structs, pointers still available but their complexity is hidden
eC makes a greater distinction between class and struct than C++.

Classes offer the following features:
  • Virtual functions. Each instance can even have their own methods and virtual table if necessary.
  • Default property values, constructors and destructors (always virtual)
  • Reference counter
  • Memory managed when inside other classes
  • Runtime Type Information available
  • Objects are allocated on the heap
  • They are typically used for typical key objects for the application
Structs on the other hand:
  • They can be used as C structures
  • They have no overhead (consists only of data members)
  • Objects are allocated on the stack (no memory hassle)
  • They are used for small self-contained data types, e.g. Point, objects we want allocated on the stack, object to be stored contiguously in arrays
A compromise between the two also exists, allowing to strip classes of their overhead information so that it contains only data members. Such a class will behave the same way as a regular class, except it will not support reference counting, runtime type information, or virtual functions (destructors will not be virtual either). It is typically used for numerous objects for which we don't need the overhead of regular classes, but which are allocated individually, such as those to be stored in linked lists.

These distinctions allow for significant advantages:
  • MyClass * object = new MyClass is simplified to MyClass object { }
  • It removes the need for declaring parameters using the passing by address (&) operator or a pointer operator (*) declaring parameters:
    objects are always passed by address, simply by declaring MyFunction(MyClass object), whether a struct or a class
  • object->member is therefore simplified to the more friendly object.member
Bit Collection Classes
eC offers another kind of type constructs for encapsulating bit fields classes with great control.
The data type is stored in and is compatible with a numeric value type such as an unsigned int.
It is very useful for flag collections, and e.g. is used for colors in the Ecere SDK.

Powerful Enumeration Types
Enumerations in eC are context sensitive: their values are only resolved where their data type is expected to be used. This allows to use the same common identifiers in different enumerations (e.g. None)

Named Member Assignments
eC supports explicitly naming which instance members to assign, for greater clarity and convenience.

Dynamic Defines
eC supports introduces defining identifiers which resolve to expressions in a dynamic manner, rather than through #define macros.

Unit Data Types
eC supports defining custom unit types for numeric values of any type. They realize their full potential through conversions between related units. Operations on them obey strict rules based on the operands. The concept avoids having to use classes (which are not inherently numeric) and requiring operator overloading to achieve the same goals.

Automatic Conversions
Units, classes, enumerations and basic data types can all be related through either inheritance or supplied conversions
Conversions occur transparently and allow for shockingly simple code.
If they are constant, the compiler automatically precomputes the conversions, even if the conversions are defined in a user library.
Conversions ensure that the most efficient data type are used internally, without sacrificing the usability of the interface

Extensible Data Types
The Ecere framework contains a powerful builtin extensible data type system.
It allows for the use of custom data types in all common controls.
It supports automatic visualization, edition, conversion to and from text, sorting, serialization & marshalling.
All data types are useable for database records (it also supports active records).

Memory Management
eC already takes care of many aspects of memory management through reference counting. However, since eC is designed as an advanced C programming language, it does not do any form of garbage collection. At this point in time, reference counting is only automated for instance members inside classes and global objects.

Fortunately, the Ecere SDK offers a great technology to facilitate identifying and rapidly resolving the unavoidable typical memory problems associated with memory management in an non-managed environment such as leaks, free memory writes & reads and buffer overruns & underruns. It can be easily turned on during the debugging and will provide full call stack information as to where the problem is occuring.