This article is part of a collection of articles about Swift Basics, where I try to explain different parts of Swift development in a more understandable way.

---

In most iOS applications, you will probably need to use a UITableView at some point. In this short guide, you will find out how to create a UITableView, and populate it with your own data.

UITableView

As Apple say in the documentation, “A table view displays a list of items in a single column.”. Basically, it’s a list of cells, that you can take complete control over. With a UITableView object, there are two ways in which you can control them. They are the UITableViewDelegate, and the UITableViewDataSource. The delegate is what manages the interactions on the table cells, such as selecting and reordering. The UITableViewDataSource is as you may of guessed, what controls the data that populates the table, and also configures the cells in the Table View. However in this guide, we will just be focussing on the DataSource, as this is all we need to populate a TableView with data.

Styles

There are various ways in which you can customise the style of the TableView manually, but there are two main styles that you can choose from in the InterfaceBuilder, “Grouped” or “Plain”. There aren’t many differences, but in the “Plain” style, each cell fills the Table, and the relevant header/footer float above the cells. However in the “Grouped” style, the sections are visually separated into groups, with the addition of a background colour.

Creating the Project

We’ll start with a new Xcode project. So create a new iOS project, and select the “Single View Application” template. Then you can give it a name, for this example I’m using “TableViewExample”.

Just make sure the Language is Swift, and the other options aren’t needed for this example. This will create all the necessary files, such as “AppDelegate.swift”, “ViewController.swift”, and “Main.storyboard”.

Putting a UITableView on the Screen

Click on the “Main.storyboard” file, and from the object library on the right, drag a Table View onto the view (There should only be the one).

Then to make sure it works on all iOS devices and screen sizes, we’ll set up the layout. Just drag the corners of the TableView so that it fills the view, but keeps the top status bar visible, it should automatically align. Select the Table View, and then open up the “Add New Constraints” view from the bottom right corner. It is the icon with a square, which has a vertical line either side.

Once you constraint view appears, select the four lines around the square at the top, while making sure each value is 0. This will simply make it fit to the edges on any screen size.

Configuring the UITableView

Now we need to configure the Table View so that we can manage it later on. So select the Table View, and then click to show the “Attributes Inspector” from the right sidebar.

The only values you need to change are:

• Content – Dynamic Prototypes
• Prototype Cells – 1
• Style – Grouped

All we are doing with these settings, is making the cells in the table dynamic, so that we can update them with live data later on. Then we set the style to grouped, so we can see each section better visually.

UITableViewCell

As we also want to populate the cells with some data later on, we will make use of the dynamic prototyping in Interface Builder, to design the cells.

Firstly we will set a “Reuse Identifier” for the cell, this is so that we can reuse the same cell prototype when loading the TableView. To do this, just select the cell (it may be easier to do this in the Document Outline to the left”, and while still showing the “Attributes Inspector”, set the Reuse Identifier to “PlainCell”.

Linking the UITableView to the ViewController

We will manage the Table View from the initial View Controller, so the next step is to set it as the DataSource of the Table. You can do this programatically, but for this example we will do it using Interface Builder. To do this, select the Table View, and then choose the “Connections Inspector” in the right sidebar.

From there, just click and drag from the open circle to the right of “delegate” and “dataSource” to the View Controller icon at the top of the view. Then in the “ViewController.swift” file, we will need to set the class to be the DataSource. Just replace the current class definition:

class ViewController: UIViewController {

To the following:

class ViewController: UIViewController, UITableViewDataSource {

It will show some errors right now, but that is just because we haven’t implemented the required functions yet.

Populating the Table View

We have the Table View set up in Interface Builder, and it’s linked to the View Controller, so now it’s time to populate it with real data. At the top of the View Controller class, just below the code you’ve just written, copy the below code:

let sections = ["Fruit", "Vegetables"]
let fruit = ["Apple", "Orange", "Mango"]
let vegetables = ["Carrot", "Broccoli", "Cucumber"]

This is just three arrays that will be used for the section headings, and the content of each of them.

UITableViewDataSource

To fill the table with data, we need to write four functions to do the following:

• Set the headings for each section.
• Set the total number of sections.
• Set the total number of rows in each section.
• Configure the individual cells with the relevant data.

Section Headings

We already defined the section headings before, so all we need to do here is to return the string for the associated section, which the function receives as an Int.

func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
    return sections[section]
}

Number of Sections

This is quite a simple method, and it just tells the TableView how many sections there are. We already have the section headings in an Array, so we can just return the count value of this.

func numberOfSections(in tableView: UITableView) -> Int {
return sections.count
}

Number of Rows

Very similar to the method above, but this time we have slightly more complexity in how we return the value of the number of rows. As this method is for every section, we first need to check which section it is for, and then return the count value of the relevant array.

func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
  switch section {
  case 0:
    // Fruit Section
    return fruit.count
  case 1:
    // Vegetable Section
    return vegetables.count
  default:
    return 0
 }
}

Configure the Cell

The last part of populating the Table View, is to load the data into the cell. We do this by first creating a UITableViewCell object, by making use of the dequeueReusableCell(withIdentifier:) function. This uses the Reuse Identifier we set earlier, to dynamically reuse one of the cells that have already been created. Then depending on the section that the cell is in, we set the text of the text label of the cell, to the value from the relevant array. After this, the cell is returned, and it is displayed.

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
  // Create an object of the dynamic cell "PlainCell"
  let cell = tableView.dequeueReusableCell(withIdentifier: "PlainCell", for: indexPath)
  // Depending on the section, fill the textLabel with the relevant text
  switch indexPath.section {
  case 0:
    // Fruit Section
    cell.textLabel?.text = fruit[indexPath.row]
    break
  case 1:
    // Vegetable Section
    cell.textLabel?.text = vegetables[indexPath.row]
    break
  default:
    break
  }
// Return the configured cell
return cell
}

