Using custom PresentationController and PanGestureRecognizers

Having recently spent countless hours of searching for tutorials that simply explain how to create a “draggable” view, I’ve decided to take a stab at creating a tutorial that I wish I had when l first started out.
In this article, I’m going to show you step by step how we can achieve this beautiful draggable popup view in Swift!

The main frameworks we’re going to be using from UIKit in this tutorial are: UIPresentationController, and UIPanGestureRecognizer.

A UIPresentationController is an NSObject that manages the transition animations and the presentation of view controllers onscreen.

A UIPanGestureRecognizer is a distinct gesture recognizer that interprets panning gestures. — Apple Docs

Step 1: Create your custom UIPresentationController

In an Xcode project, go ahead and create a new Swift file called FilterPresentationController.swift
This class will conform to UIPresentationController where we’ll be overriding methods and adding customization.

Let’s not get overwhelmed by this chunk of code. We’re going to go through it step by step.

1. This method initializes our class to handle the transitioning between two view controllers and sets a blur effect on the containerView (The view that is currently behind the presented view).
   You also see here that we’re adding a tapGesture so that we can dismiss the presentedViewController!
2. This function lets you customize the point at which you want the view to show. We set the presented view controllers starting point (`x = 0`) to the top left of the screen, the height (`y = 0.4%`) to be a fraction of the screen. In addition, the width is equal to the container view (`width = screen width`) and the height to be a fraction of the screen (`height = 0.6%`). You can customize the size to however you’d like! Very cool to see the views change as you tweak the numbers.
3. Adding the blurEffectView on the background as it starts the presentation.
4. Removes the blurEffectView on the background as it dismisses.
5. Here is where we can round our presentedViewController.view’s corners! I’m using a helper method for rounding which will be covered in Step 2.
6. The layout has ended on the container view.
7. The selector method for when the tapGesture fires off an action. Where we dismiss the presentedViewController.

Step 2: Adding a helper method to round the view’s top left and right corners

Since the presentedViewController’s height is only 0.6 % of the entire screen. That means if we set presentedView?.layer.cornerRadius = 22, the bottom corners will round as well. Like in this picture below.. which we’re not going for here!

roundCorners(_:radius:) method allows you to specify which corners you’d want with a cornerRadius such as: topLeft, topRight, bottomLeft, bottomRight, and allCorners. Now that we call this helper method on .topLeft and .topRight, it’s back to looking normal!

Step 3: Creating the main view controller

If you already have a view controller in mind that you’d want to present the presentation view controller on, great. If not, you can create a simple view controller with a button like below.

Step 4: Creating the presented view controller

This is going to be the filter view controller that’s presented by our main view controller above.

Code above sets up a viewController with a topView, which you might have guessed already why we would add an empty view with a clear background.. Correct! We’re going to be adding a panGestureRecognizer to that so we can drag the view!

Step 5: Implement our custom presentation

Let’s go back to the main view controller you created and add in some code.

1. We’re going to present our FilterViewController using a custom modalPresentationStyle as well as setting the transitioning delegate to self(ViewController).
2. Here is where we declare our custom UIPresentationController that we created in step 1. We know that the FilterViewController will present itself only 0.6 % height of the whole screen like in the picture below👇🏼👇🏼

Step 6: Add a PanGestureRecognizer to FilterViewController

We’re so close to finishing with this entire implementation! A panGestureRecognizer is a subclass of the UIGestureRecognizer class that looks for panning or dragging gestures. Perfect use in this case for dragging a view down. Let’s add this gesture to the FilterViewController’s topView.

Above you see that we added 2 new properties to the FilterViewController: pointOrigin which is a CGPoint along with hasSetPointOrigin.

1. We should set the point origin (pointOrigin) during the first call to viewDidLayoutSubviews. We put a check around this since any time the view changes its points, it will call viewDidLayoutSubviews.
2. Adding the panGesture to topView with an action so whenever it receives a pan or drag, it will trigger an action!
3. Here’s where the math comes in.. we first get the coordinates of the pan gesture, where that’s happening in the view. I’m putting a guard statement here because I don’t want to move the view up if the pan gesture moves upward (which means it increases negatively).
   On line 28, we’re setting the FilterViewController’s frames to the current point origin with the addition of how far the pan gesture went in the y direction. For example when the user drags straight down, this effects the y position.
   The last step is to calculate the velocity of how fast the gesture was. This is super cool because you can simply call sender.velocity(in: view) and that’ll give you a CGPoint object. We can check against the velocity’s y position. And here I’m allowing the velocity of 1300 or more to dismiss the view controller. (The greater the number, means the faster the user dragged on the screen). If the velocity isn’t too fast, I’m resetting the view back to it’s original point.

That was quite a lot to comprehend. But let’s see a little demo below what that math looks like in action.

Wrapping Up

And that’s a wrap on today’s tutorial on custom presentation transitions along with the great use of pan gesture recognizers. To give you more context, here are a couple examples of apps that have a similar feature to what we covered in this tutorial: Yelp, DoorDash, Instagram, OpenTable, etc.
I know it’s 2020 and SwiftUI has been out for a while now, but hopefully there’re some people out there that needed this guide! And I hope in the next tutorial, I can start diving into SwiftUI and creating articles about that! Stay tuned and please give me a follow if you’d want to see more of these :)

Resources:
UIPresentationController — raywenderlich
Custom modal presentation — Maxim Vialyx
Draggable View — YouTube/Wilson Balderrama
Stéphane de Luca — UIView extension

Thank you for checking out this blog post!

If you have any questions or comments, please feel free to reach out to me. And don’t forget to give this article some claps! 👏🏼*up to 50x*👏🏼 if you found it helpful.

This article is an extension from my recent article: Memory Management with Heaps & Stacks. I wanted to touch more based on the data structure of heaps and stacks since Swift used these terms to manage memory. If you want to learn more on swift’s memory management and haven’t yet checked out that article, I highly recommend checking it out!🔝🔝

Today’s article is going to go in detail of what these data structures are and how you would implement it in Swift!

Heaps

“Not all roots are buried down in the ground some are at the top of the tree.” ― Jinvirle

The heap data structure allows us to find minimum and maximum values which is laid out very similarly to the tree data structure.

In the diagram above, we can see that the data represents nodes which has a value, a left reference, and a right reference. There can be 2 types of heaps: min heaps & max heaps.

Min heaps — The parent node’s value must always have a smaller value than that of both their child nodes. As seen in the diagram above, it can be referred that the smallest value will always be at the top. Min-heaps are often used to implement priority queues where it allows for efficient sorting of objects.

Max heap — The parent node’s value must always have a larger value than that of both their child nodes.

Generally, heaps are implemented with an array under the hood. (Read more on arrays in this article). We can say that each node in the heap matches an element of the array. This is so we can use indexing to point to our data within the tree. Let’s go ahead and write out the heap struct.

struct MinHeap<T: Comparable> {
  var items = [T]() 
}

MinHeap conforms to the Comparable protocol which means that you can compare instances of the type with any of the relational operators, such as >, <, >=, <=,including ==.

We’re using generics once again! If you aren’t familiar with generics in Swift, they simply enable your models to be reusable and work with any given type. So when we initialize a MinHeap structure, we would initialize it as we would like minHeap = MinHeap() but instead we will explicitly give it a type:

var minHeap = MinHeap<Int>()

