InRhythmU

May 08 2023

InRhythm Presents The Propel Spring Quarterly Summit

Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

New York, NY – InRhythm recently concluded its very first Propel Spring Quarterly Summit; a premiere event consisting of six individual coding workshops aimed to support the learning and growth of engineering teams around the world.

Over the last three weeks, our consulting practices have led a series of interactive experiences that delved into the latest technology trends and tools, designed to propel professionals forward into their careers.

The workshops are free to access as a unique part of InRhythm’s mission to build a forward-thinking thought leadership annex:

SDET Workshop (03/17/23)

This workshop worked as an introduction to writing and running tests using Microsoft Playwright. Our SDET Practice went over Playwright’s extensive feature set before diving more in-depth with its API.

For the workshop, the team went over setup and installation of the tool, as well as wrote a series of comprehensive tests against a test application. Once tests were run, the team afforded participants the opportunity to go over some of Playwright’s advanced features, such as its powerful debugger and enhanced reporting.

To close out the workshop, SDET Practice Leadership compared Playwright’s features to some of its competitors, went over its pros and cons, and discussed why they believed it to be a paramount tool to consider for automated testing solutions.

Web Workshop (03/24/23)

Our Web Practice focused their workshop on their top three, intertwining technologies for development cycles.

With many modern web applications sharing many of the responsibilities that a middle layer/presentation and service layer/backend provide to the frontend layer, the project was kicked off by organizing the elements with a mono-repository.

Once the application moved into its build phase, it was time to accelerate the architecture to the next level using NextJS.

Web Practice Leadership wrapped their project, with an intuitive overview of web bundling and the variety of methods utilized – in order to best adapt to each individual build.

DevOps Workshop (03/29/23)

In this workshop, the DevOps Practice demonstrated tools for provisioning infrastructure as well as how to construct a self-servicing platform for provisioning resources. With these new developments in the industry, bridging the gaps between development and ops by allowing developers to self-manage cloud infrastructure to satisfy their needs will be a paramount skill to adopt. Our DevOps practitioners discussed the pros and cons of a number of tools for provisioning infrastructure and identified which tools can best fit a business’ needs.

For the hands-on interactive session, the team ran through the necessary steps to get started with Pulumi and provision a resource onto AWS, along with demonstrating Terraform in order to get a feel for the difference between the two popular infrastructure-as-code tools. After that, we set up some plugins to enhance the development experience with IaC.

Self-servicing platforms are the best way to allow for engineers to provision resources and infrastructure for their needs en-masse. With Backstage, the team was able to demonstrate a platform for engineers to come to and fulfill their needs whether it be creating a new microservice, a new repository, or even provisioning a new k8s cluster. Furthermore, the provisioning of these resources were proven to standardize and bring uniformity to ensure that best practices are enforced. Long gone are the days of submitting a ticket to create a new instance to deploy an application, with a wait time of a few hours or even a few days. Self-servicing tools are the future of bringing operations into the hands of developers and bridging the gap between development and operations.

Finally, DevOps Practice Leadership set up a self-servicing platform and hooked it into the aforementioned IaC repository to allow for the provisioning of resources from a GUI.

Managing infrastructure can quickly become tedious as the number of resources being used on a cloud provider continue to grow. With infrastructure-as-code, not only DevOps engineers, but developers can now lay out infrastructure using code. Since it’s managed via code, version-controlling/source-code management tools are also available, making management of infrastructure significantly easier.

iOS Workshop (03/28/23)

Our iOS Practice did a full overview of Swift Async/Await for iOS application development

Async/Await is a programming feature that simplifies asynchronous operations by allowing software engineers to write asynchronous code in a synchronous manner. It also makes code easy to read/write, improves performance/responsiveness, and reduces the likelihood of errors.

In short, Async/Await is a powerful modern feature in every avenue from development speed and simplified code to and application performance.

Android Workshop (04/11/23)

Our Android Practice performed a comprehensive demonstration of the practical integration of Kotlin Multi-Platform Mobile (KMM) for cross-platform development.

Kotlin Multi-Platform Mobile is an exciting, growing new technology that allows sharing core code between Android, iOS, and Web.

In this workshop, Android Practice Leadership explored what KMM was, how to setup a project for KMM, a walkthrough implementing a core module to a few APIs (network layer, data models, parsers, and business logic), and then consumed this core library in an Android (Jetpack Compose) and iOS (SwiftUI) application.

