diff --git a/.gitignore b/.gitignore
index 0f6f5fb9..ca7505a9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,5 +28,5 @@ docs/tmp/
docs/java-getting-started/
docs/deploying-spring-boot-apps/
setenv.sh
-
+setenv.cmd
/etc/pom.xml
diff --git a/etc/development/archiv/deploying-spring-boot-apps.md b/etc/development/archiv/deploying-spring-boot-apps.md
deleted file mode 100644
index 91a0d368..00000000
--- a/etc/development/archiv/deploying-spring-boot-apps.md
+++ /dev/null
@@ -1,254 +0,0 @@
-```
-:::-- rundoc
-email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`
-
-Rundoc.configure do |config|
- config.project_root = "deploying-spring-boot-apps"
- config.filter_sensitive(email => "developer@example.com")
-end
-```
-
-
-The Spring Boot model of deploying standalone applications is a great
-fit for Heroku. You can use either Maven or Gradle to deploy a Spring application on Heroku, but for this guide we'll assume that you're using Maven and have [Maven 3](http://maven.apache.org/download.html) installed on your machine.
-
-To begin, create a [free Heroku account](https://signup.heroku.com/).
-Then download and install the Heroku CLI.
-
-Download the Heroku CLI
-
-Once installed, you can use the `heroku` command from the terminal to log in using the email address and password you used when creating your Heroku account:
-
-```term
-$ heroku login
-heroku: Press any key to open up the browser to login or q to exit
- › Warning: If browser does not open, visit
- › https://cli-auth.heroku.com/auth/browser/***
-heroku: Waiting for login...
-Logging in... done
-Logged in as me@example.com
-```
-
-To check that your key was added, run `heroku keys`. If your key isn’t there, you
-can add it manually by running `heroku keys:add`. For more information about SSH
-keys, see [Managing Your SSH Keys](https://devcenter.heroku.com/articles/keys).
-
-## Creating a Spring Boot app
-
-To create a new Spring Boot application, first install the Spring Boot CLI as described in the [Spring Boot documentation](https://docs.spring.io/spring-boot/docs/current/reference/html/cli-using-the-cli.html). This will add a `spring` command to your path.
-
->note
->You can also start with a working [sample app](https://github.com/heroku/java-getting-started) if you'd prefer.
-
-Use the CLI to create a new application by running this command:
-
-```term
-:::>- $ spring init --dependencies=web demo
-```
-
-Then move into the application directory:
-
-```term
-:::>- $ cd demo
-```
-
-The application does not have any custom logic by default -- it's just an empty template. To add some behavior, open the `src/main/java/com/example/demo/DemoApplication.java` file and put the following code in it:
-
-```java
-:::>> file.write src/main/java/com/example/demo/DemoApplication.java
-package com.example.demo;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.stereotype.*;
-
-@Controller
-@SpringBootApplication
-public class DemoApplication {
-
- @RequestMapping("/")
- @ResponseBody
- String home() {
- return "Hello World!";
- }
-
- public static void main(String[] args) {
- SpringApplication.run(DemoApplication.class, args);
- }
-}
-```
-
-This creates a simple request mapping that displayed "Hello World!" in the browser. You could run the application locally to confirm this, but we'll jump straight to running it on Heroku.
-
-## Preparing a Spring Boot app for Heroku
-
-Before you can deploy the app to Heroku, you'll need to create a Git repository for the application and add all of the code to it by running these commands:
-
-```term
-:::>- $ git init
-:::>- $ git add .
-:::>- $ git commit -m "first commit"
-```
-
-You'll deploy the app by pushing this Git repo to Heroku. It's also possible to deploy using the [Heroku Maven plugin](deploying-java-applications-with-the-heroku-maven-plugin), but this guide will focus on using Git and the Heroku CLI.
-
-In order to deploy to Heroku, you'll first need to provision a new Heroku app. Run this command:
-
-```term
-:::>> $ heroku create
-```
-
-This also creates a remote repository called `heroku` in
-your local git repo. Heroku generates a random name (in this case `nameless-lake-8055`)
-for your app. You can rename it later with the `heroku apps:rename` command.
-
-Now deploy your code:
-
-```term
-:::>- $ git push heroku master
-:::-> | $ (head -6; echo "..."; tail -18)
-```
-
-Heroku automatically detects the application as a Maven/Java app due to the presence of a `pom.xml` file. It installed Java 8 by default, but you can easily configure this with a `system.properties` file as described in the [Specifying a Java version](https://devcenter.heroku.com/articles/java-support#specifying-a-java-version) Dev Center article. It will run your app using the [default command](https://devcenter.heroku.com/articles/java-support#default-web-process-type).
-
-All that said, the application is now deployed. You can visit the app's URL by running this command:
-
-```term
-:::>- $ heroku open
-```
-
-You'll see the "Hello World!" text in the browser.
-
-You can view the logs for the application by running this command:
-
-```term
-:::>- background.start("heroku logs --tail", name: "tail", wait: "State changed from starting to up", timeout: 45)
-:::-> | tail -10
-:::-- background.stop(name: "tail")
-```
-
-Reload your application in the browser, and you’ll see another log message generated for that request. Press `Control+C` to stop streaming the logs.
-
-To learn more about the basics of deploying a Maven-based Java application on Heroku, try following the [Getting Started with Java on Heroku](getting-started-with-java) guide. This guide covers many steps that are not specific to Spring Boot.
-
-The remainder of this article provides a cursory overview of some of the most common settings you'll need to adjust.
-
-## Connecting to a database
-
-You can attach a PostgreSQL database to your app by running the following command from the CLI:
-
-```term
-:::>- $ heroku addons:create heroku-postgresql
-```
-
-If you prefer to use MySQL or another database vendor, check out [Add-ons Marketplace](https://elements.heroku.com/addons) to see what is available.
-
-Now you can list the configuration variables for your app to display the URL needed to connect to the database, DATABASE_URL:
-
-```term
-:::>> $ heroku config
-```
-
-Heroku also provides a `pg` command that shows a lot more:
-
-```term
-:::>> $ heroku pg
-```
-
-This indicates a hobby database (free) is running Postgres 9.3.3, with a single row of data.
-
-Once the database add-on has been created, Heroku will automatically populate the environment variables `SPRING_DATASOURCE_URL`, `SPRING_DATASOURCE_USERNAME`, and `SPRING_DATASOURCE_PASSWORD`. These environment variables should allow your Spring Boot application to connect to the database without any other configuration as long as you add a PostgreSQL JDBC driver to your dependencies like so:
-
-```xml
-:::>> file.append("pom.xml#26")
-
- org.springframework.boot
- spring-boot-starter-jdbc
-
-
- org.postgresql
- postgresql
-
-```
-
-You can customize your application's database configuration in your `application.properties`. For example:
-
-
-```properties
-:::>> file.write src/main/resources/application.properties
-spring.datasource.driverClassName=org.postgresql.Driver
-spring.datasource.maxActive=10
-spring.datasource.maxIdle=5
-spring.datasource.minIdle=2
-spring.datasource.initialSize=5
-spring.datasource.removeAbandoned=true
-```
-
-Then you can then add a configuration bean to your app.
-
-```java
-:::>> file.write src/main/java/demo/DatabaseConfig.java
-package com.example.demo;
-
-import com.zaxxer.hikari.*;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.*;
-import javax.sql.DataSource;
-
-@Configuration
-public class DatabaseConfig {
-
- @Value("${spring.datasource.url}")
- private String dbUrl;
-
- @Bean
- public DataSource dataSource() {
- HikariConfig config = new HikariConfig();
- config.setJdbcUrl(dbUrl);
- return new HikariDataSource(config);
- }
-}
-```
-
-```
-:::-- $ git add .
-:::-- $ git commit -m "database"
-:::-- $ git push heroku master
-:::-- $ cd ..
-:::-- $ mv demo deploying-spring-boot-apps
-```
-
-For more information, see [Connecting to Relational Databases on Heroku with Java](articles/connecting-to-relational-databases-on-heroku-with-java).
-
-Now your application should be able to connect to the database. You can follow our guide on [Running Database Migrations for Java Apps](https://devcenter.heroku.com/articles/running-database-migrations-for-java-apps) to initialize the database. The [sample app](https://github.com/kissaten/spring-boot-heroku-demo) uses Liquibase.
-
-## Customizing the boot command
-
-You can override the default command used to run your app or define custom process types using a [`Procfile`](https://devcenter.heroku.com/articles/procfile). The correct command depends on what you need to do with your app. Common process types are used to [run a web process](https://devcenter.heroku.com/articles/java-support#default-web-process-type) or [run database migrations](https://devcenter.heroku.com/articles/running-database-migrations-for-java-apps).
-
-## Next steps
-
-For more complete examples of Spring Boot apps that run on Heroku see:
-
-* [Getting Started on Heroku with Java](articles/getting-started-with-java#introduction)
-* [Spring Petclinic Demo for Heroku](https://github.com/kissaten/spring-petclinic)
-
-Heroku provides a wide range of features for Spring applications. You can provision
-add-ons that introduce third-party cloud services like persistence, logging, monitoring and more.
-The [add-on marketplace](https://elements.heroku.com/addons/#data-stores) has a large
-number of data stores, from Redis and MongoDB providers, to Postgres and MySQL.
-
-You can read more about [How Heroku Works](https://devcenter.heroku.com/articles/how-heroku-works)
-to get a technical overview of the concepts you’ll encounter while writing, configuring, deploying and running applications.
-Then visit the [Java category on Dev Center](https://devcenter.heroku.com/categories/java-support)
-to learn more about developing and deploying Spring applications.
-If you experience any trouble with your application as you migrate to Heroku, reach out to any of our [Support channels](https://devcenter.heroku.com/articles/support-channels).
-
-For more information on deploying Spring apps, see the [Spring documentation](http://projects.spring.io/spring-boot/#quick-start) and the [Spring Boot documentation on deploy to Heroku](http://docs.spring.io/spring-boot/docs/current/reference/html/cloud-deployment.html#cloud-deployment-heroku).
diff --git a/etc/development/archiv/java-getting-started.md b/etc/development/archiv/java-getting-started.md
deleted file mode 100644
index c63ccdd0..00000000
--- a/etc/development/archiv/java-getting-started.md
+++ /dev/null
@@ -1,554 +0,0 @@
-```
-:::-- rundoc
-email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`
-
-Rundoc.configure do |config|
- config.project_root = "java-getting-started"
- config.filter_sensitive(email => "developer@example.com")
-end
-```
-
-
-Introduction
-
-This tutorial will have you deploying a Java app in minutes.
-
-Hang on for a few more minutes to learn how it all works, so you can make the most out of Heroku.
-
-The tutorial assumes that you already have:
-
-* A free Heroku account
-* Java 8 installed
-* Maven 3 installed
-
-If you'd prefer to use Gradle instead of Maven, please see the [Getting Started with Gradle on Heroku](getting-started-with-gradle-on-heroku) guide.
-
-Set up
-
->callout
->The Heroku CLI requires **Git**, the popular version control system. If you don't already have Git installed, complete the following before proceeding:
->
-> * Git installation
-> * First-time Git setup
-
-In this step you'll install the Heroku Command Line Interface (CLI). You use the CLI to manage and scale your applications, provision add-ons, view your application logs, and run your application locally.
-
-Download and run the installer for your platform:
-
-
-
-When installation completes, you can use the `heroku` command from your terminal.
-
-On Windows, start the Command Prompt (cmd.exe) or Powershell to access the command shell.
-
-Use the `heroku login` command to log in to the Heroku CLI:
-
-```term
-$ heroku login
-heroku: Press any key to open up the browser to login or q to exit
- › Warning: If browser does not open, visit
- › https://cli-auth.heroku.com/auth/browser/***
-heroku: Waiting for login...
-Logging in... done
-Logged in as me@example.com
-```
-
-This command opens your web browser to the Heroku login page. If your browser is already logged in to Heroku, simply click the **Log in** button displayed on the page.
-
-This authentication is required for both the `heroku` and `git` commands to work correctly.
-
-Note that if you’re behind a firewall that requires use of a proxy to connect with external HTTP/HTTPS services, [you can set the `HTTP_PROXY` or `HTTPS_PROXY` environment variables](articles/using-the-cli#using-an-http-proxy) in your local development environment before running the `heroku` command.
-
-Prepare the app
-
-In this step, you will prepare a sample application that's ready to be deployed to Heroku.
-
->callout
->If you are new to Heroku, it is recommended that you
->complete this tutorial using the Heroku-provided sample application.
->
->However, if you have your own existing application that you want to deploy
->instead, see this article
->to learn how to prepare it for Heroku deployment.
-
-To create a local copy of a sample app that you can deploy to Heroku, execute the following commands in your local command shell or terminal:
-
-
-```term
-:::>- $ git clone https://github.com/heroku/java-getting-started
-:::>- $ cd java-getting-started
-:::-- $ git fetch
-:::-- $ git merge origin/master
-```
-
-You now have a functioning Git repository that contains a simple Java application. The application includes a `pom.xml` file, which is used by Java's dependency manager, Maven.
-
-Deploy the app
-
-In this step you'll deploy the sample app to Heroku.
-
-First, create an app on Heroku, which prepares Heroku to receive your source code:
-
-```term
-:::>> $ heroku create
-```
-
-When you create an app, a Git remote (named `heroku`) is also created and associated with your local Git repository.
-
-By default, Heroku generates a random name (in this case `warm-eyrie-9006`) for your app. You can pass a parameter to specify your own app name.
-
-Now deploy your code:
-
-```term
-:::>- $ git push heroku master
-:::-> | $ (head -6; echo "..."; tail -18)
-```
-
-The application is now deployed. Ensure that at least one instance of the app is running:
-
-```term
-:::>- $ heroku ps:scale web=1
-```
-
-Now visit the app at the URL generated by its app name. As a handy shortcut, you can open the website like so:
-
-```term
-:::>- $ heroku open
-```
-
-View logs
-
-Heroku aggregates all of the output streams from both your app and the platform's components into a single channel of time-ordered logs.
-
-View information about your running app using the `heroku logs --tail` command:
-
-```term
-:::>- background.start("heroku logs --tail", name: "tail", wait: "State changed from starting to up", timeout: 45)
-:::-> | tail -10
-:::-- background.stop(name: "tail")
-```
-
-Visit your application in the browser again to generate another log message.
-
-Press `CTRL+C` to stop streaming logs.
-
-Define a Procfile
-
-Heroku apps use a special plaintext file called the [Procfile](procfile) to explicitly declare what command should be executed to start your app.
-
-The `Procfile` in the example app you deployed looks like this:
-
-```yaml
-:::-> $ cat Procfile
-```
-
-This declares a single process type, `web`, and the command needed to run it. The name `web` is important here. It declares that this process type will be attached to Heroku's [HTTP routing](http-routing) stack, and it will be able to receive web traffic.
-
-Procfiles can contain additional process types. For example, you might declare one for a background worker that processes items off of a queue.
-
-Scale the app
-
-Right now, your app is running on a single web [dyno](dynos). A dyno is a lightweight Linux container that runs the command specified in your `Procfile`.
-
-You can check how many dynos are running using the `heroku ps` command:
-
-```term
-:::>> $ heroku ps
-```
-
-By default, your app is deployed on a free dyno. Free dynos sleep after thirty minutes of inactivity (i.e., if they don't receive any traffic). This causes a delay of a few seconds for the first request upon waking. Subsequent requests will perform normally.
-
-Free dynos consume from a monthly, account-level quota of [free dyno hours](free-dyno-hours). As long as the quota is not exhausted, your free apps can continue to run.
-
-To avoid dyno sleeping, you can upgrade to a hobby or professional dyno type as described in [Dyno Types](dyno-types). For example, if you migrate your app to a professional dyno, you can easily scale it by running a command telling Heroku to spin up a specific number of dynos, each running your web process type.
-
-Scaling an application on Heroku is equivalent to changing the number of dynos that are running.
-
-Scale the number of web dynos to zero:
-
-```term
-:::>- $ heroku ps:scale web=0
-```
-
-Access the app again by refreshing your browser or running `heroku open`. You will get an error message because your app no longer has any web dynos available to serve requests.
-
-Scale it up again:
-
-```term
-:::>- $ heroku ps:scale web=1
-```
-
-To prevent abuse, scaling a non-free application to more than one dyno requires [account verification](account-verification).
-
-Declare app dependencies
-
-Heroku automatically identifies an app as a Java app if it contains a `pom.xml` file in the root directory. You can create a `pom.xml` file for your own apps with the `mvn archetype:create` command.
-
-The demo app you deployed already has a `pom.xml` ([see it here](https://github.com/heroku/java-getting-started/blob/master/pom.xml)). Here's an excerpt:
-
-```xml
-:::-> $ sed -n '27,35p' pom.xml
-```
-
-The `pom.xml` file specifies dependencies that should be installed with your application. When an app is deployed, Heroku reads this file and installs the dependencies by running `mvn clean install`.
-
-Another file, `system.properties`, indicates the version of Java to use (Heroku supports many [different versions](java-support#supported-java-versions)). The contents of this optional file are straightforward:
-
-```
-:::-> $ cat system.properties
-```
-
-Run `mvn clean install` in your local directory to install the dependencies, preparing your system for running the app locally. Note that this app requires Java 8, but you can push your own apps using a different version of Java.
-
-```term
-:::>- $ mvn clean install
-:::-> | $ (echo "..."; tail -7)
-```
-
-If you do not have Maven installed, or get an error like `'mvn' is not recognized as an internal or external command`, then you can use the wrapper command instead by running `mvnw clean install` on Windows or `./mvnw clean install` on Mac and Linux. This both installs Maven and runs the Maven command.
-
-The Maven process compiles and build a JAR, with dependencies, placing it into your application's `target` directory. This process is accomplished with the `spring-boot-maven-plugin` in the `pom.xml`.
-
-If you aren't using Spring in your app, you can accomplish this with the following plugin configuration in the `pom.xml` file.
-
-```xml
-
- maven-assembly-plugin
- 3.0.0
-
-
- jar-with-dependencies
-
- helloworld
-
-
-```
-
-Once dependencies are installed, you can run your app locally.
-
-Run the app locally
-
-Start your application locally with the `heroku local` CLI command (make sure you've already run `mvn clean install`):
-
-```term
-:::>- background.start("heroku local web", name: "local1", wait: "Tomcat started", timeout: 30)
-:::-> | $ (echo "..."; tail -4)
-:::-- background.stop(name: "local1")
-```
-
-Just like the Heroku platform, `heroku local` examines your `Procfile` to determine what command to run.
-
-Open [http://localhost:5000](http://localhost:5000) with your web browser. You should see your app running locally.
-
-To stop the app from running locally, go back to your terminal window and press `CTRL+C` to exit.
-
-Push local changes
-
-In this step you'll learn how to make local changes to your app and deploy them to Heroku. As an example, you'll add a dependency and some code that uses it.
-
-Modify `pom.xml` to include a dependency for `jscience` by adding the following code inside the `` element:
-
-```xml
-:::>> file.append pom.xml#28
-
- org.jscience
- jscience
- 4.3.1
-
-```
-
-Now add the following `import` statements to `src/main/java/com/example/Main.java` to import the library:
-
-```java
-:::>> file.append src/main/java/com/example/Main.java#19
-import static javax.measure.unit.SI.KILOGRAM;
-import javax.measure.quantity.Mass;
-import org.jscience.physics.model.RelativisticModel;
-import org.jscience.physics.amount.Amount;
-```
-
-Add the following `hello ` method to `Main.java`:
-
-```java
-:::>> file.append src/main/java/com/example/Main.java#59
-@RequestMapping("/hello")
-String hello(Map model) {
- RelativisticModel.select();
- Amount m = Amount.valueOf("12 GeV").to(KILOGRAM);
- model.put("science", "E=mc^2: 12 GeV = " + m.toString());
- return "hello";
-}
-```
-
-Finally, create a `src/main/resources/templates/hello.html` file with these contents:
-
-```xml
-:::>> file.write src/main/resources/templates/hello.html
-
-
-
-
-
-
-```
-
-[Here's the final source code](https://github.com/heroku/java-getting-started/blob/localchanges/src/main/java/com/example/Main.java) for `Main.java` - yours should look similar. [Here's a diff](https://github.com/heroku/java-getting-started/compare/localchanges) of all the local changes you should have made.
-
-Now test your changes locally:
-
-```term
-:::>- $ mvn clean install
-:::-> | $ (echo "..."; tail -7)
-:::>- background.start("heroku local web", name: "local2", wait: "Tomcat started", timeout: 30)
-:::-> | $ (echo "..."; tail -4)
-:::-- background.stop(name: "local2")
-```
-
-Visiting your application's `/hello` path at [http://localhost:5000/hello](http://localhost:5000/hello), you should see some great scientific conversions displayed:
-
- E=mc^2: 12 GeV = (2.139194076302506E-26 ± 1.4E-42) kg
-
-Now you can deploy. Almost every Heroku deployment follows this same pattern. First, use the `git add` command to stage your modified files for commit:
-
-```term
-:::>- $ git add .
-```
-
-Next, commit the changes to the repository:
-
-```term
-:::>- $ git commit -m "Demo"
-```
-
-Now deploy, just as you did previously:
-
-```term
-:::>- $ git push heroku master
-```
-
-Finally, check that your updated code is successfully deployed:
-
-```term
-:::>- $ heroku open hello
-```
-
-Define config vars
-
-Heroku lets you externalize your app's configuration by storing data such as encryption keys or external resource addresses in [config vars](config-vars).
-
-At runtime, config vars are exposed to your app as environment variables. For example, modify `src/main/java/com/example/Main.java` so that the method obtains an energy value from the `ENERGY` environment variable:
-
-```
-:::-- $ sed -e '56,68d' src/main/java/com/example/Main.java
-```
-
-```java
-:::>> file.append("src/main/java/com/example/Main.java#56")
-@RequestMapping("/hello")
-String hello(Map model) {
- RelativisticModel.select();
- String energy = System.getenv().get("ENERGY");
- if (energy == null) {
- energy = "12 GeV";
- }
- Amount m = Amount.valueOf(energy).to(KILOGRAM);
- model.put("science", "E=mc^2: " + energy + " = " + m.toString());
- return "hello";
-}
-```
-
-Now compile the app again so that this change is integrated by running `mvn clean install`.
-
-`heroku local` automatically sets up your local environment based on the contents of the `.env` file in your app's root directory. Your sample app already includes a `.env` file with the following contents:
-
-```
-ENERGY=20 GeV
-```
-
->warning
->Your own apps should _not_ commit the `.env` file to version control, because it often includes secure credentials. Include `.env` in your repo's `.gitignore` file.
-
-If you run the app with `heroku local` and visit it at [http://localhost:5000/hello](http://localhost:5000/hello), you'll see the conversion value for 20 GeV.
-
-To set the config var on Heroku, execute the following:
-
-```term
-:::>> $ heroku config:set ENERGY="20 GeV"
-```
-
-View the config vars that are set using `heroku config`:
-
-```term
-:::>> $ heroku config
-```
-
-Deploy your updated application to Heroku to see this in action.
-
-Start a one-off dyno
-
-The `heroku run` command lets you run maintenance and administrative tasks on your app in a [one-off dyno](one-off-dynos). It can also lets you launch a REPL process attached to your local terminal for experimenting in your app's environment, or code that you deployed with your application:
-
-```term
-:::>- $ heroku run java -version
-:::-> | $ tail -4
-```
-
-If you receive an error, `Error connecting to process`, then you might need to [configure your firewall](one-off-dynos#timeout-awaiting-process).
-
-Don’t forget to type `exit` to exit the shell and terminate the dyno.
-
-Provision add-ons
-
-Add-ons are cloud services that provide additional services for your application, such as databases, logging, and monitoring.
-
-By default, Heroku stores your app's 1500 most recent log lines. However, the full log stream is available as a service, and several logging add-ons are available that provide features such as log persistence, search, and alerting.
-
-In this step you'll provision one of these logging add-ons, Papertrail.
-
-Provision the [Papertrail](papertrail) add-on like so:
-
-```term
-:::>> $ heroku addons:create papertrail
-```
-
->callout
->To help prevent abuse, provisioning an add-on requires [account verification](account-verification). If your account has not been verified, you will be directed to visit the [verification site](https://heroku.com/verify).
-
-The add-on is now deployed and configured for your application. You can list your app's active add-ons like so:
-
-```term
-:::>- $ heroku addons
-```
-
-To see this particular add-on in action, visit your application's Heroku URL a few times. Each visit generates more log messages, which should now be routed to the Papertrail add-on. Visit the Papertrail console to see the log messages:
-
-```term
-:::>- $ heroku addons:open papertrail
-```
-
-Your browser will open up a Papertrail web console that shows the latest log events. The interface lets you search and set up alerts:
-
-
-
-Use a database
-
-Heroku provides managed data services for Postgres and Redis, and the [add-on marketplace](https://elements.heroku.com/addons/categories/data-stores) provides a variety of additional data services, including MongoDB and MySQL.
-
-In this step you'll learn about the free Heroku Postgres add-on that is provisioned automatically with all Java app deploys.
-
-Heroku Postgres is itself an add-on, so you can use the `heroku addons` command for an overview of the database provisioned for your app:
-
-```term
-:::>> $ heroku addons
-```
-
-Listing your app's config vars will display the URL that your app is using to connect to the database (`DATABASE_URL`):
-
-```term
-:::>> $ heroku config
-```
-
-The `heroku pg` command provides more in-depth information on your app's Heroku Postgres databases:
-
-```term
-:::>> $ heroku pg
-```
-
-This indicates that the app has a `Hobby-dev` database (the free plan), running Postgres 9.3.3, currently with zero rows of data.
-
-The example app you deployed already has database functionality, which you can reach by visiting your app's `/db` path. For example, if your app's root URL is `https://wonderful-app-287.herokuapp.com/` then visit `https://wonderful-app-287.herokuapp.com/db`.
-
-The code to access the database is straightforward. Here's the method to insert values into a table called `tick`:
-
-```java
-:::-> $ sed -n '45,50p;78,109p' src/main/java/com/example/Main.java
-```
-
-This ensures that when you access your app using the `/db` route, a new row is added to the `tick` table, and all rows are then returned so that they can be rendered in the output.
-
-The HikariCP database connection pool is initialized with the configuration value `spring.datasource.url`, which is defined in `src/main/resources/application.properties` like this:
-
-```
-:::-> $ sed -n '1p' src/main/resources/application.properties
-```
-
-This sets `spring.datasource.url` to the value in the `JDBC_DATABASE_URL` environment variable, [set by the database add-on](articles/connecting-to-relational-databases-on-heroku-with-java), and establishes a pool of connections to the database.
-
-Deploy your changes to Heroku. Now, when you access your app's `/db` route, you will see something like this:
-
-```
-Database Output
-* Read from DB: 2014-08-08 14:48:25.155241
-* Read from DB: 2014-08-08 14:51:32.287816
-* Read from DB: 2014-08-08 14:51:52.667683
-```
-
-Assuming that you have [Postgres installed locally](heroku-postgresql#local-setup), use the `heroku pg:psql` command to connect to the remote database and see all the rows:
-
-```term
-$ heroku pg:psql
-psql (10.1, server 9.6.10)
-SSL connection (protocol: TLSv1.2, cipher: ECDHE-RSA-AES256-GCM-SHA384, bits: 256, compression: off)
-Type "help" for help.
-
-DATABASE=> SELECT * FROM ticks;
- tick
-----------------------------
-2018-03-01 20:53:27.148139
-2018-03-01 20:53:29.288995
-2018-03-01 20:53:29.957118
-2018-03-01 21:07:28.880162
-(4 rows)
-=> \q
-```
-
-Read more about [Heroku PostgreSQL](heroku-postgresql).
-
-A similar technique can be used to install [MongoDB or Redis add-ons](https://elements.heroku.com/addons/categories/data-stores).
-
-
-## Next steps
-
-Congratulations! You now know how to deploy an app, change its configuration, scale it, view logs, and attach add-ons.
-
-Here's some recommended reading to continue your Heroku journey:
-
-* [How Heroku Works](how-heroku-works) provides a technical overview of the concepts you’ll encounter while writing, configuring, deploying, and running apps.
-* The [Java category](/categories/java-support) provides more in-depth information on developing and deploying Java apps.
-* The [Deployment category](/categories/deployment) provides a variety of powerful integrations and features to help streamline and simplify your deployments.
diff --git a/etc/development/db-createdb-and-user-linux.sql b/etc/development/db-createdb-and-user-linux.sql
new file mode 100644
index 00000000..e0aedde1
--- /dev/null
+++ b/etc/development/db-createdb-and-user-linux.sql
@@ -0,0 +1,45 @@
+
+CREATE USER simpleworklist WITH PASSWORD 'simpleworklistpwd' SUPERUSER INHERIT CREATEDB CREATEROLE REPLICATION;
+
+GRANT pg_monitor TO simpleworklist;
+GRANT pg_read_all_settings TO simpleworklist;
+GRANT pg_read_all_stats TO simpleworklist;
+GRANT pg_signal_backend TO simpleworklist;
+GRANT pg_stat_scan_tables TO simpleworklist;
+
+
+CREATE DATABASE simpleworklist WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_default WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist_default TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_branch_master WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist_branch_master TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_testing WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist_testing TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_qa WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist_qa TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_qa WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist_qa TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_heroku WITH OWNER simpleworklist TEMPLATE 'template1' ENCODING 'UTF8' LC_COLLATE 'de_DE.UTF-8' LC_CTYPE 'de_DE.UTF-8';
+
+GRANT ALL ON DATABASE simpleworklist_heroku TO simpleworklist WITH GRANT OPTION;
+
+
+GRANT ALL ON DATABASE artifactory TO artifactory WITH GRANT OPTION;
+
+
+
+
+
diff --git a/etc/development/db-createdb-and-user-win10.sql b/etc/development/db-createdb-and-user-win10.sql
new file mode 100644
index 00000000..b90462d0
--- /dev/null
+++ b/etc/development/db-createdb-and-user-win10.sql
@@ -0,0 +1,45 @@
+
+CREATE USER simpleworklist WITH PASSWORD 'simpleworklistpwd' SUPERUSER INHERIT CREATEDB CREATEROLE REPLICATION;
+
+GRANT pg_monitor TO simpleworklist;
+GRANT pg_read_all_settings TO simpleworklist;
+GRANT pg_read_all_stats TO simpleworklist;
+GRANT pg_signal_backend TO simpleworklist;
+GRANT pg_stat_scan_tables TO simpleworklist;
+
+
+CREATE DATABASE simpleworklist WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_default WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist_default TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_branch_master WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist_branch_master TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_testing WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist_testing TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_qa WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist_qa TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_qa WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist_qa TO simpleworklist WITH GRANT OPTION;
+
+CREATE DATABASE simpleworklist_heroku WITH OWNER simpleworklist TEMPLATE 'template0' ENCODING 'UTF8' LC_COLLATE 'de-DE' LC_CTYPE 'de-DE';
+
+GRANT ALL ON DATABASE simpleworklist_heroku TO simpleworklist WITH GRANT OPTION;
+
+
+GRANT ALL ON DATABASE artifactory TO artifactory WITH GRANT OPTION;
+
+
+
+
+
diff --git a/setenv-sample.cmd b/setenv-sample.cmd
new file mode 100644
index 00000000..6e8d1b95
--- /dev/null
+++ b/setenv-sample.cmd
@@ -0,0 +1,10 @@
+@echo on
+set PORT=5000
+set MAIL_SMTP_HOST=mailhost
+set MAIL_SMTP_PORT=465
+set MAIL_SMTP_USERNAME='mailuser'
+set MAIL_SMTP_PASSWORD='mailuserpassword'
+set MAIL_FROM='noreply@example.org'
+set MAIL_URL_APP_HOST='localhost:5000'
+set JPA_DLL_AUTO='update'
+#set JPA_DLL_AUTO='create-drop'
macOS
-
- 
Windows
- 
Ubuntu 16+
-