And this is how generics in Swift are so powerful and advantageous when creating or dealing with our own structures/classes, where we might want to use it on different data types!

Let’s go ahead and start implementing the fun part and give our MinHeap structure some functionality. 🔮🎱🔮

Methods
We are going to use the following heap, diagram A, to get an easier grasp on the different method implementations.

Can you guess what type of heap this is?…

The array which represents this heap: [4, 7, 11, 9, 18, 15, 22]

You’re right! this is a min heap since the smallest value corresponds to our root node.

Methods for index accessing:

getLeftChildIndex() Calculates our left child’s index when given a parent node’s index

private func getLeftChildIndex(n: Int) -> Int {
  return (2*n) + 1
}

If we call this function giving the parameter 0(node with value of 4), the function will return 1(node with value of 7).

getRightChildIndex() Calculates our right child’s index when given a parent node’s index

private func getRightChildIndex(n: Int) -> Int {
  return (2*n) + 2
}

If we call this function giving the parameter 1(node with value of 7), the function will return 4(node with value of 18).

getParentIndex() Calculates our parent’s index when given a child node’s index

private func getParentIndex(n: Int) -> Int {
  return (n - 1) / 2
}

If we call this function giving the parameter 1(node with value of 7), the function will return 0(node with value of 4).

Methods for checking states:

hasLeftChild() Returns a bool if the node’s given index has a left child

This may look confusing at first, but the logic is pretty straight forward!
1. In the first line of our function, we’re creating a variable that calculates what our “supposed” left child index would be.
2. The function will return true if leftChildAtIndex is less than the numbers of items in our heap structure.

Since the heap adds items from left to right, a node will only have a left child if the index is less than total amounts of elements in the array.
Let’s take an example from the diagram above. We want to check if the node with value of 9 has a left child or not. We want this to return false since we know from the image that it does not have a pointer to a left node. When we run the function the variable leftChildAtIndex will equal to 7. And our total count of items in the heap is equal to 7. leftChildAtIndex isn’t less than 7 so it would return false as we expected!

hasRightChild() Returns a bool if the node’s given index has a right child

Has the same steps as the method above but instead we’re using the private function getRightChildAtIndex instead.
1. Calculate what our “supposed” right child index would be.
2. The function will return true if rightChildAtIndex is less than the numbers of items in our heap structure.

Methods that return values in the heap:

leftChild() Returns the left node’s value of a given node’s index

rightChild() Returns the right node’s value of a given node’s index

parent() Returns the parent node’s value of a given node’s index

peek() Returns the value at top most of the heap

We make sure that our heap has a value within it so we can return the top most node(root node). If the heap is empty, we return nil.

Method to build the heap:

Before we go into the code, we will be using the mutating keyword to declare our function. Since structs are value types, by default, we can not modify the properties within its instance methods. The mutating keyword, in quick and simple terms, allows you to change(mutate) variables in place and these changes are written back to the original struct once the method ends executing.

add() Inserts an element to the bottom of heap

1. Add a new value to the end of our array. This is a min heap so we would need to make sure that the newly inserted value is greater than it’s parent’s value.
2. Create a variable to keep track of the index of the item we just added to the array. Declare it with a var keyword, hence the changing of value in our while loop.
3. Only begin to loop through this while loop if the parent node’s value is greater than the item we just added. Since this is a min heap and we need the parents value to be less than the child value!
4. This built in swapAt() method on an array swaps the places of two items at their indices. This will swap the parent’s node to to take place of it’s child node.
5. Set the variable to be the parent index since now our parent index is the item we just added into the heap

Stacks

Is a simple data structure where you can push(add items) onto the stack or pop to remove the top most element in the stack.
FILO(First In Last Out)

Let’s go ahead and look further into these method calls on the stack struct. But before implementing these methods, let’s create the base code for it.

struct Stack<T> {
   var array = [T]()
}

We create our Stack by using a struct not a class because we want to be able to copy over the instantiated object in memory instead of having a reference point to it. Furthermore, we’re using generics so implementation on this stack can be on any type such as strings, integers, models, or objects.
On the second line, you can see that we are using an array to handle our stack and we declare it using ‘var’ since we will be adding and removing items!

Stacks can be implemented with any data structure of your choice.
In this tutorial I will be using an array, but as a stretch challenge, I encourage you to try using it on a linked list!😁

Methods in stacks

push() Adding something on to the stack.
Runtime: O(1)
The first item can either be added to the front or the end of our data structure we chose to build with.

mutating func push(_ item: T) {
   stack.append(item)          
}

Because value types in Swift don’t allow us to modify properties within it, we have to use the mutating keyword — mutating allows us to modify(mutate😲😌) properties within the struct and update it.

The peek element is at the end of the array so we can make changes to the array generally with the runtime of O(1).

pop() Deleting something off of stack and returning it’s value.
Runtime: O(1)
If we pushed from the end of the stack, we’ll have to remove it from the end as well. Same goes to the other way round.

1. Making sure there’s something in the array so we can remove and return the last value.

top Checking the top most element without removing or changing the value.
Runtime: O(1)

var top: T? {
   return stack.last
}

You can see that top is not a method but a variable where we set it to the last element. Since this is an optional, it can return nil. Keep in mind here that Swift’s method last on an array will return nil if the collection we’re calling it on is empty.

Good reads to check💯:
Swift Equatable and Comparable — useyourloaf.com
Heaps — RayWenderlich

Video to check:
Heaps — Devslopes

Thank you for checking out this blog post!

If you have any questions or comments, please feel free to reach out to me. And don’t forget to give this article some claps! 👏🏼*up to 50x*👏🏼 if you found it helpful.

In todays article, we’ll take a dive in to learning more about graphs and their implementation to solving real world problems. Some common examples of situations where you can use graphs are: social network(friends of friends), page recommendations(based on most popular search), the study of molecules in chemistry and physics, transportation networks, and etc.

Things to know about graphs

Parts of a graph
1. Vertices(nodes) — Where data is stored.
2. Edges(connections) — Connects 2 different vertices together. And they can also go in one direction. Which creates what’s called directed graphs or digraphs. Additionally, these edges can have weights.

Types of graphs
1. Undirected — Vertices on both sides of the edges have connection to each other and you can see that the relationship goes both ways.
2. Directed — Vertices on both sides of the edges have connection to each other. But the connection only goes one way(either from the first vertex to the second vertex, or otherwise).
3. Weighted — Branches that have a numerical weight.

Properties of a graph
These properties define the graph itself, and is not a specific drawing of the graph. Here are some examples of graph properties.
1. Path — A sequence of vertices where they are adjacent to the vertex next to it
2. Coloring — An assignment of different colors to all vertices so the vertex at the end of each edge has a unique color
3. Degree — The number of edges that point out of the vertex
4. Weight — The value attached on its edges.
5. Diameter — The longest shortest path of that graph
6. Connected graph — When a graph has at least 1 vertex and there is a path between all vertices

Problems that can be solved
Here are a set of problems that can be questioned and solved in a graph model
1.Verification — Do these vertices form a path?
2. Existence — Is there a path in this graph?, Is there a path of length n?
3. Instance — Find a path from source vertex to distance vertex.
4. Enumeration — How many paths of length n exists in this graph?
5. Optimization — What is the longest path?, What is the shortest path?

Before heading in to solving a real world problem using graphs, I want to introduce algorithms that are very common and you will most likely be using or even get asked in some technical interviews.

Graph Algorithms

