Nexus Web Development Company Blog

Social Meta Tags : Powerful, Special Tags You Should Know

2015-11-02T16:29:00+00:00

You've created a compelling website and brand, why lose impact when you try to share your content?

Having your website indexed and shared on social sharing platforms can be a powerful way to increase engagement through social media channels. One thing to be aware of are the social meta tags that should exist on your content pages.

For your website to be found and indexed properly on the social media sharing platforms, including Facebook, Google+, LinkedIn, Twitter and Pinterest, it is important to have these simple meta tags in your page's header. It will help to ensure that your website is discoverable and represented properly.

Below is a Social Media Tag Template for a Blog Article page:

<!-- Update your html tag to include the itemscope and itemtype attributes. -->

<html itemscope itemtype="http://schema.org/Article">

<!-- Place this data between the <head> tags of your website -->

<title>Page Title. Maximum length 60-70 characters</title>

<meta name="description" content="Page description. No longer than 155 characters." />

<meta itemprop="name" content="The Name or Title Here">

<meta itemprop="description" content="This is the page description">

<meta itemprop="image" content="http://www.example.com/image.jpg">

<meta name="twitter:card" content="summary_large_image">

<meta name="twitter:site" content="@publisher_handle">

<meta name="twitter:title" content="Page Title">

<meta name="twitter:description" content="Page description less than 200 characters">

<meta name="twitter:creator" content="@author_handle">

<!-- Twitter summary card with large image must be at least 280x150px -->

<meta name="twitter:image:src" content="http://www.example.com/image.html">

The importance of Open Graph data

If you could choose only one type of meta data to include, Open Graph meta tags would be it, because all of the platforms can use it as a fallback, including Twitter to a large degree.

<!-- Open Graph data -->

<meta property="og:title" content="Title Here" />

<meta property="og:type" content="article" />

<meta property="og:url" content="http://www.example.com/" />

<meta property="og:image" content="http://example.com/image.jpg" />

<meta property="og:description" content="Description Here" />

<meta property="og:site_name" content="Site Name, i.e. Nexus Web Development" />

<meta property="article:published_time" content="2015-11-15T05:59:00+01:00" />

<meta property="article:modified_time" content="2015-11-16T19:08:47+01:00" />

<meta property="article:section" content="Article Section" />

<meta property="article:tag" content="Article Tag" />

<meta property="fb:admins" content="Facebook numberic ID" />

The meta tags above should be self explanatory. For the article:published_time and the article:modified_time, the content Time is expressed with an offset time from UTC (Coordinated Universal Time).

Example : 2015-11-05T08:15:30-05:00 corresponds to November 5, 2015, 8:15:30 am, US Eastern Standard Time.

Tools for Social Meta Tag Testing and Approval

A. Twitter Validation Tool

Before your cards show on Twitter, you must first have your domain approved. Fortunately, it's a super-easy process. After you implement your cards, simply enter your sample URL into the validation tool. After checking your markup, select the "Submit for Approval" button.

B. Facebook Debugger

You don't need prior approval for your meta information to show on Facebook, but their debugging tool provides a wealth of information about your meta tags and can analyze your Twitter tags as well.

C. Google Structured Data Testing Tool

Webmasters typically use the structured data testing tool to test authorship markup and preview how snippets will appear in search results, but you can also use see what other types of meta data Google is able to extract from each page.

D. Pinterest Rich Pins Validator

Like Twitter, Pinterest requires an approval process to enable Rich Pin functionality. Use the Rich Pin Validator tool to test your data markup and apply for approval at the same time.

These social meta tags can go a long way towards enhancing your site's visibility on social platforms. On WordPress sites, they can be implemented automatically by some plugins.

AngularJS 2 for TypeScript Cheat Sheet Javascript Developer Preview

2015-10-28T09:40:00+00:00

Angular for TypeScript Cheat Sheet (v2.0.0-alpha.44)

Developer Preview : Some details may change

Template syntax
`<input [value]="firstName">`	Binds property value to the result of expression firstName.
`<div [attr.role]="myAriaRole">`	Binds attribute role to the result of expression myAriaRole.
`<div [class.extra-sparkle]="isDelightful">`	Binds the presence of the css class extra-sparkle on the element to the truthiness of the expression isDelightful.
`<div [style.width.px]="mySize">`	Binds style property width to the result of expression mySize in pixels. Units are optional.
`<button (click)="readRainbow($event)">`	Calls method readRainbow when a click event is triggered on this button element (or its children) and passes in the event object.
`<div title="Hello {{ponyName}}">`	Binds a property to an interpolated string, e.g. "Hello Seabiscuit". Equivalent to: <div [title]="'Hello' + ponyName">
`<p>Hello {{ponyName}}</p>`	Binds text content to an interpolated string, e.g. "Hello Seabiscuit".
`<my-cmp [(title)]="name">`	Sets up two-way data binding. Equivalent to: <my-cmp [title]="name" (title-change)="name=$event">
`<video #movieplayer ...> <button (click)="movieplayer.play()" >`	Creates a local variable movieplayer that provides access to the video element instance in data- and event-binding expressions in the current template.
`<p *my-unless="myExpression">...</p>`	The * symbol means that the current element will be turned into an embedded template. Equivalent to: <template [my-unless]="myExpression"><p>...</p></template>
`<p>Card No.: {{cardNumber \| myCreditCardNumberFormatter}}</p>`	Transforms the current value of expression cardNumber via pipe called creditCardNumberFormatter.
`<p>Employer: {{employer?.companyName}}</p>`	The Elvis operator (?) means that the employer field is optional and if undefined, the rest of the expression should be ignored.

