Forem: Nilay Jayswal

Why NextBillion.ai Chose Rust to Enhance Its Routing APIs

Nilay Jayswal — Tue, 02 May 2023 13:10:32 +0000

Some of the technologies used in the geospatial world are pretty old school. The histories of certain projects can be traced back to the 1960s. Back then, people weren’t spoilt for choice when it came to coding languages as we are today, so it’s not surprising that many routing APIs are coded in C/C++.

This blog was orginally published HERE

At NextBillion.ai, we modify and customize some of these projects for use in our routing API offerings. As you might expect, this is not a simple proposition, because of the use of C/C++. The most obvious option to consider was to continue coding the APIs fully in C/C++.

However, there are challenges in doing so:

It’s hard to recruit engineers who have C/C++ experience these days
It’s difficult to ensure memory safety and code quality, and to use modern programming techniques and frameworks

So, here’s how we did it instead. We split our dev into two parts.

The first part had to do with changes that absolutely must go into C/C++ code; the second part could be coded using something less painful, which integrates with C/C++ code through FFI.

We then asked ourselves, what’s the best way to call a C/C++ library at runtime? This is where Rust entered the picture.

There are so many programming tools/languages that provide FFI as a feature, but in different ways. Rust, the shiny new toy that everyone keeps talking about, is one of them.

Rust is quite popular these days; there are a number of user satisfaction and success stories, such as: https://discord.com/blog/why-discord-is-switching-from-go-to-rust

Coming back to NextBillion.ai’s dilemma, we now had to ask ourselves: Could something as new as Rust be married with old-school routing engines/APIs?

Let’s explore some of the pros and cons of Rust and why we went with it for NextBillion.ai’s routing APIs.

Pros

Rust calls a C library like C calls a C library

Rust has no inherent overhead when calling a C library. This is not the case for Java/Python/Node, or even Golang. First of all, Rust is not a GC language and smartly manages memory safety at compile time. Thus it strikes an almost perfect balance between runtime overhead and memory safety. This means we get to enjoy its runtime performance while not worrying too much about data racing, segmentation fault and memory leaking.

Rust has fearless concurrency

Rust enforces its ownership model, which addresses most concurrency problems at runtime. You would typically find it significantly harder to write a piece of code that has concurrency bugs in Rust compared to almost all other programming languages. On top of that, Rust does not have built-in abstraction for multitasking. You can choose what makes most sense for you, be it CSP (Golang), Actor Model, Async Await or Raw Multi-Threading. You’re spoilt for choice!

Rust is blazing fast

Rust frameworks appear very high in web-API performance ranking lists. In fact, Rust often has similar performance compared to programs coded using C/C++.

Rust supports modern tool-chains

Say goodbye to makefiles, because Rust has Cargo. Also, it’s enjoyable Unitesting Rust code.

Cons

Rust is “slow” at compile time

Every modern programming language provides memory safety and programmer-friendly features at a cost. For example, Golang gives goroutine and GC, but does allow you to know which thread your code is running on. Python gives you multi-threading, but locks everything with GIL. Node.js is lock-free, but removes multi-threading completely. In Rust’s case, it gives fabulous runtime performance and memory safety, but makes you suffer at compile time. Newbie Rustaceans have to learn to manage its steep learning curve and persevere through that period of time when it just makes them want to smash their keyboards.

Rust is too flexible and powerful for beginners

Rust offers a lot of flexibility and can be married with almost all programming concepts and models. New Rustaceans can get seriously confused or overwhelmed with the options at hand. You need to know what you’re doing! We completed our full evaluation by putting all of these pros and cons on the table, and decided that it was absolutely worth trying in our situation.

Our journey with Rust so far

There are two sets of problems in routing APIs/engines:

Less to no flexibility, but the ability to calculate real fast!
More flexibility, but with performance penalties.

Obviously, the more flexible your APIs, the less pre-calculation and caching can be done beforehand, and more things to be done at runtime. Let’s focus on problem set number 1 today.

In the early days, when we quickly prototyped a solution for problem set number 1, we directly modified the C/C++ library where it was absolutely necessary and did everything else with a GC language. The result was a working API with acceptable performance.

And then new challenges arose from client requests.

Some examples:

Calculate A→B driving distance, ETA and route with a very good P95 latency under certain request concurrencies
Calculate ETAs for 4000×4000 origins and destinations (AKA large distance matrix) as fast as possible.

We realized that it was very hard to solve these challenges with the fast prototype API. When you want your API to perform as fast as possible, you have to muster all your strengths, including the choice of the programming language itself.

GC languages are inherently slower; we also wanted to maintain full control of how our program runs, so we decided that we needed the power and control that Rust grants.

It was not an easy road, though. We did everything from scratch, such as learning Rust, passing its stringent compile time checks, writing a proper FFI layer, choosing the right concurrency model and more. At the end of it all, we were able to craft a solution that had 5ms P95 latency for simple routing requests, as demanded by some clients. Obviously, there are more variables in the whole latency equation, but marrying our routing engine with Rust paved the way for us to achieve the overall goal.

Are you evaluating various programming tools for a project that requires C FFI? Hopefully the pros and cons listed in this blog could be a good starting point for you!

Start With NextBillion.ai Today!

How To Build a Food Delivery App Like UberEats Using NextBillion.ai

Nilay Jayswal — Mon, 10 Apr 2023 13:28:03 +0000

If you plan on building an app similar to, with a mapping component and location-based functions, you should consider using NextBillion.ai’s APIs and SDKs.

This content was originally posted HERE

NextBillion.ai is a mapping technology platform that offers APIs and SDKs for building location-based applications. With NextBillion.ai, you get access to a variety of tools, such as the Distance Matrix API, Directions API, Navigation SDK, Route Optimization API, Geofencing API, Snap-to-Road API, etc.

This step-by-step guide will show you how to use NextBillion.ai to build a UberEats-like app.