Cloud Native Application Development Workshop (04/21/23)

In this workshop our Cloud Native Application Development Practice introduced the participants to gRPC, which is Google’s take on Remote Procedural Calls. Our Practice Leadership presented a brief history of gRPC and Protocol Buffers. Google and other companies use gRPC to serialize data to binary which results in smaller data packets. Throughout the presentation our team went over some of the pros and cons of using gRPC for individual API calls.

In our hands-on workshop portion participants created a simple application to manage users and notes powered by Java, gRPC, and Postgres. The grand finale featured a full-circle moment as we worked together to create a series of CRUD APIs in Java using gRPC to send/receive data packets, translate those into objects, and store them in a database.

About InRhythm

InRhythm is a leading modern product consultancy and digital innovation firm with a mission to make a dent in the digital economy. Founded in 2002, InRhythm is currently engaged by Fortune 50 enterprises and scale-ups to bring their next generation of modern digital products and platforms to market. InRhythm has helped hundreds of teams launch mission-critical products that have created a positive impact worth billions of dollars. The projects we work on literally change the world.

InRhythm’s unique capabilities of Product Innovation and Platform Modernization services are the most sought-after. The InRhythm team of A+ thought leaders don’t just “get a job,” they join the company to do what they love. InRhythm has a “who’s who” clients list and has barely scratched the surface in terms of providing those clients the digital solutions they need to compete. From greenfield to tier-one builds, our clients look to us to deliver their mission-critical projects in the fields of product strategy, design, cloud native applications, as well as mobile and web development.

Apr 20 2023

Closures Vs. Combine Vs. Async Await

Based on a Lightning Talk by: Joshua Buchanan, Lead iOS Engineer @ InRhythm on March 28th, 2023 as part of the Propel Spring Quarterly Summit 2023

Author: Mike Adams, Senior Technical Writer @ InRhythm

Introduction

This image has an empty alt attribute; its file name is IR-Spring-Summit-ZOOM-Bg_iOS-1024x576.jpg — Design Credit: Joel Colletti, Lead UI/UX Designer @ InRhythm

There are three methods of asynchronous coding in Swift: Closures (i.e. completion handlers), Combine, and Async/Await.

Closures are a fundamental feature of Swift that allow developers to define self-contained blocks of functionality, while Combine provides a modern way to handle asynchronous events and data streams. Async/Await is a new feature that makes it easier to write asynchronous code that looks and feels like synchronous code, improving the readability and maintainability of Swift code.

Closures – Introduced in Swift 2.0, WWDC 2015
Combine – iOS 13 and macOS Catalina in 2019
Async/Await – Swift 5.5 WWDC 2021

Asynchronous Coding Methods

Closures

In Swift programming, closures are a powerful and versatile feature that allow you to capture and store functionality for later use. A closure is a self-contained block of code that you can pass around and execute at a later time, similar to a function or method.

A common use case for closures is handling asynchronous operations, such as network requests or animations. Defining a closure that executes when the operation completes helps you to keep your code organized and avoid callback functions.

You can use closures in Swift in different ways:

As a function argument: Pass the closure as a function argument to define a custom behavior tailored to a specific use case.
As a function return value: As the return value of a function, you can create functions that generate other functions.
As a variable: You can assign a closure to a variable for later use.

Closures can capture and retain references to values outside of their own scope which allows you to define closures that can access and modify variables defined outside of their own function or method.

Combine

Combine is a powerful framework that allows developers to handle asynchronous events and data streams in a more intuitive and functional way. The Combine framework provides a declarative way to define and manipulate data streams using a set of operators that can transform, filter, and combine data in various ways.

Key use cases for the Combine framework include:

Handling asynchronous events: Combine allows developers to handle asynchronous events, such as network requests or user input, in a more elegant and concise way than traditional callback-based APIs
Managing data streams: Combine provides a unified way to manage data streams from various sources, such as user input, network requests, and local storage
Composing reactive UI: Combine can be used to create reactive UI, where the UI updates automatically in response to changes in the underlying data
Testing: Combine’s declarative syntax makes it easy to write unit tests for asynchronous code

The key building blocks of Combine are publishers and subscribers. Publishers are objects that emit a stream of values over time, while subscribers consume these values and perform some action in response. Publishers can be transformed, combined, and filtered using various operators to create complex data pipelines.

In summary, the Combine framework provides a powerful way to handle asynchronous events and data streams in Swift programming.

