Eve Manifest

Eve empowers developers with a domain-specific, modular programming language. Designed for improved productivity and ease of learning. Eve fosters a safe, versatile, and effective environment for data manipulation tasks across various domains. This includes working with text data, binary data (like images and video streams), and database connectivity.

EVE Architecture

The EVE ecosystem is built upon a biological model of systemic efficiency, composed of three distinct yet symbiotic elements designed to handle data. EVE environment include two languages Eve and Bee designed to work together to solve large scale distributed data processes.

The Hive (The Infrastructure)

The Hive represents the environment—our persistent storage, the database nodes, and the distributed systems where data resides. It is the static ground truth that requires constant maintenance and synchronization.

The Bee (The Worker)

Bee is our execution unit. These are small, autonomous, and high-velocity modules or agents designed to perform specific, granular tasks. Like bees in a colony, they are purpose-built to search, extract, process, and return data efficiently.

Virtual Machine

Eve is the orchestrator—a declarative 4th-generation language designed to control the Bees within the Hive. EVE parses the landscape, directs the workers, and ensures that data manipulation is both secure and precise. Eve is a scripting language inspired from Ruby, Python, Go and Java.

Operational Capabilities

By leveraging the EVE-Bee-Hive hierarchy, we achieve seamless data movement between internal databases and external interfaces. Our architecture aim to optimizes for high-signal processing and low-overhead maintenance. We target following goals:

  • Data Compression: Streamlines Hive resources for transmission.
  • Database Synchronization: Ensures bidirectional consistency across the Hive.
  • Data Curation: Automates the cleansing of raw data packets.
  • Data Encryption: Maintains the integrity of payloads during transit.
  • Archiving & Restoration: Provides a robust recovery path for Hive integrity.

Key Features

Eve language is inspired from Ruby and Ada. Is easy to grasp like Python but has type checking like Java. Is a multi-paradigm language, hybrid: Procedural, Functional and Object Oriented. We can say EVE is a "Process Oriented Language".

  • Readable Syntax

    Eve leverages familiar keywords and syntax inspired by established languages like Java, C++, Ada, Pascal, and Ruby. It employs an explicit, consistent, and verbose style for enhanced code readability and learning by example. Additionally, Eve supports syntax highlighting and colorization for improved code comprehension.

  • Effective and Productive

    Eve is tailored towards domain-specific jobs, prioritizing developer productivity. It focuses on effectiveness over extreme efficiency or high-performance computing.

  • Type-Safe by Design

    Eve utilizes a static type system to ensure type safety. It mitigates null pointer exceptions by employing boxed values and initializing basic types with zero values.

  • Modular Architecture

    Eve encourages code reusability through scripts and modules, promoting separation of concerns in larger projects. It offers three module types:

    • Drivers: Serve as executable entry points for your programs.
    • Aspects: Represent individual processes launched from drivers and unloaded from memory upon completion.
    • Modules: Provide reusable but non-executable components that persist until the driver finishes.

  • Versatile Data Handling

    Eve will be able to connect and manipulates data from various databases. It reads and writes diverse data formats, including text, images, and video streams. We will create specific drivers for each database we interact with and optimize data access for reliability and performance.

Code Example

This Eve program calculates the 5th number in the Fibonacci sequence. Here's a breakdown:

# 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;

Explanation

  • Driver and Function Definition:
    • The line "driver fibonacci:" declares the main program named "fibonacci".
    • The line "function fib(n:Integer) => (y:Integer)" defines a function named "fib" that takes an integer "n" as input and returns an integer value.
  • Recursive Calculation:
    • The "fib" function uses recursion to calculate the nth Fibonacci number.
    • The "if" statement checks if "n" is either 1 or 0, which are the base cases in the sequence (both 1).
    • The "else" block calculates "fib(n)" using the values of "fib(n-1)" and "fib(n-2)", demonstrating recursion.
  • Main Program Execution:
    • The "process" block defines the main execution flow.
    • A variable "r" is declared to store the result.
    • The line "let r := fib(5);" calls the "fib" function with "5" and assigns the result (5th Fibonacci number) to "r".
    • The "print r;" statement displays the calculated value to the console.

Ready to dive deeper into Eve? This brief demo has only scratched the surface of its capabilities. Explore the detailed explanations we've prepared to unlock the full potential of Eve for your data manipulation needs. As you delve into Eve's design, you'll gain valuable insights into programming language principles. Who knows, maybe one day you'll be inspired to create your own language or even contribute to the ongoing evolution of Eve!