As I embark on a new side project, I've decided to explore Kotlin Multiplatform Mobile (KMM) to create a shared library that will house all business logic. This will include components like the database, app state, and network connectivity. Inspired by the BLoC architecture pattern, popular in Flutter, my goal is to adapt this pattern for use in both Kotlin and native iOS and Android environments. The cherry on top? Each platform will still boast native UIs to ensure top-notch, pixel-perfect animations and visuals.

Setting the Stage

First, a bit of setup is required. As of now, Android Studio supports KMM through a plugin, but IntelliJ IDEA Ultimate does not. This is an interesting gap in JetBrains' otherwise comprehensive tool support. Regardless, Android Studio will suffice for our needs.

Building the Library

Android

To create an Android Archive (AAR) file:

• Open the terminal and navigate to the root of your project.
• Run the command:

./gradlew clean build

• Once the build completes, you can find the AAR file in:

/{module_name}/build/outputs/aar

This AAR file contains all your Android-specific code packaged neatly.

iOS

To build an XCFramework for iOS, which allows the inclusion of binaries for multiple architectures:

• Execute the following command:

./gradlew clean assembleXCFramework

• Detailed instructions and variations of this command can be found in the Kotlin Multiplatform documentation.
• The XCFramework will be located in:

/{module_name}/build/XCFrameworks

Integrating the Library into Your Projects

Android

1. Place the AAR file within the modules directory at the root of your Android project (e.g., modules/sample_core.aar).
2. In your module’s build.gradle.kts, add the following dependency:

dependencies {
    implementation(files("../modules/sample_core.aar"))
}

iOS

1. Copy the XCFramework into your iOS project’s directory.
2. Through Xcode, navigate to your project's settings, then to "Frameworks, Libraries, and Embedded Content."
3. Use the '+' button to add the XCFramework from your local filesystem.
4. Import the framework in any Swift or Objective-C class where it’s needed.

Conclusion

This post covers the fundamental steps to create and integrate a Kotlin Multiplatform library into Android and iOS projects. Upcoming posts will dive deeper into implementing a database, managing network connectivity with KMM, and utilizing the BLoC pattern to handle state across platforms. Stay tuned for more insights and keep experimenting!

Google News RSS feeds are an excellent source of up-to-date information from various domains. However, these feeds often contain links within the Google News domain that do not provide clear information about the destination. To uncover the actual destination of these links, one must navigate through a series of redirections. In this blog post, we will explore how to achieve this using TypeScript, a powerful programming language, and Cheerio, a popular library for parsing HTML and manipulating the DOM. By the end of this post, you'll be equipped with the knowledge to extract the final destination URL from Google News links with ease.

Getting Started: Understanding the Challenge

When dealing with Google News RSS feeds, you may encounter links like https://news.google.com/articles/12345, which don't reveal the actual destination. To solve this mystery, we will create a TypeScript function using Cheerio to fetch the Google News article URL buried beneath these ambiguous links.

The Solution: TypeScript and Cheerio in Action

Let's break down the TypeScript code you provided to understand how it works:

import { load } from "cheerio";

export async function getGoogleNewsArticleUrl(feedUrl: string): Promise<string> {
    const response = await fetch(feedUrl);
    if (!response.ok) {
        throw new Error(response.statusText);
    }

    const $ = load(await response.text());
    const newUrl = $('a[rel="nofollow"]').attr("href");
    if (newUrl) {
        return newUrl;
    } else {
        throw new Error("URL not found");
    }
}

Here's how the function works:

1. Fetching the Data: The function takes a feedUrl as input and uses the fetch function to retrieve the HTML content of the given URL.
2. Parsing with Cheerio: The HTML content is loaded into Cheerio, allowing you to use jQuery-like selectors to navigate the DOM tree.
3. Extracting the Redirection URL: The function looks for anchor (<a>) elements with the attribute rel="nofollow", which typically represents the ambiguous Google News links. It then extracts the href attribute, which contains the redirection URL.
4. Returning the Final URL: If a redirection URL is found, it is returned. If not, an error is thrown indicating that the URL was not found.

Conclusion: Mastering the Art of Unraveling Google News Links

With the provided TypeScript function and the power of Cheerio, you can now confidently tackle Google News RSS links and extract their final destinations. By understanding the structure of the RSS feed and employing the right tools, you can enhance your web scraping and data extraction skills, making you more adept at handling real-world challenges in web development.