Async/Await

Async/Await provides a more intuitive and concise way to write asynchronous code. With Async/Await, developers can write asynchronous code that looks and feels like synchronous code, which makes it easier to read, write, and maintain.

Previously, developers used callbacks or closures to handle the results of asynchronous operations which often lead to complex and difficult-to-read code, as well as potential issues with callback hell and race conditions.

With Async/Await, developers can use familiar keywords like Await and Async to write asynchronous code, which allows them to pause the execution of a function until a result is available, without blocking the main thread. This makes it easier to write code that is both asynchronous and easy to understand.

For example, this code uses Async/Await to perform a network request:

func fetchUser() async throws -> User {
    let url = URL(string: "https://example.com/user")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

In the example, fetchUser() function is marked as Async, indicating that it is an asynchronous function. Inside the function, the await keyword is used to wait for the result of the network request, without blocking the main thread. The result is then returned as a User object.

Overall, Async/Await is a powerful new feature that makes it easier to write asynchronous code in Swift, while also improving readability and maintainability.

Comparison

Features

Note that while Closures and Combine are both used for handling asynchronous operations, they operate at different levels of abstraction. Closures are used for defining code blocks with captured values, whereas Combine is a reactive programming framework that provides a unified way to manage asynchronous data streams. Async/Await, on the other hand, is a language-level feature that simplifies the process of writing asynchronous code by allowing developers to write asynchronous code that looks and feels like synchronous code.

Feature/ Item	Closures	Combine	Async/Await
Introduction	Introduced in Swift 2.0 (2015)	Introduced in iOS 13 and macOS Catalina	Introduced in Swift 5.5 (2021)
Purpose	Define code blocks with captured values	Reactive programming framework	Simplify asynchronous programming
Syntax	`{ (parameters) -> ReturnType in }`	Publisher, Subscriber,operator	async, await
Benefits	Simplify code, increase readability,“it’s the way we’ve always done it”	Manage asynchronous data streams. Pub/Sub works without much effort. Once subscribed, the “watcher” always sees the message.	Very simple to code.Write asynchronous code that looks synchronous.Powerful parallelization.Less complex code.Better device utilization (additional CPU cores, etc.).More similar to other modern languages.
Shortcomings	Easy to miss “closing a loop.”Difficult to scaleDifficult to debugApple’s first try at an async coding paradigm.	The developer is responsible for coding the publishers / subscribers and ensuring that the messages are published.Difficult to use in conjunction with Closures and Async/Await.	For Swift Concurrency feature completeness, the minimum deployment target is iOS 15+.Though supported from iOS13+, APIs were unavailable until iOS15.Not foolproof.Apple’s direction.
Used for	Event handlers, completion blocks	Asynchronous data handling, UI binding	Network requests, file I/O, async operations
Concurrency	Can run on any thread, but can cause race conditions	Concurrent data handling	Non-blocking, can run concurrently without blocking the main thread
Error handling	Uses try, catch, throw	Uses sink, catch, replaceError	Uses try, catch, async let, throws
Compatibility	Available in all versions of Swift	Available in iOS 13+ and macOS Catalina+	Available in Swift 5.5+

Side-By-Side Code Function Definition

The Closure example code is fairly complex and a developer would need to examine the entire code block to be certain of its operation.

In the Combine block, the code is slightly less complex. The addition of .map, .decode, and .mapError help make it more understandable.

In the Async/Await code block, not only is there less code, it is also easier to understand what the code does: Set the path, create the request, make the call, and send the data back.

The code is still doing all of the “heavy lifting” for asynchronous coding, but it doesn’t LOOK as though it is doing the heavy lifting.

Side-By-Side Function Usage

The comparison of the three approaches really becomes clear when you look at the synchronizing calls inside of the same function.

As you can see, the result of the first call (i.e. getting a list of food by name) must come back to complete the second call (i.e. getting a list of foods that have the same “category” as the initial result).

Managing the response from the initial call is rather difficult, especially if we need to obtain sensible information about an error when something does go wrong. That difficulty only increases when we become reliant not only on a successful response, but also rely on the data as a result of that second response to power the second request.

Resources

Combine
- Apple Combine: https://developer.apple.com/documentation/combine
- Getting Started with Combine: https://www.vadimbulavin.com/swift-combine-framework-tutorial-getting-started/
- Is Combine Dead? https://remotion.com/blog/is-swift-combine-dead
- Lightning Talk: Swift Combine https://youtu.be/6AB_3oFWvBg
Async Await
- “Getting Started with Swift Concurrency” https://developer.apple.com/news/?id=o140tv24
- “Async Await in Swift explained with code examples” https://www.avanderlee.com/swift/async-await/

Apr 12 2023

Structured Concurrency In Swift

Based on a Lightning Talk by: Joshua Buchanan, Lead iOS Engineer @ InRhythm on March 28th, 2023 as part of the Propel Spring Quarterly Summit 2023

Author: Mike Adams, Senior Technical Writer @ InRhythm

Swift Concurrency

Concurrency is a task-based system that allows developers to take full advantage of the “await” portion of the Async/Await keywords to perform concurrent task execution. An Async/Await task waits until its process finishes before continuing.

Async/Await lets you take advantage of parallelization to make full use of all the available CPU cores to give your users the best user experience.

Swift Concurrency includes, Async/Await, Tasks, and Task Groups. As you read “Async/Await,” assume that it means the entirety of Swift Concurrency and not simply, Async/Await.

Here are the keywords and concepts we’ll use in discussing Structured Concurrency:

Task – That portion of the concurrency framework that creates the concurrent environment. It can throw errors and return values
Child Task – A task generated and managed by a Parent Task.The Parent is responsible for task execution
Cancellation – In Swift, you can cancel or stop any task from completing. Unlike Combine, structured concurrency does not require a strong reference to emit values from the publisher (i.e., the Task) and continue to run even if you remove references to the publisher. If you don’t want the task to run, you must either cancel or stop it
Priorities – Structured Concurrency’s Task Priorities are very similar to Apple’s Quality of Service system. Task Priorities include:
- High
- Background
- Low
- Medium
- userInitiated
- Utility

When using Structured Concurrency in your code, remember that while priority setting in your code tells the system which tasks are most important, those priorities are only a suggestion, not a mandate.

Async/Await

Async/Await provides the Structured Concurrency that removes the necessity of manually propagating errors and managing cancellation, as well as any other types of concurrency issues (e.g., race conditions). It makes program logic simpler to follow as the methods execute linearly rather than with the back and forth required when using completion handlers.

Structured concurrency also improves performance and allows for cleaner, more readable code with more precise error handling. In structured concurrency, long-running tasks are self-managing in regard to resources, error propagation, or any concurrency issues.

Async/Await was first popularized in 2012 via the C# programming language. Between 2012 and 2020, other languages began adopting Async/Await, including but not limited to:

Python / Typescript in 2015
Kotlin in 2018
Rust in 2019
C++ in 2020
Swift in 2021

Tasks

Although Tasks appear very basic, behind the scenes there is a great deal happening.

The Task keyword tells the compiler that the code inside the brackets must run in its own area using different rules than the rest of the application. This is the beginning of writing concurrent code in Swift.

In Swift, Tasks check if they were cancelled at appropriate times during execution. If cancelled, the Task begins whatever processing is necessary to cease execution and then responds to the cancellation. Depending on the code, the response could be returning partially finished work, returning an empty collection (or nil), or throwing a cancellation error.

Task Example

The load function shown below displays all the parts of a concurrent function coded as a task.

Child Tasks

Child Tasks are bound to a Parent Task and inherit the Parent Task’s Priority. Parent Tasks can have multiple Child Tasks and a Child Task can be a Parent Task to other Child Tasks.

While Parent Tasks can cancel a Child Task, a Child Task can not cancel their Parent task. Child Tasks begin whatever process is necessary for them to halt once their Parent Task is cancelled. All Child Tasks must finish before the Parent Task can be completed.

Cancellations

Unlike Combine, Tasks in Structure Concurrency will continue to run even when there are no Subscribers. Tasks run until they are completed or until you cancel them in code or programmatically. Cancellations are not determined by strong reference.

Tasks “know” whether they’ve been canceled and you can explicitly cancel a Task. You can also use the Task.checkCancellation() call to check if a Task was cancelled.

There are a number ways to programmatically cancel a Task including:

Navigating away from a view where the task was triggered
Canceling that Task’s Parent Task to cancel all of its Child Tasks
When another Child Task of the same Parent throws an Error

Async Let

Async Let is a variation of Async/Await that differs from the Await version, in that it will immediately launch a known number of Tasks in parallel and manage them in a slightly different manner than Async/Await. Where an Async/Await call suspends the Parent Task during Child Task execution, the Async Let call allows the Parent Task to continue running normally.

You would use Async Let when you’re certain that the Async code can run independently. Note that unlike a regular Async/Await Call, you cannot directly cancel Async Let calls.

A further difference is that you can only use Async Let in local declarations, not at the top level.

Use Async Let when you need the results from the call later in your application, not immediately. For example, you could use multiple Async Let calls to load gallery images without blocking the main thread, thereby allowing the user to continue using the application’s GUI while the images load.

Use Async Let when:

You have enough detail to request the information you need prior to making the call
The calls do not depend on another call’s results
You are returning different kinds of data
The order in which the app returns results is unimportant

Task Groups

Task Groups allow you to combine an unknown number of parallel Child Task calls that return the same Type of data into a batch, and then wait until the last Child Task finishes before completing the call. This is most useful when the results are a consistent type, such as when combining API responses into a single object. Task Groups only complete after all Child Tasks in the Task Group are complete.

It is important to never mutate the Task Group using code from outside the Task where the Task Group was created. Doing so interleaves data obtained by the Task Group with the data from outside the Task Group which leaves the results inconsistent.

Using Try Await allows you to handle any potential thrown errors in the grouped call using additional code.

For example, let’s say you have a function that returns a string value and you need to call the function n times. Each time that function returns, you want to append the resultant string to an array of strings:

Once all the Tasks in the Task Group are complete, you want the Task Group to return a String array. The “of” type for the Task Group is String because the result of the parallel task is a String and the returning type is an array of Strings

Coding UIImages in Task Groups will appear more familiar. For example, let’s say that you have a list of indeterminate size composed of URLs that point to specific images, and a function that downloads an image from each of those URLs and then adds it to an image array returned from the Task Group.

In this case, the “of” type for your Task Group is UIImage, and because the parallel function inside the task is downloading UIImage data, and the returning type for the Task Group is an array of UIImages.

Task Group Example

The Of type for this example Task Group scenario is UIImage and because the parallel function inside the task is downloading UIImage data, the “returning” type of the task group is an array of UIImages.

There are two things happening in this example code. The first is the execution of the parallel downloading task for the individual images located at each URL. The second takes the results from the previous task (the UIIMage) and combines them into a single array of images.

Resources

Apple Developer: Getting Started with Swift Concurrency
InRhythm Swift Lightning Talk (Deck): Structured Concurrency in Swift
Linkedin Video: InRhythm Propel Workshop (Video)
GitHub Repo: Async Await Propel Workshop GitHub Repo
Blog, Antoine van der Lee: Async await in Swift explained with code examples

Mar 16 2023

An Introduction To Cross-Platform Mobile Development

Author: Minhazur Rahman, Senior Android Developer @ InRhythm

Overview

As mobile technology continues to evolve, we as developers are faced with the challenge of creating mobile apps that work great on all platforms. Traditionally, this has meant building separate apps for each platform, which is very time consuming and costly. However, with the rise of cross-platform mobile development, developers can now write code once and deploy it across multiple platforms.

We will explore:

The pros and con of cross-platform mobile development
How it compares to native development
Some of the most common tools and frameworks used in cross platform development

What Is Cross-Platform Mobile Development?

Cross-platform mobile development refers to the process of writing code once and deploying it across multiple platforms, such as iOS and Android. This is achieved using frameworks and tools that allow developers to write code in a single codebase and then compile it for multiple platforms.

Cross-platform development offers several advantages over native development, including:

Cost Savings: With cross-platform development, developers can write code once and deploy it across multiple platforms, reducing the time and cost required to develop separate app for each platform
Wider Audience: By deploying an app on multiple platforms, developers can reach a wider audience, increasing the app’s potential user base
Consistent User Experience: Cross-platform development allows developers to ensure that users have a consistent experience across multiple platforms, improving the overall user experience

However, cross-platform development also has some limitations, including:

Performance Issues: Cross-platform apps may not perform as well as native apps, particularly for complex apps that require heavy processing or graphics
Limited Access To Native Features: Cross-platform development may not provide access to all of the native features of each platform, limiting the app’s functionality
Development Limitations: Cross-platform development may limit the development process, as developers may need to compromise on certain features or design elements to ensure compatibility across multiple platforms

Cross-Platform Development vs. Native Development

To better understand the pros and cons of cross-platform development, it’s important to compare it to native development. Native development involves building separate apps for each platform using that platform’s specific language and tools.

Native development offers several advantages, including:

Access To Native Features: Native development provides access to all of the native features of each platform, allowing developers to create apps with rich functionality and design
Better Performance: Native apps generally perform better than cross-platform apps, particularly for complex apps that require heavy processing or graphics
Better User Experience: Native apps can provide a better user experience, as they are designed specifically for each platform, taking into account the unique features and design elements of each platform

Native development has limitations as well:

Time And Cost: Developing separate apps for each platform can be time-consuming and costly, as developers need to learn multiple programming languages and use platform-specific tools
Limited Audience: Developing separate apps for each platform may limit the app’s audience, as users may only be able to access the app on one platform
Inconsistent User Experience: Developing separate apps for each platform may result in inconsistent user experience, as users may have different experiences depending on the platform they are using

Common Tools and Frameworks For Cross-Platform Development

To make cross-platform development easier, there are several tools and frameworks available that allow developers to write code once and deploy it across multiple platforms. Here are some of the most common ones:

React Native: React Native is a popular framework for building cross-platform apps using JavaScript and React; a popular JavaScript library for building user interfaces. It allows developer to write code once and deploy it on both iOS and Android

Xamarin: Xamarin is a cross-platform development tool that uses C# to build apps for iOS, Android, and Windows. It allows developers to share code between platforms, reducing development time and cost

Flutter: Flutter is a popular framework for building cross-platform apps using Dart: a programming language developed by Google. It allows developers to create beautiful and fast apps that work seamlessly across multiple platforms

Ionic: Ionic is a popular open-source framework for building cross-platform mobile apps using web technologies such as HTML, CSS, and JavaScript. It allows developers to create hybrid apps that work on both iOS and Android

When To Choose Cross-Platform Over Native Development

Choosing between cross-platform and native development depends on several factors, including the app’s complexity, budget, and timeline.

Here are some scenarios where cross-platform development may be the better option:

Limited Budget: If you have a limited budget, cross-platform development can be a cost-effective solution as it allows you to write code once and deploy it on multiple platforms
Tight Timeline: If you need to develop an app quickly, cross-platform development can help you save time as you don’t need to write separate code for each platform
Simple Apps: If your app is simple and doesn’t require access to many native features, cross-platform development can be a good option
Maintenance: If you need to maintain your app on multiple platforms, cross-platform development can be a more efficient solution as you can make changes to the codebase once and deploy it across all platforms

However, there are also scenarios where native development may be the better option, such as:

Complex Apps: If your app requires access to many native features or requires heavy processing or graphics, native development may be the better option as it can provide better performance
Design: If your app requires a unique design that is specific to each platform, native development may be the better option as it allows you to design the app specifically for each platform
Budget: If you have a larger budget, native development may be a better option as it can provide a better user experience and access to all of the native features of each platform

Conclusion

Cross-platform mobile development is a popular solution for creating apps that work seamlessly across multiple platforms. While it offers several advantages, such as cost savings and a wider audience, it also has limitations, such as performance issues and limited access to native feature.

Choosing between cross-platform and native development depends on several factors, including the app’s complexity, budget, and timeline. By weighing the pros and cons, developers can choose the best solution for their app development needs.

Jan 04 2023

Creating An Effective Proxy Using Node And Express

Overview

Engineers are often faced with the challenge of pulling together multi-website/application projects, without full cross-platform permissions. Utilizing both a Node and an Express proxy, can pull together two websites/applications in a formal and cohesive format.

The aforementioned situation comes up more often than one would think, whether it be a question of host permissions or compatibility, it can undoubtedly pull up a number of possible roadblocks. There are several reasons a developer might not be able to run a site or app in their local environment; perhaps it’s complex to set up or involves a number of permissions. Regardless of the reason, Node and Express can present a novel way to solve the problem.

In Matt Billard’s Lightning Talk session, we will be uncovering the the primary strategies for Creating An Effective Proxy Using Node And Express:

Overview
The Architecture
How It Works
“Gotchas” To Avoid
Live Demonstrations
Closing Thoughts

The Architecture

The browser makes a request to the Node Express proxy server where the following three scenarios crop up:

If the user requested an HTML page, we need to combine the page from website 1 and 2. The proxy first asks website 1 and then website 2 for its HTML. It then modifies the two HTML files, combines them, and returns the result to the browser. (Details on how this works below.)
The HTML page will then request the CSS, JavaScript, and other assets it requires. These requests will again go through the proxy which will pass on the requests. If website 1 has the asset, great, the proxy will return it to the browser.
If website 1 does not have the asset, the proxy will then ask website 2 and return it to the browser.

In the example below, when using the InRhythm.com website as the target into which an engineer can inject some local code (in this case a basic Create React App project); the final result is an actual screenshot of the 2 websites living together in the same browser window.

How It Works

As mentioned above, website 1 and 2’s HTML are combined. This involves a few steps. Webpages can’t have 2 doctype, html, head, or body tags, so the use of some regex to strip those, will be required. Now that website 2’s HTML is ready, a coder can inject it before website 1’s closing </body> tag.

The above code shows the modifications to website 1’s HTML.

It shows a few things:

Many websites have full ‘absolute URLs’ for their links. They look like this: https://www.inrhythm.com/who-we-are/. The problem is if the user clicks on this, they’ll be taken away from our proxy and go to the target website. One can solve this by removing all www.something.com pieces while retaining the language the after the slash.
Injecting the CSS as discussed above, removes backgrounds and allows clicks to pass through website 2 to website 1. (Keep in mind this will probably be slightly different depending on the two sites a coder is combining.)
Injecting the HTML from website 2 must be modified before closing the </body> tag.

“Gotchas” To Avoid

It can take a variety of trial and errors in order to develop a proxy to one’s exact specifications. Some of the most common occurrences, a coder may find themselves troubleshooting are:

Websites usually compress or “Gzip” their content. Normally this is a great thing. It means less data is transferred and websites load more quickly. However, when in need of a proxy, it can become quite troublesome for ease of use. An engineer can’t parse, manipulate, and modify HTML if it looks like gibberish. The solution is actually quite simple: as it turns out, there’s a header one can send with their request to ask the server not to Gzip anything.

When using a proxy, all requests are going to have the header “host” set to “localhost.” Now this is probably not a problem for most sites, but to the target server, this doesn’t look like a very normal request, and indeed, one will find some websites responded abnormally and will return pages that looked nothing like expected. The solution cab be found in modifying one of the headers of the request.

Due to needing to modify requests quite a bit, this may result in some possible browser abnormalities. The solution to this problem is to delete the ‘content-length’ header before the proxy sends the browser any final response. This will stop the browser from truncating the response and removing all the hard work needed to customize one’s proxy.

When combining sites that use https, the proxy might complain that the SSL certificates don’t match what it’s expecting. Turns out it’s rather easy to relax this with the following code:

Live Demonstrations

Matt Billard has crafted an intuitive demonstration to help guide you through these principles in practicum:

Be sure to follow Billard’s entire Lightning Talk to view this impressive demonstration in real time.

Closing Thoughts

The Node.js framework Express allows an engineer to create web servers and APIs with minimal setup. Using Express in a Node.js application to create an API Proxy to request data from another API and return it to a consumer, is a vital skill to add to one’s skills toolkit. Using Express middleware to help optimize the API Proxy, will allow a coder to raise the bar and improve performance for returning data from the underlying API.

To develop and learn from Billard’s signature “Code Collider” proxy, feel free to download the direct code from GitHub.

Happy coding!

To learn more about Creating An Effective Proxy Using Node And Express, along with some live test samples, and to experience Matt Billard’s full Lightning Talk session, watch here.

InRhythmU

SDET Workshop (03/17/23)

Web Workshop (03/24/23)

DevOps Workshop (03/29/23)

iOS Workshop (03/28/23)

Android Workshop (04/11/23)

Cloud Native Application Development Workshop (04/21/23)

About InRhythm

Introduction

Asynchronous Coding Methods

Closures

Combine

Async/Await

Comparison

Features

Side-By-Side Code Function Definition

Side-By-Side Function Usage

Resources

Swift Concurrency

Async/Await

Tasks

Task Example

Child Tasks

Cancellations

Async Let

Task Groups

Task Group Example

Resources

Overview

What Is Cross-Platform Mobile Development?

Cross-Platform Development vs. Native Development

Common Tools and Frameworks For Cross-Platform Development

When To Choose Cross-Platform Over Native Development

Conclusion

Overview

The Architecture

How It Works

“Gotchas” To Avoid

Live Demonstrations

Closing Thoughts

Footer

Interested in learning more?