Start translate to EN

_navbar.md

@@ -0,0 +1,9 @@
+* Translations
+  * :fr: **Français** 
+  * [:us: <ins>English</ins>](en/)
+
+* <span><strong>Vertigo sites</strong></span>
+
+  * [Website](https://vertigo.io/)
+  * [Github](https://github.com/vertigo-io)
+  * [Discord](https://discord.gg/6DngkVh)

en/README.md

@@ -0,0 +1,28 @@
+# Vertigo : Boost your apps
+
+?> Boost your apps, or how to create value in your projects, better and faster.
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**Vertigo** is a Java platform for building modern, comprehensive, maintainable, and scalable business applications or information systems.
+
+It is designed to maximize value addition:
+- Simple tasks are straightforward.
+- More complex tasks are handled by minimizing their impact through plug-ins.
+- Several high-value components are provided out-of-the-box, including modern UI, search functionality, and security features.
+
+The automotive industry has embraced the concept of a “platform,” allowing rapid creation of different models (sedans, compacts, SUVs, etc.) from a common base. Customizations and options enhance the range of choices while sharing costs, minimizing industrial risks, and maximizing value for customers.
+
+**Vertigo**, applies this principle to information systems and digital services. Its core application ensures robustness, quality, and development efficiency. Innovative options can be added based on business objectives. **Vertigo** is an *Opinionated Software Development Framework*, maximizing development efficiency for business applications (especially management applications) while allowing flexibility beyond that scope. Unlike broad general-purpose frameworks, it excels in its domain while still accommodating a wide range of use cases.
+
+
+**Vertigo**, as the core application of the platform, natively incorporates all essential components for a modern application: search, security, mobility, analytics, and data visualization.
+
+Here’s a breakdown of the components that make up Vertigo:
+
+- [**Vertigo-Core**](/overview/core) : A powerful and lightweight Java framework.
+- [**Vertigo-Extensions**](/overview/extensions) : A collection of extension modules that address key challenges in business applications, allowing rapid development
+- [**Vertigo-Connectors**](/overview/connectors) : A set of low-level connectors to third-party libraries and products, simplifying development in edge cases
+- [**Vertigo-Studio**](/overview/studio) :  A dedicated design tool for business applications, enhancing efficiency and consistency
+
+Vertigo empowers developers to create robust and efficient applications while maintaining flexibility beyond typical management applications. It’s a platform designed to maximize value and accelerate project delivery

en/_navbar.md

@@ -0,0 +1,9 @@
+* Translations
+  * [:fr: <ins>Français</ins>](/)
+  * :us: **English**
+
+* <span><strong>Vertigo sites</strong></span>
+
+  * [Website](https://vertigo.io/)
+  * [Github](https://github.com/vertigo-io)
+  * [Discord](https://discord.gg/6DngkVh)

en/_sidebar.md

@@ -0,0 +1,70 @@
+<hr/>
+	<h3 class="q-version-select">
+	Vertigo  
+	<select id="versions" onchange="javascript:location.href=this.value+location.hash">
+    <!-- <option value="/vertigo-docs/v2.1.0/">v2.1.0 (current)</option> -->
+  </select>
+	</h3>
+<hr/>
+
+- Introduction
+  - [Why Vertigo ?](/en/intro/why.md)
+  - [Philosophy](/en/intro/philosophie.md)
+  - [References](/en/intro/references.md)
+  - [Ecosystem](/en/intro/ecosystem.md)
+- Overview
+  - [Core](/en/overview/core.md)
+  - [Extensions](/en/overview/extensions.md)
+  - [Connectors](/en/overview/connectors.md)
+  - [Studio](/en/overview/studio.md)
+- Getting-started
+  - [Prerequisites](/en/getting-started/requirements.md)  
+  - [How to Start the Engine…](/en/getting-started/helloworld.md)
+  - [Real world Hello World !](/en/getting-started/realworld_helloworld.md)  
+- To Get Started
+  - [Concepts](/en/basic/concepts.md)
+  - [Configuration](/en/basic/configuration.md)
+  - [Components](/en/basic/composants.md)
+  - [MDA](/en/basic/mda.md)
+  - [Data Access](/en/basic/dao.md)
+  - [Search](/en/basic/recherche.md)
+  - [Security](/en/basic/securite.md)
+  - [Web Services](/en/basic/webservices.md)
+  - [UI](/en/basic/ui.md)
+  - [Analytics](/en/basic/analytics.md)
+- Going Further
+  - [Commons](/en/extensions/commons.md)
+  - [DataModel](/en/extensions/datamodel.md)
+  - [Account](/en/extensions/account.md)
+  - [Vega](/en/extensions/vega.md)
+  - [UI](/en/extensions/ui.md)
+  - [Orchestra](/en/extensions/orchestra.md)
+  - [Quarto](/en/extensions/quarto.md)
+- [Design System](/en/design-system/intro.md)
+  - [Atomes](/en/design-system/atoms.md)
+  - Molecules
+    - [Buttons](/en/design-system/molecules/buttons.md)
+    - [Forms](/en/design-system/molecules/form.md)
+    - [Grid](/en/design-system/molecules/grid.md)
+    - [Text Input](/en/design-system/molecules/text-input.md)
+    - [Numeric Input](/en/design-system/molecules/numeric-input.md)
+    - [Boolean Input](/en/design-system/molecules/boolean-input.md)
+    - [Date Input](/en/design-system/molecules/date-input.md)
+    - [Selection](/en/design-system/molecules/select-input.md)
+    - [Geolocation](/en/design-system/molecules/geolocation-input.md)
+  - Organismes
+    - [Blocs](/en/design-system/organismes/block.md)
+    - [Collections](/en/design-system/organismes/collections.md)
+    - [Card Lists](/en/design-system/organismes/cards.md)
+    - [Item Lists](/en/design-system/organismes/items.md)
+    - [Tables](/en/design-system/organismes/table.md)
+    - [Menu](/en/design-system/organismes/menu.md)
+  - Templates
+    - [General Structure](/en/design-system/templates/structure.md)
+    - [Tabs](/en/design-system/templates/tab.md)
+    - [Editing/Consultation](/en/design-system/templates/read-edit.md)
+    - [Search](/en/design-system/templates/search.md)
+- <a href="apidocs/index.html" target="_blank">API documentation</a>
+- [Changelog](/en/changes.md)
+- [Changelog-extensions](/en/changes-extensions.md) 
+- [FAQ](/en/extensions/faq.md)

en/intro/ecosystem.md

@@ -0,0 +1,16 @@
+# Technological Ecosystem
+
+Vertigo is a base built on standard infrastructure bricks
+
+![](./images/techno_infra.png)
+
+
+It aggregates and binds specialized technologies…
+
+![](./images/techno_impl.png)
+
+
+…and allows you to simply extend your applications to complete market tools
+
+![](./images/techno_extension.png) 
+

en/intro/philosophie.md

@@ -0,0 +1,46 @@
+# Objectives
+Our goal in building Vertigo is to provide an application framework that is:
+
+- Centered around needs
+- Informed by experience
+- Consistent, yet flexible
+- Simple—making straightforward tasks easy
+- Open—allowing for more complex operations
+
+To achieve this, Vertigo adheres to the following design principles.
+
+# Design Principles
+
+![](./images/designPrinciples.png)
+
+# Simple
+![](./images/simple-icon.png)John Maeda, a design professor at MIT, authored a book titled The Laws of Simplicity, where he outlines principles of simplicity. The final law succinctly captures the essence :
+
+**Simplicity is about subtracting the obvious, and adding the meaningful.**
+
+# Modular
+![](./images/modular-icon.png)Modularity is a key element in computer systems and forms the foundation of UNIX. As Eric Raymond states in his work Basics of the Unix Philosophy:
+
+**Rule of Modularity : Write simple parts connected by clean interfaces.** 
+
+![](./images/modularity.png)
+
+# Elastic
+![](./images/elastic-icon.png)Elasticity refers to a system’s ability to distribute processing in order to:
+
+- Handle heavy loads
+- Confine specific tasks to dedicated servers
+
+![](./images/elastic.png)
+
+# Fast
+![](./images/fast-icon.png)According to usability expert Jacob Nielsen, there are three critical timeframes for user attention. Our goal is to **build applications that respond instantly**.
+
+- 0.1 seconds provides an instantaneous feeling of response
+- 1 second maintains the user’s flow of thought
+- 10 seconds is the limit for keeping the user engaged in the dialogue
+
+![](./images/fast.png)
+
+# Fluid
+![](./images/fluid-icon.png)Because users perceive applications through their interfaces, it’s crucial for the interface to be fluid and ergonomic.

en/intro/references.md

@@ -0,0 +1,12 @@
+# Vertigo in numbers
+
+Vertigo has been forged, enriched, demonstrated, through
+
+![](./images/vertigo_chiffres.png)
+
+# References
+
+Vertigo is deployed at numerous actors 
+
+![](./images/vertigo_refs.png)
+

en/intro/why.md

@@ -0,0 +1,28 @@
+# Vertigo : Boost your apps
+
+?> Boost your apps, or how to create value in your projects, better and faster.
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**Vertigo** is a Java platform for building modern, comprehensive, maintainable, and scalable business applications or information systems.
+
+It is designed to maximize value addition:
+- Simple tasks are straightforward.
+- More complex tasks are handled by minimizing their impact through plug-ins.
+- Several high-value components are provided out-of-the-box, including modern UI, search functionality, and security features.
+
+The automotive industry has embraced the concept of a “platform,” allowing rapid creation of different models (sedans, compacts, SUVs, etc.) from a common base. Customizations and options enhance the range of choices while sharing costs, minimizing industrial risks, and maximizing value for customers.
+
+**Vertigo**, applies this principle to information systems and digital services. Its core application ensures robustness, quality, and development efficiency. Innovative options can be added based on business objectives. **Vertigo** is an *Opinionated Software Development Framework*, maximizing development efficiency for business applications (especially management applications) while allowing flexibility beyond that scope. Unlike broad general-purpose frameworks, it excels in its domain while still accommodating a wide range of use cases.
+
+
+**Vertigo**, as the core application of the platform, natively incorporates all essential components for a modern application: search, security, mobility, analytics, and data visualization.
+
+Here’s a breakdown of the components that make up Vertigo:
+
+- [**Vertigo-Core**](/overview/core) : A powerful and lightweight Java framework.
+- [**Vertigo-Extensions**](/overview/extensions) : A collection of extension modules that address key challenges in business applications, allowing rapid development
+- [**Vertigo-Connectors**](/overview/connectors) : A set of low-level connectors to third-party libraries and products, simplifying development in edge cases
+- [**Vertigo-Studio**](/overview/studio) :  A dedicated design tool for business applications, enhancing efficiency and consistency
+
+Vertigo empowers developers to create robust and efficient applications while maintaining flexibility beyond typical management applications. It’s a platform designed to maximize value and accelerate project delivery

en/overview/connectors.md

@@ -0,0 +1,77 @@
+# Vertigo-Connectors
+
+The *Connectors* are somewhat special components. Their purpose is to provide other components with a pre-configured client/driver for a third-party product or library to simplify its use for the application developer.
+The advantage of such an approach is twofold:
+
+- **Simplify** the technological openness of Vertigo to include more innovation with controlled risk
+- **Help** the developer in edge cases that require the use of advanced functions of third-party products and libraries
+
+While the __extensions__ offer "high-level" usage-oriented APIs and therefore of great stability, the __connectors__ provide "low-level" access directly subject to the evolutions of third-party solutions.
+
+!> The use of __connectors__ in an application must be reasoned in order to minimize and centralize adhesions to third-party products and thus facilitate the scalability of the application.
+
+?> The plugins included in the Vertigo extensions use the __connectors__ to access third-party products and libraries.
+
+In the context of a project, it is very simple to add a new *Connector* if needed. This allows in particular to take advantage of the configuration mechanisms of a Vertigo application to configure the client/driver of the third-party library
+
+Each third-party solution has a dedicated module and possibly offers several *Connectors* if several access modalities are possible.
+
+The __connectors__ included in Vertigo are as follows
+
+## vertigo-redis-connector
+
+> Access to the [Jedis](https://github.com/redis/jedis) client
+
+## vertigo-elasticsearch-connector
+
+> Access to the [elasticsearch](https://github.com/elastic/elasticsearch) client, and starts an embedded ElasticSearch server
+
+## vertigo-javalin-connector
+
+> Starts a local [Javalin](https://github.com/tipsy/javalin) server or in Servlet Filter mode
+
+## vertigo-influxdb-connector
+
+> Access to the [influxdb-java](https://github.com/influxdata/influxdb-java) client
+
+## vertigo-keycloak-connector
+
+> Access to the Java client [KeyCloak](https://github.com/keycloak/keycloak)
+
+## vertigo-ldap-connector
+
+> Accesses an LDAP server via native Java APIs
+
+## vertigo-mail-connector
+
+> Provides a mail client via native Java APIs either directly or a JNDI resource
+
+## vertigo-mongodb-connector
+
+> Access to the Java client [mongodb-driver-sync](https://github.com/mongodb/mongo-java-driver)
+
+## vertigo-mqtt-connector
+
+> Access to the MQTT Java client [Paho](https://github.com/eclipse/paho.mqtt.java)
+
+## vertigo-neo4j-connector
+
+> Access to the Java bolt client of [Neo4j](https://github.com/neo4j/neo4j-java-driver)
+!> Starts a local Neo4J server (GPLv3 license)
+
+## vertigo-openstack-connector
+
+> Access to the Java client [openstack4j](https://github.com/openstack4j/openstack4j)
+
+## vertigo-spring-connector
+
+> Enriches the spring component space with Vertigo components to allow interoperability with [Spring](https://github.com/spring-projects/spring-framework) via the `@EnableVertigoSpringBridge` annotation
+
+## vertigo-twitter-connector
+
+> Access to the Java client [Twitter4j](https://github.com/Twitter4J/Twitter4J)
+
+## vertigo-iftt-connector
+
+> Accesses certain functions of the IFFT API via native code
+

en/overview/core.md

@@ -0,0 +1,65 @@
+# Core
+
+Vertigo-core is the mini framework that allows a Vertigo application to function. It is very light, very robust but has everything of a large one, its design being the fruit of several decades of efforts.
+
+Its missions for a Vertigo application are:
+
+- **Configure**: describes what it does and how it does it
+- **Run**: starts the application and stops it
+- **Monitor**: collects statistics to assess its state at any time
+
+To do this, an application consists of two distinct spaces:
+
+- **ComponentSpace**: the space of components, which corresponds to treatments (pure and stateless mathematical functions)
+- **DefinitionSpace**: the space of definitions, which corresponds to immutable information that describes the elements manipulated by the application.
+
+The startup cycle therefore aims to fill these two spaces. Once the application is started, these two spaces are locked (they can no longer be modified), the state of the application can no longer be altered. The result is a robust application, whose behavior is reproducible, without side effects, in a word **reliable**.
+
+## Configuration
+
+In the concept of configuration, we have chosen to differentiate the **structural** configuration of an application (what it does) from its settings (which influence how it operates). Thus, the configuration of a Vertigo application is done via two very different means:
+
+- the configuration: which lists the modules of the application and for each module the activated features (according to two modalities: YAML file or Java API)
+- the settings: which provide values of named parameters used by the components. (the provision of parameter values can be done by as many modalities as necessary via dedicated plugins)
+
+The configuration of the application is therefore by nature immutable, which is not the case for parameters that can have their own strategy.
+
+An application is made up of modules, each bringing both its **definitions** and its **components**.
+
+## Run
+
+Starting from the configuration and settings of an application, it is then possible to create an execution node (Node). The startup cycle is as follows:
+
+1. Creation of all components: module by module and using an inversion of control mechanism to resolve dependencies between components
+2. Locking of the component space (no new component can be registered)
+3. Registration of all definitions: module by module via the DefinitionProvider, the components themselves can be DefinitionProvider
+4. Locking of the definition space (no new definition can be registered)
+5. Starting of all components: call of the start() method of the activatable components, they then have access to the definition space 
+(5.bis Creation of ephemeral *Initializer* components for certain needs)
+6. Execution of pre-activation functions registered during the startup of the components.
+7. At the end of this startup cycle, the *Node* is ready, and all of its functionalities are usable via its components.
+
+When stopping the application node, all components are stopped in the reverse order of their startup.
+
+On the other hand, Vertigo-Core provides an execution environment dedicated to daemons, in the sense of a recurring technical task, through the `DaemonManager`. To register a new daemon, simply create a `DaemonDefinition`. A simplified way is to add the `@DaemonScheduled` annotation on a public method of a component registered in the `ComponentSpace`.
+
+
+## Monitor
+
+Once an application is started, it is important to monitor its activity and performance. A native analytics module is present in Vertigo to allow fine tracking of the treatments that are performed. It allows to follow three types of indicators:
+
+- **HealthStatus**: Allows to indicate a health status (red, orange, green) for a specific function
+- **AProcess**: Allows to trace complete executions within the application by passing through different checkpoints. This allows in particular to count the nature and duration of the different processes.
+- **Metric**: Allows to collect metrics at regular time intervals to follow the evolution over time of a characteristic of an application.
+
+Probes are placed at strategic locations of the treatments in the different Vertigo extensions. Each additional project/module can add new checkpoints for each type of indicator.
+
+## Plugin API
+
+- **analytics.socketLoggerConnector**: Analytics data is sent using the log4j/log4j2 SocketAppender connector
+  - `appName` *Optional*: Application name
+  - `hostName` *Optional*: Collection server
+  - `port` *Optional*: Collection port (default 4562 for log4j2, set to 4650 if you are using log4j)
+- **analytics.smartLoggerConnector**: Connector that analyzes the execution process and calculates the elapsed times and the number of calls
+  - `aggregatedBy` *Optional*: Defines the category of sub-processes to aggregate
+  - `durationThreshold` (ms) *Optional*: Threshold beyond which the call is logged as an error *(default 1000ms)*