Prerequisites

Before we start building our app, here are a few prerequisites:

Basic knowledge of JavaScript and Node.js
Text editor of your choice (e.g., VS Code, Atom, Sublime, etc.)
Node.js and NPM installed on your machine
A NextBillion.ai account to access the required APIs and SDKs

NextBillion.ai terminology

Here’s a quick explanation of some of the terms we’ll be using in this tutorial:

API key: An API key is a unique identifier that allows you to authenticate and access NextBillion.ai APIs
Distance Matrix API: The Distance Matrix API calculates the distances and times between two or more locations
Route Optimization API: The Route Optimization API helps you find the most efficient routes to cover multiple destinations

Steps covered in this tutorial:

Setting up NextBillion.ai
Setting up the development environment
Creating the app
Integrating NextBillion.ai APIs

Let’s get started!

Setting up NextBillion.ai

To use NextBillion.ai, you’ll need to create an account and get an API key.

Go to the NextBillion.ai website and create an account
After creating your account, go to the dashboard and click ‘API Keys’ on the left
Click ‘Create New API Key’ to generate a new key
Copy the key and store it in a safe place — you’ll need it later

Setting up the development environment

Before we start coding, we need to set up our development environment.

Open your terminal and create a new folder for your app
Change into the new folder by typing cd your-folder-name
Run npm init to initialize a new NPM package
Follow the prompts to create a new package.json file for your app

Creating the app

Now that our development environment is set up, let’s create the app.

Create a new file called app.js in your app folder
Open the file in your text editor and create a new Node.js project by requiring the necessary packages:

javascriptCopy code

const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');

Create a new instance of the express app:

const app = express();

Use body-parser to parse JSON data:

app.use(bodyParser.json());

**Also read –

Measuring Impact of Inaccurate ETAs for an On-Demand Ride/Delivery Organization – Effective ETAs 102**

Integrating NextBillion.ai APIs

Now with our app set up, let’s integrate NextBillion.ai APIs. Here’s how to use the Distance Matrix API to calculate the distance and time between two locations.

Create a new API endpoint in your app.js file:

app.get('/distance', async (req, res) => {
    const origin = req.query.origin;
    const destination = req.query.destination;
    const apiKey = process.env.NEXTBILLION_API_KEY;
    const apiUrl = `https://api.nextbillion.ai/maps/api/distancematrix/json?origins=${origin}&destinations=${destination}&key=${apiKey}`;
    const response = await axios.get(apiUrl);
    const distance = response.data.rows[0].elements[0].distance.text;
    const time = response.data.rows[0].elements[0].duration.text;
    res.json({
        distance,
        time
    });
    });

This code will create a new API endpoint called /distance; it accepts two query parameters: origin and destination
The apiKey variable gets the API key we generated earlier
The apiUrl variable stores the URL for the Distance Matrix API, with the origin, destination and apiKey query parameters added
The response variable makes a request to the Distance Matrix API using the axios library
The distance and time variables extract the distance and time data from the API response
Finally, the API endpoint returns the distance and time in a JSON format

Similarly, you can use the Route Optimization API to find the most efficient delivery routes for multiple destinations.

Create a new API endpoint in your app.js file:

app.post('/optimize-route', async (req, res) => {
    const apiKey = process.env.NEXTBILLION_API_KEY;
    const apiUrl = `https://api.nextbillion.ai/maps/api/route-optimization/json?key=${apiKey}`;
    const body = {
        locations: req.body.locations
    };
    const response = await axios.post(apiUrl, body);
    res.json(response.data);
    });

This code will create a new API endpoint called /optimize-route; it accepts an HTTP POST request with a JSON payload containing a list of locations
The apiKey variable gets the API key we generated earlier
The apiUrl variable stores the URL for the Route Optimization API, with the apiKey query parameter added
The body variable creates a new JSON payload with the locations array extracted from the HTTP request
The response variable makes a request to the Route Optimization API using the axios library
Finally, the API endpoint returns the response from the Route Optimization API in a JSON format

Final outcome

With the above API endpoints, you can now build a UberEats-like app that uses NextBillion.ai tools to calculate distances and times between locations, and find the most efficient delivery routes to cover multiple destinations.

In this tutorial, we covered the basics of using NextBillion.ai’s APIs to build location-based applications. We also went over how to set up your development environment and create a basic Node.js app that integrates NextBillion.ai APIs. With this knowledge, you can build your own location-based app using NextBillion.ai tools!

Vivaldi is live on Neverinstall

Nilay Jayswal — Wed, 20 Jul 2022 11:28:05 +0000

What is Vivaldi?

Vivaldi is a customization-friendly internet browser developed by the team that created Opera. It was launched in 2016 when the team discovered discontentment amongst users of Opera due to changes introduced after its shift to Chromium. The developers originally built the browser to target former users of the Opera browser and offer familiar functionality and customizations of the old Opera. However, eventually, the project evolved into a viable Chromium-based internet browser that offered heavy personalization and an array of out-of-the-box features to enhance user productivity.

Try Vivaldi on Neverinstall.

Why Vivaldi over other internet browsers?

Vivaldi has a niche audience and is a fairly new player in the market compared to Chrome and Firefox. However, we wanted to bring the browser to our platform to serve even the smallest of our user groups. The browser was requested by several users and so we decided to understand why, above other more popular options, users would prefer to use Vivaldi, and here is what we discovered.

Customizations and Gestures

The most evident reason was the virtually unlimited customization options that Vivaldi offers. The browsers allow users to change everything from color schemes across elements within the application to preparing a completely personalized Start Page. The themes section of the browser allows users to select from a large list of default options and edit them to the T.

Further, the browser offers a gestures feature that allows users to create custom mouse or trackpad-based gestures to perform a variety of functions. Vivaldi already has a set of pre-defined gestures offered by default which can be edited to perform a particular task as per the users’ requirements.