Built-in directives	`import {NgIf, ...} from 'angular2/angular2';`
`<section *ng-if="showSection">`	Removes or recreates a portion of the DOM tree based on the showSection expression.
`<li *ng-for="#item of list">`	Turns the li element and its contents into a template, and uses that to instantiate a view for each item in list.
`<div [ng-switch]="conditionExpression"> <template [ng-switch-when]="case1Exp">...</template> <template ng-switch-when="case2LiteralString">...</template> <template ng-switch-default>...</template> </div>`	Conditionally swaps the contents of the div by selecting one of the embedded templates based on the current value of conditionExpression.
`<div [ng-class]="{active: isActive, disabled: isDisabled}">`	Binds the presence of css classes on the element to the truthiness of the associated map values. The right-hand side expression should return {class-name: true/false} map.

Forms	`import {FORM_DIRECTIVES} from 'angular2/angular2';`
`<input [(ng-model)]="userName">`	Provides two-way data-binding, parsing and validation for form controls.

Class decorators	`import {Directive, ...} from 'angular2/angular2';`
`@Component({...}) class MyComponent() {}`	Declares that a class is a component and provides metadata about the component.
`@Pipe({...}) class MyPipe() {}`	Declares that a class is a pipe and provides metadata about the pipe.
`@Injectable() class MyService() {}`	Declares that a class has dependencies that should be injected into the constructor when the dependency injector is creating an instance of this class.

@Directive configuration (used as @Directive({ property1: value1, ... }) )
`selector: '.cool-button:not(a)'`	Specifies a css selector that identifies this directive within a template. Supported selectors include: element, [attribute], .class, and :not(). Does not support parent-child relationship selectors.
`providers: [MyService, provide(...)]`	Array of dependency injection providers for this directive and its children.

@Component configuration (@Component extends @Directive, so the @Directive configuration above applies to components as well)
`viewProviders: [MyService, provide(...)]`	Array of dependency injection providers scoped to this component's view.
`template: 'Hello {{name}}' templateUrl: 'my-component.html'`	Inline template / external template url of the component's view.
`styles: ['.primary {color: red}'] styleUrls: ['my-component.css']`	List of inline css styles / external stylesheet urls for styling component’s view.
`directives: [MyDirective, MyComponent]`	List of directives used in the the component’s template.
`pipes: [MyPipe, OtherPipe]`	List of pipes used in the component's template.

Class field decorators for directives and components	`import {Input, ...} from 'angular2/angular2';`
`@Input() myProperty;`	Declares an input property that we can update via property binding, e.g. <my-cmp [my-property]="someExpression">
`@Output() myEvent = new EventEmitter();`	Declares an output property that fires events to which we can subscribe with an event binding, e.g. <my-cmp (my-event)="doSomething()">
`@HostBinding('[class.valid]') isValid;`	Binds a host element property (e.g. css class valid) to directive/component property (e.g. isValid)
`@HostListener('click', ['$event']) onClick(e) {...}`	Subscribes to a host element event (e.g. click) with a directive/component method (e.g., onClick), optionally passing an argument ($event)
`@ContentChild(myPredicate) myChildComponent;`	Binds the first result of the component content query (myPredicate) to the myChildComponent property of the class.
`@ContentChildren(myPredicate) myChildComponents;`	Binds the results of the component content query (myPredicate) to the myChildComponents property of the class.
`@ViewChild(myPredicate) myChildComponent;`	Binds the first result of the component view query (myPredicate) to the myChildComponent property of the class. Not available for directives.
`@ViewChildren(myPredicate) myChildComponents;`	Binds the results of the component view query (myPredicate) to the myChildComponents property of the class. Not available for directives.

Directive and component change detection and lifecycle hooks (implemented as class methods)
`constructor(myService: MyService, ...) { ... }`	The class constructor is called before any other lifecycle hook. Use it to inject dependencies, but avoid any serious work here.
`onChanges(changeRecord) { ... }`	Called after every change to input properties and before processing content or child views.
`onInit() { ... }`	Called after the constructor, initializing input properties, and the first call to onChanges.
`doCheck() { ... }`	Called every time that the input properties of a component or a directive are checked. Use it to extend change detection by performing a custom check.
`afterContentInit() { ... }`	Called after onInit when the component's or directive's content has been initialized.
`afterContentChecked() { ... }`	Called after every check of the component's or directive's content.
`afterViewInit() { ... }`	Called after onContentInit when the component's view has been initialized. Applies to components only.
`afterViewChecked() { ... }`	Called after every check of the component's view. Applies to components only.
`onDestroy() { ... }`	Called once, before the instance is destroyed.

