docs: correct referances to the Frank!Framework

CONTRIBUTING.md

@@ -21,7 +21,7 @@ You can download Python and Pip from https://www.python.org/downloads/. You also
 * `pip install sphinx_rtd_theme`
 * `pip install pyyaml`
 
-WARNING: By the beginning of March 2021, the latest official Sphinx release does not build the Frank!Manual successful. The shown Sphinx release is a bugfix. WeAreFrank! does not know when this fix will be included in an official release.
+WARNING: By the beginning of March 2021, the latest official Sphinx release does not build the Frank!Manual successful. The shown Sphinx release is a bugfix. It is not known when this fix will be included in an official release.
 
 You may be able to use Linux instead of Windows and you may be able to do without MinGW. When using other tools, please check carefully whether everything works well. Make sure that you check-in all text files with UNIX-style line endings (not \r\n but \n).
 
@@ -51,22 +51,18 @@ The only exception is reference material about individual Java classes. This mat
 
 The manual should everywhere use the same word for the same thing, with the same spelling.
 
-#### WeAreFrank! and their Products
+#### Terminology
 
-In January 2020, the company Integration Partners changes their name to WeAreFrank!. Please use the right words to reference the company and their products, as listed below:
+Please use the right words to reference the company and their products, as listed below:
 
-* WeAreFrank!: The name of the company that produces the Frank!Framework. The exclamation sign is part of the company name, the dot isn't.
-* Frank!Framework: The product being documented in this manual. Note that the exclamation mark is part of the name and that there are two capitals. The dot is not part of the name.
-* Frank: A solution produced with the Frank!Framework. This is the combination of the Frank!Framework and Frank configs deployed on it.
-* Franks: Plural of Frank.
-* Frank config(uration): A set of XML files and property files that configures the Frank!Framework to provide a solution for a customer. A Frank config is typically created by a Frank developer. This word is also used for a set of adapters that is defined in or included from the same ``Configuration.xml`` file. When you have multiple ``Configuration.xml`` files within your Frank, you have multiple Frank configs.
-* ~Frank code~: For Java developers who edit this manual, it is tempting to use this phrase. We kindly ask them to write about "Frank config" instead. You do not have to be a programmer to use the Frank!Framework.
-* ~Frank language~: Franks are written in XML, not in a propriatary programming language. You can say that Frank configurations are XML documents that satisfy the Frank configuration schema.
-* Frank config(uration) schema: The XML schema document that defines what XML code is valid for configuring the Frank!Framework.
+* Frank!Framework: The organisation and product being documented in this manual. Note that the exclamation mark is part of the name and that there are two capitals. When no special characters are allowed, we use ``frankframework``.
+* Frank!: A solution produced with the Frank!Framework. This is the combination of the Frank!Framework and Frank configs deployed on it.
+* Franks!: Plural of Frank.
+* Frank!Config(uration): A set of XML files and property files that configures the Frank!Framework to provide a solution for a customer. A Frank config is typically created by a Frank developer. This word is also used for a set of adapters that is defined in or included from the same ``Configuration.xml`` file. When you have multiple ``Configuration.xml`` files within your Frank, you have multiple Frank configs.
+* Frank!Config(uration) schema: The XML schema document that defines what XML code is valid for configuring the Frank!Framework.
 * Frank!Console: The graphical user interface of the Frank!Framework.
 * Frank!Doc: A complement to this manual that is shorter but provides better search capability. It can be accessed through the Frank!Console.
-* Frank developer: Engineer who writes Frank configs.
-* integration specialist: Engineer who wants to integrate software systems at a customer site. She may be interested in using the Frank!Framework to do her job.
+* Frank!Developer: Engineer who writes Frank configs.
 
 #### Cross references
 

INSTALLATION_NO_ADMINISTRATOR.md