And let's not forget the Philips Hue Integration that allows users to replicate their browser's colors and gradients on LEDs for an added effect.

Stacking and Web Panel

Vivaldi offers a unique feature called Tab Stacks that allows users to consolidate a group of tabs and stack them over each other. The Tab Stacks can be used as instant bookmarks, and when clicked, show thumbnails of the grouped tabs to enable a quick view.

Next, the browser offers the Web Panel feature, a mini-browser within the browser to browse in a split-screen-esque manner. The feature is especially useful for users to get instant access to their most frequented or favorite websites while browsing the internet.

The web panel opens mobile versions of the websites in the sidebar, enabling user-friendly navigation and scrolling.

Hibernated and Lazy Tabs

Vivaldi allows users to hibernate tabs, i.e., to put open tabs to sleep while they are not in use without closing them completely. The browser retains relevant information from the tab while reducing its compute and memory consumption.

Additionally, when users re-open a previous session or load a saved session on Vivaldi, tabs other than the current one are automatically opened in hibernation mode. The Lazy Loading feature allows tabs to remain dormant until the user interacts with them. Therefore, a tab only loads (and, therefore, consumes system resources) when a user clicks on it.

Quick Commands

To all the fans of Apple’s Spotlight feature, getting access to everything the system has to offer from a single node without navigating; Vivaldi has got you covered.

The browser has incorporated the Quick Commands feature to access everything offered by the browser from a single search console. Users can simply press F2 (or command+E for Mac users) and a search console will appear within the browser.

Vivaldi as a cloud browser - Neverinstall it

Supercharging internet browsers has always been a primary goal of our team at Neverinstall. Therefore, we introduced Vivaldi on our platform to allow users to upgrade their browsing experience with unparalleled performance, speeds of up to 1 Gbps, and the ability to open virtually unlimited tabs.

Performance

A common grievance with Vivaldi has been sluggish performance and its overconsumption of system memory that brings computers to a halt. Much of this can be attributed to the Chromium platform and is a common program across other Chromium-based browsers as well. So, we offloaded the heavy lifting to our remote servers, from where the browser is streamed to the native browser of the user.

The users need only open a single tab on their native machine with - Neverinstall | Your browser is the new operating system - and everything else can be done within the platform.

Tabs and extensions. Never too many.

No matter if you’re opening a single tab that takes up too many resources or 1000 tabs, Neverinstall doesn’t break a sweat. Where native machines would fail miserably when users open more than a few tabs on most systems, Neverinstall allows users to open virtually any number of tabs on the platform without diminishing the performance of Vivaldi.

Similarly, users are free to install as many extensions on their browser as they want, and all the juice required to run it is offered by our platform.

How we did it

Neverinstall is a next-generation cloud computing platform that allows users to run pre-installed and pre-configured GUI applications over their browser. As the name suggests, users do not need to download or install any applications, instead, they can simply stream these applications like a movie without worrying about system requirements.

Try streaming a browser today. Neverinstall an app again.

Collaborative Coding and Reviews: Remote and Real-Time with Neverinstall

Nilay Jayswal — Tue, 19 Jul 2022 10:07:11 +0000

What are code reviews?

A code review is an act of intentionally and systematically connecting with fellow software developers to comb through each other's code. This is done for the purpose of getting a second set of eyes on a codebase, which helps with identifying bugs, logical errors, or unforeseen edge cases.

Try coding with your team on Neverinstall here.

Code reviews also check for things like inconsistent formatting, adherence to best coding practices, obvious vulnerabilities, and violations of conventions that might make the code difficult to execute, maintain and scale.

Writing code is a human activity. No matter how many automation tools come into existence, it is a human coder who crafts the skeleton on which software is built. And since, to err is human, code reviews act as necessary fail-safes to weed out errors even before the code reaches any automated review tools.

How developers currently review code

Currently, code reviews work like this:

Once they are reasonably certain of the code quality themselves, the developer uploads their code to a repository on GitHub (or some other code hosting repo).
The developer creates a pull request or PR (a request to merge code).
Once the code is in the repo, both the dev and the reviewer (usually a senior team member) review it.
In the repo, the reviewer checks the code and leaves their comments.
All changes to the code can be tracked within the GitHub UI.

While this process may seem easy enough, there are certain limitations with GitHub and similar tools. They are discussed in the section below.

How code reviews on GitHub leave something missing

Despite its many advantages, code reviews on GitHub come with a few significant drawbacks. To start with:

Devs must upload their code to the repo from whatever dev environment they are using in order to get it reviewed.
Once the code is uploaded, the reviewer must create a local copy of it to run on their machine.
On GitHub, the reviewer can only leave comments (such as on Google Docs), but they edit it or run the code in real-time.

This two-step process is not just unnecessarily time-consuming, but also leads to issues such as the “works on my machine” problem. This serves to slow down the development pipeline and hold up shipping due to entirely unavoidable roadblocks.

Real-Time Code Reviews made easier with Neverinstall

Fortunately, a solution to the aforementioned problems does exist - one designed to convert code reviews into a mutually contributive, time and effort-effective process.

Neverinstall.

On Neverinstall, users can directly access applications such as developer tools through their browser. The applications run in a cloud environment supported by a remote server and are streamed to the user’s screen. In this case, said application would be an IDE.

Instead of uploading and downloading code to review and run it, Neverinstall enables devs to share their entire instance with the reviewer. By doing so, different devs can access the same IDE in the same environment, thus facilitating real-time collaboration.

Utilizing Neverinstall cuts out the extra steps in between, and caters to a growing need for real-time collaboration. This is quickly emerging as a mandate, thanks to the increasing complexity of modern-day software development pipelines.

Neverinstall empowers devs to review code in real-time, right within the environment where it is written. They can leverage pre-configured dev environments that work in every machine, and perfectly inspect the accuracy, elegance, and efficiency of code, right at its point of creation.