Dependency injection configuration	`import {provide} from 'angular2/angular2';`
`provide(MyService, {useClass: MyMockService})`	Sets or overrides the provider for MyService to the MyMockService class.
`provide(MyService, {useFactory: myFactory})`	Sets or overrides the provider for MyService to the myFactory factory function.
`provide(MyValue, {useValue: 41})`	Sets or overrides the provider for MyValue to the value 41.

Routing and navigation	`import {RouteConfig, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, ...} from 'angular2/router';`
`@RouteConfig([ { path: '/:myParam', component: MyComponent, as: 'MyCmp' }, { path: '/staticPath', component: ..., as: ...}, { path: '/*wildCardParam', component: ..., as: ...} ]) class MyComponent() {}`	Configures routes for the decorated component. Supports static, parameterized and wildcard routes.
`<router-outlet></router-outlet>`	Marks the location to load the component of the active route.
`<a [router-link]="[ '/MyCmp', {myParam: 'value' } ]">`	Creates a link to a different view based on a route instruction consisting of a route name and optional parameters. The route name matches the as property of a configured route. Add the '/' prefix to navigate to a root route; add the './' prefix for a child route.
`@CanActivate(() => { ... })class MyComponent() {}`	A component decorator defining a function that the router should call first to determine if it should activate this component. Should return a boolean or a promise.
`onActivate(nextInstruction, prevInstruction) { ... }`	After navigating to a component, the router calls component's onActivate method (if defined).
`canReuse(nextInstruction, prevInstruction) { ... }`	The router calls a component's canReuse method (if defined) to determine whether to reuse the instance or destroy it and create a new instance. Should return a boolean or a promise.
`onReuse(nextInstruction, prevInstruction) { ... }`	The router calls the component's onReuse method (if defined) when it re-uses a component instance.
`canDeactivate(nextInstruction, prevInstruction) { ... }`	The router calls the canDeactivate methods (if defined) of every component that would be removed after a navigation. The navigation proceeds if and only if all such methods return true or a promise that is resolved.
`onDeactivate(nextInstruction, prevInstruction) { ... }`	Called before the directive is removed as the result of a route change. May return a promise that pauses removing the directive until the promise resolves.

Source: https://angular.io/

How To Choose A Nosql Database Like A Pro

2015-10-25T11:28:00+00:00

The days of one database system for the entire enterprise, are over. Now even simple mobile applications demand more than one database. The good news is that we have entered a golden age of open-source NoSQL databases. Developers have access to great open-source database technologies with robust communities behind them.

The difficulty is knowing which NoSQL database to choose for a particular use case.

"NoSQL: a broad class of data management systems where the data is partitioned across a set of servers, where no server plays a privileged role." --Emin Gün Sirer

Types and examples of NoSQL databases based on data model, include the following:

Columnar: Accumulo, Cassandra, Druid, HBase, Vertica
Document: Clusterpoint, Apache CouchDB, Couchbase, DocumentDB, HyperDex, Lotus Notes, MarkLogic, MongoDB, OrientDB, Qizx
Key-value: CouchDB, Oracle NoSQL Database, Dynamo, FoundationDB, HyperDex, MemcacheDB, Redis, Riak, FairCom c-treeACE, Aerospike, OrientDB, MUMPS
Graph: Allegro,Neo4J, InfiniteGraph, OrientDB, Virtuoso, Stardog Multi-model:OrientDB, FoundationDB, ArangoDB, Alchemy Database, CortexDB

Some common characteristics of NoSQL databases:

Not using the relational model (nor the SQL language)
Open source
Designed to run on large clusters
Based on the needs of 21st century web properties
No schema, allowing fields to be added to any record without controls

According to the Forum for Innovation, 90% of the world's data was created in the last 2 years.

NoSQL databases are increasingly being used in big data and real-time web applications. NoSQL databases provide a mechanism for storage and retrieval of data that is modeled in different ways than the tabular relations used in relational databases. Such databases have existed since the late 1960s, but did not obtain the "NoSQL" moniker until the surge of popularity in the early twenty-first century, triggered by the needs of modern Web companies like Twitter, Facebook, Google and Amazon.com.

Motivations for this non-relational approach include: the requirement to store and access much larger volumes of data quicker, simpler "horizontal" scaling to clusters of machines, which is a problem for relational databases, the ability to store schema-less data and more granular control over availability.

Although Big Data has been the primary driver for NoSQL’s rise, it is not the only reason to use NoSQL databases. Many NoSQL databases are designed to run well on large clusters, which makes them more attractive for large data volumes. But often people select NoSQL to benefit from better performance, easier interactions with their applications and the ability to use schema-less data.

Big Data has been defined by the four “V”s: Volume, Velocity, Variety, and Value. These become a reasonable test to determine whether you should add NoSQL capabilities to your information architecture.

Volume. While volume indicates more data, it is the granular nature of the data that is unique. Big Data requires processing high volumes of low-density data, that is, data of unknown value, such as Twitter data feeds, clicks on a web page and network traffic.

Value. Data has intrinsic value, but it must be discovered. There are a range of quantitative and investigative techniques to derive value from data, from discovering consumer preferences or sentiment, to making relevant offers by location, or for identifying a piece of equipment that is about to fail.

