The importance of visual feedback

To create an exercise we start with a plan, depending of training stage, the purpose of the exercise, etc. imagining how it is going to look like. When the goal is defined, initial data prepared; starts the process of running a simulation to validate the data - further refinements to match the initial goal. The goal is a realistic simulation with appropriate sector occupancy matching the training plan. If there's anything wrong, we go back to an editor (it's usually a text one), make necessary adjustments, save, export and re-run the simulation to verify the results. If new ideas come up along the way - we go back to the editor. Most of the time, refining the exercise is spent in the editor working on text without an immediate connection to the impact of the edits. We have to maintain mental mapping and predict the impact of the modifications which can be overwhelming at times, eg. when a simulation includes multiple sectors and a lot of vertical profile changes.

Switching context to edit and run a simulator to validate inputs, interferes with the thought process making a complex simulation time-consuming and imprecise. It causes some of the initial plans to be skipped because of new conflicts occurring; the corners are cut by leaving out some of the elements for the sake of time and resource constraints.

Live editing with an interactive simulator in background

ATCStudio tests the way of designing simulations with an immediate response without the need of running a simulator to see and validate results. It explores the solution of making the process interactive and focused, using the tools ATCO is already familiar with, avoiding the need for switching context in the edit-reload-run loop.


A flight in the app can be created by choosing any location on the display. The clicked location becomes the flight starting position. The pre-populated "New Flight Sheet" will pop up (data can be edited) with the routes sorted by distance from the clicked position, it auto-selects the nearest flight route.
As soon as the flight is created, the simulation is updated and can be tested immediately. A time slider controlling the simulation time is located at the bottom of the display. Dragging a mouse over the time slider moves the simulation time back and forth displaying the traffic situation changes as you drag over the timeline (or rotate a mouse wheel).

Creating FPL and time control

After a flight's been created, the flight position can be modified by dragging and dropping the flight symbol to a new location at any time of the simulation. When the flight position is changed it's reflected immediately. Seeing the changes instantly is crucial for developing the exercise and carrying out the proposed plan.
If the dragging is started when the flight is at its starting position, dragging the flight symbol is going to change the starting position without changing the flight start time.

Changing a flight initial position

A flight position can be modified while the flight is somewhere along its route, not just at the initial position. eg. if you realise you want the flight to be slightly further or back along its route, in the middle of the simulation, you can simply drag the flight symbol along the route and drop it at another position on the route. It allows precise positioning of the flight to a new location along its route at any time.

In the example below, we're at time 00:04:28 of the simulation and we notice TCW502 having short separation with another traffic. We can move to the desired time on time slider, grab one of the flights and drag it back or forth along its route to adjust the separation between the flights at a specific time. The current simulation time will stay the same, but TCW502 position is going to change as you drag the mouse.
In the background, the operation is going to re-calculate the flight plan start time, respecting the aircraft type performance, calculating new start time to reach the specified position at the current time on the time slider:

Interactive retiming along a flight route

A flight plan re-timing can be also performed via Flight List window. The flight list shows the planning map of all the flight plans in the simulation. Sliding a flight strip changes the flight start time/position accordingly. It may be less precise than dragging the flight symbol on the display interactively, but the flight list provides a good overview of all the flights in the simulation and visual overview of the estimated times along the flights' routes and time occupancy. The flights' strips can be arranged vertically or arbitrary sorted. The list is always in sync with the simulation and displays the latest changes. By default, the flights are sorted by the assigned FL, but it can be overridden by drag and drop.

Flights list and sectors occupancy overview

Re-timing a flight or updating the flight position automatically triggers real-time:

• route recalculation
• safety net analysis
• sector occupancy recalculation

Making it easier to get an overview of the occupancy of the sectors and conflicts between the flights at any time of the simulation. This way the simulation can be adjusted to match the initial exercise plan without interrupting the design workflow, without leaving the display screen from start to finish, providing immediate feedback of the changes. If necessary, the flight plan route can be edited on the fly.
Changing and analysing vertical profile changes are the same as we do it at a workplace, where the impact on other flights and sectors can be analysed for each second; there is a real-time display of the sectors occupancy. FL change action is recorded and can be undone at any time during a simulation. The unlimited undo/redo is part of the workflow, any destructive operation can be undone (route, FL, position change...) so there is no fear of making mistakes or starting over.