Happy coding!

Have you ever found yourself working on a project, only to discover that the changes you made didn’t reflect in the application? I recently faced a similar issue while working on a TypeScript project. After spending hours debugging an unexpected problem that didn’t seem to exist, I realized the source of my frustration: I had been modifying the source code, but the changes weren’t being compiled into the project. It turned out that the compiled version of the project was being used instead of the new one. To avoid this kind of situation in the future, I decided to reconfigure Visual Studio Code to start the build task whenever I opened the project automatically.

The Problem:

The root cause of my issue was the manual triggering of the build task in Visual Studio Code. Every time I made changes, I had to remember to start the build process manually. Forgetting to do so resulted in confusion and wasted time. To permanently resolve this problem, I needed a way to ensure that the build task would start automatically whenever I opened the project.

The Solution:

The solution to this problem lies in the tasks.json file in your Visual Studio Code project. By configuring this file properly, you can automate the build process to run automatically when you open your project.

Here’s what you need to add to your tasks.json file:

       "runOptions": {
            "runOn": "folderOpen",
        }

Here is a full example of the tasks.json file:

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "typescript",
            "tsconfig": "tsconfig.json",
            "option": "watch",
            "problemMatcher": [
                "$tsc-watch"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "runOptions": {
                "runOn": "folderOpen"
            },
            "label": "tsc: watch - tsconfig.json"
        }
    ]
}

In this configuration, the crucial addition is the "runOptions" section. By setting "runOn": "folderOpen", you instruct Visual Studio Code to automatically start the specified build task whenever the project folder is opened. This eliminates the need for manual intervention and ensures that your changes are always compiled and reflected in the application.

Conclusion:

By reconfiguring Visual Studio Code to automatically start the build task on the project open, you can save time, reduce frustration, and avoid unexpected issues caused by outdated or incorrect builds. Taking a few moments to set up this automation can significantly improve your development workflow and make your coding experience much smoother. Happy coding!

The Beauty of Direct Access

Directly interacting with RethinkDB using native JavaScript driver methods simplifies your application's structure. It eliminates unnecessary layers of abstraction, ensuring that your codebase remains clean and intuitive. The DatabaseRepository class presented here provides a straightforward interface for common database operations like creating databases and tables, inserting, updating, and deleting records, executing queries, and handling real-time changes.

Code Insight: Creating a New Database

Let's take a look at how easy it is to create a new database using the createDatabaseIfNotExists method:

async createDatabaseIfNotExists(name: string) {
    if (this.conn === null) {
        throw new Error('Connection is null');
    }

    const dbList = await r.dbList().run(this.conn);
    if (dbList.includes(name)) {
        return;
    }
    await r.dbCreate(name).run(this.conn);
}

In this snippet, the function checks if the specified database name already exists. If not, it creates a new database, all with a few lines of code.

Lightweight and Future-Proof Architecture

One of the major advantages of using direct access is the lightweight nature of your application. By avoiding unnecessary dependencies, your project's footprint becomes smaller, leading to faster load times and more responsive performance. Moreover, this approach future-proofs your application. As your project evolves, you won't be tied down by the constraints of third-party libraries. Your code remains adaptable and ready to embrace future changes in technology.

Experience the Efficiency

Direct access to RethinkDB ensures efficiency not just in terms of code simplicity, but also in runtime performance. Every operation performed through direct access is optimized for speed, making your application more responsive and scalable.

Get Started with Your RethinkDB Project

If you're eager to implement this efficient approach in your Node.js and RethinkDB projects, you're in luck. The DatabaseRepository class showcased here is part of an autogenerated start template for Node.js and RethinkDB projects. You can find the complete code and more examples on GitHub.

Incorporating direct access to RethinkDB in your projects not only streamlines your development process but also ensures a robust, lightweight, and future-proof architecture. Experience the power of simplicity and efficiency in your database interactions by embracing direct access today.

Happy coding!

Command Line Interface (CLI) arguments are a fundamental part of many Node.js applications, enabling developers to pass configurations and options during program execution. In this blog post, we'll explore an object-oriented approach to handling CLI arguments in Node.js TypeScript. Let’s delve into the code to understand how it efficiently manages CLI configurations using TypeScript features.

Understanding the Code:

The provided code snippet demonstrates a TypeScript implementation of handling CLI arguments through an object-oriented paradigm. Let’s break down the key components of this code:

// Importing the Env enum from the Constants module
import { Env } from "./Constants";

// Class representing CLI configuration
export class CLIConfiguration {
    readonly arg1: string; // Command line argument 1
    readonly env: Env; // Environment mode (Development or Production)

    // Private constructor to create an instance of CLIConfiguration
    private constructor(arg1: string, env: Env) {
        this.arg1 = arg1;
        this.env = env;
    }

    // Static method to create CLIConfiguration instance from command line arguments
    static fromCommandLineArguments(argv: string[]): CLIConfiguration {
        // Extracting value of arg1 from command line arguments
        const args = argv.find(arg => arg.startsWith('--arg1='))?.split('=')[1];
        
        // Checking if production mode flag is present in command line arguments
        const producationMode = argv.find(arg => arg.includes('--runmode=producation'));

        if (args) {
            // Determining the environment based on the presence of production mode flag
            const env = producationMode !== undefined ? Env.Prod : Env.Dev;
            // Creating and returning a new CLIConfiguration instance
            return new CLIConfiguration(args, env);
        } else {
            // Throwing an error if arg1 is not provided in the command line arguments
            throw new Error("Fatal error: Configuration argument not provided.");
        }
    }
}

Object-Oriented Approach:

Encapsulation:

The CLIConfiguration class encapsulates related properties and methods within a class, promoting a cleaner and more organized code structure.

Modularity:

The fromCommandLineArguments method encapsulates the logic for parsing CLI arguments, promoting modularity and reusability.

Data Abstraction:

The CLIConfiguration class abstracts away the complexity of parsing and validating CLI arguments, providing a simple interface for accessing configuration details.

Usage Example:

// Extracting command line arguments
const args = process.argv;

// Creating CLIConfiguration object from the extracted CLI arguments
export const configuration: CLIConfiguration = CLIConfiguration.fromCommandLineArguments(args);

// Logging the configuration details
console.log("Application started with configuration: " + configuration.arg1 + ", environment: " + configuration.env);

Conclusion:

By leveraging TypeScript’s object-oriented features, the provided code exemplifies a robust and maintainable approach to handling CLI arguments in Node.js applications. Encapsulation, modularity, and data abstraction are key principles demonstrated here, enabling developers to build scalable and readable CLI argument-handling mechanisms.

This object-oriented approach enhances code organization and readability and facilitates easier testing and future enhancements. By adopting similar practices, developers can ensure their Node.js applications are structured, maintainable, and adaptable to evolving requirements.

Check out the comprehensive guide for further reading on automating Node.js project setup with a bash script. Happy coding!

Setting up a new Node.js project with a well-defined structure, dependencies, and configuration can be a time-consuming task. To streamline this process, we can create a Bash script that automates the project setup. In this blog post, we'll explore the reasons for creating such a script, its purpose, and go through each feature implemented in the script.

Reasons for Automation

1. Consistency: Automation ensures that every project follows the same structure and configuration, leading to consistency across your codebase.
2. Efficiency: Setting up a project manually can take a significant amount of time, especially if you need to repeat the process frequently. Automation saves time and effort.
3. Reduced Errors: Manual setups can lead to configuration errors. Automation reduces the chance of human error by following a predefined, error-free script.
4. Rapid Prototyping: With a quick setup script, you can prototype ideas faster, allowing you to focus on the actual development and testing.

Purpose of the Script

The purpose of this Bash script is to create a robust foundation for a Node.js project. It includes:

1. Directory Structure: The script sets up a predefined directory structure to organize the project logically.
2. Node.js and npm Check: It checks if Node.js and npm are installed on the system.
3. TypeScript Support: The script ensures TypeScript is globally installed and initializes a TypeScript configuration file.
4. Git Repository: Initializes a Git repository for version control.
5. Visual Studio Code Integration: Creates necessary Visual Studio Code configuration files for tasks and debugging.
6. RethinkDB and TypeScript Definitions (Optional): Asks the user if they want to install RethinkDB and TypeScript definitions for it.

Features Explained

1. Directory Structure

The script creates a directory structure based on best practices. Here's a breakdown:

• src/: Contains the application source code.
• application/: Business logic, services, and other application-specific code.
• config/: Configuration files.
• domain/: Database models and domain logic.
• error-handling/: Custom error handling logic.
• infrastructure/: Database connections, repositories, and external integrations.
• interfaces/: API routes, controllers, middlewares, and other interface-related code.