@@ -1,4 +1,4 @@
-If you do not have administrator rights on your computer, you need some hacks to get your development environment ready. Martijn Dirkse from WeAreFrank! expects that Git and MinGW can easily be installed without administrator rights. If you have trouble installing these tools, please contact Martijn Dirkse or WeAreFrank! (https://www.wearefrank.nl). The remainder of this page focuses on Python and Pip. That installer requires administrator rights to run.
+If you do not have administrator rights on your computer, you need some hacks to get your development environment ready. Martijn Dirkse expects that Git and MinGW can easily be installed without administrator rights. If you have trouble installing these tools, please contact Martijn Dirkse or any other maintainer. The remainder of this page focuses on Python and Pip. That installer requires administrator rights to run.
 
 To install Python and Pip without a Windows installer, please do the following:
 

docs/source/advancedDevelopment/deployment/basicFrankWebapp.rst

@@ -26,7 +26,7 @@ Some points of this file may need some explanation:
 
   .. NOTE::
 
-     You may want to work with a stable release, for example ``7.7``. Release ``7.7`` will work if you apply some minor changes to ``Configuration.xml``. To see what changes are needed, you need file the ``FrankConfig.xsd`` that belongs to that version of our framework. Please contact WeAreFrank! if you want this file.
+     You may want to work with a stable release, for example ``7.7``. Release ``7.7`` will work if you apply some minor changes to ``Configuration.xml``. To see what changes are needed, you need file the ``FrankConfig.xsd`` that belongs to that version of our framework. You can download the file from `GitHub <https://github.com/frankframework/frankframework/blob/master/core/src/main/resources/xml/xsd/FrankConfig.xsd>`_
 
   .. NOTE::
 
@@ -38,13 +38,13 @@ Some points of this file may need some explanation:
 * Jetty and Apache Tomcat do not fully satisfy the Jakarta EE specification. The Frank!Framework expects some classes that are part of the Jakarte EE specification, but that are not included in your application server. This has been fixed by including the ``geronimo-jms_1.1_spec`` dependency.
 * The Frank!Framework depends on some system properties that are explained in section :ref:`properties`. These are set in the ``<configuration>`` tag of the Jetty plugin. These settings only apply when Maven is used to start the project in application server Jetty. These values are not packaged.
 * Jetty scans JAR files included in the webapplication for web app configuration data. The number of JAR files searched is limited by the ``<webInfIncludeJarPattern>`` tag.
-* An application server can host multiple webapplication. It supports users to login to these webapplications. Some webapplications share users, while others keep track of their own users without sharing them. Application servers support this using login services. Each webapp can declare a login service. When multiple webapplications declare the same login service, they share their users. Jetty expects an implementation for every declared login service. This is the purpose of the ``<loginServices>`` tags: each inner ``<loginServices>`` tag fixes how the named login service is implemented. WeAreFrank! recently changed the name of the login service declared by the framework. The name changed from ``Ibis`` to ``Frank``. This is why two login services are listed.
+* An application server can host multiple webapplication. It supports users to login to these webapplications. Some webapplications share users, while others keep track of their own users without sharing them. Application servers support this using login services. Each webapp can declare a login service. When multiple webapplications declare the same login service, they share their users. Jetty expects an implementation for every declared login service. This is the purpose of the ``<loginServices>`` tags: each inner ``<loginServices>`` tag fixes how the named login service is implemented. Recently the name of the login service declared by the framework was changed. The name changed from ``Ibis`` to ``Frank``. This is why two login services are listed.
 
   .. NOTE::
 
      If application server Apache Tomcat is used, then implementations of login services can be omitted if the related webapplications do not require users to login.
 
-* The ``<repository>`` tag is needed to download Frank!Framework version 7.8-20220509.173348 or any other non-stable version. Only stable releases like 7.7 are published to Maven Central, the repository of all public artifacts. The ``<repository>`` tag allows access to a repository of Maven artifacts hosted by WeAreFrank!.
+* The ``<repository>`` tag is needed to download Frank!Framework version 7.8-20220509.173348 or any other non-stable version. Only stable releases like 7.7 are published to Maven Central, the repository of all public artifacts. The ``<repository>`` tag allows access to a repository of Maven artifacts hosted by Frank!Framework.
 
 4. Create ``work/src/main/resources/DeploymentSpecifics.properties`` with the following contents:
 

docs/source/advancedDevelopment/deployment/javaBasics.rst

@@ -12,6 +12,6 @@ A key concept with Java development is the **classpath**. When the JVM starts, i
 The remainder of this section presents instructions to give you hands-on experience. To follow them, you need Java and Maven. There are two ways to get started:
 
 #. Download the Frank!Runner. Execute the ``cmd.bat`` script in the checkout directory. This starts a command prompt with Maven at your disposal. Please keep in mind that you do not have Maven anymore after closing this command prompt. Start ``cmd.bat`` again to resume using Maven.
-#. Prepare yourself manually. Download the Java Development Kit (JDK) version 8. You do not need the Oracle JDK. An open JDK is sufficient; WeAreFrank! works with the `AdoptOpenJdk <https://adoptopenjdk.net/>`_. It is important to use JDK 8; earlier and later JDKs may not work. Second, you have to download `Apache Maven <https://maven.apache.org/download.cgi>`_. It is important to set system variable ``JAVA_HOME`` to reference the JDK you downloaded. Maven uses this variable to access Java.
+#. Prepare yourself manually. Download the Java Development Kit (JDK) version 8. You do not need the Oracle JDK. An open JDK is sufficient; At the Frank!Framework organisation the `AdoptOpenJdk <https://adoptopenjdk.net/>`_ is used. It is important to use JDK 8; earlier and later JDKs may not work. Second, you have to download `Apache Maven <https://maven.apache.org/download.cgi>`_. It is important to set system variable ``JAVA_HOME`` to reference the JDK you downloaded. Maven uses this variable to access Java.
 
 In both cases, the installation can be tested by typing ``mvn -v``. The output should show a Maven version and a Java version, which should include ``1.8``.

docs/source/advancedDevelopment/deployment/maven.rst

@@ -3,7 +3,7 @@
 Maven
 =====
 
-The Frank!Framework is a Java webapplication that integrates other applications. The Frank!Framework needs to be configured with XML files that describe how messages are received, transformed and sent to their target systems. Chapter :ref:`gettingStarted` explained how to write these configuration files. The configurations were executed with WeAreFrank!'s `Frank!Runner <https://github.com/ibissource/frank-runner>`_, which was useful during development. The Frank!Runner was not designed however to deploy Frank configurations to a production environment.
+The Frank!Framework is a Java webapplication that integrates other applications. The Frank!Framework needs to be configured with XML files that describe how messages are received, transformed and sent to their target systems. Chapter :ref:`gettingStarted` explained how to write these configuration files. The configurations were executed with the `Frank!Runner <https://github.com/ibissource/frank-runner>`_, which was useful during development. The Frank!Runner was not designed however to deploy Frank configurations to a production environment.
 
 Maven has been developed to build Java webapplications. The Frank!Framework is a Java webapplication. You can use Maven to package the Frank!Framework and one configuration into a single executable file. That file has extension ``.war``. It can be executed by an application server like `Apache Tomcat <https://tomcat.apache.org/>`_, `WildFly <https://www.wildfly.org/>`_, `JBoss EAP <https://developers.redhat.com/products/eap/overview>`_ or `WebSphere <https://www.ibm.com/cloud/websphere-application-server>`_. Maven projects can easily be tested and deployed within continuous delivery pipelines using for example `Jenkins <https://www.jenkins.io/>`_, `GitLab <https://about.gitlab.com/>`_  or `GitHub actions <https://github.com/features/actions>`_.
 

docs/source/advancedDevelopment/deployment/mavenWebapp.rst

@@ -29,7 +29,7 @@ Next, the ``pom.xml`` is updated:
 
 The Java compiler has to resolve the import of class ``javax.servlet.http.HttpServlet`` and some other classes. These are found in artifact ``javax.servlet``. Therefore, this artifact is added as a dependency. The artifat does not have to be packaged in the ``.war`` however, because every application server should provide the classes of this artifact. This common feature of application servers is required by the `Jakarta EE Servlet specification <https://jakarta.ee/specifications/servlet/>`_. It explains why there is an additional line ``<scope>provided</scope>`` in the ``pom.xml``.
 
-During development, we want to run our webapplication from the command prompt. For this purpose, Maven plugins have been created that start an application server and run the webapplication deployed in it. WeAreFrank! has chosen the ``jetty-maven-plugin`` that uses application server Jetty. We gain access to this plugin by adding it to the ``pom.xml``. Most developers prefer to use their Integrated Development Environment (IDE), for example Eclipse or IntelliJ IDEA, to run their webapplication. In Eclipse (and probably also IntelliJ IDEA, but the author did not test that), you can configure an applications server along with configuration settings to apply. This way, you can start your webapplication from a graphical user interface. You do not need a Maven plugin for this anymore. If you use Eclipse, you may experience errors that are hard to debug. Eclipse, Apache Tomcat and Maven do not cooperate perfectly. In this case, it may be helpful to have the command prompt and the ``jetty-maven-plugin`` as a backup.
+During development, we want to run our webapplication from the command prompt. For this purpose, Maven plugins have been created that start an application server and run the webapplication deployed in it. The ``jetty-maven-plugin`` uses the application server Jetty. We gain access to this plugin by adding it to the ``pom.xml``. Most developers prefer to use their Integrated Development Environment (IDE), for example Eclipse or IntelliJ IDEA, to run their webapplication. In Eclipse (and probably also IntelliJ IDEA, but the author did not test that), you can configure an applications server along with configuration settings to apply. This way, you can start your webapplication from a graphical user interface. You do not need a Maven plugin for this anymore. If you use Eclipse, you may experience errors that are hard to debug. Eclipse, Apache Tomcat and Maven do not cooperate perfectly. In this case, it may be helpful to have the command prompt and the ``jetty-maven-plugin`` as a backup.
 
 The webapplication is done. It can be started as follows:
 

docs/source/advancedDevelopment/properties/deploymentEnvironment.rst

@@ -39,7 +39,7 @@ Logical characteristics
 
 There are also logical characteristics of your deployment environment. These are not related to the infrastructure being used, but they reflect information about the way the deployment is used.
 
-First, it is wise to differentiate between test environments and production environments. In general, an enterprise application is first tested by the development team on a development environment (D). If the development team considers a release, the application is deployed and tested on a test environment (T). If these tests are successful, the application is delivered to the customer. The customer deploys the application on a test environment for acceptance testing (A). Only when the acceptance tests succeed, the application is deployed on the production environment (P). This story explains the meaning of the DTAP acronym. At WeAreFrank!, we add the L (Local) for development testing on the laptop of an individual developer.
+First, it is wise to differentiate between test environments and production environments. In general, an enterprise application is first tested by the development team on a development environment (D). If the development team considers a release, the application is deployed and tested on a test environment (T). If these tests are successful, the application is delivered to the customer. The customer deploys the application on a test environment for acceptance testing (A). Only when the acceptance tests succeed, the application is deployed on the production environment (P). This story explains the meaning of the DTAP acronym. The Frank!Framework uses an extra stage: the L (Local) for development testing on the laptop of an individual developer.
 
 The Frank!Framework expects that the deployer sets property ``dtap.stage`` to one of the following values: ``LOC``, ``DEV``, ``TST``, ``ACC`` or ``PRD``. Details on how to do this are in chapter :ref:`deploying`.
 

docs/source/advancedDevelopment/properties/framework.rst

@@ -99,7 +99,7 @@ warnings.suppress.sqlInjections.ManageDatabase
   From section :ref:`databaseInitialization`, remember that the Frank!Console offers the JDBC | Execute Query page, a service to Frank developers to enter SQL queries and have them executed! In DTAP stage LOC, the option to inject SQL is not a security risk. In this case, you want to suppress the warning. You can do this by setting this property to true.
 
 warnings.suppress.sqlInjections.<your adapter>
-   Set this property to true if you want your adapter to execute dynamic SQL on your database. Dynamic SQL statements are SQL statements that are generated based on user input. Such queries may be a security risk, because they may allow attackers to corrupt the database. In some situations, executing dynamic SQL statement is a useful service, however. An example is the "ManageDatabase" adapter provided by WeAreFrank!. This adapter is used to provide the JDBC | Execute Query page of the Frank!Console, see the description of the previous property ``warnings.suppress.sqlInjections.ManageDatabase``. If your adapter, say "myAdapter", was designed to process dynamic SQL, then suppress the warning by setting property ``warnings.suppress.sqlInjections.myAdapter`` to true.
+   Set this property to true if you want your adapter to execute dynamic SQL on your database. Dynamic SQL statements are SQL statements that are generated based on user input. Such queries may be a security risk, because they may allow attackers to corrupt the database. In some situations, executing dynamic SQL statement is a useful service, however. An example is the "ManageDatabase" adapter. This adapter is used to provide the JDBC | Execute Query page of the Frank!Console, see the description of the previous property ``warnings.suppress.sqlInjections.ManageDatabase``. If your adapter, say "myAdapter", was designed to process dynamic SQL, then suppress the warning by setting property ``warnings.suppress.sqlInjections.myAdapter`` to true.
 
 .. NOTE::
 
@@ -129,4 +129,4 @@ larva.timeout
 
   .. NOTE::
 
-     WeAreFrank! introduces the prefix ``soap.bus.`` in the property names because we use the CXF library for multiple purposes. In the future, we may need other Frank!Framework properties that map to the same CXF properties.
+    The prefix ``soap.bus.`` is in the property names because we use the CXF library for multiple purposes. In the future, we may need other Frank!Framework properties that map to the same CXF properties.