Breadth First Search (BFS)
BFS is a way to traverse through the graph in an order where it’s closest to the root vertex. In an iterative approach, we use a Queue data structure to keep track of each step in the traversals.

Below is a representation of running bfs on a graph. The list of order call orders from the first vertex visited, to the last vertex visited.

Graph problems that can be solved using the BFS algorithm:
• Finding a path from a vertex to another
• Finding the minimum path from a vertex to another
• Finding all the paths from a vertex to another
• Finding a minimum spanning tree of an unweighted graph

Depth First Search (DFS)
DFS is a way to traverse through the graph in a way where it tries to go farthest from the root vertex. DFS requires to use a Stack data structure so we go furthest away from the vertex instead of a level search like the bfs algorithm.

Below is a representation of running dfs on a graph. The list of order call orders from the first vertex visited, to the last vertex visited.

Graph problems that can be solved using the DFS algorithm:
• Proving that a graph is connected
• Finding if there are existing paths within the graph
• Checking if a graph is bipartite (A graph is bipartite when the vertices can be divided into 2 independent sets and all the edges from one of the set connect to the other. Or we can also say a bipartite graph will not contain any odd length cycles.)

Prim’s Algorithm
Prim’s algorithm is a greedy algorithm that finds a minimum spanning tree in a weighted undirected graph. The algorithm builds up a tree one vertex at a time choosing its minimal weight of a vertex in each step.

Dijkstra’s Algorithm
Dijkstra’s algorithm is another greedy algorithm that that finds the shortest path between vertices in a graph. The algorithm finds the shortest path between the given vertex and every other connecting vertex to it. We can also optimize the run time of this algorithm by using a priority queue. This reduces the time of looking up the vertex that has the least distance.

Sample Real World Implementation

We’re going to examine graph theory application on Apple Map Routes. Have you ever noticed that out of thousands of routes you can take from getting from one location to another, Apple maps, or any other online map, will chose to take the shortest path.
However, The map applications we use have much more values to account for apart from its distance, such as traffic, or road blockage during specific times in a day.

We are going to solve these common problems in this sample project:
1. Checking if there is a path from location A to location B
2. Finding the fastest route from location A to location B
3. Seeing how many places we can travel to based on our starting location

Let’s start off by creating a graph and vertex class to handle our calculations. You can follow this link to get to my GitHub repository for this project!

The rest of the article will be me explaining the pseudocode that I followed to get to the solutions! Please try to solve them first even if it’s just a few minutes of brainstorming your ideas. It will be helpful to understand the problem and some ideas of solving it first!

1. Checking if there is a path from location A to location B

Finding a path between 2 vertices can be solved by either using BFS or DFS.
Check out the code to this problem!

Properties:
visited —Set to store all vertices that will be passed in bfs.
queue —Queue for bfs

Pseudocode:
• Add the source vertex to our empty queue as well as adding it to the visited set.
• Loop through the queue while there’re still vertices in it.
• dequeue an item from the queue and store it in a variable named curr
• check if curr is the destination vertex inputted in the function parameter. If it is so, then we can return true, and our function is complete!
• We’re not at the end yet so we would want to continue our bfs algorithm.
• Start off by creating another for loop on curr’s neighbors. And only do the following if the neighbor vertex is not in the visited set:
enqueue neighbor to our queue, and
add neighbor to the visited set.
• Once the while loop has finished executing, we can return false since we’ve looped through the connecting vertices in this graph and still have not found the destination vertex!

2. Finding the fastest route from location A to location B

This problem can be solved by either using BFS or DFS. The functionality is very similar to the solution above🤔 I recommend you try finding the solution to this problem from the pseudocode above before looking below!
Check out the code to this problem!

Properties:
path_found — Boolean variable that is initially the value False. The value will change once we find the destination vertex!
visited—Set to store all vertices that will be passed in bfs.
queue —Queue for bfs
path — Array to store the connecting paths of vertices from the source to the destination vertex .

Pseudocode:
• Add the source vertex to our empty queue as well as adding it to the visited set.
• Loop through the queue while there’re still vertices in it.
• dequeue an item from the queue and store it in a variable named curr
• check if curr is the destination vertex inputed in the function parameter. If it is so, we can set path_found to true and break out of the while loop.
• Otherwise, we would want to create a for loop on curr’s neighbors. And only do the following if the neighbor is not in the visited set:
1. Enqueue neighbor to our queue
2. Add neighbor to the visited set
3. Set the neighbor’s parent variable to curr vertex
• Once the while loop has finished executing, we want to do a check statement if path_found is true. If it’s true, that means we can start appending to our path array! But we must follow these steps carefully:
1. Set our curr vertex to be the destination vertex,
2. Loop through while curr still has a value so we can: append curr to our path array, and update curr to become curr’s parent.
[I just want to note that in this step, with the parent variable, we’re traversing up the tree. And you can visualize it as the root node being the source vertex, and the distance vertex is the last node in the tree.]
• Outside the while loop, we can return path in reverse order!

3. Seeing how many places we can travel to based on our starting location

Since our graph represents vertices as a location, we can implement finding the degree of that vertex! A degree of a vertex simply means the count of the connecting edges. Let’s jump right in our brainstorm!
Check out the code to this problem!

Properties:
vert_obj —Vertex object from our graph

Pseudocode:
• Since our vertex class has a property that tracks all it’s neighbors, we can simply return the length of calling the vertex’s neighbors!

And that will be a wrap on this article on solving problems through graphs! I hope you found value in this blog post and I highly encourage you to try implementing all these methods or even create your own graph theory application!

For this article, I want to discuss a couple topics in the iOS world I’ve always found interesting: memory management, heaps, and stacks. I’ve never really understood the difference between them or how heaps and stacks relate to storing memory in Swift.

So, I decided to do some of my own research and dig deep into memory management in Swift. I hope you’re looking forward to this topic as much as I am! Let’s dive right in.

How is Memory Managed in Swift?

Swift uses ARC (Automatic Reference Counting). Some of you might find this term familiar. But if not, no worries! We’re all here to learn something new today 🙂.

Reference counting is the process of storing reference counts of initialized objects (normally instances of a class), pointers, or blocks. These are stored in memory and cleaned up—in other words, deallocated—once the objects are no longer needed.

ARC keeps track of strong references to an object, and when the count goes down to 0 (free from all strong references), the object will automatically deallocate from memory. I specifically say strong references because only strong references increase the count. Whereas weak or unowned references do not increase the count. (We’ll go into more detail about this distinction below.)

However, if the memory count of an instance never goes down to 0, this causes something that’s called a retain cycle, which leads to a memory leak.

Memory Leaks

A memory leak, as shown above, happens when the objects within the system never get deallocated from memory. This also means that the retain count of these two objects will never come down to 0, and as such they’ll always retain each other in memory!

Retain count — Represents the number of owners for a particular object.
Let’s take a small look at this example and see how the retain count increases.

class Person {
  let name: String

  init(name: String) {
    self.name = name
  }
  deinit {
  }
}

let person1 = Person(name: "Swifts")   // retain count: 1

let person2 = person1                 // retain count: 2
let person3 = person1                 // retain count: 3

The first incremental increase of the retain count happens when we initialize a Person object. We then create two more objects that refer to person1, making the retain count go up to 3 since they’re strong references by default.

How are objects never deallocated?

With the help of ARC, Swift automatically deallocates instances that are no longer used / needed (but remember, only when the reference goes down to zero).