Results

If you run this project now, it should look like this:

Final Code

Here is the final code for the View Controller that we created:

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
let sections = ["Fruit", "Vegetables"]
let fruit = ["Apple", "Orange", "Mango"]
let vegetables = ["Carrot", "Broccoli", "Cucumber"]
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
}
// MARK: UITableViewDataSource
func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
return sections[section]
}
func numberOfSections(in tableView: UITableView) -> Int {
return sections.count
}
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
switch section {
case 0:
// Fruit Section
return fruit.count
case 1:
// Vegetable Section
return vegetables.count
default:
return 0
}
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
// Create an object of the dynamic cell "PlainCell"
let cell = tableView.dequeueReusableCell(withIdentifier: "PlainCell", for: indexPath)
// Depending on the section, fill the textLabel with the relevant text
switch indexPath.section {
case 0:
// Fruit Section
cell.textLabel?.text = fruit[indexPath.row]
break
case 1:
// Vegetable Section
cell.textLabel?.text = vegetables[indexPath.row]
break
default:
break
}
// Return the configured cell
return cell
}
}

You can find the example project on GitHub.

Congratulations! You’ve now developed an app that makes use of a UITableView, along with a UITableViewDataSource to dynamically populate data, and also to configure the UITableViewCell. As this is an ongoing series of articles, you can expect more guides on how to take this project even further.

The very first Apple Watch was released 21 months ago, in April 2015. It was to me, a revolutionary new product, and I just had to get it. So I did.

In September 2016, 18 months after the original Watch was released, Apple then updated the original model, naming it Series 1, while also releasing a whole new version, Series 2.

You could argue that the Series 0 (first edition) to 1 change wasn’t even worth noting, the only main difference was that the Apple S1 processor used in the Watch was replaced with a dual-core variant. However in the Series 2, they added a newer Apple S2 processor which was also dual-core, but also an ambient light sensor, 50 m water resistance, 2x brighter display, and a GPS sensor.

So we can all agree that Series 0 → 2 was a decent update.

Therefore, you would expect that because of this, along with the fact that the Series 0 is a version 1.0 of a new product, that the need and desire to upgrade would be huge.

Except for me, it wasn’t. And it still isn’t.

My Watch

My Watch is a 42 mm Sport in Space Grey with the original matching Sport band, it still provides the same use as when I first purchased it, but now so much more.

At The Beginning

When I first started using the watch, the main feature that I used was the notifications. This was the major benefit for me, as it meant when I was on the move, be it walking or on the train for example, I didn’t have to keep taking my phone out of my pocket to find out what was trying to catch my attention.

Since then, I have rethought my take on how I manage notifications, but this has been a steady constant on the benefits of wearing the Apple Watch.

Of course, like everyone else, I thought the Apple Watch would be the kickstart I needed to become more active. I would start a new workout whenever I was walking somewhere, or maybe I’d try and jog, or maybe I would take an extra trip somewhere simply because I knew it was tracking me.

Then there was the apps, they took an awfully long time to load, and at the beginning they were run off the paired iPhone, so even at runtime they weren’t the best experience. Although in September 2015, Apple released watchOS 2, which meant that apps could be installed directly on the watch, and therefore would be faster. This was slightly the case, but it still wasn’t the best situation, as sometimes it would be much faster to take your phone out of your pocket, than it would be to just do the simple task on your wrist.