Simply sign up with Neverinstall, and directly access powerful devtools through your browser. With apps like VS Code, Eclipse, and PyCharm, and more accessible through your browser (at exceptionally high speeds, no less), it becomes a simple task to just share your workspace with a reviewer and vice versa.

Final thoughts

As the world moves more online by the day, software must keep pace with end-users’ demands for efficacy and high functionality - fast. To keep up with these requirements, developers must produce better code, which means making extensive use of code reviews to ferret out any errors as early as possible.

Neverinstall empowers code reviews in real-time, on the cloud – thus bringing coders into a more collaborative workflow. By facilitating easier, faster, and more dependable code reviews, the tool contributes to the production of better software in shorter timelines. Using Neverinstall allows devs to generate cleaner, tighter code while cutting down on the effort currently required to do so.

Upgrade code reviewing for your projects. Sign up on Neverinstall.

Android Studio on Cloud: Code, Test & Deploy

Nilay Jayswal — Wed, 13 Jul 2022 07:34:14 +0000

Taking systems to a crawl

Android Studio is one of the usual suspects when it comes to hogging the system resources of developers. The sharp recommended system requirements and the application structure make it an ideal candidate for destroying system speed, often leading to criminally slow computers.

Try Android Studio here.

And don’t forget the Gradle nightmare; the excruciatingly long build times it brings.

As a developer, time is of the essence, the longer it takes to develop an application, the longer it will take for ideas to materialize. Sluggish performance and delayed results are suboptimal outcomes in a world headed literally towards Mars.

Developers often stumble upon several possible fixes that can accelerate Android Studio, however, either the changes are negligible or the noticeable ones are short-lived. Fixes such as offline working to speed up Gradle by avoiding repository connections, installing SSDs, or even disabling plugins are often impractical, ineffective, or expensive.

So, how?

Native on the cloud

If we can move to Mars, surely the cloud isn’t such a bad bet.

We need to understand the importance of solving resource-hungry applications such as Android Studio and offloading the heavy lifting. Solutions such as the cloud and virtual machines are making it possible by eliminating the barriers of system requirements, delays in build times, and even inefficiencies with pre-requisites such as set up and installation.

Contrary to popular belief, an experience closer to native can be achieved over the cloud. Hosting over remote servers can deliver a practical version of the platform to developers, enabling app development without traditional hindrances. An ideal way to achieve this is through application streaming.

Essentially, you stream Android Studio installed on a remote server similar to a Netflix show and interact with it like it is installed on your local machine.

The cloud enables platform-agnostic access to AS from any device and location over an internet connection, reducing the interaction of AS with the local machine to a minimum. The local machine, while streaming AS remains only a node to connect peripherals with the application and the entire development process is now available on the cloud.

Test waters without switching boats - Emulators

Well, you’ve built your app, but does it work? Time to bring out your good old Android device, plug it into your local machine, load your freshly brewed code, install it, and now you can see if your long hours bore fruit. Simple, right?

Not impressed? It does sound arduous and full of effort but then there are emulators.

Write, run, simulate

The results of your code are only visible when you run it on a device, but that is too much work. Enter emulators! Simulate your Android environment using these ingenious programs to test your code, without downloading, installing, or even having a device!

Emulators allow developers to accelerate their process by enabling faster testing and results. However, they are quite participative in dwindling productivity themselves. Emulators, similar to the Android Studio platform itself, are quite notorious for consuming system resources, especially the memory while simulating an Android device.

The best of both worlds - Android Emulators on Neverinstall

At Neverinstall, we have supported Android development for a long time. A large number of our users are active Android developers, giving us active feedback regularly to ensure that we deliver the best to them. And one of the most frequent requests from our users was support for emulators within the platform, so we brought it.

Android Studio Emulator Support

Android Studio on the Neverinstall platform now supports emulators out-of-the-box.

We clubbed unparalleled performance of a native-like Android Studio instance over the cloud with support for emulators to enable developers to create Android Virtual Devices for testing their apps as they code.

Since the emulators are installed on the cloud similar to the Android Studio platform itself, developers now get access to unhindered development, testing, and deployment.

Deploy your Android apps with Neverinstall today! Sign up here.

Collaborative Browsing: A virtual solution for real-time participation

Nilay Jayswal — Thu, 07 Jul 2022 07:29:43 +0000

Understanding Collaborative Browsing

Collaborative browsing or co-browsing refers to the act of two or more individuals simultaneously browsing a web page. Essentially, both individuals can see how the other person interacts with the page…as they do it.

Surf the internet with your team. Try co-browsing with Neverinstall now.

Imagine that you have to help someone in a different city fill out a form on the internet or explore a product online. Chances are, they might also face trouble with some fields, links, or information. The current regime dictates that they share screens on a video call so you can guide them. However, patience runs thin within us amid all the communication gaps, the learning curve, and errors.
**
But what can be done? It’s self-explanatory.**

Co-browsing allows you to browse the same web page as others - in the same instance, interacting with the same information in real-time. Like sitting together with multiple mice and keyboards on the same machine, but more practical and convenient.

Contemporary use cases of collaborative browsing

The simplicity and efficacy of collaborative browsing allow it to add significant value to multiple use-cases that require personalized online interactive participation. Here are some use cases of co-browsing that users are exploring right now:

Customer Support: With co-browsing at their fingertips, customer service personnel do not have to share their screen to see what issues a customer might be facing. They can observe the customer’s experience as they demonstrate the user journey, leading the service agent to identify the problem quickly. Naturally, this will result in lower resolution times. Collaborative browsing also makes it easier for customers to highlight their issues.
Document Review: Often, product documentation can be complicated for certain customers, especially those without a tech background. A company representative can help customers look through docs and extract the information they require in a collaborative browsing session.
Customer Onboarding: No matter the industry, onboarding a new customer can be a painstaking process. However, co-browsing offers a high-touch, collaborative process that simplifies the procedure to a great extent. By pairing online conversation with a visual context (guiding them as they go through onboarding), onboarding becomes easier and more personalized - a win-win for both company and customer.