Changing a vertical profile, route and unlimited undo/redo

Integration

Once the exercise plan is fulfilled, the flight plan data can be exported to another format acceptable to another software. For internal use, I wrote BEST exporter module, but with plug-in modules, the simulation data can be exported to a format readable to another system.
We tested using Eurocontrol NEST output, importing the previous traffic data into the app to capture and replay some of the peak hours. The scenario is useful eg. when creating contingency training exercises.

Learning

ATCStudio can be used as a learning tool for both OJTI and ATC students. It takes a minute to create a traffic situation and validate possible results (radar vectoring, wind impact, route network, etc.), Different outcomes can be tested fast, with minimal interference due interactive create, edit, undo/redo support, with a minimal learning curve, in the familiar interface used at a workplace.

Further Improvements

Real-time safety net and airspace analysis are computationally expensive. ATCStudio goal is to keep 'close to real-time' interactivity so it doesn't reduce the degree of flexibility or impair thought process during working on an exercise, that is the paramount feature.
Since there can be a lot of elements processing at the same time, offloading a part of the computations to the graphic unit would improve responsiveness since the computational workload would be shared between CPU and GPU. It's significant for RT airspace analysis. I tested it on a small part.
It'd be interesting to connect the app to a real-time system eg. flight-radar to be able to capture and create simulations from real-time data.
Machine learning and analysis can help to automate and prototype new ideas.

A plan is to publish and maintain ATCStudio free for personal and educational use. If you're interested in supporting the development or have a suggestion, feel free to send me an email.

Technical Details

ATCScenario is written in Swift, SwiftUI, it runs on MacOS 10.15+. It's compatible with iPadOS (tested on iPad Pro, iPadOS 13.4) with minimal changes. For the initial release I focused on the desktop version since when editing a simulation on a smaller screen, the display easily becomes overcrowded.
PROJ.4 is used for cartographic projection and coordinate transformations.
Initially, the idea was born after I attended IANS - 'Design of ATC Simulation Exercises' course and working with different systems at SMATSA.

Resources

SKYbrary
Aviation Formulary

