Sage-Code Laboratory
index<--

Eve features

Eve is a front-end data processiong imperative programming language. Eve is multi-paradigm, statically typed, with type inference and gradual typing. Our intention is to create a verbose robust language for enterprise applications.

Names: {eve, Eve, EVE) are related. Eve is the language name, EVE is the virtual machine, *.eve is the source code extesion for script files. Initially Eve use to be called Level 123 but we have simplified the name. Level project was archived in 2007.

Targt Features:

#FeatureDescription
1 readable use familiar keywords
2 effective focus on domain specific jobs
3 safe use static data type system
4 modular has reusable scripts and modules
5 versatile can connect to multiple databases
Design: Eve has a classic design inspired from Ada, Ruby & Fortran. Therefore learning Eve is more easy if you know one of these languages. Eve is not a curly bracket language, and is much more different than C, C++, Java, Rust, Go, Swift, JavaScript.

Readable

Eve is designed to be learned by reading code examples. It has an explicit consistent and verbose syntax. We believe future users will learn a language much more easly, when the syntax looks right.

Eve has ...

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 highlight every statement. This can not be achieved in a curly bracket language.

# Fibonacci series demonstrate
driver fibonacci:

** declare Fibonacci routine
function fib(n:Integer) => (y:Integer):
  if (n == 1) or (n == 0) then
    let y := 1; -- first value
  else
    let y := fib(n-1) + fib(n-2);
  done;
return;

process
   ** local variable for result
   new r: Integer;

   ** call fib rule using argument 5
   let r := fib(5);

   ** print the result to console
   print r;
return;

Effective

Eve is aiming to be effective and feasible. This means Eve is design to improve developer productivity and get the job done. Effective does not necessarily imply extreme efficiency or higher performance. Eve is design to be productive and easy to learn.

Eve ...

Safe

Eve is designed to be a safe. For this we avoid using Null pointers. Eve is using boxed values that are actually references but we initialize all the basic types with zero values. Null is equivalent to zero value. We believe the next principles will help us design a better language:

  1. We favor safety over performance,
  2. It is better to be productive than efficient,
  3. Implicit values are better than wrong values,
  4. A good error message worth more than gold,
  5. If the system is not ready it should tell you,
  6. If a process fail it should report the errors,
  7. Sometimes if you try a second time it works!

Modular

Eve applications are usually small, based on single source file that do one job. However we enable usage of multiple files for separation of concerns in large project. There are 3 kind of modules defined for Eve, as follows:

    Eve Modules

    Eve modular design

  1. One master script called "driver"
  2. Multiple secondary scripts called "aspects"
  3. Multiple reusable modules organized in lybraries.

Drivers and aspects are executable while modules are reusable but not executable. Aspects are launched from the driver and are individual process. 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 variables and parameters can be declared using: type hint, type inference and gradual typing. This improve readability and reduce clutter;
  2. Eve use implicit data types that are static but enable also variant type. The variant type can support a number of alternative data types that can be specified.
  3. Eve has processes that can support input/output parameters. A process can run in a separate thread. However a process can not be used in expressions.
  4. Eve has functions. Functions are usually defined in modules. A function can return one or more results. You can define the result name and type explicit.
  5. Eve has lambda expressions. These are similar to functions but restricted. A lambda expression can't have side effects and can return a single value.
  6. 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.
  7. In a subroutine, native type parameters are transferred by value. You can sent parameters by reference using "@" prefix.
  8. Eve has two assignment operators: "::" (colne) and ":=" (assign). Developers can control the asignment explicit.

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, or Ruby you will be confortable learning Eve.

  1. Eve is using classic control flow statements: {decision, selection, repetition, error handlers} that you already know from other languages.
  2. Eve is using ASCII operators, and keyword based operators but not Unicode. This enable fast code input required to write large business oriented scripts.
  3. Eve has user defined data types (classes). Eve is a hybrid language it has suport for object oriented programming OOP.
  4. Eve is familiar with SQL, HTML and JSON. To deal with many SQL dialects, Eve have specific drivers that enable direct interaction with major databases.

Read next: Eve Syntax