What's New in Swift 3

Chapter 4. Swift on the Server, and Swift on Linux

One of the most exciting aspects of the Swift project is that the language works on non-Apple platforms. You can download binaries of the latest version of Swift for Ubuntu 14.04 and Ubuntu 15.10 from the Swift project website and make use of them right away.

Various contributors to the Swift community are also working on support for Windows, as well as the potential beginnings of Android support. It’s an exciting time to be working with Swift!

Note

Swift for Windows isn’t nearly as ready for production use as Swift for Apple platforms or Swift for Linux. But, in time, we would expect it to reach parity with, at the very least, Swift on Linux. Ars Technica interviewed Apple’s SVP of Software Engineering, Craig Federighi, who reported that Windows support isn’t something that Apple and their Swift team wishes to take on directly, but that Apple thinks it possible that the development community would take it on.

To get the basics up and running on Linux, you can follow the Getting Started guide provided by the Swift project, but if you want to go a little deeper, we’re going to briefly touch on getting Swift set up for server-side development.

Swift on Linux

Swift on Linux offers a huge range of exciting possibilities, from running Swift-based web frameworks (as we’ll discuss shortly), to eventually building apps for Linux desktop, Raspberry Pi, or even Android.

In this section, we’ll take a quick look at the process of installing Swift on Linux, how to work with Swift on Linux, and what works and what doesn’t, yet, in the Linux version.

Tip

If you’re running a Mac, or Windows, and want to have a go with the Linux version of Swift, you can set it up in Docker, or run Linux inside VirtualBox. Vagrant makes the configuration of Linux, and then Swift, within VirtualBox trivial. We’ll set up Vagrant in the next section.

Installing Swift on Linux

We’re primarily developers for Apple platforms, so for us the best way to run Swift on Linux is on a Mac using Vagrant and VirtualBox. This lets you play with the version of Swift available for Linux from the comfort of your Mac, in a way that allows you to clear things out and experiment with different versions.

To get Swift on Linux running, on your Mac:

1. Download and install VirtualBox.

2. Download and install Vagrant.

3. Make sure you have Git installed, and clone the following repository: https://github.com/IBM-Swift/vagrant-ubuntu-swift-dev.git.

4. Once you’ve cloned the repository, navigate into its directory: cd vagrant-ubuntu-swift-dev.

5. Run the command vagrant up.

6. Wait. The vagrantfile included in the repository you cloned, which tells Vagrant what to do, downloads Ubuntu 15.10, the Swift prerequisites, the prerequisites for libdispatch, the Swift concurrency library, the Sphinx documentation system, and then clones the Swift repository and creates a script that allows you to build Swift. This might take a while and will download a few gigabytes of stuff.

7. Once Vagrant is done, you can run the following command to connect to the Linux installation: vagrant ssh.

8. Then, once in Linux, run the following script to build Swift: /vagrant/swift-dev/swift/utils/build-script (This might also take a while, depending on the speed/capabilities of your computer.)

9. You can then run the following command to verify Swift is up and running: swift --version.

10. You can then create some .swift files, and compile them with the swiftc command. We’ll cover this in the next section, as well as in more depth later in the report.

Using Swift on Linux

Once you’ve got Swift installed, whether on a real Linux machine or within VirtualBox or similar, you can start using it! To confirm that you’ve got Swift installed properly, enter the following command in your terminal:

$ swift --version

If everything is up and running, you should be greeted with something resembling the following:

Swift version 3.0-dev (LLVM 834235, Clang 3434, Swift 354636)
Target: x86_64-unknown-linux-gnu

To test that your compiler is actually functioning, create a new file named hello.swift. Inside the file, add the following line:

print("Hello from Swift!")

Now, using your terminal, compile your Swift program by running the following command:

$ swiftc hello.swift

Ideally, you’ll then have a compiled binary in the same folder, which you execute from your terminal as follows:

$ ./hello

You should be greeted by the output: Hello from Swift! Tada! Swift is working on Linux.

Of course, you can do more than just print output to the console (you’d hope so, wouldn’t you?). One of the most interesting parts of the Swift open source project is Foundation framework, an open source implementation of the basic Foundation library that comes with Mac OS and iOS.

A Working Example

There’s no better way to get a feel for using Swift on Linux to write actual programs than to write an actual program! In this section, we’ll write a simple little Swift program, using the Swift Foundation libraries provided as part of the Swift 3 release.

Tip

If you want to work with Swift for Linux on your Mac, check back to “Swift on Linux” to see how to set it up.

The program we’ll write will read a text file of comma-separated data containing a date, a price, and a note. The data file will look like this:

2016-07-13,2.52,Bus ticket
2016-07-12,1.21,Coffee
2016-07-15,5.00,Orange Juice

And, using this data, it will print out an easier-to-read report, like this:

Wednesday, 13 July 2016: $2.52 for Bus ticket
---
Wednesday, 13 July 2016: $1.21 for Coffee
---
Wednesday, 13 July 2016: $5.00 for Orange Juice

This program makes use of Swift 3 and showcases a number of different elements changed through Swift evolution proposals, many of which we discussed earlier, including:

• Removed prefixes

