This is an automated email from the ASF dual-hosted git repository.

zkaoudi pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-wayang-website.git


The following commit(s) were added to refs/heads/main by this push:
     new dcaeb4f  commit edited files
dcaeb4f is described below

commit dcaeb4fef1fae29a2d4e07a0ad794ab52bf9c6ef
Author: Zoi <[email protected]>
AuthorDate: Wed Dec 27 15:13:50 2023 +0200

    commit edited files
---
 documentation.md | 10 +++++-----
 index.md         | 19 +++++++++----------
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/documentation.md b/documentation.md
index 1dadc01..41468b9 100644
--- a/documentation.md
+++ b/documentation.md
@@ -22,18 +22,18 @@ In contrast to classical data processing systems that 
provide one dedicated exec
 
 This approach aims at freeing data engineers and software developers from the 
burden of knowing the zoo of different data processing systems, their APIs, 
strengths and weakness; the intricacies of coordinating and integrating 
different processing platforms; and the inflexibility when tying to a fix set 
of processing platforms. As of now, Apache Wayang has built in support for the 
following processing platforms:
 
-* Java 8 Streams
+* Java Streams
 * [Apache Spark](https://spark.apache.org/)
-* [GraphChi](https://github.com/GraphChi/graphchi-java)
+* [Apache Flink](https://flink.apache.org)
 * [Postgres](http://www.postgresql.org)
 * [SQLite](https://www.sqlite.org/)
-* [Apache Flink](https://flink.apache.org)
+* [Apache Giraph](https://github.com/GraphChi/graphchi-java)
 
 ## How to use Apache Wayang
 
 ### Requirements:
 
-Apache Wayang is built with Java 8 and Scala 2.11. However, to execute Apache 
Wayang it is sufficient to have Java 8 installed. If you want to build Apache 
Wayang yourself, you will also need to have <a 
href="http://maven.apache.org";>Apache Maven</a> installed. Please also consider 
that processing platforms employed by Apache Wayang might have further 
requirements.
+Apache Wayang is built with Java 11 and Scala 2.12. However, to execute Apache 
Wayang it is sufficient to have Java 8 installed. If you want to build Apache 
Wayang yourself, you will also need to have <a 
href="http://maven.apache.org";>Apache Maven</a> installed. Please also consider 
that processing platforms employed by Apache Wayang might have further 
requirements.
 
 ### Get Apache Wayang:
 
@@ -43,7 +43,7 @@ Apache Wayang is available via Maven Central. To use it with 
Maven, for instance
 <dependency>
     <groupId>org.apache.wayang</groupId>
     <artifactId>wayang-***</artifactId>
-    <version>0.6.0</version>
+    <version>0.7.1</version>
 </dependency>
 ```
 
diff --git a/index.md b/index.md
index 3554633..a849520 100644
--- a/index.md
+++ b/index.md
@@ -18,22 +18,21 @@ layout: home
 title: "Enabling Federated Data Processing"
 section-1:
   title: |
-    Federated Data Processing Engine
+    Federated Data Analytics
   subtitle: |
-    Enabling Data Regulation Compliant Application Agnosticism 
+    Enabling Engine Agnosticism and Data Regulation Compliance
   text:   |
-    Apache Wayang is an API-first system designed to fully support 
cross-platform data processing: Wayang enables users to run data analytics over 
multiple data processing platforms, without changing the native code. </br>
-    Wayang provides an abstraction on top of existing platforms in order to 
run data processing and analytic tasks on top of any set of platforms. As a 
result, users can focus on the logics of their applications rather on the 
intricacies of the underlying platforms.
+    Apache Wayang is a system designed to fully support unified and federated 
data processing: Wayang enables users to run data analytics over multiple data 
processing engines, without changing their native code. </br>
+    Wayang provides an abstraction on top of existing platforms in order to 
run data processing and analytic tasks on top of any set of platforms. As a 
result, Apache Wayang (incubating) frees data engineers and software developers 
from the burden of learning all different data processing systems, their APIs, 
strengths and weaknesses; the intricacies of coordinating and integrating 
different processing platforms; and the inflexibility when trying a fixed set 
of processing platforms.
 section-2:
-  title: Turning shadows into a show
+  title: Adding a virtualization layer on top of multiple execution engines 
   text: | 
-    Read more on how Apache Wayang converts the light and shadows of data 
processing platforms to amazing theatre for you.
+    In contrast to traditional data processing systems that provide one 
dedicated execution engine, Apache Wayang (incubating) can transparently and 
seamlessly integrate multiple execution engines and use them to perform a 
single task. In Wayang, users can specify any data processing application using 
one of Wayang's APIs and then Wayang will choose the data processing 
platform(s), e.g., Postgres or Apache Spark, that best fits the application. 
Finally, Wayang will perform the execution, [...]
 section-3:
   title: Features
-  text: How we move the strings for you
+  text: What Apache Wayang can do for you
 section-4:
-  title: Why is Apache Wayang faster as other, modern frameworks?
+  title: Why is Apache Wayang faster than other modern frameworks?
   text: |
-   Apache Wayang uses internal optimization patterns to detect the best 
possible combination of computation and nodes. We know, just adding more nodes 
into a cluster doesn't mean more speed; each additional node has several 
tradeoffs, be it shuffle or communication bottlenecks.
-   Apache Wayang understands the UDF's and optimizes the function for the 
underlying processing platform. It also uses small JVM instances to reduce the 
operational overhead when processing a reduced number of data points.
+   Apache Wayang uses query optimization and AI to detect the best possible 
combination of execution engines. By combining multiple execution engines, one 
can gain significant performance. Apache Wayang understands the UDFs and 
optimizes the function for the underlying processing platform. It also uses 
small JVM instances to reduce the operational overhead when processing a 
reduced number of data points.
 ---

Reply via email to