Sage-Code Laboratory
index<--

EVE Features

EVE is a scripting programming language. It is made for ETL applications to handling large data sets. ETL stands for Extract Transform Load but EVE stands for Extract Validate Export. This is a similar paradigm that requires a specialized language having following features:

Features:

#FeatureHow
1 readable use familiar keywords
2 effective focus on domain specific jobs
3 safe use static type system
4 modular has reusable scripts and modules
5 versatile can connect to multiple databases
Classic: EVE has a classic design inspired from Ada language. It uses classic keywords and structures that we are familiar with. Therefore learning EVE is more easy if you know other programming languages like Ada, Pascal, PL/SQL. The code is more readable than C++ and other curly bracket languages.

Readable

EVE is designed to be learn fast by reading the code. It is very similar to Java but is multi-paradigm not pure Object Oriented. We believe that next design choices will make EVE code easy to read therefore easyer to comprehend and debug:

The result of these choices is demonstrate below with an example. You can observe different comment notations enable different colors. Syntax colorizer is able to identify the keywords and highlite every statement. This can not be achieved using a language that has curly brackets used as delimitors for blocks.

Fibonacci

EVE program example


Effective

EVE is aiming to be echonomic feasible. This means EVE is design to improve developer productivity and get the job done as quicly as possible. Effective does not necesarly imply efficiency or higher performance. EVE is designed to perform one task very well one time or a limited number of times by using a time scheduler.

Safe

EVE is designed to be a safe language. For this we avoid using Null pointers. EVE is using boxed values that are actually references but we initialize all the variables with zero value. We avoid having Null references. EVE is and Object Oriented and declarative language. We belive the next priciples will help us to design a safe language:

  1. We favor safety over extreme performance,
  2. It is better to be productive than efficient,
  3. If the system is not ready it should tell you,
  4. Implicit values are better than wrong values.
  5. A good error message worth more than gold,

Modular

EVE applications are usually small, based on single source file. However EVE enable usage of multiple files for separation of concerns. There are 3 kind of modules in a large EVE application as you can see in the following diagram:

    EVE Modules

    EVE modular design


  1. One main script called "driver"
  2. Multiple secondary scripts called "aspects"
  3. Multiple library modules called simple "modules"

Drivers and aspects are executable while modules are reusable but not executable. Aspects are executed from driver process and are individual proceses. Once an aspect is resolved it is removed from memory, unlike modules that are persistent until the driver ends.

Versatile

EVE is a domain specific language but it looks and feel like a general purpose language. We do not do graphics but we manipulate data in any form. This can be text data but also row bit data. So we can read and write images and video streams. Next design choices will make EVE a versatile language:

  1. EVE use implicit data types that are static but enable also variant type. The variant type can support a number of other data types that can be specified. So one variant is more like a pointer than regular variables.
  2. EVE has routines that can support input/output parameters. That enable developers to define multiple results for a routine. However a routine can not be used in expressions.
  3. EVE has functions. However the functions are like named expressions. A function must be simple and can return a single result and can not have side-effects.
  4. Variables and parameters are automatically initialized with zero value when there is no explicit initialization. Also, if a parameter has explicit initial value it becomes optional.
  5. EVE has two assignment operators: "::" and ":=". First is called "clone" second is called "assign" value. Developers can control what assignment operator to use depending on the algorithm requirements.
  6. In a subroutine, primitive type parameters are transferred by reference, but regular parameters are imutable, protected by the compiler. The output parameters on the other hand are mutable but can not have initial values.

Classic

EVE is using a familiar syntax. We try to avoid being disruptive. If you know Java or C++ you will be able to learn EVE in less then one week. Also if you know Ada or Pascal, you will find EVE most similar.

  1. EVE is using classinc control flow keywords: {if, loop, while, for, repear, break } that you already know from other languages. Also the end of blocks are using "end" that is so common in other languages.
  2. EVE is using ASCII operators, in contrast to Bee language that is using Unicode. This enable fast code input required to write large business oriented scripts.
  3. EVE has user defined data types but also classes. In Java you can define classes but no data types while in Ada you can define types but no classes. EVE is a hybrid language that enable both paradigms.
  4. EVE is using embeded SQL for data query. Instead of inventing a new query language we will try to stick with the standard SQL dialect as much as possible.

Read next: EVE Syntax