Velocity. A fast rate that data is received and perhaps acted upon. The highest velocity data normally streams directly into memory versus being written to disk.
As an example, eCommerce applications seek to combine mobile device location and personal preferences to make time sensitive offers. Operationally, mobile application experiences have large user populations, increased network traffic, and the expectation for immediate response.

Variety. New unstructured and semi-structured data types, such as text, audio, and video require additional processing to derive meaning from the content and the supporting metadata. Frequent or real-time schema changes are an enormous burden for both transactional and analytical environments.

The data structures used by NoSQL databases (e.g. document key-value or graph) differ from those used by default in relational databases, making some operations much faster using a NoSQL database. The particular suitability of a given NoSQL database depends on the the type data to be stored, how it will be accessed and whether ACID (Atomicity, Consistency, Isolation, Durability) or joins are required. The data structures used by NoSQL databases are considered to be "more flexible" than relational database tables.

Many NoSQL stores sacrifice consistency, in the sense of the CAP(Consistency,Availability,Partition tolerance) theorem, in favor of availability, partition tolerance, and speed. Most NoSQL stores lack true ACID transactions, although a few recent systems including ArangoDB, CouchDB and OrientDB have made them central to their designs. Instead they provide the concept of "eventual consistency" in which database changes are propagated to all nodes "eventually" (typically within milliseconds), so queries for data might not return updated data immediately.

CAP Theorem

Consistency (all nodes see the same data at the same time)
Availability (a guarantee that every request receives a response about whether it succeeded or failed)
Partition tolerance (the system continues to operate despite arbitrary partitioning due to network failures)

ACID

Atomicity: all or nothing (of the n actions): commit or rollback
Consistency: transactions never observe or cause inconsistent data
Isolation: transactions are not aware of concurrent transactions
Durability: acknowledged transactions persist in all events

ACID is a set of properties that guarantee that database transactions are processed reliably. In the context of databases, a single logical operation on the data is called a transaction. For example, a transfer of funds from one bank account to another, even involving multiple changes such as crediting one account and debiting another, is a single transaction.
The degree to which the capability is fully supported in a manner similar to most SQL databases or the degree to which it meets the needs of a specific application varies.

Not all NoSQL systems live up to the promise of "eventual consistency" and partition tolerance, in experiments with network partitioning, some NoSQL databases exhibited lost writes and other forms of data loss. Fortunately, some NoSQL systems do provide concepts such as Write-ahead logging to avoid data loss.

Handling Relational Data in a NoSQL Database

Because most NoSQL databases lack the ability for JOIN queries, the data and access methods generally need to be designed differently. The three main techniques for handling relational data in a NoSQL database without JOIN support are as follows:

Caching/replication/non-normalized data Instead of only storing foreign keys, it's common to store actual foreign values along with the model's data. For example, each blog comment might include the username in addition to a user id, thus providing easy access to the username without requiring another lookup. When a username changes however, this will now need to be changed in many places in the database. Thus this approach works better when reads are much more common than writes.

Nesting data With document databases like MongoDB, it's common to put more data in a smaller number of collections. For example in a blogging application, one might choose to store comments within the blog post document so that with a single retrieval one gets all the comments. In this approach a single document contains all the data you need for a specific task.

Multiple queries Instead of retrieving all of the data with one query, it's common to do several queries in order to get all of the desired data. NoSQL queries are often much faster than relational database queries, so the cost of having to do additional queries may be acceptable. If an excessive number of queries would be necessary, one of the other two approaches would be more appropriate.

There are several more aspects to consider when choosing a NoSQL database, such as durability, availability, consistency, scalability, and security. Your particular use case will determine whether ad hoc queryability is important or if mapreduce will suffice.

Often the best approach is to use multiple databases, with specific applications using the particular database that is most appropriate for the type of data, performance and acccess requirements.
Virtual machine hosts and “the cloud” are becoming so cheap and easy these days as to become largely trivial problems driven as much by preference as necessity. In order to scale your organization's applications in this age, choosing the right database or databases for a particular task will more than likely alleviate your true bottleneck.

For more information about choosing and implementing the ideal database systems for your particular use case, Get in touch.

References:
https://en.wikipedia.org/wiki/NoSQL
http://nosql-database.org/

Node.js : The Most Important Tool in Your Toolbox: Here's Why

2015-10-17T20:36:00+00:00

Node.js enables you to build fast, scalable web applications capable of handling a huge number of simultaneous connections with high throughput.

The Node.js infographic below shows some of the many reasons why Node.js could be the most important tool in your web development toolbox. (Click for full size image)

MongoDB : Simple Database Solution For Kick-Ass Performance

2015-10-13T08:24:00+00:00

MongoDB : A simple database solution for kick-ass performance.

MongoDB is a powerful, flexible, high performance document-orientated database that provides high availability and automatic scaling with features such as secondary and geospatial indexes, range queries, sorting and aggregation.

Tens of thousands of organizations, including Adobe, Bosch, Carfax, Craigslist, Ebay, Forbes, and McAfee use MongoDB to build high-performance systems at scale. Over a third of the Fortune 100 and many of the most successful and innovative web companies rely on MongoDB to effectively handle their constantly growing data requirements.