2. TypeScript Configuration

The script sets up TypeScript support, creating a tsconfig.json file with predefined compiler options for a smooth TypeScript development experience.

3. Git Repository Initialization

The script initializes a Git repository in the project folder, allowing for version control and collaboration.

4. Visual Studio Code Integration

The script creates .vscode directory with tasks.json and launch.json configurations. These files enable running TypeScript compilation tasks and debugging inside Visual Studio Code.

5. RethinkDB and TypeScript Definitions (Optional)

The script asks the user if they want to install RethinkDB. If chosen, it installs RethinkDB and TypeScript definitions for RethinkDB. This ensures a seamless integration with RethinkDB while writing TypeScript code.

Conclusion

By automating the Node.js project setup, developers can save valuable time, maintain consistency, and focus on the core aspects of development rather than spending time on repetitive and error-prone tasks. This script provides a robust foundation for any Node.js project, enabling developers to kickstart their projects efficiently and effortlessly. Remember to customize the script according to your specific project requirements, and happy coding!

Final Script

The final version of the Bash script discussed in this blog post can be found on GitHub:

GitHub Repository: setup-nodejs-project.sh

Feel free to explore the script, modify it according to your needs, and use it to automate your Node.js project setups. Happy coding!

Seeking a solution, I painstakingly reviewed countless posts and forum threads addressing openWRT speed limitations, but to no avail. My breakthrough came from a Reddit discussion, where I found several users criticizing Realtek NICs due to their subpar drivers. This convinced me to try switching to an Intel NIC.

With high hopes, I purchased a dual-port Intel NIC and connected it to my Zimaboard via a PCIe slot. Disappointingly, the improvement was marginal, with the speed topping at around 1.5 Gbps, with none of my tweaks boosting the performance further. However, I did notice a significant change in CPU utilization.

Desperate for a solution and to achieve full performance, I decided to reconfigure my setup. I connected the WAN to the Intel NIC via PCIe, and the LAN via a USB 2.5 Gbps NIC. The result was promising - I saw speeds reach about 1.8 Gbps.

I was almost there, but one final hurdle remained. To squeeze the last bit of performance out of my setup, I forced the CPU to work at its top frequency using the command:

for a in /sys/devices/system/cpu/cpufreq/policy*/scaling_governor; do echo performance > $a; done

Much to my delight, this last measure proved successful. The full throughput of 2.5 Gbps was finally achieved! My journey of troubleshooting network speed limitations was arduous but ultimately rewarding.

This experience underscored the importance of comprehensive hardware and software knowledge in navigating the complex landscape of network configurations. I hope this account may be a resource for others facing similar challenges in optimizing their network speeds.

Step 1: Setting Up the Linux Environment

Before we can begin, you need to have a Linux environment ready. Any popular distribution like Ubuntu, Debian, or CentOS will work perfectly. Ensure your system is up to date using your distribution's package manager.

Step 2: Download the OpenWRT Image

Visit the OpenWRT download page and locate the latest version for the Zimaboard. As Zimaboard uses an x86/64bit architecture, choose an image compatible with this architecture. Download the image to your Linux machine.

Step 3: Decompressing the Image

After the image has been downloaded, we need to decompress it. Navigate to the directory where the file was downloaded and use the following command:

gunzip <filename>

Replace <filename> with the name of the file you downloaded. For instance, if you have downloaded the file 'openwrt-22.03.2-x86-64-generic-ext4-combined.img.gz', the command would be:

gunzip openwrt-22.03.2-x86-64-generic-ext4-combined.img.gz

This command will decompress the image and you'll end up with 'openwrt-22.03.2-x86-64-generic-ext4-combined.img' ready to be flashed onto your USB stick.

Step 4: Identifying Your Disk

Use the lsblk command to display all disks connected to your system. This command will provide a list of all storage devices, making it easier to identify the one you'll be using:

lsblk

Step 5: Flashing the Disk with the OpenWRT Image

Once you've identified the correct disk, you can flash the OpenWRT image onto it using the 'dd' tool. In the command below, replace "openwrt-22.03.2-x86-64-generic-ext4-combined.img" with the filename of your OpenWRT image and "/dev/sda" with your disk identifier:

dd if=openwrt-22.03.2-x86-64-generic-ext4-combined.img of=/dev/sda bs=4M; sync;

Step 6: Resizing the Disk to Use Full Capacity

By default, OpenWRT doesn't use the full disk space. But you can adjust this by resizing the partition. First, verify your disk again with lsblk.

Next, install the 'parted' tool, which we will use for resizing. On Debian-based distributions, you can use:

sudo apt-get install parted

Use 'parted' to print your disk layout:

parted /dev/sda print

This command will show you two partitions. The first one is used for booting, while the second one is what we want to resize. Resize the second partition to use the full available space with the command below. In this case, we're resizing it to 16GB:

parted /dev/sda resizepart 2 16G

Check your result by printing the disk layout again with parted /dev/sda print.

Step 7: Resizing the Filesystem

The final step is to resize the filesystem. Execute the following command:

resize2fs /dev/sda2

Congratulations! You have successfully created an OpenWRT USB stick for Zimaboard that utilizes the full disk space. This USB stick can be used as a live boot device or for installing OpenWRT onto other systems.

Script Walkthrough:

This script is designed for macOS and uses Homebrew as the package manager. It automates the installation and configuration of RethinkDB on your system. Let's break down the steps involved in the script:

1. Define the RethinkDB data directory path in the DB_PATH variable. This is where the database files will be stored.
2. Check if Homebrew is installed on the system. If not, the script will install Homebrew automatically.
3. Install RethinkDB using Homebrew by running. brew install rethinkdb
4. Stop any running RethinkDB service with brew services stop rethinkdb
5. Adjust the RethinkDB configuration file. The script creates a backup of the original configuration file, modifies the data directory path, and changes the network bind address to allow connections from the local network. This will make it possible to connect to the RethinkDB server from other devices in the same network.
6. Change the ownership of the RethinkDB data directory and log file to the current user and the wheel group. This step ensures that the current user can manage the RethinkDB files.
7. Set RethinkDB to autostart on boot by running brew services start rethinkdb. This command also starts the RethinkDB service immediately. The brew services list command shows the status of the RethinkDB service.
8. Finally, the script unsets the local DB_PATH variable to clean up the environment.

After running this script, RethinkDB will be installed, configured, and set to start automatically whenever your system boots up. With RethinkDB as the backbone

#!/bin/bash

# 1. Set directory path to a local property
DB_PATH=/Users/lukasztomaszewski/Documents/server2.0/database

# 2. Check if Homebrew is installed
if ! command -v brew &> /dev/null
then
    echo "Homebrew is not installed. Installing now..."
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
fi

# 3. Install RethinkDB with Homebrew
echo "Installing RethinkDB..."
brew install rethinkdb

# 4. Stop any running RethinkDB service
echo "Stopping RethinkDB service..."
brew services stop rethinkdb

# 5. Adjust RethinkDB configuration
echo "Adjusting RethinkDB configuration..."
cp /opt/homebrew/etc/rethinkdb.conf /opt/homebrew/etc/rethinkdb.conf.backup
sed -e "s|directory=/opt/homebrew/var/rethinkdb|directory=$DB_PATH|" \
    -e 's|# bind=127.0.0.1|bind=all|' \
    /opt/homebrew/etc/rethinkdb.conf.backup > /opt/homebrew/etc/rethinkdb.conf

# 6. Change ownership of RethinkDB data directory and log file
echo "Changing ownership of RethinkDB data directory and log file..."
sudo chown -R $USER:wheel $DB_PATH /opt/homebrew/var/rethinkdb

# 7. Set RethinkDB to autostart on boot
echo "Setting RethinkDB to autostart on boot..."
brew services start rethinkdb
brew services list

# 8. Unset local property
unset DB_PATH

1. In Xcode, go to "Window" > "Devices and Simulators"
2. Select the device or simulator you want to disable logs for.
3. In the device's or simulator's detail view, click on the Gear icon at the bottom left corner.
4. Select Edit Scheme.
5. Under Run > Arguments, add the argument OS_ACTIVITY_MODE with a value of disable.
6. Close the scheme editor and run your app again. System logs should now be disabled.

One solution to this issue is to disable the analytics during installation. To do this, you can use the command REALM_DISABLE_ANALYTICS=1 npm install. This sets the environment variable REALM_DISABLE_ANALYTICS to 1, which tells Realm to skip sending analytics during installation.

