DEV Community: Abdullah Khan

Getting Started with Vapor: Building Swift Web Apps with Ease

Abdullah Khan — Mon, 16 Dec 2024 19:00:46 +0000

Introduction

Imagine creating powerful mobile apps that easily connect to server side features using Swift. With the Vapor framework, you can use your Swift capabilities to build fast, efficient, and flexible backends for your mobile apps. Whether you are an expert in Swift or a beginner like me, Vapor makes it easy to build APIs that are simple to implement into your apps. In this blog, we'll look at how to download and set up Vapor so that you can use it in your Swift app.

Why Vapor?

Launched in 2016 Vapor has become the top choice for Swift developers for building server side apps, because of features like async/ await and the Fluent ORM, which makes it simpler for developers to interact with the databases, by allowing them to work with Swift objects instead of raw SQL. Fluent ORM makes it easy to define models, manage relationships and create queries while still being able to work with postgreSQL. Compared to frameworks like Vapor is the better choice since it is simple to use, it has a larger user base and a better broader ecosystem.

Getting started with Vapor

Getting Vapor up and running on your Mac is easier than you might think! Here’s a step-by-step guide to get started:

Step 1: Check for the current version of Swift

Open terminal and type the following command

Swift --version

This will give you the current version of Swift you are running, If you don’t see a version number, install Swift before continuing, your terminal should look like this after running the command:

Step 2: Install Homebrew

In your terminal run this command and press enter

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After running this command you will get the prompt to put in your mac password, after that your terminal will start to download brew on to your mac.
Why this matters: Homebrew is a powerful package manager for macOS that simplifies the installation of software like Vapor. Think of it as your app installer for development tools!

brew --version

You should see this in your terminal.

Step 3: Install Vapor Toolbox

In terminal type:

brew install Vapor

After running the command your terminal should look like this

To confirm that Vapor is now installed in our computer we can run this command to see the current version that we are running.

Confirm it’s installed:

Vapor --version

Your terminal should look like this

Seeing this in your terminal is completely normal because when you run Vapor --version, it checks if you're in a Vapor project directory to provide version information specific to that project. If you're not in a project directory, it will display the warning about not finding a Package.resolved file and suggest that you ensure you're in a Vapor project or have run Swift build.
However, the toolbox version (toolbox: 18.7.5) should still be displayed, indicating that the Vapor command-line tool is installed correctly. This behavior is normal and just means the Vapor command can't find a project context to work with. Since we can see the (toolbox: 18.7.5) command at the end we have successfully installed Vapor on our computer and can move on.

Step 4: Create a Vapor Project

In terminal type this command

Vapor new MyVaporApp

Select "default" when prompted.
Why this matters: This command generates a complete project with all the files and folders you need to get started. It’s like a starter kit for your Vapor journey.

Step 5: Navigate to Your Project

Move to your new project’s folder:

cd MyVaporApp

Why this matters: You need to be inside your project directory to run commands or make changes to your app.

Step 6: Start the Server

Run this command:

Vapor run

Why this matters: This launches the local development server. Your app will be live and accessible, ready for testing.

Step 7: Test Your Setup

Open a browser.
Visit: http://localhost:8080.
Look for the "It works!" message.
Why this matters: This confirms that Vapor is installed and your server is running correctly.

Connecting Vapor to an Existing Swift Project

While creating a new Vapor project is straightforward, you may want to integrate Vapor into an existing Swift project to extend its functionality with server-side capabilities. Here’s how to seamlessly connect Vapor to an existing Swift project:

Step 1: Add Vapor to Your Project Dependencies

Open your existing Swift project in Xcode.
Locate the Package.Swift file in your project root. This file manages your project's dependencies.
Add Vapor as a dependency by including the following line in the dependencies array:
Swift

.package(url: "https://github.com/Vapor/Vapor.git", from: "4.0.0")

Add Vapor modules to your target dependencies. For example:

.target(
    name: "YourProjectName",
    dependencies: [
        .product(name: "Vapor", package: "Vapor"),
    ]
)

Save the file and run:

Swift package resolve

This will fetch the Vapor package and integrate it into your project.

Step 2: Launch Vapor from your project

To make sure the Vapor server runs with your app. Modify your app's entry point (e.g., main.Swift or AppDelegate.Swift for UIKit apps). This will start the Vapor server when your app runs.
Add the following code to launch the Vapor server:

do {
    let app = try configureVaporApp()
    try app.run()
} catch {
    print("Failed to start Vapor: \(error)")
}

Step 3: Test the Integration

Build and run your Swift app.
Open a browser and visit http://localhost:8080/hello.
You should see the message: "Hello, Vapor!".

Conclusion

Getting started with Vapor is simple, and the powerful framework makes building server-side Swift apps efficient and fun, for both new and experienced programmers. Whether you are starting a new project or adding a server functionality to a existing project, with these steps it's pretty straightforward and easy to understand, you are now ready to start building full stack apps using Swift and Vapor.

Happy coding and have fun!

Beyond JavaScript: The Swift Path to iOS Development

Abdullah Khan — Thu, 28 Nov 2024 02:47:06 +0000

As developers, one of the most exciting milestones in our learning journey is venturing beyond our first programming language. After mastering the fundamentals of JavaScript, I decided to explore Swift, Apple's modern language for building iOS, macOS, watchOS, and tvOS applications. In this blog, I’ll compare JavaScript and Swift, highlighting key differences, commonalities, and tips for transitioning as a JavaScript developer.

Why Learn Swift?

Performance: Swift is designed to be fast. Unlike JavaScript, which relies on an interpreter in the browser or Node.js, Swift compiles directly into machine code. This makes Swift applications noticeably quicker and more efficient, especially for resource-intensive tasks.
Popularity and Ecosystem: Swift has gained immense popularity since its release in 2014. Supported by a robust Apple ecosystem, it continues to grow with frameworks like SwiftUI and Vapor. While it’s not as universal as JavaScript, its niche is highly valuable.
Career Opportunities: With the demand for mobile apps, iOS development provides rewarding career opportunities. Swift, as Apple's primary language for iOS, is essential for anyone looking to develop apps for iPhones, iPads, Macs, and even Apple Watches.

Key Differences Between Swift and JavaScript

Type System: Swift is statically typed, while JavaScript is dynamically typed. Swift's static typing ensures safer and faster code, catching errors at compile time, whereas JavaScript's dynamic typing gives more flexibility but can lead to runtime errors.

Runtime Behavior: Swift code compiles to machine code, enabling high-performance execution directly on Apple devices. JavaScript code, by contrast, runs within an engine (like V8 or JavaScriptCore), relying on interpretation or JIT compilation, making it more flexible but typically slower.

Essential Syntax: Data Types in Swift

Swift provides several basic data types to improve code reliability and type safety. Understanding how to declare and use these data types is critical for writing effective Swift code.

Swift is a statically typed language, meaning every variable and constant has a specific type determined at compile time. You must declare the type explicitly when creating a variable (e.g., var age: Int = 19) unless the compiler can infer it from the assigned value (e.g., var name = "Alice"). This ensures safer, more predictable code and allows for compile-time type checking and optimization.

var message: String
var isValid: Bool
var total: Int
// Statically typed
var name: String = "Alice" // A variable holding a string 
let age: Int = 19 // A constant holding an integer

In the example above:
name is declared as a string.
age is declared as an integer.

You can also use type inference, where Swift can figure out the type based on the assigned value:

var message = "Hello, Swift!"  // Type inferred as String
var isValid = true  // Type inferred as Bool
var total = 42  // Type inferred as Int

Assigning Values to Variables
Once you declare a variable with a type annotation, you must assign a value that matches that type. Swift will generate a compile-time error if the types do not match.

var total: Int = 42
total = "forty-two"  // Error: Cannot assign value of type 'String' to type 'Int'