However, if we don’t create our own resources properly (meaning your classes have the same pointer to the same instances), this can cause instances to remain in memory even after their lifecycles have ended.

This article is great to check out if you want to take an in-depth look at how a retain cycle is created in code.

How can we identify memory leaks?

Xcode has a built in memory graph debugger. It allows you to see how many reference counts you have on an object and which objects currently exist.

How can we fix memory leaks?

Swift provides two ways to solve reference cycles when working with a class type: weak references, and unowned references . — Swift Docs

Both weak and unowned references do not create a strong hold on objects.

weak — An object that can become nil at any point in time. These types must be optional. And the type must be declared as a variable (not a constant) since the value may be changed (to nil).

unowned — Assumes that the object will never become nil and is defined using non-optional types.

Dangers of memory leaks

Before moving on to memory organization, let’s take a quick look at how memory leaks are dangerous to your app 🆘❗️

• Increases memory footprint of the app: The action of creating objects is constantly repeating. This causes memory to constantly grow, which leads to memory warnings and app crashes.
• Unwanted side effects: Say we have an object that starts listening to an event upon creation and stops listening to that event when the object is deallocated. If there’s a memory leak from this object, it will never die and therefore will forever listen in on this event.
• Crashes: Multiple objects altering the database / user interface /state of app can cause crashes.

You might be thinking—we already know a lot about memory management in Swift. We do! However, Swift goes deeper and separates the ways in which it stores memory under the hood. Let’s take a look at the two following methods for memory allocation.

Heaps and Stacks

Memory Organization

Generally speaking, Swift has 2 fundamental parts for memory allocations.
Keep in mind that Swift automatically allocates memory in either the heap or the stack.

Table of contents

A. Heap
1. Memory that lives in the heap
2. Example of code that gets stored in the heap
3. When the heap is used

B. Stack
1. Memory that lives in the stack
2. Example of code that gets stored in the stack
3. When the stack is used

C. Heaps and Stacks Data structure
1. How memory management ties in to these data structures

Heap

The heap allows you to allocate memory dynamically, unlike the stack. All objects located on the heap are reference types, such as classes. Although they are more expensive to use in memory, classes are great to use as an identity and for indirect storage. You can imagine the heap like this: when you create an instance of a class, the memory is thrown right into the heap pile.

Reference types — When instantiating a new object of a class, a reference to that object is created instead of a whole new copy. This means they can be passed around and referenced by many objects! Take a look at this example below.👇🏼👇🏼

class Drink {
  var type: String
  
  init(type: String) {
    self.type = type
  } 
}

let favoriteDrink = Drink(type: "Chocolate")
let secondFavorite = favoriteDrink

secondFavorite.type = "Matcha"

print(secondFavorite.type)          // "Matcha"
print(favoriteDrink.type)           // "Matcha"

As you can see above, favoriteDrink is also modified when we change the value of secondFavorite. The reason this happens is because, under the hood, these objects are pointing to the same location in memory. So if you modify a value, all other instances that are pointing to that same object/location will also get modified!💥

What goes on in the heap?

When you create a new object, some memory gets allocated to the heap. Just like stacks, the memory goes away once it’s not being used. However, in heaps, the memory isn’t tied to functions or programs; instead, the data in the heap is global.

The heap is less memory efficient because memory is allocated to it by assigning reference pointers. All memory within the heap are instances of reference types only.

Conclusions of the heap

• It’s more dynamic but less efficient than the stack.
• Can grow and shrink in size.
• Stores reference types such as classes.
• Goes through 3 steps: allocation, tracking reference counts, and deallocation. As such, this process is less efficient when compared to stacks.

Stack

Stacks are where all value types are stored. When a function is called, all local instances in that function will be pushed on to the current stack. And once the function has returned, all instances will have been removed from the stack.

Value types — Independent instances that hold data in their own memory allocation. This is helpful in that, when you modify a value, you won’t accidentally change the value of another instance. Such as this example below.👇🏼👇🏼

var firstValue = 22
var secondValue = firstValue

secondValue += 2

print(secondValue)           // 24
print(firstValue)            // 22

Use value types when you want to compare data of the instances with the == operator or when you want your copies to have independent states. Some examples of value types are arrays, strings, dictionaries, structs, enums, etc.

What goes on in the stack?

All of our allocation happens in what’s called a function call stack. When a function exits, all the data will pop off the stack. Data will only exist while the function is still running.

Let’s take a look at what our function call stack looks like, going through the code below along with the diagram!

struct Point {
  var x: Double
  var y: Double
}

// step1
let point1 = Point(x: 0, y: 0)

// step2
var point2 = point1

// step3
point2.x = 2

// step4
// completed all tasks above

Before our code runs, we allocate space for point1 and point2 instances.

Step 1 — When we instantiate point1, we’re pushing it onto the stack.

Step 2 — point1 is assigned to point2, which means a new copy of point1 is created and pushed onto the stack.

Step 3 — Simply changing the value x for point2. Notice that only point2 is altered and not point1☝🏼.

Step 4 — Once we’re done executing these tasks(functions), point1 and point2 are deallocated from memory and our stack now contains no data.

If we have a function that calls another function, the execution of all functions remains suspended until the very last function returns its values. Very interesting how so similar this is to recursion! Turns out, recursion actually uses a stack implementation as well.

Conclusions of the stack

• More efficient when allocating and deallocating data.
• Stacks store value types, such as structs and enums.
• Data stored in the stack is only there temporarily until the function exits and causes all memory on the stack to be automatically deallocated.
• Makes memory lookup and access very fast from how well it is organized.
• The most frequently reserved block is the first to be freed.

Heaps and Stacks Data Structure

The ways in which heaps and stacks are used in Swift to store memory have a lot of similarity with how we use data structures. In the next article, we’re going to see what these data structures do and how both are implemented in Swift!

That’s it for today’s article! Thank you so much for sticking with me. I hope you gained some deeper understanding for iOS development and how memory gets stored in Swift. If you have any questions, comments, or concerns, please feel free to reach out to me, and I’ll get back to you as soon as I can.🙂

Good reads to check 💯
Stack vs Heap — GribbleLab
Memory Management — SwiftRocks

Thank you for checking out this blog post!

If you have any questions or comments, please feel free to reach out to me. And don’t forget to give this article some claps! 👏🏼*up to 50x*👏🏼 if you found it helpful.

Editor’s Note: Heartbeat is a contributor-driven online publication and community dedicated to providing premier educational resources for data science, machine learning, and deep learning practitioners. We’re committed to supporting and inspiring developers and engineers from all walks of life.

Editorially independent, Heartbeat is sponsored and published by Comet, an MLOps platform that enables data scientists & ML teams to track, compare, explain, & optimize their experiments. We pay our contributors, and we don’t sell ads.

If you’d like to contribute, head on over to our call for contributors. You can also sign up to receive our weekly newsletters (Deep Learning Weekly and the Comet Newsletter), join us on Slack, and follow Comet on Twitter and LinkedIn for resources, events, and much more that will help you build better ML models, faster.

Memory Management in Swift: Heaps & Stacks was originally published in Heartbeat on Medium, where people are continuing the conversation by highlighting and responding to this story.

GetAtIndex, insertAtIndex, append, prepend

This diagram represents our linked list we will be working with! Each rectangle represents a node which has 3 slots in it. The middle slot represents value of the node, the left slot represents the previous pointer, and the right slot represents the next pointer. In addition to that, our linked list will keep count of a head and a tail.