• Changed function parameter labels

• Simplified parameters

• Enums have become camelCased

Let’s get started!

First, we need to import the Foundation framework that we’re going to use:

  // Import the necessary classes from the Foundation framework
  import Foundation

Now, we’ll read the data file containing the comma-separated data:

  // Get the data from a file called "Data.txt"
  let data = try! String(contentsOfFile: "Data.txt")

Note

You’ll need to make sure you create a text file in the same folder as your Swift program for this to work!

Next, we’ll split the data into different lines, filtering to remove any blank lines:

  // Split into lines and remove blank lines
  let rows = data.components(separatedBy: "\n")
      .filter({ $0.characters.count > 0 })

We need to be able to understand dates in order to print them nicely in the output, so we need two data formatters: one for the input and one for the output. Create the input date formatter:

  // Create the first date formatter, for reading the date
  let dateInputFormatter = DateFormatter()
  dateInputFormatter.dateFormat = "dd-MM-YY"

Now, create the the output date formatter:

  let dateOutputFormatter = DateFormatter()
  dateOutputFormatter.dateStyle = .fullStyle

Next we’ll create a formatter to format the currency:

  // Create a number formatter for formatting the currency
  let numberFormatter = NumberFormatter()
  numberFormatter.numberStyle = .currency

And a place to store the output lines of the pretty report we’re creating:

  // The lines in our report will go in here
  var reportLines : [String] = []

Finally, we’ll iterate through the rows of data from the input file:

  // Process each row
  for row in rows {

splitting each row into columns, based on the position of the comma:

  // Split the row into columns
  let columns = row.components(separatedBy: ",")

and then extracting each piece of data we want, from each column of the row we’re working with:

  // Extract the data from each column
  let dateColumn = columns[0]
  let amountColumn = columns[1]
  let noteColumn = columns[2]

We’ll grab the currency amount, pulling a double variable out of the string we are working with:  

  // Read the price as a number
  let scanner = Scanner(string: amountColumn)

  var price : Double = 0

  scanner.scanDouble(&price)

and format it as currency, using the currency formatter we created earlier:

  // Format the number
  let priceFormatted =
      numberFormatter.string(from:price) ?? "$0.00"

Also formatting the date, using the date output formatter we created earlier:

  // Format the date
  let dateFormatted = dateOutputFormatter.string(from: Date())

And then add a nice, pretty line to the report variable:  

      // Add the line to the report
      reportLines.append(
          "\(dateFormatted): \(priceFormatted) for \(noteColumn)")

  }

Last, to display our nice report, we’ll create one big string, with each line separated by a new line and a series of dashes:

  // Turn the report lines into a single string,
  // separated by lines of '---'
  let report = reportLines.joined(separator: "\n---\n")

and print the report:

  // Finally, print the report
  print(report)

To test this program, put this text in a file called Data.txt, and make sure it’s in the same folder as your Swift file:

2016-07-13,2.52,Bus ticket
2016-07-12,1.21,Coffee
2016-07-15,5.00,Orange Juice

Then compile your Swift, like so:

swiftc SimpleDemo.swift

Then run the newly compiled program:

./SimpleDemo

If everything worked as intended, then you’ll get this:

Wednesday, 13 July 2016: $2.52 for Bus ticket
---
Wednesday, 13 July 2016: $1.21 for Coffee
---
Wednesday, 13 July 2016: $5.00 for Orange Juice

Tip

This Swift code will work just fine on Mac OS, and likely even in Swift Playgrounds on an iPad.

Kitura: A Web Framework for Swift

IBM has been doing some amazing work with Swift, and one of the most interesting pieces that it’s produced is the Kitura Swift web framework and HTTP server. Kitura features the basics you’d expect to find in a modern web framework, and…not much more…yet. It’s got:

• URL routing, with GETs, POSTs, PUTs, and DELETEs

• URL parameters

• Static file serving

• JSON parsing

And really, that’s about it so far. But it’s a phenomenal start—it’s very Swifty in approach, and everything feels like it should feel in a Swift web framework. Kitura supports Swift 3 and can be run on Mac OS and Linux (as well as in Docker or Vagrant, if that’s your thing).

To install Kitura, follow the guides available on the project page for your preferred platform. The basics of Kitura should be familiar to you if you’ve used web frameworks on other platforms.

First, you import the Kitura framework and create a constant to store a router in:

import Kitura

let router = Router()

Then you sit up the router to response to requests, and display something when the root URL (/) is hit with a GET request:

router.get("/") {

    request, response, next in

    response.send("Hello from Kitura!")

    next()

}

Finally, you can start Kitura’s built-in HTTP server and fire up the Kitura framework:

Kitura.addHTTPServer(onPort: 80, with: router)

Kitura.run()

To run your simple web app, you’d then need to compile it. (You hadn’t forgotten that Swift is a compiled language, had you? It’s easy to forget!) To compile it, you’ll need to run some variant of the Swift build command on your terminal. On Mac OS, that’s likely to be:

$ swift build

You’ll then end up with a compiled binary that you can fire up, and then surf to the URL it’s serving to be greeted by “Hello from Kitura!” Pretty nifty!