MongoDB was developed in order to address the rapid rise in the amount of data stored, the frequency in which this data is accessed, and the performance and processing needs of modern web applications. Relational databases in contrast, were not designed to cope with the scale, performance and agility challenges that face modern web applications today.

High Performance Database

Extraordinary performance was a primary design goal for MongoDB, almost every aspect of MongoDB was designed to provide high performance data access.

Although MongoDB is very powerful and replaces many features of relational databases systems, it is not intended to do everything that a relational database does. When possible, the MongoDB enables processing to be done by the drivers or by the application itself. Maintaining this streamlined design is one of the reasons MongoDB can achieve such high performance.

In addition to support for embedded data models which reduces I/O activity on the database system, and indexes support for faster queries that can include keys from embedded documents and arrays, MongoDB makes extensive use of RAM to speed up database operations. Reading data from memory is measured in nanoseconds, whereas reading data from hard drives is measured in milliseconds; reading from memory is approximately 100,000 times faster than reading data from disk.

Data Compression

The WiredTiger storage engine used by MongoDB supports native compression, reducing physical storage footprint by as much as 80%. In addition to reduced storage space, compression enables much higher storage I/O scalability as fewer bits are read from disk.

MongoDB is ideal for:

Large volumes of structured, semi-structured, and unstructured data.
Object-oriented programming that is easy to use and flexible.
Creating efficient, scalable systems instead of expensive, monolithic ones.

Dynamic Schemas

Data in MongoDB has a flexible schema. Unlike SQL databases, where you must first determine and declare a table’s schema before inserting data, MongoDB uses structures known as documents which are paired with key values. Documents can contain many different key-value pairs, key-array pairs, or even nested documents. This document based approach enables the insertion of data without a predefined schema, which makes it easy to make significant changes to the application in real-time, without worrying about down time or service interruptions. You can change the structure of documents simply by adding new fields or deleting existing ones. Documents in a collection do not need to have an identical set of fields.

By enabling embedded documents and arrays, it is possible to represent complex hierarchical relationships within a single record. This fits naturally into the way developers using modern object-oriented languages think about their data.

Data within MongoDB is stored in Binary JSON (BSON)format, which is a binary extension of the JavaScript Object Notation (JSON) format. JSON is an open, human and machine-readable standard that facilitates easy, accurate data interchange, and is the main format for data exchange in modern web applications. JSON supports all of the basic data types, including numbers, strings, and boolean values, as well as arrays and hashes.

Because of the use of the JSON data format, query results can be easily parsed, with little or no transformation by the application with most popular programming languages.

MongoDB Scales Easily by Auto-Sharding

As the amount and type of data that organizations need to store grows and changes, the choice of how should you scale your databases arises. Scaling a database comes down to the choice between vertical scaling (getting a bigger machine) or sharding (partitioning data across more machines).

Because of the way they are structured, relational databases usually scale vertically. Vertical scaling requires more CPU and storage resources to increase capacity. Scaling by adding hardware to a single machine has physical limitations. As a result there is a practical maximum capability for vertical scaling.

Sharding, or horizontal scaling, by contrast, divides the data set and distributes the data over multiple servers, or shards. Each shard is an independent database, and collectively, the shards make up a single logical database.

MongoDB was designed to scale out. Its document-oriented data model makes it easier for it to split up data across multiple servers. MongoDB automatically takes care of balancing data and load across a cluster, redistributing documents automatically and routing user requests to the correct machines. This allows developers to focus on programming the application, not scaling it. When a cluster needs more capacity, new machines can be easily added and MongoDB will figure out how the existing data should be distributed to them.

MongoDB or any NOSQL database is not for every use case, but if your data can be arranged in such a way as to benefit from the document based data model then your system can benefit greatly from increased performance and scalability.

Contact us to learn more about developing a high performance database solution for your business.

Why Node.js Is More Important Than You Think

2015-10-10T16:27:00+00:00

Node.js is an open-source, cross-platform JavaScript runtime environment for developing server-side web applications, that uses the V8 engine developed by Google for use in Chrome. Node.js applications are written in JavaScript and can be run within the Node.js runtime on OS X, Microsoft Windows and Linux. The V8 engine compiles JavaScript into native machine code which executes at lightning speeds.

High Performance Web Development

Node.js enables you to build fast, scalable web applications capable of handling a huge number of simultaneous connections with high throughput.

Node.js provides an event-driven architecture and a non-blocking I/O API designed to optimize an application's throughput and scalability for real-time web applications.

Event loop

In addition to lightning fast JavaScript execution, the real magic behind Node.js is the event loop. The event loop is a single thread that performs all I/O operations asynchronously. Traditionally, I/O operations either run synchronously (blocking) or asynchronously by spawning off parallel threads to perform the work. This old approach consumes lots of memory and can be the source of performance issues. In contrast, when a Node application needs to perform an I/O operation, it sends an asynchronous task to the event loop, along with a callback function, and then continues to execute the rest of its program. When the async operation completes, the event loop returns to the task to execute its callback.

