Intermodal Routing: A Step towards Building Smart Urban Public Transportation System

Intermodal Routing: A Step towards Building Smart Urban Public Transportation System

Make urban public transit seamless with intermodal routing service that helps to plan the entire journey on a single platform by combining multiple modes of transport and creates a more sustainable environment in the city.

Commuting in today’s fast-paced world has become more accessible to everyone because of smart transportation technologies. On-demand transport platforms like ride-sharing, bike-sharing, and shuttle services, autonomous vehicles, smart infrastructure, and other highly-effective digital urban public transit solutions have rapidly changed the way people commute on a daily basis.

The Routing Race begins here…

Although many transport technologies have been introduced worldwide, finding the most suitable combination of modes can be a time-consuming task. Commuters have to rely on multiple routing channels – apps that provide information for the entire journey. They have to shift from one app to another to drive more information, and that’s frustrating. Furthermore, many routing apps provide insufficient information about transit data, traffic, vehicle arrivals, or delays. Switching multiple apps for booking different means of transport is also annoying. Therefore, presenting a powerful routing service, in the form of “Intermodal Routing” will enable commuters to choose the best suitable transport mode for the journey on a single platform.

Let us understand ‘Intermodal Routing’

The term indicates the combination of multiple transportation modes for a better mobility experience. It makes the journey attractive by including more than one form of transportation such as walking, bikes, buses, trains, private cars, ferries, trams, and much more. It integrates different transport modes into a single transport network in such a way that the entire ecosystem creates organized, coordinated, and efficiently planned routes for a seamless journey.

Intermodal Routing requires,
Integration and Interconnection of all the multiple transport modes
Placement of conveniently located transport stations or connections
Improved coordination in the transport system
Proper management of E-ticketing system for all the routes
The adequate distribution system of all the transport modes
Implementation of different transportation technologies
Strict adherence to government policies

The main objective of implementing intermodal routing most productively for the transportation industry is to minimize the travel time and emission of CO2. Because the bustling transportation industry is expanding at a superior level along with urbanization and, so are the complexities people face in urban areas related to traffic congestion, higher fuel consumption, increase in commuting time, and lot more. This results in CO2 and Greenhouse Gas (GHG) Emissions, which causes climate change on the earth’s surface, making the atmosphere warm. Hence, integrating other powerful routing technologies in the market will provide commuters a reliable and safe travel experience.

Read More About Intermodal Routing.

Teach yourself SQL Step by Step | Simpliv

Teach yourself SQL Step by Step | Simpliv

Teach yourself SQL Step by Step

Structured Query Language (SQL) is a special purpose language for interacting with relational databases. In this course, Teach yourself SQL Step by Step, you will learn the basics of Structured Query Language. First, you will learn how to query data and shape results. Next, you will focus on creating and modifying data in your tables. Finally, you will touch on how to set relations with tables and extract matching data. By the end of this course, you'll understand the basics of how to create and use a relational database.

Basic knowledge
No prior computer knowledge required, all you need is a computer with SQL server installed
What will you learn
Understanding Database Concepts
Installation of SQL server
Connection and Disconnection
Difference between Admin Login and User Login
SQL commands for creating
displaying and deleting database
SQL commands for creating
displaying and deleting tables
Commands for exploring tables
Organizing data
Setting relations and understanding joins
To continue:

Laravel 6 Routing Tutorial Step by Step

Laravel 6 Routing Tutorial Step by Step

laravel 6 route tutorial, how to create route in laravel 6, how to create post route in laravel 6, how to create new route in laravel 6, laravel 6 routing tutorial, routing in laravel 6 example, route in laravel 6 controller

Hi Guys,

In this blog , I will explain you step by step laravel 6 routing tutorial.we will show how to create new route in laravel 6. we will also create how to create route in laravel controller.

we will create step by step process of how to create route in laravel 6. Routing is one of the essential concepts in Laravel. Routing in Laravel allows you to route all your application requests to its appropriate controller.

The main and primary routes in Laravel acknowledge and accept a URI (Uniform Resource Identifier) along with a closure, given that it should have to be a simple and expressive way of routing.

What is Laravel Routing?

Using Routing you can create a request URL for your application. you can design set of HTTP request like POST Request, GET Request, PUT Request and DELETE Request using routing in laravel.

I will describe you bellow step by step how you can create it and how it works, so let's see step by step explanation.

Link :-

Step by step: Building and publishing an NPM Package

Step by step: Building and publishing an NPM Package

In this article, we'll look at creating an npm package that can be installed as a dependency and publish to npm.

Every Node.js developer knows that when creating a new Node project, one of the very first things you'll do is type npm init and answer couple questions, and then install dependencies and devDependencies.

Table of Contents

  • What is a package and module?
  • Prerequisites
  • Setup
  • Getting started
  • Test
  • Publish
  • Conclusion
What is a package and module?

npm has specific definitions of packages and modules, which are easy to mix up. I'll like to discuss these definitions and explain certain default files.


  • A package is a folder containing a program described by a package.json file that defines the package.
  • A module is a folder with a package.json file, which contains a main field, that enables loading the module with require() in a Node program.
  • The node_modules folder is the place Node.js looks for modules.

Generally, most npm packages are modules. However, there's no requirement that an npm package should be a module. There are CLI packages, that contain only executable command-line interface(CLI) and don't provide a main field to be loaded with require(), these type of package is not a module.

In the context of a Node program, the module is loaded from a file. For example, in the following program:

    var acronym = require('acronym');

we can say that "variable acronym refers to the acronym module".



  1. Important words are highlighted.
  2. Bold words emphasis a point.
  3. Previous / Next code appears like this . . . .