Be advised, since we're going to run both Lisk Core and Neo4j in docker (to speed up the process and avoid Lisk and Neo4j installations), the tutorial assumes you have docker installed and running, and you're familiar with terminal. (I'm running macOS but the process should be the same on other operating systems.)

Run Lisk Core in Docker

First, we need to run and synchronise Lisk Core to have the latest blockchain data available.

1. Download and unzip this archive. The archive contains docker configuration for Lisk Core (mainnet) and Adminer.
2. cd to folder where you've downloaded and extracted the archive and run curl --output main_blockchain.db.gz https://downloads.lisk.io/lisk/main/blockchain.db.gz to download the latest Lisk blockchain snapshot. (It'll be used by step 3, otherwise it'll take days to synchronise database from scratch.)
3. Run make coldstart (it's necessary only first time) to start Lisk docker container.
4. Take a coffee, it will take some time for the script to populate Lisk database from the snapshot...

Run Neo4j in Docker

Once we have Lisk Core synchronised and running, we're going to start Neo4j in docker. Open a terminal window and run:

docker run \  
    --name testneo4j \
    -p7474:7474 -p7687:7687 \
    -d \
    -v $HOME/Docker/neo4j/data:/data \
    -v $HOME/Docker/neo4j/logs:/logs \
    -v $HOME/Docker/neo4j/import:/var/lib/neo4j/import \
    -v $HOME/Docker/neo4j/plugins:/plugins \
    --env NEO4J_AUTH=neo4j/test \
    neo4j:latest

Once Neo4j container is up and running you can start Neo4j browser. Go to http://localhost:7474/ in your browser to get feel of Neo4j browser.

Export data from Postgres (Lisk) database to CSV

With both Neo4j and Lisk ready, we're ready to export blockchain data to csv files later to imported to Neo4j:

1. Open a termninal window and type: psql -h localhost -p 5432 -U lisk lisk to connect to Lisk Postgres database (enter 'password' when asked for password) .
2. Enter commands below in psql shell to export the data as csv:

\COPY (SELECT address, balance FROM mem_accounts) TO '/Users/sdrpa/Downloads/accounts.csv' WITH CSV header;
\COPY (SELECT id, trs."senderId", trs."recipientId", timestamp, amount FROM trs WHERE type = 0) TO '/Users/sdrpa/Downloads/trs.csv' WITH CSV header;

After that you'll have accounts.csv and trs.csv files ready to be imported to Neo4j.

Import CSV data to Neo4j database

We need to copy accounts.csv and trs.csv to Neo4j container to be able to import the data to Neo4j.
Open a terminal window and run:

docker cp accounts.csv testneo4j:/var/lib/neo4j/import/accounts.csv  
docker cp accounts.csv testneo4j:/var/lib/neo4j/import/trs.csv  

Alternatively, you can use Finder to copy the files to $HOME/Docker/neo4j/import/ (but it's only applicable to macOS)

Now we need to create the nodes and the relationships for Neo4j graph. We'll do it using cypher shell.
Open a terminal window and run cypher-shell -u neo4j -p test to start Neo4j cypher shell.
In cypher shell type:

```
// Create accounts
USING PERIODIC COMMIT  
LOAD CSV WITH HEADERS FROM "file:///accounts.csv" AS row  
CREATE (:Account {address: row.address, balance: toInteger(row.balance) / 10^8});

// Create transactions
USING PERIODIC COMMIT  
LOAD CSV WITH HEADERS FROM "file:///trs.csv" AS row  
CREATE (:Transaction {tid: row.id, timestamp: date(datetime({epochSeconds: toInteger(row.timestamp) + 1464109200})), amount: toInteger(row.amount) / 10^8});

// Create indexes
CREATE INDEX ON :Account(address);  
CREATE INDEX ON :Transaction(tid);

// Create SEND_TO relationship
USING PERIODIC COMMIT  
LOAD CSV WITH HEADERS FROM "file:///trs.csv" AS row  
MATCH (sender:Account {address: row.senderId})  
MATCH (recipient:Account {address: row.recipientId})  
MERGE (sender)-[:SENT_TO]->(recipient);  

It creates Neo4j models (Account, Transaction) and (SENT_TO) relationship.

Explore blockchain transactions flow

Finally, you're ready to explore Lisk accounts and transactions flow with Neo4j browser.
Open Neo4j browser in your browser http://localhost:7474/ and enter initial query:

MATCH (sender:Account { address: '5055500162731337929L' })-[:SENT_TO]->(recipient:Account)  
RETURN sender, recipient  

Maximize graph window and start exploring:

Resources

SQL on Lisk blockchain via Lisk Docker and Adminer
How-To: Run Neo4j in Docker
Tutorial: Import Relational Data Into Neo4j

Chain Story's client is a React app. The backend interacting with IPFS and Lisk API is written in Golang.

Both the client and server source code are available at:

https://github.com/sdrpa/chainstory-client
https://github.com/sdrpa/chainstory-server

Lisk Docker will be used to automate the setup of the server, Lisk Core and PostgreSQL web client.
This tutorial assumes you have Docker installed and running.

First, download and unzip this archive.
(The archive contains docker-compose.yml, a copy of Lisk Docker mainnet image with additional postgres port exposed[1] and added Adminer image - PostgreSQL web client.)

Open Terminal, cd to directory where you unzipped archive and run:

make coldstart  

Get a coffee and wait until it completes. This can take a few minutes.
(It will download the latest Lisk blockchain snapshot, docker images, create docker containers, start Lisk Core and restore Lisk blockchain database from the snapshot.)

Once done, it will auto-start synchronizing Lisk Core with main chain.
(You can visit http://localhost:8000/api/blocks/getHeight to check the current block height.)

Now open http://localhost:8080 to access Adminer login page:

Use:

System: PostgreSQL  
Server: db  
Username: lisk  
Password: password  
Database: lisk_main  

Once logged in, click SQL command link and you're ready to execute SQL queries!

Here are some SQL queries you may find useful:

Which delegate paid me the most?

-- Which delegate paid me the most
WITH xs AS (  
  SELECT "senderId" AS address, username AS delegate
  FROM trs
  JOIN delegates ON delegates."transactionId" = trs."id"
)
SELECT  
  delegate, 
  SUM(trunc(amount::numeric/100000000, 8)) as amount
FROM trs  
JOIN xs ON xs.address = trs."senderId"  
WHERE "recipientId" = '14775206447342278732L' AND amount > 0  
GROUP BY delegate  
ORDER BY amount DESC;  

-- Which delegate paid me the most in the last n days, months...
WITH xs AS (  
  SELECT "senderId" AS address, username AS delegate
  FROM trs
  JOIN delegates ON delegates."transactionId" = trs."id"
), constants(LISK_EPOCH) AS (
  -- 1464109200 = Lisk Epoch (2016–05–24T17:00:00.000Z)
  VALUES (1464109200)
)
SELECT  
  delegate, 
  SUM(trunc(amount::numeric/100000000, 8)) as amount
FROM constants, trs  
JOIN xs ON xs.address = trs."senderId"  
JOIN blocks ON blocks.id = trs."blockId"  
WHERE to_timestamp(blocks."timestamp" + LISK_EPOCH)  
  BETWEEN (now() - '6 months'::interval) AND now() -- Use '1 day', '2 days', '1 week', '6 months'...
AND amount > 0  
AND "recipientId" = '14775206447342278732L'  
GROUP BY delegate  
ORDER BY amount DESC;  

Lisk Distribution

SELECT t.arange AS amount_range, COUNT(*) AS num_accounts  
FROM (  
  SELECT address, username AS delegate,
    CASE
      WHEN balance/100000000 <= 0                                             THEN '0'
      WHEN balance/100000000 > 0          AND balance/100000000 <= 1          THEN '0-1'
      WHEN balance/100000000 > 1          AND balance/100000000 <= 10         THEN '1-10'
      WHEN balance/100000000 > 10         AND balance/100000000 <= 100        THEN '10-100'
      WHEN balance/100000000 > 100        AND balance/100000000 <= 1000       THEN '100-1000'
      WHEN balance/100000000 > 1000       AND balance/100000000 <= 10000      THEN '1000-10000'
      WHEN balance/100000000 > 10000      AND balance/100000000 <= 100000     THEN '10000-100000'
      WHEN balance/100000000 > 100000     AND balance/100000000 <= 1000000    THEN '100000-1000000'
      WHEN balance/100000000 > 1000000    AND balance/100000000 <= 10000000   THEN '1000000-10000000'
      WHEN balance/100000000 > 10000000   AND balance/100000000 <= 100000000  THEN '10000000-100000000'
      WHEN balance/100000000 > 100000000                                      THEN '100000000+'
      ELSE 'unknown'
    END AS arange
  FROM mem_accounts
) AS t
GROUP BY t.arange  
ORDER BY t.arange DESC;  

How much lisk is forged by each delegate

WITH xs AS (  
  SELECT "senderId" AS address, username AS delegate, "senderPublicKey" AS publicKey
  FROM trs
  JOIN delegates ON delegates."transactionId" = trs."id"
)
SELECT  
  delegate,
  SUM(reward/100000000) as reward
FROM blocks  
JOIN xs ON xs.publicKey = blocks."generatorPublicKey"  
WHERE reward > 0  
GROUP BY delegate  
ORDER BY reward DESC;  

Total Lisk from forging (block rewards)

SELECT  
  SUM(reward/100000000) as reward
FROM blocks;  

Above returns 24,453,036. Current supply according to Lisk Explorer is 124,453,036. I guess supply is the sum of the block (forging) rewards and 100,000,000 (premind Lisk)

All outgoing transactions for an account

-- Outgoing transactions
WITH constants(LISK_EPOCH) AS (  
  -- 1464109200 = Lisk Epoch (2016–05–24T17:00:00.000Z)
  VALUES (1464109200)
)
SELECT to_timestamp(blocks."timestamp" + LISK_EPOCH) as datetime,  
  "senderId", trunc(amount::numeric/100000000, 8) as amount
FROM constants, trs  
JOIN blocks ON blocks.id = trs."blockId"  
WHERE "senderId" = '14775206447342278732L' AND amount > 0;  

All incoming transactions for an account

-- Incoming transactions
WITH constants(LISK_EPOCH) AS (  
  -- 1464109200 = Lisk Epoch (2016–05–24T17:00:00.000Z)
  VALUES (1464109200)
)
SELECT to_timestamp(blocks."timestamp" + LISK_EPOCH) as datetime,  
  "senderId",
  --"recipientId", 
  trunc(amount::numeric/100000000, 8) as amount
FROM constants, trs  
JOIN blocks ON blocks.id = trs."blockId"  
WHERE "recipientId" = '14775206447342278732L' AND amount > 0  
ORDER BY amount DESC;  
--ORDER BY datetime DESC;

To clean

docker-compose down  

To start again

docker-compose up  

[1] Not necessary for this tutorial, it's required if you want to use own PostgreSQL client eg. pgAdmin

Create a test account

Use Lisk Nano to create an account on testnet and register it as delegate. You'll need some test Lisk to register as delegate (the delegate registration costs 25 LSK). I asked on lisk.chat for some test Lisk (thanks @lisksnake).

Create a droplet (server node)

For this tutorial, a 4GB - 2vCPUs - 80GB SSD - 16.04.3 x64 droplet is used.

If you've never created a droplet before, follow this guide. You can choose a different configuration but be advised I found 2GB of RAM is the minimum when installing Lisk from source (otherwise npm install won't work correctly).

Once you've created the droplet, you will receive an email from digitalocean containing the IP address and the root password required to access the droplet:

ssh root@123.456.789.012  

There is a very good tutorial on how to do Initial Setup with Ubuntu 16.04, describing each step in detail, I'll focus on what commands you need to execute (in the given order) to setup a delegate node and start forging.

Create a new user and add the user to the sudo group

On the server

adduser sdrpa  
usermod -aG sudo sdrpa  
su - sdrpa  

Disable Password Authentication and Root Login

Create ~/.ssh/authorized_keys file on the server and paste local machine public key to ~/.ssh/authorized_keys file. (If you've never created SSH keys follow this guide to create the RSA key pair):

mkdir ~/.ssh  
chmod 700 ~/.ssh  
nano ~/.ssh/authorized_keys  
# paste content of ~/.ssh/id_rsa.pub from your local machine and save the file

chmod 600 ~/.ssh/authorized_keys  
sudo nano /etc/ssh/sshd_config  

In /etc/ssh/sshd_config, set:

PasswordAuthentication no  
PermitRootLogin no  

Reload the SSH daemon and exit

sudo systemctl reload sshd  
exit  

Now you should be able to login to the remote server without a password

$ ssh sdrpa@123.456.789.012

Welcome to Ubuntu 16.04.3 LTS (GNU/Linux 4.4.0-112-generic x86_64)  
...

Update all packages

sudo apt-get update && sudo apt-get dist-upgrade  

Set up ufw firewall and install fail2ban

sudo ufw allow OpenSSH  
sudo ufw allow 7000  
sudo ufw enable  
sudo apt-get install fail2ban  

Install ntp

sudo apt-get install ntp  
sudo ufw allow ntp  
sudo service ntp stop  
sudo apt-get install ntpdate  
sudo ntpdate pool.ntp.org  
sudo service ntp start  

Install Lisk

wget https://downloads.lisk.io/lisk/test/installLisk.sh  
cd lisk-test  
chmod +x installLisk.sh  
./installLisk.sh install

You'll be asked several questions, choose default location, testnet and when asked if you want to synchronize with genesis account answer no.

chmod +x lisk.sh  
./lisk.sh stop

Edit ~/list-test/config.json to enable forging

Replace secret with your passphrase (passphrase for the testnet account you've created before)

...
"forging": {
        "force": false,
        "secret": ["first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth"],
        "access": {
            "whiteList": [
                "127.0.0.1"
            ]
        }
    },
...

Rebuild with the latest Lisk blockchain snapshot

./lisk.sh rebuild -u https://testnet-snapshot.lisknode.io -f blockchain.db.gz

Visit testnet explorer to check the current block height

Wait some time for your node to be fully synchronized with testnet.
You can check your node current height with:

./lisk.sh status

# output:
√ Lisk is running as PID: 7369
Current Block Height:  4344100  

Once your node is in sync with testnet, the forging will be activated. Check it with:

grep Forging logs/lisk.log

# output:
[inf] 2018-01-31 13:41:34 | Forging enabled on account: 5055500162731337929L

That's it.

I advise you to check Best practices for hardening a new sever for further information regarding the server security, but at this point, you have a solid foundation for your delegate node.

Notes

I skipped enabling swap space on the server. According to Digitalocean recommendation:
"Although swap is generally recommended for systems utilizing traditional spinning hard drives, using swap with SSDs can cause issues with hardware degradation over time. Due to this consideration, we do not recommend enabling swap on DigitalOcean or any other provider that utilizes SSD storage...If you need to improve the performance of your server on DigitalOcean, we recommend upgrading your Droplet...".

Resources

Initial server setup with Ubuntu 16.04, Digitalocean
How To Use SSH Keys with DigitalOcean Droplets
How to add swap space on Ubuntu 16.04
Lisk GitHub, LiskHQ
Lisk Documentation, LiskHQ
How to setup a Lisk node (on testnet and mainnet), KyleFromOhio

Demo:

Payment workflow:

• When 'Purchase' button is clicked, the user is presented with instructions to send the required amount (1 LSK in our case) to the wallet address of the webstore. At the same time, in the background, the web client sends a 'new order' message (a message containing user's wallet address and item description) to the server.

• The server receives the order message and creates a pending order. It starts waiting for the user's transaction to be completed.

• A user can use Lisk Nano or mobile wallet to send Lisk to the webstore Lisk address.

Since there is no way for the server to be notified when a transaction has been completed (we're not running own Lisk node), we use Lisk Transactions API to fetch the transactions for the store wallet address.
Every 10 seconds (The Lisk network forges blocks in 10s intervals) via Lisk Transactions API the server checks whether the transaction has been completed (whether the user has paid the order).

• Once the transaction (containing sender address, required amount and our webstore address) is fetched from Lisk blockchain, the store database is updated (order is marked as completed) and a success message is broadcasted to the client.

There are several checks skipped for the sake of the code simplicity:

• It should be checked if the amount paid is equal to the item price, basically the item price should be fetched from a database and compared to the transaction amount.
• Transaction reuse should be prevented. A user should not be able to use old transactions for new orders.

Lisk payments are very fast, there’s no application to fill out, it'd be great to see online stores using the benefits of Lisk ecosystem.

Download the source code: server, client.

Feel free to ask me anything regarding the source code. You can reach me by email, or as sdrpa on Twitter.

Rules?

The 3 closest predictions win.
One prediction per transaction, the price must be unique.
Predictions must be placed at least 24 hours before the end date.
The winning price is determined according to Lisk's price on Bittrex at midnight on the end date.

How to participate?

Send 1 LSK to 6300871565689347639L.
Copy transaction ID of the transaction from Lisk Nano.
Enter your prediction in USD and the transaction ID.

What’s to win?

1st prize 60% of the Pools Fund.
2nd prize 25% of the Pools Fund.
3rd prize 10% of the Pools Fund.

Pools Fund is the total amount of Lisk raised from all submitted predictions.
Reward payouts will be paid out to winner accounts automatically on the next day.

The source code is available at GitHub: server app, client app.

Basically, I want to filter out small transactions in order to see bigger buy/sell orders, check what orders have affected price the most, have longer market history and be able to sort orders and history table by clicking a table header...
Lisk price in Satoshi is with too many decimals for me so I adjusted the presentation towards displaying the values in USD and customized chart presentation to display RSI and MACD.

The project is open source, consisting of two parts:
1. Backend app written in Swift, using Kitura - Source
2. Front-end app with React/Bootstrap - Source.

The app uses Mac’s camera to set up and assess your posture. Once you set up a "baseline" posture, the app analyzes your posture over time.
You can score your posture over time keeping track of your success.

With three different modes available, you can choose between:
Live - The camera constantly tracks your posture over time,
Custom Intervals - The camera analyzes your posture at predefined time intervals (e.g. every 2 minutes),
Manual - Posture check is triggered manually with a system wide shortcut or from the menu bar.

Sit Up Straight can be disabled or paused at any time and there are various settings (alert sound, reminder color/opacity, time intervals ...) to better control the desired behavior.

Demo Version (7-day trial) download →
Mac App Store link →

Sit Up Straight requires macOS 10.10+.

Preferences

Menu bar

Tip: Hold ALT while menu is open to display time to next check (when using custom intervals)

Please feel free to send a feedback or report any bugs you find.

Download and install Swift:

wget https://swift.org/builds/swift-3.1.1-release/ubuntu1604/swift-3.1.1-RELEASE/swift-3.1.1-RELEASE-ubuntu16.04.tar.gz  
tar xzf swift-3.1.1-RELEASE-ubuntu16.04.tar.gz  
sudo mv swift-3.1.1-RELEASE-ubuntu16.04 /usr/local  
rm swift-3.1.1-RELEASE-ubuntu16.04.tar.gz  

Install required dependences:

sudo apt install clang libicu-dev  
sudo apt-get install libcurl3  
sudo apt-get install libsqlite3-dev  
sudo apt-get install uuid-dev  

Add Swift to system PATH:

echo 'export PATH=/usr/local/swift-3.1.1-RELEASE-ubuntu16.04/usr/bin:$PATH' ~/.profile  
source .profile  

I assume you've created your app (eg. webapp) ... If you haven't, below is a 'Hello world' main.swift:

import Foundation  
import PerfectLib  
import PerfectHTTP  
import PerfectHTTPServer

let server = HTTPServer()  
var routes = Routes()  
routes.add(method: .get, uri: "/", handler: {  
   request, response in
   response.appendBody(string: 'Hello world!')
   response.completed()
})
server.addRoutes(routes) // Add the routes to the server  
server.serverPort = 8181 // Set a listen port of 8181  
// Launch the HTTP server
do {  
   try server.start()
} catch PerfectError.networkError(let error, let msg) {
   print("Network error thrown: \(error) \(msg)")
}

Copy app directory to a directory on the server (eg. to /var/www/webapp). To compile and test the app:

cd /var/www/webapp  
swift build -c release  
./.build/release/webapp

Install supervisor

apt-get install -y supervisor  

To setup app running through Supervisor, create:

/etc/supervisor/conf.d/webapp.conf

[program:webapp]
command = /var/www/webapp/.build/release/webapp serve --ip=127.0.0.1 --port=8181  
directory = /var/www/webapp/  
user=www-data  
autostart = true  
autorestart = true  
stdout_logfile = /var/log/supervisor/%(program_name)-stdout.log  
stderr_logfile = /var/log/supervisor/%(program_name)-stderr.log  

Append following to your nginx configuration:

location ~ ^/webapp(/?)(.*)$ {  
    alias /var/www/webapp;

    proxy_set_header   X-Real-IP $remote_addr;
    proxy_set_header   Host      $http_host;
    proxy_pass         http://127.0.0.1:8181/$2$is_args$args;
}

Restart nginx

service nginx restart  

Register the app with Supervisor:

supervisorctl reread  
supervisorctl add webapp  

Visit:

http://yourserver.com/webapp  

To start/stop app:

supervisorctl start webapp  
supervisorctl stop webapp  

In case if anything goes wrong...

/var/log/supervisor/webapp-stdout.log
/var/log/supervisor/webapp-stderr.log
/var/log/nginx/access.log;
/var/log/nginx/error.log;

Links:

Swift
Perfect
Getting started with Swift 3 on Linux
Deploying Vapor example

References:

Interstellar

How to use Functional Reactive Programming without Black Magic - Slide num. 40

var observableKey: UInt8 = 0

extension NSTextField: NSTextFieldDelegate {

    // text is a readonly property (proxy). We create an observable string when text property is read for the first time and add the observable string as a custom property of the NSTextField.
    // To be able to receive the notification when text in text field changes we set self as the self delegate.
    // controlTextDidChange(:) is called when the text changes where we can update the observable string with the textField.stringValue
    public var text: Observable<String> {
        var observable: Observable<String>
        if let existing = objc_getAssociatedObject(self, &observableKey) as? Observable<String> {
            observable = existing
        } else {
            observable = Observable<String>()

            self.delegate = self
            objc_setAssociatedObject(self, &observableKey, observable, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
        return observable
    }

    // Update text (observable string) with textField.stringValue when text in text field changes
    override open func controlTextDidChange(_ notification: Notification) {
        guard let textField = notification.object as? NSTextField else {
            return
        }
        self.text.update(textField.stringValue)
    }
}

// Two-way binding between CustomStringConvertible and NSTextField
extension Observable where T: CustomStringConvertible {

    func bind(to textField: NSTextField)  {
        self.subscribe { stringConvertible in
            textField.stringValue = String(describing: stringConvertible)
        }
        textField.text.subscribe { string in
            guard let value = string as? T else {
                return
            }
            self.update(value)
        }
    }
}

// Usage:

class ViewController: NSViewController {

    @IBOutlet weak var textField: NSTextField!

    let text = Observable<String>()

    override func viewDidLoad() {
        super.viewDidLoad()

        self.text.bind(to: self.textField)
    }
}

Download demo project here

Download Docker for Mac from https://www.docker.com/products/docker#/mac
Install and run Docker.

Open two terminal windows.
The first terminal window will be used to enter docker commands (i.e. to start/save the container), the commands are prefixed with:

macbook:~ sdrpa$ ...

The second terminal will be the container running Ubuntu, the commands are prefixed with:

root@a3f8e5c13ff8:/# ...

Here we go:

Pull ubuntu 14.04 image and run a container:

macbook:~ sdrpa$ docker pull ubuntu:14.04
macbook:~ sdrpa$ docker run --privileged -t -i ubuntu:14.04 /bin/bash

Get the container's name:

macbook:~ sdrpa$ docker ps

Copy Swift archive to the container:

macbook:~ sdrpa$ docker cp /Users/sdrpa/swift-3.0-PREVIEW-6-ubuntu14.04.tar.gz <CONTAINER NAME>:/root/swift-3.0-PREVIEW-6-ubuntu14.04.tar.gz

Now inside the container extract and delete the archive:

root@a3f8e5c13ff8:/# tar -xvf swift-3.0-PREVIEW-6-ubuntu14.04.tar.gz
root@a3f8e5c13ff8:/# rm -f swift-3.0-PREVIEW-6-ubuntu14.04.tar.gz

Install required libs:

root@a3f8e5c13ff8:/# apt-get update
root@a3f8e5c13ff8:/# apt-get install clang
root@a3f8e5c13ff8:/# apt-get install binutils
root@a3f8e5c13ff8:/# apt-get install libedit2
root@a3f8e5c13ff8:/# apt-get install libicu52
root@a3f8e5c13ff8:/# apt-get install libxml2
root@a3f8e5c13ff8:/# apt-get install python2.7-dev

Edit PATH so Ubuntu can find Swift binaries (I prefer nano but you can use vi):

root@a3f8e5c13ff8:/# apt-get install nano
root@a3f8e5c13ff8:/# cd ~
root@a3f8e5c13ff8:/# nano .profile and add export PATH=/root/swift-3.0-PREVIEW-6-ubuntu14.04/usr/bin:"${PATH}"
root@a3f8e5c13ff8:/# source .profile

The container is ready, save the changes:

macbook:~ sdrpa$ docker ps -l
macbook:~ sdrpa$ docker commit <CONTAINER ID> swift

To start container next time:

macbook:~ sdrpa$ docker run --privileged -t -i swift /bin/bash --login

Related links:

http://www.swiftprogrammer.info/swiftubuntu1.html
http://code.tutsplus.com/tutorials/how-to-use-swift-on-linux--cms-25934