Node.js registers itself with the operating system so that it is notified when a connection is made, and the operating system will issue a callback. Within the Node.js runtime, each connection is a small heap allocation. Traditionally, relatively heavyweight OS processes or threads handled each connection. Node.js uses the event loop for scalability, instead of processes or threads. In contrast to other event-driven servers, Node.js's event loop does not need to be called explicitly. Instead callbacks are defined, and the server automatically enters the event loop at the end of the callback definition. Node.js exits the event loop when there are no further callbacks to be performed.

Asynchronous I/O

By performing all I/O intensive operations asynchronously, Node.js is able to scale to large volumes of clients. Node.js is built to handle asynchronous I/O from the ground up and is a good match for handling a lot of common web and network development tasks.

Node.js can read/write streams to websockets just as well as it can read/write streams to HTTP. For example, we can pipe stdout from a running process on the server to a browser over a websocket, and have the webpage display the output in real-time.

In other words, reading and writing to network connections, reading/writing to the filesystem, and reading /writing to the database, all very common tasks in web applications, execute very, very fast in Node.

Node.js is used by many large companies including Ebay, IBM, Microsoft, Yahoo!, Walmart, Groupon, SAP, LinkedIn, PayPal and GoDaddy.

PayPal reported: By using Node for their account overview page, one of the most trafficked apps on the website, they were able to double the number of requests per-second and reduced response time by 35%.

Walmart is able to serve some very sophisticated features to mobile users by using Node.js.

In 2013 WalMart Labs put all of their Mobile traffic through Node.js on black-friday, the busiest shopping period of the year. The team at WalMart Labs tweeted against #nodebf tag showing the performance of the Node.js application. On Black Friday the WalMart servers didn’t go over 1% CPU utilisation and the team did a deploy with 200,000,000 users online.

Because of the modular nature of Node, developing new services with Node.js is easy. Writing applications the Node-way means that applications are composed of small modules, which are piped together. This enables changes to be made to a module or new functionality to be added without requiring changes to be made deep inside the entire code-base. Over time traditional monolithic applications become rigid and difficult to adapt as new requirements are added. Eventually traditional applications begin to creak under the weight and the stress put on them by the requirements they were not designed for.

The package manager for Node.js is npm and it works very well. In many ways it resembles package managers from other ecosystems, but npm is fast, robust, and consistent. It does a great job specifying and installing project dependencies. It keeps packages isolated from other projects, avoiding version conflicts. But it also handles global installs of shell commands and platform-dependent binaries.

Creating an HTTP Server is trivial with Node.js

Node.js contains a built-in library to allow applications to act as a web server without software such as Apache HTTP Server, Nginx or IIS.

In contrast to other web development languages, we do not need to set up a seperate HTTP web server. With Node.js, when the application is implemented, the whole HTTP server is part of the implementation.

Below is the code for creating a basic Node.js HTTP server. In the root directory of your application, create a file named server.js and fill it with the code below:

var http = require("http");

var server = http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/html"});

response.write("<!DOCTYPE html>");

response.write("<html>");

response.write("<head>");

response.write("<title>Hello World Page</title>");

response.write("</head>");

response.write("<body>");

response.write("<h1>Hello World!</h1>");

response.write("</body>");

response.write("</html>");

response.end();

});

server.listen(9000);

console.log("Server is listening");

In a terminal window cd to the root directory of the application, to run the server.js script with Node.js type the command: node server.js

Now open your favorite browser and hit http://localhost:9000/. This should display a web page that says “Hello World!”.

Well now, lets see what’s actually going on here.

The first line requires the http module that ships with Node.js and makes it accessible through the variable http.

You defined the requestHandler function to handle the requests.

You called one of the functions that http module offers: createServer. This function returns an object, which is stored in var server.

This(server) object has a method named listen, and takes a numeric value which indicates the port number our HTTP server is going to listen on.

Whenever a request received, requestHandler function gets triggered and two parameters are passed into it, request and response.

You write the page header with response.writeHead(), which sends an HTTP status and content-type in the HTTP response header.

You send the HTML and H1 wrapped text “Hello World" in the HTTP response body with response.write() .

You finish the response with response.end().

Contact us to learn more about getting a high performance Node.js application built for your website.

How to Explain Polymorphism to your Mom

2015-10-08T11:39:00+00:00

Polymorphism provides one of the most powerful programming techniques of the object-oriented paradigm.

Generally speaking, polymorphism is the ability to appear in many forms. The word polymorphism is derived from two Greek words poly which means many and morphos which means forms. Thus, polymorphism is defined as one thing in many forms. Polymorphism is the ability of an object to take on many forms. In software development, it is the ability to treat an object of any subclass of a base class as if it were an object of the base class. A base class has, therefore, many forms: the base class itself, and any of its subclasses.

When applied to object oriented programming languages like Java, it describes a language’s ability to process objects of various types and classes through a single, uniform interface.

Polymorphism is considered to be a requirement of any true object-oriented programming language (OOPL).

Polymorphism includes the ability to define multiple classes with functionally different, yet identically named methods or properties that can be used interchangeably by client code at run time.

More specifically, polymorphism is the ability to redefine methods for derived classes. For example, given a base class Animal, polymorphism enables the programmer to define different kinds of Animal methods for any number of derived classes, such as sounds they make, food they eat, what they do. No matter what kind of Animal an object is, applying the Sound method to it will return the correct results.