The Need for Co-browsing

The possibilities and potential of co-browsing are immense. Above all else, co-browsing is integral to offering a more engaging, personalized experience to virtually all users.

It enables real-time collaboration without the limitations of screen sharing. Depending on either party’s internet connection or tech setup, the shared screen may not be perfectly visible (low resolution) or experience lags and delays. Collaborative browsing solves this by removing the need for screen sharing entirely.
By recording and documenting co-browsing sessions, sales and marketing teams can clearly understand how to walk customers through solving specific issues. This facilitates team-wide learning and makes customer support activities much simpler. Users can use the same process to introduce customers to new products through demos and even train employees.
Since collaborative browsing requires no download actions for the customer, users eliminate friction and setup time. Thus, contributing to a smoother user experience for all parties involved.

Co-browsing for the Metaverse

Co-browsing brings communication and collaboration one step closer to replicating real-life proximity. When you are co-browsing, the experience is similar to another person in the same room. By eliminating the screen sharing element, collaborative browsing removes a visible reminder of a person’s geographic distance during the shared session.

While this may still be a few years away, the co-browsing experience is bound to feed into the larger principle of the Metaverse - an embodied internet you can “step inside.” In other words, the metaverse seeks to give you the full spectrum of the human experience online.

Sharing a virtual space through collaborative browsing aligns with what the Metaverse seeks to accomplish - real-life experiences over the internet. By stripping away one more virtual barrier (screen sharing), co-browsing brings us closer to the final vision of the Metaverse.

The many advantages of collaborative browsing are on their way to making it a fixture in online communication. With customer experience being a key differentiator for most businesses, collaborative browsing elevates the customer experience from ordinary to extraordinary, thus giving companies a competitive edge.

Collaboration with Neverinstall

At Neverinstall, we believe in the power of collaboration and teamwork. Therefore, we built the platform in a way that enables users to work with their teams or just surf the internet with friends seamlessly.

Users can share their workspace with others to collaborate, co-browse, or co-watch content from within the platform. When a user shares a workspace on Neverinstall with another user, our servers stream the same application to different machines in different places. Instead of two separate instances, users can interact with the same application instance in real-time.

Users can also interact with peers and colleagues and experience seamless collaboration on projects, thanks to our in-built cursors and options to hand over or take control of a page.

Experience unparalleled collaboration with Neverinstall. Watch, surf, or work with your friends in real-time. Sign up here.

Creating a React App on Neverinstall - A review from Deepankar Bhade

Nilay Jayswal — Wed, 06 Jul 2022 07:48:20 +0000

At Neverinstall, we are passionate about developing software that can help users from every domain. Unsurprisingly, we are always looking for developers who can teach us how we can solve more problems to serve our users better. Today, we would like to introduce Deepankar Bhade, an avid React developer.

Create a React app VS Code on Neverinstall here.

He is a software engineer working on a variety of tech stacks from a young age. At the age of 17, he started an online community that currently has over 16,000 followers, and went on to build Chloromaps, a platform to help non-developers build choropleth maps with ease. We thank Deepankar for taking the time to review our platform.

We reached out to Deepankar to get granular feedback and learn more about how our platform is helping developers work on different tech stacks. In this article, we share with you Deepankar’s experience of creating a React App using Node.js with VS Code on Neverinstall.

Deepankar selected VS Code as his integration with Node.js and launched the app on the platform as shown below.

He noted that the app was built in under 10 seconds and the app could immediately be opened in a new tab. He could then see VS Code open up the integrated terminal where he would start working on his project.

Creating the app

Deepankar started by creating a new directory “react-app” to begin his project. Inside the directory, he ran the following script - npx create-react-app

The script created a sample react app for him.

After the sample React app was prepared, he ran the script "npm-start", and voila! It opened up the app in a new tab within Neverinstall as shown below.

We asked Deepankar how our platform fared to his expectations, and here is what we found out, verbatim.

Setup time

As a primary requirement, if you want to build something with React you must have Node.js, npm, and a code editor installed and configured on a machine, moreover, you actually need a physical machine as well which is typically a personal computer.

The process of installing the tools and configuring them to set up your dev environment easily takes up 15-30 minutes and that is with a decent internet connection.

However, with Neverinstall it hardly took 10 seconds, which is ridiculous!

Further, running the script “npx-create-app” locally on my PC (a maxed-out Macbook Pro 13-inch) took about 2 minutes and 30 seconds. While on Neverinstall it took less than 1 minute.

Collaboration

While tools like CodeSandbox and GitHub Codespaces are trying to make software development more collaborative, I feel they are still very narrow in their approach. Although the solutions are fairly decent, they do not offer full-fledged control over development while collaborating.

I feel there’s a lot of potential in a platform like Neverinstall for a live collaboration use case. The platform can be used by teams of multiple teams to work on the same instance in real-time. Moreover, the collaboration capabilities are not only restricted to IDEs but are also available to the terminal and practically everything offered on the platform.

Latency

Although latency might seem like a concern and most users would be skeptical toward a cloud development solution such as this, Neverinstall does a pretty good job of making the experience seamless.

The latency issue can be eliminated for most users who have access to a decent internet connection. And although there still might be a slight delay noticeable in some places, the platform is being updated regularly and the latency becoming less noticeable with each month.

Code from anywhere

The platform makes the experience of using a dev tool closer to how we carry internet browsers with us everywhere. The platform can be used on mobile and tablet devices, and the platform delivers a native experience regardless of the device.

As someone who travels and often codes on the go, this is an awesome tool to quickly bootstrap ideas and even review code in a snap, without having to deal with pull requests and repositories on GitHub.

Resources Consumed