Make sure to check out my singly linked list article here for previous references!😃 There, I go in depth of how to create a singly linked list class as well as a node class to start implementing the different methods within it.

How are doubly linked lists different from singly linked lists? Doubly has a previous pointer which points to its previous node! This can be favorable based upon what type of actions we want to do on our data structure which we will go into furthermore in this article.⏬✔️

Table of Contents

1. Pros and Cons of a Doubly LinkedList
2. Creating the Node Class Using Generics
3. Creating the LinkedList Class Using Generics
4. Methods in Doubly LinkedList class:
   • Append
   • Prepend
   • Items
   • Get node at index
   • Insert at index
5. Examples of Using Doubly Linked List in Real Life
6. Stretch Challenges!
   • Delete all nodes in the linked list
   • Inserting a node after a specific node
   • Print out the linked list in order
   • Print out the linked list in reverse order

Pros and Cons of a Doubly Linked List

Node class

As you can see in this Node class above, each node holds exactly 3 variables; a value(data), a next which will hold the node after it, and a prev which will hold the node before it.

Generics

Generic code enables you to write flexible, reusable functions and types that can work with any type, subject to requirements that you define. — Swift Docs

Swift Array and Dictionary types are generic collections.
In our case, we would also want to create our linked list class using generics so we can create nodes with whichever type we want such as Integers, Floats, Doubles, Strings, Tuples, or even our own Models!

Linked List class

This linked list class will contain properties of the head, tail, and size. This size value will be helpful when we want to find the length of the entire linked list.

Now that we have our foundation written down, we can start implementing different methods to our LinkedList class👇🏼👇🏼👇🏼

Methods in DoublyLinkedList class

I highly recommend to try coding these functions or writing down pseudocode before looking at the solutions!! 📝 ✍🏼
Don’t forget to keep account for both next pointers and previous pointers while implementing the following methods.

• Append

Adding a new item to the end of the linked list.

This is where self.size will be used and updated!

1. Create a new node from the value passed in the parameter
2. Create a guard statement to make sure the head value is not nil in order to continue lines after 12.
3. If the head is nil, meaning our linked list is empty, we initialize the head and tail to be the new node created on line 3.
4. Now that we are sure our linked list isn’t empty, we know there is a tail value. So we set the tail’s next pointer to be newNode. We also give newNode a previous pointer to our tail. Lastly, is to update the tail to become the newNode.
5. Incrementing our size by 1 since we just added a new member to our list family. 😲😄

• Prepend

Adding a new item to the beginning of the linked list.

1. Create a new node from the value parameter
2. Using a guard statement to make sure there is a head value or else lines 8–11 will get executed.
3. Initializing our head and tail to be newNode without having to change or add any pointers.
4. Now that the case of the linked list isn’t empty, we go ahead and do the following:
   Setting the head’s previous pointer to be newNode
   Giving newNode a next pointer to our head
   And finally updating the head to our first node(newNode)
5. Incrementing our size by 1 since we just added a new member to our list family. 😲😄

• Items

Returning all items in the linked list as an array of values sorted from the head to tail.

1. If the linked list is empty, we return an empty array
2. Create an empty array where we will be appending all the node values
3. Loop through the linked list starting from self.head.
   In the while loop we first append the current node’s value, and then update curr to become the next node.
4. Once we hit the end of the linked list, we can return the array which is now filled with all the values of nodes in the linked list!

• Insert at index:

Inserting a node at the given position we would want to insert it at.

Don’t be alarmed by this huge chunk of code! We’ll get through this together step by step and see how this magic all happens.🔗🔗

1. We first need to check the input index must be in range of our items in the linked list. Let’s say we have 3 nodes in our linked list, the indexes we can only go up to is 3. If given index is larger than 3, we’ll return out of the function with a print statement saying the index is out of bounds.

⚠️Before going into steps 2, 3, and 4, we must know there are 3 possibilities of where we want to insert the node.
 — Inserting at the front: changing self.head
 — Inserting at the end: changing self.tail
 — Inserting between 2 nodes: changing next and previous reference pointers.
We would want to check for these cases separately so our code is more efficient!

2. index == 0 means we’re inserting in front of our list.
Here’s what’s going on in the prepend method. (Order matters!☝🏼)
- Set the current head’s previous pointer to our newNode
- Set our newNode’s next pointer to the self.head. We do not need to set newNode’s previous pointer since it’s set by default to nil
- Change the head to be our newNode!!

3. index == self.size means we‘re inserting to the end of our list.
Here’s what’s going on in the append method. (Order matters!☝🏼)
- Set the current tail’s next pointer to our newNode
- Set our newNode’s previous pointer to the current tail
- then we change the tail!

4. index is somewhere between 2 nodes which means we’ll have to traverse the linked list until we get to the desired index.
- 1: Create a new node with the desired value
- 2: Loop through the linked list, updating our curr node to become the node right at the index we would want to insert newNode
- 3: Attaching our current’s previous’s next pointer to newNode.
And also attaching our newNode’s previous pointer to our current’s previous node.
Now we can reassign current’s previous pointer to newNode.
And our newNode’s next pointer to the current node.
- 4: Incrementing self.size by 1. And we’re only doing this step in the else clause because both append and prepend methods already cover the incrementation.

• Get node at index

This method simply returns the value of the node at the given index.

1. Checks that the input index is in the range from 0 to self.size. Or else, we will return nil since there are no values at that invalid index.
2. start from self.head and traverse through the linked list. If say the index was 1, then we update ‘curr’ to the next node 1 time. Likewise, if the index was 0, the code won’t execute the for loop at all (0 times).
3. Lastly, we return the value of that current node because it is correctly at the index we are looking for.

Examples of Using Doubly Linked Lists in Real Life

• Creating a music playlist 🎶🎵🎶. This article even gives you a coding example on how to implement your own class!
• Drawing from a deck of cards. The nodes can represent the rank, and color of one card.
• And finally, the undo and redo functionality on a browser!! This is where you can reverse the node to get to the previous page.

Stretch Challenge Methods

1. deleteAll(): Deletes all the nodes in the linked list
2. insertAfter(_ value: T, after: T): Takes in the value you want to insert and, a value of the node you want to insert right after
3. listForward(): prints out the linked list node’s values from front to back
4. listBackward(): prints out the linked list node’s values from back to front

I hope you found value in this blog post and I highly encourage you to try implementing all these methods in a Swift playground

Thank you for checking out this blog post!

If you have any questions or comments, please feel free to reach out to me. And don’t forget to give this article some claps! 👏🏼*up to 50x*👏🏼 if you found it helpful.

Append, Prepend, Remove, Find, and Replace

As you may have heard the term linked list pop in every now and then. It’s a form of data structure that can store a collection of items. Linked list consists of a group of nodes together to represent a sequence, relative of the same type.
If you are here to learn how to implement linked lists in Swift and learn some tips, you’re in the right place!

As you might have guessed, the picture above demonstrates a linked list. In this case, the linked list contains many nodes, a head, and a tail. The head represents the beginning node and the tail represents the last node in the linked list. Each node contains a value(data) and a next referencing to a new node.

Node class contains: value, and next

Linked List class contains: head, and tail

We conform to the ‘Equatable protocol’ in both classes.
Equatable protocol — has a constraint where you are able to check equality between objects of the same type. Thus, allows us to perform the == operation on our T type, and on our Nodes!!