It's important to note that disabling analytics will not affect the functionality of Realm. It will only prevent analytics from being sent during the installation process. This can help to resolve the issue of npm hanging during the installation of Realm.

To install Realm via npm without any issues, it is best to use the command REALM_DISABLE_ANALYTICS=1 npm install instead of the usual `npm install` command.

let integers = [1, 2, 3, 4, 5]
let doubled = integers.reduce(into: [:]) { $0[$1] = $1 * 2 }
print(doubled)  // [1: 2, 2: 4, 3: 6, 4: 8, 5: 10]

Or you can use the Dictionary init method like this:

let array = [1, 2, 3, 4, 5]
let dictionary = Dictionary(uniqueKeysWithValues: array.map { ($0, $0 * 2) })
print(dictionary) // [1: 2, 2: 4, 3: 6, 4: 8, 5: 10]

You can also use zip method to map array to dictionary

let array = [1, 2, 3, 4, 5]
let keys = array
let values = array.map { $0 * 2 }
let dictionary = Dictionary(uniqueKeysWithValues: zip(keys, values))

1. Make sure you have Node.js and npm (Node Package Manager) installed on your system. You can check if you have them installed by running the commands node -v and npm -v in the terminal.

2. Create a new directory for your project and navigate to it in the terminal.

3. Initialize a new Node.js project by running the command npm init in the terminal. This will create a package.json file in your project directory.

4. Install the "TradingView-API" package from GitHub by running the following command in the terminal:

npm install Mathieu2301/TradingView-API

This will install the package as a dependency in your project.

5. Create a new file called SimpleChart.js in your project directory. This file will contain the main logic of your application.

6. Open the SimpleChart.js file in a text editor and import the "TradingView-API" package at the top of the file by using the following line of code:

const TradingView = require('@mathieuc/tradingview');

7. Use the functions and classes of the package in your code as you need. Here is example of use to get the most recent Bitcoin price from Binance:

const TradingView = require('@mathieuc/tradingview');

const client = new TradingView.Client();
const chart = new client.Session.Chart(); // Init a Chart session

chart.setMarket('BINANCE:BTCBUSD', { // Set the market
  timeframe: '15',
  range: 20000
});

chart.onError((...err) => { // Listen for errors (can avoid crash)
  console.error('Chart error:', ...err);
  // Do something...
});

chart.onSymbolLoaded(() => { // When the symbol is successfully loaded
  console.log(`Market "${chart.infos.description}" loaded !`);
});

chart.onUpdate(() => { // When price changes
  if (!chart.periods[0]) return;
  console.log(`[${chart.infos.description}]: ${chart.periods[0].close} ${chart.infos.currency_id}`);
});

9. Once you have finished writing your code, you can run it by using the command. node SimpleChart.js

10. If you want to share your project with others or deploy it to a production environment, you can use the npm pack command to create a tarball of your project, which can then be distributed and installed using npm install <tarball-file>

Please note that the package you are trying to install is not officially supported by TradingView, it could be that it's not working properly or is no longer maintained. Make sure to check the Github repository and read the README file to get more information about how to use the package.

It is worth noting that, trading can be a high-risk activity and it's important to have realistic expectations, keep emotions in check and not to invest more than you can afford to lose. It is always recommended to consult a financial advisor before making any investment decisions.

EMA = (current_price * k) + (previous_EMA * (1 - k))

Where current_price is the most recent price point, previous_EMA is the previous period's EMA, and k is the smoothing constant. This constant is calculated as 2 / (n + 1), where n is the number of periods in the EMA.

Here is some sample code to calculate a 10-period EMA:

let data = [3.0, 4.0, 5.0, 4.5, 4.0, 5.5, 6.0, 5.5, 5.0, 4.5]
let n = 10
let k = 2 / Double(n + 1)
var ema = data[0]

for i in 1..<data.count {
    ema = (data[i] * k) + (ema * (1 - k))
}

print(ema)

You can also use the reduce function to calculate the EMA.

let k = 2 / Double(n + 1)
let ema = data.suffix(n).reduce(data.first!) { (prev, curr) in (curr * k) + (prev * (1 - k)) }

In this code snippet, data is an array of Double containing the trading data, n is the number of periods in the EMA, k is the smoothing constant, ema is the calculated EMA.

Keep in mind that the first EMA value is typically the SMA of the first n periods, and then the EMA is calculated based on that value.