Runtime polymorphism is essentially referred to as method overriding. Method overriding is when you implement inheritance in your program.

An important example of polymorphism is how a parent class refers to a child class object. In fact, any object that satisfies more than one IS-A relationship is polymorphic in nature.

In Java, all Java objects are polymorphic, since any object will pass the IS-A test for their own type and for the class Object.

As a simple real world example: An application can have Animal class, and its specialized sub classes like Cat and Dog. These subclasses will override the default behavior provided by Animal class + some of its own specific behavior.

For instance, lets consider a class named Animal and let Dog be a subclass of Animal. So, any dog "IS A" Animal. Here, Dog satisfies the IS-A relationship for its own type as well as its super class Animal.

In the following example we make cats and dogs subtypes of animals. The procedure letsHear() accepts an animal, but will also work correctly if a subtype is passed to it:

abstract class Animal {

abstract String talk();

}

class Cat extends Animal {

String talk() {

return "Meow!";

}

class Dog extends Animal {

String talk() {

return "Woof!";

}

void letsHear(Animal a) {

println(a.talk());

}

void main() {

letsHear(new Cat());

letsHear(new Dog());

}

The underlying mechanism that makes polymorphism possible is dynamic binding.

To see how to use polymorphism in a Java program, consider the family of types. To use an object of type Animal, you must create an Animal object with new and store the returned reference in a variable:

Animal myFavoritePet = new Animal();

The myFavoritePet variable holds a reference to an Animal object. This is a sensible arrangement; however, there is another possibility brought to you courtesy of polymorphism. Because of polymorphism, you can assign a reference to any object that "is a" Animal to a variable of type Animal.

Animal myFavoritePet = new Dog();

// or...

Animal myFavoritePet = new Cat();

Therefore, you can sprinkle some polymorphism into your Java program simply by using a variable with a base type to hold a reference to an object of a derived type.

To get the full benefit of polymorphism in your programs, however, you'll need to go further. To fully realize the wonders of polymorphism, you must send a message to an object without knowing the actual class of the object. To do this in Java, you just invoke a method defined in a base type on an object referenced by a variable of the base type.

Top 9 Practical Benefits of Java Web Applications

2015-10-07T23:11:00+00:00

Java is a concurrent, class-based, object-oriented general-purpose computer programming language that was specifically designed to have as few implementation dependencies as possible. The development of Java was initiated by James Gosling, Mike Sheridan, and Patrick Naughton at Sun Microsystems in 1991. Java was one of the first programming languages which was not dependent on any particular hardware or operating system. Applications developed in Java can be executed anywhere and on any system or device by utilizing the JVM (Java Virtual Machine).

The Top 9 Practical Benefits of Java Applications are as follows:

1. Compiled and Interpreted

Basically computer software languages are either compiled or interpreted. Java combines both of these approaches thus making Java a two-stage system.

The Java compiler translates Java code to Bytecode instructions and the Java Interpreter generates machine code that can be directly executed by machine that is running the Java application.

2. Platform Independent and portable

One of the primary features of Java applications is portability. Java applications can be easily moved from one computer system to another, regardless of the hardware or software configuration of the host system. Changes and upgrades in operating systems, processors and system resources will not require modifications to Java applications. This is one reason why Java has become such a popular language for developing Internet applications, the environment which interconnects many different types of systems worldwide. Java enables portability in two ways. The first of which is, the Java compiler generates the bytecode that can be executed on any machine. The other is the size of primitive data types are machine independent.

3. Object- oriented

Java is truly an object-oriented language. In Java, almost everything is an object. All program code and data exist in objects and classes. Java comes with an extensive set of classes; organized in packages that can be used in applications by inheritance. The object model in Java is trouble-free and easy to extend.

4. Robust and secure

Java is a strong, stable language which provides many securities mechanisms in order to ensure reliable code. It is designed with garbage collection, which helps Java programmers handle memory management issues. Java also includes the concept of exception handling, which catches serious errors and significantly reduces the threat of crashing the system.

Security is an important feature of Java and this is one of the reasons it is so well suited for developing applications on the Internet.

The absence of pointers in Java ensures that parts of an application cannot access a memory location without proper approval.

5. Distributed

As the first language designed from the bottom up with networking in mind, Java makes it very easy for computers to cooperate. Java is known as as distributed language for creating applications on networks which can contribute both data and application functionality. Java applications can open and access remote objects on the Internet easily. This means that application resources can be distributed among other systems and multiple programmers at multiple remote locations can work together on a single task.

6. Simple and small

Java is very small and simple language. Designed with simplicity in mind, Java does not use pointers and header files, goto statements, etc. It eliminates operator overloading and multiple inheritance.

7. Multi-threaded and Interactive

Multi threaded is the ability of a CPU(central processing unit) or a single core in a multi-core processor to execute multiple processes or threads concurrently, managing multiple tasks simultaneously. Java intrinsically supports multi-threaded applications. This means we need not wait for the application to complete one task before starting another task. On systems that support it, this feature can greatly enhance the performance of many applications.

8. High performance

By utilizing Just-In-Time compilation, adaptive optimization, garbage collection and multi-threading, a Java application's performance can be extraordinary. Java architecture is also designed to reduce overheads during runtime.

9. Dynamic and Extensible

Java is a dynamic language capable of dynamically linking in new classes, libraries, methods and objects. Java is polymorphic, which means it a parent class reference can be used to refer to a child class object.

Java applications support functions written in other languages such as C and C++, known as native methods.

Please contact us to learn more about developing a powerful, high performance Java web application for your website.

How to Boost Your Sales with an Ideal Client Profile

2015-10-01T22:38:00+00:00

How to Boost Your sales with an Ideal Client Profile

Once you have defined your ideal client profile(s), you'll be able fine tune your marketing activities in a more effective and relevant way.

Content Creation & Mapping

When you know your ideal client profiles, you will be able to create content that will engage these particular prospects and clients in a favorable way-- Via blog and social media posts, newsletters, ebooks, or sales enablement tools.

You can then position your content by ideal client profile and lifecycle stage or where in the buying stage the prospect is. You'll want to create and package content differently depending on if the potential client is simply getting to know your agency, has been in contact with your business development team, or has a proposal sitting on their desk.

Personalization

If you specialize in different market segments or industries, you can personalize your content based on client profiles by customizing your landing pages and sections of your website to that group’s specific needs.

A Venture Beat report found that 70% to 94% of marketers have experienced an increase in key site performance indicators such as conversion by employing personalization.

Segmentation

Personalized marketing improves click-through rates by as much as 14% and conversions by 10%, and it drives 18 times more revenue than non-personalized content. With well defined client profiles, you can segment your list and create campaigns that align with their particular buying process. You can also segment these lists by prospects and current clients, so you can market either new services or additional service lines. You could also create drip email campaigns based on whether you have only had an initial meeting with the client or if the client has already been sent a proposal.

Optimized Keywords

Once you understand the language of your ideal clients and the specific words that they are using when searching, you can create highly targeted and optimized articles that will show up in the first results on search engines and found by your prospects during their search process. Not only will this bring you more traffic, but it will be targeted traffic of a much higher quality.

Sales Process

By understanding where your ideal client is in the sales process, how they make decisions, what sources they use for recommendations, how they find a vendor partner, and the average sales cycle for each type, you can craft your sales process to your prospect's persona. This will help you to better understand when sending a proposal is appropriate, what type of nurturing campaigns you should set up, what information the prospect needs to help them make the right choice and how often you should communicate with the potential client.

Please contact us to learn more about creating up a killer content marketing strategy for your business.

What You Should Know About Using WordPress

2015-09-20T12:34:00+00:00

What you should know about using WordPress

WordPress is used by many people and is generally easy to use, however we hear complaints about WordPress from clients everyday.

Some of the issues:

Vulnerability:
Most WordPress users don't realize just how vulnerable WordPress actually is. Every day of the week there are hackers trying to get access to your website. Yes, every day! If they do get access to your website you might wake up one morning to find that your website has been replaced with another one or used to distribute malicious code to unsuspecting visitors, which could do significant damage to your brand and customer's trust.

Performance:
The speed of your website is incredibly important: it is one of the factors that Google considers when ranking your site but, more significantly, if your website is slow your visitors won't come back.

This problem is now worse than ever before, because of the number of people browsing your website on a mobile device.

Updates and plug-ins:
When logged in as WordPress admin, you will constantly be reminded to update your plug-ins, your framework, your theme and WordPress itself. Most people proceed with the installation without a thought, then oops, your header image is broken, your website is blank, or your website looks different than you expected, requiring extra work.

Maybe it is due to the “duct tape,” DIY nature of PHP coding but the WordPress plug-ins repository is a labyrinth of discontinued versions and half-patched improvements.
Then, you have to go through the hassle of trying to figure out which add-ons are either incompatible with your theme, or incompatible with other plug-ins.
Finally, even if you manage to fill all of the holes in the functionality that you are after, eventually you realize that the more plug-ins you add, the more you site is going to slow to a disgusting crawl.

The Solution:

Why use WordPress or any other CMS for that matter? If you can grasp MarkDown (https://en.wikipedia.org/wiki/Markdown), which is very easy to learn, you can by pass all of the issues related to WordPress, like performance, security, updates, poorly written plug-ins or hosting expense and have complete control of your website's layout by using one of the many free static site generators like Jekyll, Hugo or Middleman. Writing in MarkDown can be hugely productive for writers or anyone who would like to create content and have the best performance possible.

We have many WordPress sites of our own that we have converted to static sites. Just tired of dealing with the lack of performance, constant updates, having to work around WordPress's platform and people trying to hack into the sites.

We are programmers and have on many occasions rewritten WordPress to work the way we would like, it is just, I think, counter-productive to have a web application generate what should be static content.

Many programmers and others are switching to static based sites for the reasons mentioned among others. There is even a WordPress plug-in for exporting your content into Jekyll's format. There are many free high quality templates that can be used for static sites and modifying them is easy.
http://jekyllthemes.org/ are a few of the many free themes. Actually, just about any theme, WordPress or other can easily be made into a static site template.

A static site can be zipped up and hosted anywhere, no database connection or PHP necessary. Also you can work on your site locally without even being connected to the Internet and upload you pages when you are ready.

Please contact us to get help started with your own static site.