Here, attempting to assign a string to the variable total, which is supposed to be an integer (Int), will result in an error.

Handling Incorrect Data Type Assignments
Since Swift is statically typed, it provides strong type checking at compile time, ensuring errors are caught early. For example, if you try to assign a value to a variable or pass an argument to a function with the wrong type, Swift will generate a compile-time error.

var total: Int = 42
total = "forty-two"  // Error: Cannot assign value of type 'String' to type 'Int'

Example: Swifts Type Safety in Action

Swift’s type safety ensures that the function will only accept values of the correct type. If you try to pass an argument of the wrong type, you will get a compile-time error.

func add(a: Int, b: Int) -> Int {
  return a + b
}

let result = add(a: 5, b: 10)  // Output: 15

let errorResult = add(a: 5, b: "Hello")  // Error: Cannot convert value of type 'String' to expected argument type 'Int'

Here, the function add only accepts integers. If you try to pass a string instead, Swift will generate an error, preventing the bug from occurring.

Functions
In Swift, functions require explicit type declarations for parameters and return values, ensuring type safety at compile time. For example, in func greet(name: String) -> String, the parameter and return type are clearly defined, preventing runtime errors from incorrect types. Unlike JavaScript, which allows any type without checks, Swift’s static typing catches errors early, improves code clarity, and enhances debugging and tooling support, making code more reliable and easier to read.

func greet(name: String) -> String {  
  return "Hello, \(name)!"  
}  
print(greet(name: "Alice"))

Arrays and Objects
JavaScript arrays and objects are more flexible, but Swift offers type safety.

In JavaScript:
let fruits = ["Apple", "Banana", "Cherry"];  
let person = { name: "Alice", age: 25 };

Swift allows you to specify the types of collections like arrays and dictionaries to ensure consistent data types.

var fruits: [String] = ["Apple", "Banana", "Cherry"] // Array of strings
var person: [String: Any] = ["name": "Alice", "age": 25] //

Dictionary with string keys and any type values

Commonalities with JavaScript

Object-Oriented Programming (OOP): Both languages support OOP concepts like classes, inheritance, and polymorphism.
Javascript:

// JavaScript
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    return `Hello, I'm ${this.name}.`;
  }
}

const alice = new Person("Alice", 25);
console.log(alice.greet());  // Output: Hello, I'm Alice.

In Swift:

// Swift
class Person {
  var name: String
  var age: Int

  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }

  func greet() -> String {
    return "Hello, I'm \(name)."
  }
}

let alice = Person(name: "Alice", age: 25)
print(alice.greet())  // Output: Hello, I'm Alice.

Functions as First-Class Citizens: Both languages treat functions as first-class objects, meaning they can be passed around as arguments, returned from other functions, and assigned to variables.
JavaScript:

// JavaScript
function greet(name) {
  return `Hello, ${name}!`;
}

const greetUser = greet;
console.log(greetUser("Alice"));  // Output: Hello, Alice!

Swift:

// Swift
func greet(name: String) -> String {
  return "Hello, \(name)!"
}

let greetUser = greet
print(greetUser("Alice"))  // Output: Hello, Alice!

Tips for Learning Swift as a JavaScript Developer

Practice Regularly: Practice on a regular basis by participating in coding challenges and projects that require Swift. Websites like Leetcode, or even sample projects found on YouTube, can be extremely useful!

Use Swift Playgrounds: A great tool for experimenting with Swift code interactively. It's perfect for practicing Swift syntax and concepts before diving into full-scale app development.

Explore Documentation and Tutorials:

Apple dev documentations for swift
Full CodeCademy course

Conclusion

While JavaScript and Swift serve distinct purposes and ecosystems, they share many fundamental concepts, making the transition easier for developers who are familiar with JavaScript. Swift's speed, type safety, and deep integration with the Apple ecosystem make it an exciting language to learn for anyone interested in mobile or macOS development. Understanding the key differences and commonalities will help you master Swift!

Happy coding and have fun!