By wearing my watch more often, I was getting more comfortable with it, sometimes even forgot I was wearing it. Slowly I was realising that the things I was using my watch for, simply were being forced, and I didn’t actually want to do them. I just wanted to use the watch.

watchOS 3

With the release of watchOS 3 in September 2016, the Apple Watch was suddenly brought back to life.

This update brought significant increases to the speed of the device, which was helped out largely by the new Dock. By choosing to keep apps in the dock, the system would automatically keep them in memory, and therefore would be quicker to load. Alongside the speed benefits, there was also a bunch of new watch faces, and a huge overhaul to the way that the watch worked.

It also meant that because of these updates, developers were more likely to spend more time working on quality apps for the device, since they were able to provide a better experience for their users.

This really was the rebirth of the Apple Watch.

This Moment in Time

So right now, my watch has become a really essential part of my life, and it’s started to feel like it’s providing me with a use.
Here are the main things I now use my watch for:

• Telling the time.
• Notifications (Only for certain apps).
• Checking what’s next in my calendar.
• Weather.
• Monitoring my activity and health.
• Tracking my sleep.
• Pokémon GO (yes I still play it).

Before I go into the “smart” side of the watch, it still is a watch, so I of course use it for the time. But very much like the iPhone, the “native” use of the device isn’t what brings people to use it.

Then there were the notifications, these have been narrowed down to the very few things that require my attention. So I have Messages, a select few email notifications from Airmail, and the occasional thing such as OneFootball when I want to specifically be updated about a game when I’m out doing something.

Recently I’ve been trying to use my calendar more and more, for university lectures, events, and time-sensitive events like flights. Because of this, knowing my next calendar event is essential, as the more I rely on the calendar as my primary schedule, I relinquish control over monitoring what I should be doing. Fantastical has a brilliant app for iOS, and I use their complication on the watch to check my next event, and with a simple tap I can quickly get a list of any other events in the future (made possible by the speed increases I watchOS 3).

It’s a similar situation to the weather, with DarkSky I can have a simple complication that updates super fast, so I can find out the weather in a few seconds.

In what has become a more silent feature of the watch, is the activity and health tracking. As I’m always wearing the watch, I get an accurate measurement of my activity throughout the day, how much I’ve walked, and of course my heart rate is also monitored. I don’t have any health conditions that I need to worry about, but it’s nice to know I have all of this data being logged without me doing anything.

In addition to the health tracking that is done automatically by the watch, by using an iOS app called AutoSleep, I can track the length and quality of my sleep by wearing my watch at night. It still of course needs to be charged, but as I’m sat at my desk, or when I’m not doing anything that involves moving around or needing to receive notifications, I pop it on my little watch stand, and it’s charges pretty quickly. The app uses a whole bunch of metrics to measure the sleep, such as the last time you used your phone, whether it’s on charge, or if you’re moving. But it’s the way in which you manage the sleep tracking is what got me, you just go to sleep. There’s no need to manually say “I’m going to sleep”, you just do it, and it knows. It’s the silent processes of the watch that makes me really love it.

So I’ve got the time, notifications, calendar, activity monitoring, and sleep tracking, there must be something I do on the watch for fun? Well, I do use the Pokémon GO watch app, in companion to the iOS game, in order to gain workout based rewards. It’s the closest to a game experience I have on the device, and it also doubles as a workout tracker, so there’s something else behind it as well.

I wouldn’t say there’s that much else that I use the watch regularly to do. Sometimes I control what I’m listening to, via the Music or Overcast app. As mentioned before, I use the OneFootball app to keep updated on certain football games. Once in a blue moon I use a timer, and that’s probably the only thing I use Watch Siri for. The only other thing I’ve been using is the iOS Wallet, which brings up my boarding passes whenever they’re needed.
When I look back at all of these activities that I now do on my watch, I can clearly see that it has become so much more than a time-telling, notification bringing device.

My Watch as an Appliance

Right now, I use my watch a lot. But even so, it’s not something I desperately need to get any better. I like it how it is.
With the benefits that came with watchOS 3, the device was given a new lease of life. Which made it feel like I’d already purchased a new watch.

I no longer need to worry about it syncing to my phone, whether the apps will be refreshed in time, or even about the speed of the hardware. It’s transformed to yet another computer that sits on my wrist, to a stable appliance that I can trust.

What I Still Don’t Like

Of course nothing is perfect, and I would like a few improvements to be made to the watch experience. But these are mainly down to the software, something that can be changed without the need for me to purchase a new device.

I really don’t like the grid layout of the apps, and I think that a redesign there would be a great improvement. But saying that, the way I interact with my watch is through complications via the watch face, or by launching apps from the dock.

I would also encourage the ability to customise the watch faces even further, so you would be able to have a more custom design and colour options.