This project requires a fair understanding of Javascript Promises and Callbacks and Node.js v6.11.0 LTS or higher to support some ECMAScript 2015 features. You can follow this tutorial or view the full code for this tutorial on Github.

Now that you have completed the prerequisites, let's start!

  1. Create an empty directory and initialize it as a npm package using npm init or npm init --yes, if you're feeling lazy. It will ask you to create your package.json file.

$ mkdir acronym && cd acronym $ npm init --yes

  1. Navigate to your directory, a package.json file should exist like this :
          "name": "acronym",
          "version": "1.0.0",
          "description": "",
          "main": "index.js",
          "scripts": {
              "test": "echo \"Error: no test specified\" && exit 1"
          "author": "",
          "license": "ISC"
  1. By default, a main field will get created. The main field is a module ID, the entry point (main script) to your program. That is, if a user installs this package, and then does require("acronym"), the main module exports object will be returned.
  2. Edit the package.json file to look like this, if you want to add information for the author field, you can use the format Your Name (email is optional):
          "name": "acronym",
          "version": "1.0.0",
          "description": "Transform sentences to acronyms.",
          "main": "index.js",
          "author": "Akinjide Bankole " // optional
  1. Let's start creating our script file and open with Sublime Text (or Atom, VIM, WebStorm) :
    $ touch index.js
    $ open . -a 'Sublime Text'
Getting started
    "use strict";

    module.exports = function acronym(sentence, callback) {


module.exports encapsulates and allows the acronym function to be with other code. The acronym function takes two parameter, a string data type e.g. "for your information" and a callback function.

    . . .

    return new Promise((resolve, reject) => {


    . . .

We define and return an instance of the Promise class. A Promise is an object which can be returned synchronously from an asynchronous function, it may be in one of 3 possible states: fulfilled, rejected, or pending, and produces a single value some time in the future.

  • Fulfilled will be called when resolve() is called.
  • Rejected will be called when reject() is called.
  • Pending is either not yet fulfilled or rejected.
    . . .

    if (sentence.length === 0) {
        reject('String, Please! e.g. "for your information"');
        return callback('String, Please! e.g. "for your information"');

    . . .

The if statement checks for the length of the sentence parameter, if the condition is true, we reject with an error message (String, Please! e.g. "for your information"). The return keyword before the callback, immediately breaks out of the function call, returning the callback function with an error message.

    . . .

    else if (typeof sentence === 'function') {
        callback = sentence;

        return callback('¯\\_(ツ)_/¯');

    . . .

The else if statement checks if the user passes in a function as the first parameter instead of a string, if the condition is true, we assign the function to callback and reject with an error message (¯\\_(ツ)_/¯).

    . . .

    else {
        const words = sentence.split(' ');
        const acronym = => word[0]);

        . . .

The else statement will be the default if none of the conditions above was satified. The first line, we .split the sentence into an array ['for', 'your', 'information']. The second line, we .map and return an array, with the first character of each word ['f', 'y', 'i'] and assign to variable acronym.

    . . .

    else {
        . . .

        return callback(null, acronym.join(''));

We .join and resolve the acronym array, and return the callback function with null as error and the joined acronym array.

So far we have created the package.json, index.js file. Let's create a script file, open with Sublime Text (or Atom, VIM, WebStorm) and test our index.js:

    $ touch example.js
    $ open example.js -a 'Sublime Text'
    const acronym = require('./'); // require the `index.js` file from the same directory.

    acronym('for your information', (err, resp) => {
        if (err) {

    $ node example.js
    # fyi

Working on a package and testing iteratively without having to continually rebuild or publish to npm registry has been a major concern to package authors. npm link is an handy way of linking and testing packages locally before publishing.

npm link basically links a package folder to the global node_modules directory. Package linking is a two-step process. First, you'd npm link the pacakge folder, creating a symlink in the global node_modules.


  • Replace `` with the folder where the acronym project exists previously.
  • Replace `` with an exisiting node project or create a new one for testing.

    $ cd ~//acronym
    # go to the package directory

    $ npm link
    # create a global symlink

Next, in , `npm link acronym` creates a link from the globally installed `acronym` to the **node_modules** directory of the .

    $ cd ~// 
    # go to some other package directory.

    $ npm link acronym 
    # link-install the acronym package

Now the node_modules directory should look like this:

    ├─ node_modules   
    │   ├─ acronym -> ../../.nvm/versions/node/v4.6.1/lib/node_modules/acronym      
    ├─ package.json

With npm link, requiring the local project becomes easy and we publish to npm when we are entirely ready.

We've tested the module locally, now we publish.



  • Make sure that everything in the directory is vetted, or ignored using .gitignore.
  • Make sure that there isn't already a package with the same name, if there's a an exisiting project you'll get an error has below.

As I mentioned, we'll be publishing this package to the npm registry so that it can be installed by name. Before we publish make sure your acronym directory looks like this:

    ├─ acronym   
    │   ├─ index.js
    │   ├─ example.js
    │   ├─ package.json    

As with every registry, you must have a user on npm registry. If you don't have one, create it with npm adduser or using npm site. If you've created using npm site, use npm login to store the credentials.

Use npm whoami to ensure that the credentials are stored.

    $ npm whoami
    # akinjide

Use npm publish to publish the package. You should see the package information when you visit []( Replace `` with the package name.

    $ npm publish
    # + [email protected]


If you'd like to remove your package from the npm registry, use npm unpublish to publish the package.

    $ npm unpublish
    # - [email protected]


When you make changes to your code and want to update the package you'll need to update the version of the package. Use npm version , where `` is a sematic versioning release type patch, minor or major. After updating the version number, you'll need to publish the package again, use npm publish.


Congrats! You now know how to build a node module, make it a package and publish to the npm registry. Feel free to use the code above and contributions are welcome.