Running create-react-app is infamous for being resource-hungry, increasing CPU usage significantly. However, when I ran the script on Neverinstall, all the heavy lifting was done by the servers of the platform. Since the entire instance is being streamed to my laptop much like a movie, it didn’t hog my computer's resources.

Overall experience

The platform complements my local machine which itself is a mobile workstation. The platform offloads the resource consumption from my laptop, preventing heating and battery loss, all while delivering superior performance.

Your browser is the new VPN

Nilay Jayswal — Mon, 04 Jul 2022 12:17:53 +0000

We all know that feeling when we try to watch a web series, a YouTube video or a web article, and the content has regional restrictions sometimes. The bulk of us simply drops off, while the zealous ones look for an ideal solution. While a VPN seems like a good choice to access region-restricted content, it comes with an arduous setup and a significant detriment to internet speed.

Try a browser on Neverinstall here.

Say hello to Neverinstall, we are trying to solve this with the help of our servers across three continents and growing. We have built a cloud-based platform that offers a native browsing experience across leading browsers to the user. The user can launch either Chrome, Firefox, or Brave in a region of their choice.

We circumvent the detriment of connection speed by streaming the browser to the user, packing the browser with internet speeds of up to 1 Gbps even when the user has an internet connection 20x slower than that.

Our platform works similar to a VPN and helps protect the identity and data of the user and does not disclose the IP or other user information to any third party, ensuring privacy at all times.

Obsidian is finally on the web with Neverinstall

Nilay Jayswal — Thu, 30 Jun 2022 13:13:45 +0000

What is Obsidian?

Obsidian is a new-age note-taking and documentation application. The self-anointed second brain uses Markdown to store the notes created by the user locally. The application is known for being highly customizable, allowing users to integrate plugins and several themes and even incorporating custom CSS, enabling users to create a truly personalized experience for themselves.

Try Obsidian on Neverinstall!

Why do we love it?

Unlike most knowledge base software, Obsidian approaches documentation through a gardener approach instead of an architect approach. The goal is to make information stored anywhere within the knowledge base available to users without friction and complex navigation. As the user skips from one idea to another in their brain, so can Obsidian, creating a network of information that users can navigate seamlessly.

Obsidian achieves this through a three-pronged approach:

Graph View

Obsidian lets users view their entire knowledge base through an interactive web-like graph. This graph contains all the knowledge created by a user in the application and can present maps of different ideas.

Backlinks

The app allows users to link different pages to one another, creating a logical sequence to understand and recollect an idea. The backlinks help provide context and comprehensive insights into the origin of an idea.

Outgoing Links

Users can also create outgoing links that can lead to different ideas. Users can use this to navigate to ideas outside of a current knowledge base, to turn mentions of different ideas into links to reach them.

Obsidian for web

Although the app has become one of the most sought-after note-taking apps, users have often had contention regarding installation. Users can only use the app on native machines, i.e., you need to install it on your device. And Obsidian has done this deliberately.

One of the reasons the founders built the application this way is that the company’s vision does not incorporate support for the cloud. They strongly believe that the users’ data must sit on the local machine, not in a cloud server.

As a result, Obsidian is unavailable as a web app and cannot be used through an internet browser.

Communities across Obsidian’s Forum, Reddit, and other channels have requested that Obsidian release a web version. However, it has not borne fruit.

Why do we need it?

Since the app can only be accessed when installed on the native machine, the capabilities of such a diverse knowledge base are hindered. Here is why we need Obsidian for the web.

Accessibility

The local installation requirement of Obsidian does not allow users to move with their data. Since Obsidian stores all the data on the local machine, users cannot access it remotely over the internet while on the move.

Adaptability

Another major issue is switching platforms. As all the data of the knowledge base is stored on a local machine, migrating the data to a new system becomes a significant hassle. It also makes the Obsidian platform restrictive, and cross-platform access to the knowledge base is unavailable.

Continuity

As the size of the vault grows, users may notice their system slowing down. This often requires users to upgrade their systems and migrate their data to a different machine.

Further, if the user's local machine gets damaged or the data is corrupted, the entire knowledge base of the user is lost. Unless the user regularly maintains a backup file, chances of data loss remain high.

However, the wait is over, and today, we bring you the good news.

Obsidian is live on Neverinstall!

It had been a few months since we released a new app on the platform, and we looked for the perfect addition to the platform. And we decided on Obsidian.

Earlier this week, we released Obsidian on our platform, allowing users worldwide to create their knowledge base on the app through their internet browser, storing their files on our servers which users can access from anywhere.

Why is Obsidian on Neverinstall better?

Here is why Obsidian is better with Neverinstall and how we make the experience better for you.

Access anywhere, on any device

Through Neverinstall, users can access Obsidian on any device and from any location over their internet browser. Since the users’ data is stored on our servers, users can simply log in to their account and start using Obsidian from where they left off.

Neverinstall also makes Obsidian platform-agnostic. Users can use any device with an internet browser to access the app.

No download, no installation

Neverinstall has pre-installed Obsidian on the platform. Therefore, users do not need to download or install the application on their local machine. A user can simply log in to Neverinstall and start using the application.

No hardware limitations

As the size of a Vault in Obsidian grows, its performance (and the machines’) starts deteriorating. This requires either the user to reduce the size of their Vault or upgrade their local machine.

Flutter on VS Code with Neverinstall - A review from Aditya Thakur

Nilay Jayswal — Wed, 29 Jun 2022 11:25:38 +0000

At Neverinstall, we always try to improve our product and regularly engage with users from diverse backgrounds to get valuable feedback. In this article, we would like to introduce Aditya Thakur. He is a Developer Advocate for 100ms and runs a successful Discord community with over 1000 developers.

Try VS Code on Neverinstall here.

Aditya is a public speaker and runs a YouTube channel, covering topics around the software development landscape. So we deemed it fit to ask him to try our product. Earlier this month, we reached out to Aditya to compare his experience of using Flutter on VS Code on his native machine with the experience on Neverinstall.