Now that we have our foundation written down, we can start implementing different methods to our LinkedList class👇🏼👇🏼👇🏼

Methods in LinkedList class

I highly recommend to try coding these functions or writing down pseudocode before looking at the solutions!! 📝 ✍🏼

• Prepend (Insert at beginning)
  Runtime: O(1)

1. Create a new node from our input value
2. If our linked list is empty, assign head and tail to our new node
3. If our linked list is not empty:
   assign our new node’s next pointer to self.head
   and update the head pointer to be our new node

• Append at end
  Runtime: O(1)

1. Create a new node from our input value
2. If our linked list is empty, assign head and tail to our new node
3. If our linked list is not empty:
   set the tail’s next pointer to the new node
   and update the tail pointer to be our new node

• Remove a value
  Runtime: O(n) where n is the number of nodes we have to traverse through

In the code below, we are checking for the following cases where we want to remove the node:
case1 : is the tail
case2 : is the head
case3 : is in between nodes
case4 : is the only node (both head and tail)

1. Create variables so we have access to the current node and previous node
2. Traverse through the linked lists while current is not nil
3. Found a node that is equal to our input value!!
4. Checking the previous node has a value
5. Deleting a node at the end of a linked list
   set self.tail to be the previous node
6. Change pointer of prev’s next to curr’s next
7. Else, previous node is nil. And we’re deleting a node at the end of a linked list.
   set self.tail to be the previous node
8. Changing self.head to be the current’s next node
9. Haven’t found the item yet, so we keep looping through and checking the next node.

• Length
  Runtime: O(n) where n is the number of nodes in the linked list.
  However, the runtime can be O(1) if we have another value in the linked list class that keeps count of items as we insert/append, or remove.

1. If the linked list is empty, return 0 and leave the function
2. Create variables for count and current node
3. Traverse through the linked list while curr isn’t nil
4. Increment count by 1 and check on the next node
5. Return the count!

• Last element
  Runtime: O(1)

Returns the last element in our linked list.

• Find
  Runtime: O(n) where n is the number of nodes we traverse through.

Here we are traversing through the linked list until we find a node that is equal to our input value.
This method returns the value of that node being that it is found, else, will return nil

• Replace an old item with a new item
  Runtime: O(n) where n is the number of nodes we traverse through.

1. Create a variable to keep count of the current node
2. Traverse through the linked list while curr isn’t nil
3. We’ve found the node! So replace the curr’s value with the new input value and return out of the function
4. Haven’t found the node yet, so we loop to check the next node

Testing

Now that we have our foundation class written down and functioning, let’s go ahead and test to see if these methods actually work 🤔🤔

Append
Start off by instantiating an empty linked list and appending items to it.

let ll = LinkedList<String>()
ll.append(value: "apple")
ll.append(value: "butter")
ll.append(value: "cinnamon")

If we write a print statement checking the head and tail, it should print out “apple” and “cinnamon” respectively.

print(ll.head?.value ?? "no head found")   // apple
print(ll.tail?.value ?? "no tail found")   // cinnamon

Remove
Removing something from the start of a linked list should change the head pointer…

ll.remove(value: "apple")
print(ll.head?.value ?? "nothing found")    // butter
print(ll.tail?.value ?? "no tail found")    // cinnamon

Replace
Replaces the old value with our new value and should print out the new value.

ll.replace(old: "cinnamon", new: "chocolate")
print(ll.tail?.value ?? "no tail found")    // chocolate

These are just some methods of a linked list class implemented in Swift. Go ahead and try these out in a Swift playground and see the magic! Ѻ→Ѻ→Ѻ
I’m sure there are more methods out there and would love to see anyone share them down below😃🤓

Thank you for checking out this blog post! If you have any questions or comments, please feel free to reach out to me 🙂 And don’t forget to give this article some claps! 👏🏼👏🏼*up to 50x*👏🏼 if you found it helpful.💡

A straight forward step by step guide done programmatically.

Hi everyone! Today, I will be showing you a step by step tutorial on how to setup a TableView programmatically as well as using the delegate and datasource protocols in Swift 4.2. I hope this tutorial serves as purposeful to you in your projects and let’s jump right in! 😃

Step 1: Create a ViewController.swift file

This will serve as the View Controller where we add our tableView subview and manage the UIKit app’s interface.

class ViewController: UIViewController {

}

Step 2: In our ViewController class, instantiate a UITableView object

This is how we create a TableView object and set all the requirements for them within this scope.

Step 3: Setup the tableView and add constraints!

We add views and set constraints to them with the ViewDidLoad method. This method is called after the view has been loaded.
Instead of putting all the code inside viewDidLoad, we’re going to make this more readable by creating a function for setting up the tableView. 🙂

Once completed, try running the app and you should see the following!

Step 4: Conform to UITableViewDelegate and UITableViewDataSource

According to Apples documentation — The delegate manages table row configuration and selection, row reordering, highlighting, accessory views, and editing operations.
While the data source provides information that UITableView needs to construct tables and manages the data model when rows of a table are inserted, deleted, or reordered.
Once we inherit from the delegate and datasource in our class, we then add the protocol stubs, and assign our tableView to the delegate and datasource methods. ( tableView.delegate = self )

1. We return 10 numbers of cells in the tableView
2. Create a tableViewCell to populate the screen.
Currently everything is configured through defaults, so we cannot change the views unless we create our own UITableViewCell class! 👇🏼👇🏼

Step 5: Create our own custom subclass of UITableViewCell

Note that this is of type UITableViewCell. According to apples documentation — This class includes properties and methods for setting and managing cell content and background (including text, images, and custom views), managing the cell selection and highlight state, managing accessory views, and initiating the editing of the cell contents.

Because UIView adopts the NSCoding protocol, it requires an init(coder:) initializer. And since we’re implementing init(style:reuseIdentifier:) , our class is no longer inheriting from the super initializers resulting in the implementation of the code on line 7 👆🏼

Step 6: Register the new cell class

Once we’ve added a TableViewCell class, we can now make our ViewController inherit this cell. And, in order to make that, we’ll need to do some small changes in setupTableView method and datasource protocol.

func setupTableView() {
    ...
    tableview.register(ThirtyDayCell.self, forCellReuseIdentifier: "cellId") 
    ...
}

...

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableview.dequeueReusableCell(withIdentifier: "cellId", for: indexPath) as! ThirtyDayCell

    ...
}

The tableViewCells right now are very small, to offset this I will be adding a delegate method to increase the height for all cells.

func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
    return 100
}

Step 7: Add content to our ThirtyDayCell class

With the above photo being what we need to end up with, we need to instantiate a UIView for the background color and then a UILabel to represent each day.

• Instantiate the UIView and UILabel

In order to have this rounded cell look, we are going to add a UIView and that will represent the orange colored cells as you can see in the above picture!

• Setup the UIView and add constraints!
  This step is similar to setting up the tableView but instead we set up the view in our override init method.

• Setup the UILabel inside the UIView and add constraints!

As you can notice, there is a small line that goes across the screen right under each of our cells. By default the tableView separator color is set to grey. We can change this easily in our instantiation of the tableView

let tableview: UITableView = {
    ...
    tv.separatorColor = UIColor.white
    return tv
}()

Step 8: Customize the data in each of our cells in this tableView(_:cellForRowAt:) method

Once we type cast the cell to ThirtyDayCell, we can access all the properties and methods within that class! And with this in mind, we’re going to change the dayLabel’s text.

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableview.dequeueReusableCell(withIdentifier: "cellId", for: indexPath) as! ThirtyDayCell
    cell.backgroundColor = UIColor.white
    cell.dayLabel.text = "Day \(indexPath.row+1)"
    
    return cell
}

Completed!!

Thank you for checking out this blog post! If you have any questions or comments, please feel free to reach out to me 🙂 And don’t forget to give this article some claps! 👏🏼👏🏼*up to 50x*👏🏼 if you found it helpful.💡

Thanks to Vincenzo Marcella, Medi Assumani, and Noah Woodward

This story is published in Noteworthy, where 10,000+ readers come every day to learn about the people & ideas shaping the products we love.

Follow our publication to see more product & design stories featured by the Journal team.

An iteration on creating the product

Have you ever thought about traveling with your best friend or family and being able to know exactly where they are at every point in the trip? Look no further. There has been various occasions where people have wasted time just to catch up with others who may be arriving to the destination late or had changed routes and made the trip more complicated for others. What if there was an application to help solve that problem? From iterating over the different possibilities to help tackle this problem, we came up with this solution:

An app for users to keep track of each other where they are in real time.

From doing research, we have found several apps that tackle similar problems. The following are some example apps:
Follow: Drive together — Other users can follow the same route as the leader’s
Roadtrippers — Users can view different destinations along the route and pin them to their map.
inRoute Route Planner — Allows users to choose routes based on their preferences
The following will be our iteration process in creating and improving our product.

Strategies

• Pair programming
• Retrospective meetings
• Wireframes / Design (UI/UX)
• User journeys
• User interviews

Six common issues with pair programming.

and tips for improving

• Hard to meet up
  Sometimes we have different schedules, and it can be hard to settle on times for meeting up and working on the project together. To make meeting up go smoothly, we both had a common agreement that we would sacrifice time for the meetings and pair programming.
• One person more technical than the other
  Be patient with people you’re working with. Understand what they are struggling with then demo and explain parts of the code and also always know how to limit the scope down to be something for both to work on.
• Indecision on idea
  Try to understand the goals on both sides of the team and write down as many topics as you can. One thing that really helps is to just talk over every possible choice. sometimes just talking can spark up more ideas and I guarantee you, you will get to know a lot about your team member and what both sides are most passionate about.
• the goals of your partner
  Using a problem tree / Opportunity tree
  Write a decision document listing options with pros and cons
  Go out to mentors or instructors to check further about the idea
• Indecision on Stack & Tech
  Over scoping is the biggest risk
  Choose the most logical solution based on the people in the room and their technical skills
• Indecision on design
  Pick an area owner for UX/UI — A designated lead of design who makes the final calls
• Lack of accountability & follow through
  Pair programming — One research stated “students that worked in pairs passed 15% more of the instructor’s test cases.”
  Celebrate wins!
  Plan to share all tasks 50/50
  Set force meetings with an advisor. So you can set aggressive deadlines for yourself.
  Set small and agile goals

Retrospective Meeting Agenda

My team mate and I decided to cover these following points in every meeting:

• Define done (shipped, finished the code, completed wireframes)
• Be able to demo the finished task
• Talk about what went well last week and what went poorly
• Acknowledge the other and give shoutouts
• Plan for future improvements
• Think of the next task and goal to work on

Why Do We Pair Program?

Pair programming can by far help coders learn from each other and think of new concept and ideas along the run. Some coders may think of it as a waste of time, but it can be a good way to get to know your partner, improve communication, and practice teamwork. By far, pair programming encourages faster learning and up skilling while maintaining fewer coding mistakes.

Retrospective Meetings

November 7
Define Done:
What went well —Having a really strong idea on what we want to create right at the beginning of the project, we were able to complete most of our wireframes for the app, and implement the core feature of the app, which is a map.
What went poorly — We haven’t got much of the coding part done.
Acknowledgements —We’re very proud of the app logo we created during Mondays class, and the idea we came up with.

November 19
What went well — Had a great coding session with friends and team member. Planned out the entire framework/main features of the blog post, reiterated over the app design, and got set on an app logo.
What went poorly — Should spend more time on coding.
Acknowledgment — We are very proud of the apps theme and icon.

November 26
Define done — We created another blog post in addition to this to focus solely on the product design.
What went well — The scope and progress of both the blog post are clear and planned out.
What went poorly — Not working on the technical part of the project.
Acknowledgements — We’ve designed and scoped the blog posts out really well and we are excited to work on the technical side to make the app have more usability.

Design

Check this blog post where we go in depth of how we use color, typography, and information hierarchy to create a great design for our product which can easily be implemented into your own designs too!

tl;dr the color theme we chose for our app was warm and calming which gives a feel of nature. Over the whole project, we used the same font family to maintain simplicity and ease for users. The information hierarchy is also set with the font size and color to set the views.

User Testing

From the designs we created, we were able to conduct user tests. User testing is when you put your prototype in a target users hand and see what they do. This will give insight on how to improve your UI/UX from where users get stuck, where they are confused, and how they follow through on your intended use case.

• How is it great?
  Gives you a chance to improve the design of your product and the usage
  gives other possible choices for other ways you can implement into your product.
• How to conduct user tests:
  Ask demographic questions, give context for the test, let users start navigating through the app, and don’t forget to ask follow up questions.

Questions are very important, they allow us to fill in the gap of knowledge. This is why we conducted this question up:

“Are you a person who road travels a lot with friends and family?”

This lead us to letting users know the outline of what the app is about and knowing whether the user fits into our demographic or not.

After we have asked the demographic question, we went in and gave context of how we will be conducting the user test and handed over the computer to test the prototype use of the app. The users would speak out their thoughts the whole time. By the end, we asked some follow up questions such as;

“What are your thoughts about this app?”, “What did you like about it?”, “any feature recommendations?”, “what do you think can be more useful in the app?”.

Then ended it off with a kind thank you.

Thank you for joining us on our journey of creating this product!
A huge thanks to Rinni Swift for making this project fun. 🎈
All feedback is accepted. 😃 Don’t forget to drop some claps! 👏👏👏

Software Product Development was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.

“Habit is a cable; we weave a thread each day, and at last we cannot break it.”―Horace Mann

Ever since I was in middle school, I have always been obsessed with working out and eating healthy. Most of my friends in school would know me and my sister for that. However, when I moved overseas for college, my schedule was soon changed and I did not exercise nor be aware of the food I was eating. I had totally lacked out, and lost motivation. I came across this ted talk about adjusting your habits from small changes each day and this made me come up with an idea for an app. I want to create a platform where users can implement a really small healthy habit into their daily life.

Problems

The problem in this domain is that the many people are not educated in the field of health and nutrition. Some countries do not show the importance of keeping a healthy lifestyle through nutrition and diet. Maybe, people know what to eat, but they do not know why they should be eating like that. This creates a problem because in the era where technology has taken over many aspects of our life, we can easily get anything off the internet at ease. This convenience has changed our lifestyle mainly for the better, but it has some effects since everything is so easy to access.
Students or family members become a target for industries marketing unhealthy and cheap food. The food industry wants many people to get addicted to their products thus creating products without the best intentions for one’s health.

Solutions