This exercise aimed to understand how well our platform can replace the local installation of IDEs and code editors for a user and which use case the platform best serves a user.

Here are Aditya’s views on the platform and what he loved about it.

Setup

One of the aspects brought to our attention was the setup of the code editor, i.e., VS Code. When we built our platform, this was always one of our primary focuses, where we wanted to reduce the complexity and duration of setup for IDEs and code editors.

Ease

Aditya found the setup of the VS Code and Flutter easy and effortless. The platform only requires users to launch the code editor and select the development kit, in this case–Flutter, and the pre-configured and pre-installed application begin to run.

Developers do not need to download or install a code editor or a dev kit on their local machine and can simply log in to the platform to get instant access.

Time

VS Code started pretty quickly as compared to the local machine. The Flutter installation and the required IDE setup would have taken time on the native machine. However, it took only a few clicks to select VS code, choose the Flutter development kit, and get started with the project.

Aditya noted that creating a new project in Flutter was also a charm. He created a project by running the command – flutter create newapp – getting him started with his development exercise roughly 2 seconds from launch.

Writing code

The primary role of a development environment is to help write code, and at Neverinstall, we are trying to bring that experience closer to a native machine as much as possible. With ultra-low latency and faster setup times, we are trying to deliver the best experience to developers. Here is Aditya’s experience writing code on the platform.

Familiarity

Since a large number of developers are familiar with the Linux operating system, we choose it to be the backbone of our platform. When Aditya set up his dev environment on our platform, he found that VS Code running as a Linux app delivered a very familiar approach, allowing him to code even on the cloud comfortably.

Collaborative coding and code reviews

Neverinstall allows users to share their workspace with other users to work on the same project, browse together and even watch something together. This is one of the things we wanted Aditya to review for us from a coding perspective. He noted that collaborating with the other users was easier over the cloud, allowing different developers to work on the same project in real-time.

Since the same instance is shared with a user, code reviews also become easier. Aditya noted that review code within the instance of the developer was made possible through the platform, preventing the need to move the code to a repository.

Coding from anywhere

One of the use cases that set Neverinstall apart for Aditya was our ability to carry an entire personal computer on the cloud. Since users can log in to the platform from anywhere and using any device, developers can use the platform to code from anywhere.

Mobility is a big win for Neverinstall since it allows users to take their workspace and dev environments anywhere with them, even on their phone or tablet with the same native desktop experience, and code from virtually any place on the planet with an internet connection.

The overall experience

Here is how Aditya summed up his overall experience using Flutter on VS Code with Neversintall.

Using VS Code with Neverinstall was great, and the performance of the code editor was fairly good, considering it is streamed over the internet. The platform allows users to take their work anywhere and even switch devices without the need to download or install IDE repeatedly.

The project was running on the latest version, which goes to say that all the updates and upgrades for IDEs and dev kits are handled on Neverinstall’s end, further reducing efforts for developers.

I recommend Neverinstall for developers who regularly travel and have to move around with their work often.

Cloud Browsers: Understanding the future of web browsing

Nilay Jayswal — Tue, 28 Jun 2022 13:10:52 +0000

The perils of the native browser

Data from the first quarter of 2020 reveals that within most regular internet users’ tech stacks, a web browser was the second most common juncture for exploit attacks (attacks exploiting security vulnerabilities).

Try a browser on Neverinstall here.

In other words, the browser you use every day (Chrome, Firefox, Safari, Opera, Edge) carries a high likelihood of being infested by web-based vulnerabilities, all the way from malware, malicious hackers, and viruses whose names you might not know yet.

With the emergence of HTTPS authentication in the 1990s, devs and internet users hoped that they would see a marked improvement in online security. While that did undeniably happen, to this day, many websites simply do not provide HTTPS protection or have flawed HTTPS certificates.

In other words, you are risking malicious infiltration every time you use the browser on your device - desktop, laptop, or mobile. However, technology is nothing if not adaptable. Cloud browsers are an alternative to your native browser (the one installed on your device) that already exists.

What is a native browser?

Native browser essentially refers to the regular browsers you use daily to access the internet. You install it on your device, open it, and use it to access content on the World Wide Web. Think of your web browsers as a set of code that collaborates to perform specific tasks - locate, obtain and render content from the internet per the client's request.

Native browsers work on a client/service model - the browser (the client) sends a request to the web server for information, the server locates the information, sends it back to the client, which displays it via any internet-enabled device.

Modern browsers come with full-featured software architecture enabled to translate and render HTML, JS, and AJAX-based content sourced from web servers. A wide range of browser-compatible plugins also exists to enable browsers to render multimedia content (sound, video, special effects, etc.) to the extent that you can use browsers for video conferencing, software development, and gaming, and the like.

Cloud browsers–familiar yet better

A cloud browser does precisely what a native browser does, except for one key difference. It is run on a remote server rather than the device you use to browse the internet. However, this one difference sets it a world apart.

Browsers are hosted on powerful remote machines in isolated containers. Commands from and to the browser are executed in the container, separated from the users’ device, and users access the retrieved web content via display/streaming protocols (RDP or the latest WebRTC).

Needless to say, as the browsers run in a remote container, the user end-point stays unscathed by security breaches and attacks. It also makes the browser more manageable (thanks to it now being centralized), resource-effective and scalable.

Benefits of Cloud Browsers

Cloud browsers offer multiple advantages that give them a serious leg up over native browsers. The most significant of them are listed below:

Improved Security: Since web code is not executed on the user’s device with cloud browsers, this automatically blocks malicious code, potential threats, or anything that would risk the users’ online security.

Further, if you’re browsing within the cloud, you don’t need to install, manage and update software for added functions such as data loss protection, device security, content filters, firewalls, SSL inspection, and the like.