Through all the new technology that has been invented in the past few years, we can make good use of it and enhance our perspective toward nutrition and diet. Many apps have already been created to help out people who want to have a better diet or to be able to track calories but, none of them teach users where to start. MyFitnessPal is a popular app that calculates calories and recommends daily calorie intake based on your weight and height. Fooducate, a similar food app, gives you nutritional value of the food you search up by barcode.
As helpful as all these apps are, I think it would be great to have a single platform where users can browse shops, these don’t have to be restaurants, that only sell healthy and nutritious food. Or, for people who want to start a health journey, to have an app that integrates a small challenge about fitness and diet into their daily routine.

PEST Analysis

For laying out the foundations for my idea, I used a PEST analysis. This is a great tool to use in the world of business to help you go through all the factors. Every business moves toward profit and one single factor can prevent it from growing and improving. PEST stands for political, economic, social, and technological trends. This analysis will be used to evaluate the external factors which has influence on the health and diet domain.

Political analysis
- More and more companies focus toward health and diet nowadays
- Food and drug administration policy process
- Laws for selling food online
There’s an increasing amount of companies and businesses that are becoming more aware of health problems in society. Politics have moved towards building a more healthy society by investing in more health care programs. One of the growing concerns in America is the increasing rate of child obesity. According to the report from the journal pediatrics, “More than 40% (of children) are obese”. Because of the obesity rates increasing, there’s more campaigns aimed to encourage exercising and healthy eating. Some of these include lady Michelle Obama’s “Let’s Move” campaign and her food campaign. These campaigns are hoping to help prevent adult obesity levels hitting 50% by year 2020. The app idea I have would be a good starting solution for people who want to become more healthy but don’t know where or how to start. It will allow users to slowly integrate healthy eating and exercising habits in to their daily routine.

Economic Analysis
- Unhealthy foods cost less than healthy nutritious foods
- People are investing money toward health more than in the past
- Lack of access to healthy food
- Consumers on food choices are based off price and quality, taste, and conveniency
- Personal preferences
- Economic growth forecast
In today’s society, foods that are unhealthy are being charged for a lower price and foods that are more healthy are charged for a higher price. This means consumers that don’t have enough knowledge or income to have to choose the cheaper option which is usually not good for health. In the beginning when fast food as well as junk food emerged, society valued the convenience without knowing about the impact it may have on their health. However, society is beginning to see just how unhealthy the impact of these companies are. Improve in nutrition leads to productivity and economic development. The economic costs of malnutrition is very high — several billion dollars a year in terms of lost — and this is why companies are investing more in health and nutrition.

Social Analysis
- People’s eating behavior highly depends on social influencers and what they’re eating
- Nowadays, social media is leaning toward creating a health concerned platform
- People are moving toward making their own healthy homemade meals or healthier versions of unhealthy food
- Food decisions are made differently depending on religion
- Different culture and the diet they have
When looking at society today, eating behaviors are very dependent on social influences and social networking. Social media technology has infiltrated our societies. One of the main side effects which is Health and fitness. From pictures of ‘goals’ body images to a variety of diets that seems to be the best for human kind. However, these impacts are not all negative and may have more of a positive impact by sharing knowledge of healthy eating and exercising. Many social influencers share the importance of eating healthy by creating posts on instagram that show their health journey. There are several instagram accounts that are only used for sharing healthy meals or sharing exercise journeys. These social media platforms are really leaning toward creating a health concerned platform.

Technological Analysis
- New food technologies fitting a specific diet
- Online recipes to give ideas on how you can cook
- Companies that have a pre cooked meal plans
- Food delivering companies/apps
- Farmers and producers are using technology such as robots, agricultural drones, and chemicals to improve growth and increase yield.
Today, more than ever, people have the power to create a change in the world towards a better lifestyle by inventing new technology to cure or prevent diseases. The benefits of emerging health related technologies are encouraging people to: start having healthy habits and start having easy access to knowledge for getting a better diet. When it comes to food technologies, Soylent…a company that replaces meals with a simple drink, has made getting food/nutrients more convenient than ever. But, is this product really healthy? It is your choice to decide so. Some other companies have designed meal plans that can be shipped straight to your house at ease. This is all created from emerging technology that is constantly changing and improving for the future.

Competitive Analysis

This competitive analysis is used to compare and contrast the apps that have already been created in this field of domain. Competitive research is to collect bits of information and compare them so you have a better understanding of how you want to form your idea into an app or website. In the following image, I have compared 3 apps that are pretty similar.

Freeletics offers users access to workouts plans, routines, support, and explanations. They make sure that these are customized to you. You can also get a personal coach but you will have to pay monthly or yearly.
Sworkit allows you to easily customize workouts by type of activity. The workouts start from as short as 5 minutes.
Seven-7 minute workout only has workouts that are 7 minutes long. However, the amount of workouts you can access is very limited.

Interview Process

In my interview process, I aimed to ask unbiased questions. This is a good strategy to have in creating an effective interview and getting accurate decisions.

• Questions I asked:
  How often do you eat out per week?
  Do you like cooking homemade meals?
  Do you have any fitness goals for yourself? If so, what are they?
  Would you ever buy food online?
• Questions I avoided:
  Do you use any apps to help with ordering your food?
  How often would you consider using Uber eats? And what do you think about it?
  What is the best app in the market to help with tracking your fitness goals?
  Is there a specific diet you are following?

Feed back:
From my interview process with pedestrians at union square San Francisco and a couple of my friends at school, I found out that people want to get healthier. However, are not motivated to start working out and eating healthy because they feel like they have to get mentally prepared and ‘clean up’ their schedule. Although, there are a group of people that have already started their exercise routine and are loving it so far.

User Journeys

User journeys include the possible events or experiences a user might encounter when going through an app or product. This will allow you to analyze and structure your app idea to be clearer.

Benefits of creating user journeys:

• Finding edge cases of how users use your program or app
• Defining keywords within your code
• Designing your product for growth
• Getting an insight of how users can use your product
• Showing the basic steps of starting to create the product before going on further steps

These user journeys are from high school/college students that have either never started a health journey, or have already started but never continued. One commonality among the three journeys is that they all want to start a healthy journey and incorporate it as a daily habit.

I’m Rinni a high school student and I wanted to start my journey on health and fitness. But I didn’t know where to start and I wasn’t very motivated to jump straight into working out. I came across this app and thought it was a great idea of how I can start off with small challenges everyday.

I’m Frenny a fitness coach and came across this fitness app one day while scrolling through the browser. I would say this app is a great way to get people going in the direction of exercising and getting them to start on small changes everyday. I have suggested it to some of my clients who have not

I’m Layla a college student who is extremely in to health and diet. But as soon as I moved out to college, I totally stopped working out and now I don’t know how to get myself as motivated as to back then. However, I downloaded this app and I have been using it for a couple weeks now. I incorporated this into my daily routine and I am starting to see a change.

Wireframes

“A wireframe is a visual representation of a user interface, stripped of any visual design or branding elements.” — theuxreview

Benefits of wire framing:

• Gives the vision of the product you want to create
• Iterates quickly and saves you time
• Separates design from development
• Change and update as you get feedback
• Be more creative — come up with multiple designs

When creating wire frames for my app, I focus on keeping the design clean and colorful, and having an easy to follow functionality.
I want to create an app to help users start their health journey by implementing a small change in their daily life. Users can add emojis to express how they are feeling after each challenge. And toward the end of the week, you can check your statistics.

Helping health and fitness with tech was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.