Enhanced Privacy: Unlike native browsers, cloud browsers will safeguard a user’s identity, location, and other data by processing the information through a data center on the cloud. However, if this is a priority for you, ensure that the service you are using to access the cloud browser does in fact provide this functionality.

Consider Neverinstall, where we allow you to access the internet from different locations across the world, much like a VPN. The IP address of the user is completely masked, allowing users to access data across the world anonymously. The VPN-like nature of browsers on the Neverinstall platform also secures personal information and private data.

Cloud service benefits: Cloud browsers tend to carry several merits when it comes to maintenance, scalability, and capacity. Typically, you do not need to bother with updating your browser, installing new plugins to match new content formats, or managing your memory for optimal browser performance. The bulk of the capabilities, however, depending on the provider.

For example, at Neverinstall, one of the things we do is enable users to browse the internet at speeds of up to 1 Gbps. While a user’s ISP (internet service provider) might deliver lower bandwidth, the user can browse the internet at 1 Gbps even with a connection as slow as 1 Mbps. We do this by running the browser in a remote native environment with a high-speed internet connection and streaming it to the screen of the user, allowing them to interact with it.

Read here to know more about how we do it.

The many positives it brings to the web browsing table may very well become the future of internet exploration. Why wouldn’t users pick a more secure solution that protects their data and device, and reduces their maintenance burden?

Explore Neverinstall and see exactly how well cloud browsers work for you.

The Curious Case of Chrome's Memory Consumption - Neverinstall it

Nilay Jayswal — Mon, 27 Jun 2022 12:54:02 +0000

The usual suspect

Google Chrome, albeit the most popular internet browser in the world, has always been infamous for hogging memory on devices. While the browser generally delivers smooth operation for everyday users, problems start when users open a second tab and another, and so on.

Try Chrome on Neverinstall here.

We can attribute the popularity of the browser to its powerful V8 JavaScript engine, which translates JS code directly into machine code. The V8 engine, like the one found in 007’s DB10, is a faster engine that delivers better performance when loading web pages and apps. However, the fact that Google designed the browser to deliver superior performance makes it a nightmare when the number of active tabs becomes more than a few.

How does it happen?

One of the reasons why Chrome gets slow when you open several tabs is that the engine is trying to allocate an equitable amount of resources to each tab to deliver the best experience to the user. However, this is where the core of the problem lies.

Split processes

Chrome treats every tab as an individual process. To put it into perspective, Chrome splits every tab a user opens, along with any plugins or extensions that may be installed on the browser, as a separate process. Therefore, when a user opens a browser, the Chrome browser does not consume memory as a single entity but rather as a group of resource-hungry web apps and pages consuming the RAM simultaneously. Notably, multiple processes can be found under Chrome, acting as a subset, in the task manager.

Prerendering

Another major cause of Chrome being so punishing on system memory is prerendering. Prerendering improves browsing speed and reduces loading time for a web page. The feature analyses and anticipates a web page that the user may visit next and pre-loads text and graphics on that page before the user navigates to it. Although this reduces the loading time of a page noticeably, it takes a toll on the system memory as the prerender becomes another process in the background.

Why does it happen?

While you might think treating each tab as a separate process is a horrible approach, it is necessary to stabilize the browser and web apps. Even if one tab crashes, the rest of the browser remains active and functioning. And while prerendering might seem like a bad idea, it does help save a lot of time while surfing the internet.

Inevitably, we sacrifice memory and system speed to improve web page performance. So how do we resolve this unfair quid pro quo?

Can the cloud save us?

The cloud use case is evolving, and the good old internet browser is no stranger. Although it seems ironic to use a browser to access the same over the cloud, the results are fascinating. A cloud browser can reduce resource consumption and dependency of the browser on the native while delivering all its functionality over an internet connection. At Neverinstall, the cloud browser is one of the use cases of our product.

At Neverinstall, we are building a next-generation personal cloud computer for every user. Our platform offers pre-installed and pre-configured applications that users can simply launch and start using.

Some of our most popular applications? Internet browsers. Chrome, to be specific.

We operate much like a cloud browser, hosting browsers on a platform located on a remote server. This allows us to offload the heavy lifting for the user and deliver performance on Chrome the way Google intended.
The experiment

To show you how it works, we conducted a brief experiment.

We opened 17 tabs with 17 different websites in the same order with the same conditions on the desktop. We chose the most popular websites to give a realistic representation of a typical use case.

We opened – YouTube, Facebook, Reddit, GitHub, Amazon, Twitch, Twitter, Gmail, Outlook, Techcrunch, CNET, Wikipedia, Netflix, Prime, Hulu, Office, and LinkedIn. (In this order.)

All background processes were identical, and we took the screenshot after the same interval on the same tab. And here are the results:

What you see are the apps mentioned above opened on the Chrome browser. At 17 tabs opened in Chrome, we noted that the system consumed almost 1.5 GBs of system memory or RAM on this particular machine.

What you see are the same apps mentioned above opened on the Chrome browser. However, the browser is now running within the Neverinstall platform.

At 17 tabs opened in Chrome within Neverinstall, we noted that the system consumed less than 256 MBs of system memory or RAM on this particular machine.

We noted a reduction of almost six times in terms of memory consumption when we ran the browser on Neverinstall. While our experience remained the same, we could open more tabs without reducing the performance and speed of the system.

Further, we have built the system to open as many as 1000 tabs simultaneously without consuming more of a user’s system memory and without hiccups.

How we do it

Neverinstall is a cloud platform that can run any GUI application on its remote servers and streams the application much like a video to the user's machine through the browser. Our state-of-the-art solution allows users to interact with the application virtually indistinguishable from a native machine without the drawbacks of hardware limitations.

Our platform handles the entire process of running and executing the browser application's code. As a result, Neverinstall’s instance is the only process created on your system.

To know more about how Neverinstall works, visit here.