4 Easy Ways to Use Instagram for Business Growth

Instagram is not only the photo-sharing app; it is much more than that. Its users include celebrities, brands, athletes, bloggers, and fans, etc. Meaning thereby, people are using this space for almost every possible reason. One of the most important uses of Instagram is to promote and growth of...

[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]

by Web Desk via Digital Information World

Overview of Wearable Development Platforms

Technology is rapidly changing, and today's latest device becomes completely outdated in a flash. In such a dynamic and emerging tech environment, developers might get somewhat confused. We all want to find the best avenues to channel our learning and development efforts.

Many technologists believe that the golden age of smartphones is nearing its end. A whole new batch of hi-tech wearable devices are about to replace smartphones in the near future. What would these technologies and devices look like? Wearables can range in size from watches through to smart glasses and smart rings. Every day, they are becoming smaller in size and are boosting their performance too.

These devices have already started to redefine user interaction patterns, user behaviour, and sometimes even the user's lifestyle. In this article, you'll learn about the latest emerging wearable device platforms for which you could develop apps.

1. Smartwatches

Although smartwatches are the obvious next step, it took a while for them to challenge the dominant position of smartphones. That was mainly due to interaction problems associated with the small screen size and poor battery life. 

Most smartwatches started out as a "companion" to a smartphone. However, things are changing really fast. Several standalone smartwatches that don't need to pair with a smartphone are available now. The latest innovations have enhanced and refined the user interaction and user experience to a great extent.

If you want to develop for a smartwatch platform, you might consider one of the following.

1.1 Android Wear

Android Wear is one of the leading smartwatch platforms. Its latest version, Android Wear 2.0, has eliminated many problems of the previous versions and comes with some really cool features. The smartwatches powered by this platform can now function as standalone devices, meaning that they don't have to rely on a smartphone anymore. The UI has become more refined, more readable, and easier to navigate than ever before. It also features a full QWERTY keyboard so that the user can type on the device itself. The coolest thing is that it can directly access the Google Play store, without relying on a smartphone for the connection. 

So it's clear that Android Wear offers great opportunities for developers to explore. You could start developing either watch faces or other Android Wear apps. You are free to experiment with a broad range of supported sensors, including Bluetooth, WiFi, LTE, GPS, NFC, and the heart rate sensor. Android Wear 2.0 now even supports third-party input methods. So if you've been thinking of developing an innovative soft keyboard for the watch, this may be the time for it.

1.2 Apple Watch

Apple Watch's latest model, Series 3, has two variants. Only one has the optional LTE cellular connectivity, but both are equipped with onboard GPS. While one of them permits a standalone mode, both are optimized to be used together with a smartphone. You could come up with some weird and innovative app ideas to make use of the built-in GPS, LTE connectivity, altimeter and Siri, the voice assistant. 

Apple has also recently released watchOS 4, the latest version of its wearable OS. They have also fixed some bugs and issues, especially related to LTE connectivity. You don't have to worry much about linking it to the external world and can focus more on your app development business.

1.3 Samsung Gear S Series

While Tizen isn't as popular as Android or iOS among smartphone users, it's really a big name in the smartwatch sector. The Samsung Gear smartwatch, powered by Tizen OS, has the second largest market share in this sector. 

You should take into account the unique features of the watch when you're developing apps. These features include speech to text, GPS, in-app purchases, and a special UI element called Widget that provides easy access to frequently used tasks. The latest version is the Gear S3, and that too can be used as a standalone device. You just need to use Tizen Studio to make your app idea a reality.

2. Fitness & Activity Trackers

Some of the tech vendors have created wearables that cater to the specific needs of certain niches, rather than trying to build miniature smartphones. One such niche market consists of athletes, sportspeople, and outdoor adventure lovers. 

Wearables catering to this sector don't try to replace their users' smartphones. Instead, they're more likely to replace their regular wristwatches. These devices provide more accurate feedback on the users' sports activities. Most of them have stripped down versions of OS and hardware features, so that they can focus on their specialized job. That has enabled them to dramatically improve their battery life too.

2.1 Fitbit

Fitbit is an activity tracker that doubles as a watch. It pairs with a smartphone to provide comprehensive reports of the user's workout performance. Users can set daily goals, such as the number of calories to burn, and then view their progress towards them over a period of time. Developing apps for the Fitbit is a breeze if you are experienced in JavaScript, CSS, and SVG. Fitbit OS is a clever piece of software that makes this fitness tracker really exciting and easy to use.

You could use Fitbit Studio, the official IDE for the Fitbit OS, to develop apps and clock faces. If you want to distribute your apps, you could do that too, by uploading them to the App Gallery.

2.2 Garmin

Garmin has a series of wearables aimed at athletes, workout addicts, and outdoor adventure lovers. Almost all of their devices come ready with GPS, heart rate monitor, and dozens of useful sensors and features.

You can use Garmin's Connect IQ SDK and select from a number of APIs such as Health API, Connect API and various others to develop apps. The developer website is full of additional tools and resources such as GIS software, digital map datasets, and a lot more.

2.3 Samsung Gear Fit

While Gear S is a full-featured smartwatch, Gear Fit is more inclined towards the fitness tracker market. You could use the same tools that you used for the Gear S, but the only thing is that you need to be aware of this one's unique role as a fitness tracker.

3. Smart Glasses

Smart glasses offer a unique experience that's completely different from all the hand-worn wearables. They don't isolate the user as much from the real world as VR headsets do, but rather mix with reality. They normally do this by adding a layer of information on top of the user's view of the real world.

These smart glasses can be used in a variety of situations ranging from general consumer apps to highly technical and industrial tasks. One great example is for equipment repairs. The technician could see the actual equipment through the smart glasses, and an AR app would provide more assistance by identifying all the parts the technician touches and displaying information about them in an overlay.

3.1 Epson Moverio

Epson was a pioneer in this sector, and its latest Moverio models include Moverio BT-300, BT-350, and BT-2000 Pro versions. Although they don't support cellular data connectivity, you can use the built-in Wi-Fi or Bluetooth to connect them to any supported device.

Epson's smart glasses use Android OS and are packed with a number of sensors such as GPS, geomagnetic sensor, accelerometer, gyroscope, and illumination sensor. Now you too can become an AR app publisher, by registering on their developer website and using the Moverio SDK plus the optimized tools to create apps.

3.2 Daqri

Unlike Epson, which is more inclined towards consumers, Daqri focuses on enterprise clients. Its smart glasses and smart helmet are useful in a number of industrial and medical applications. The platform can provide real-time data visualization, job instructions, and remote expert assistance. You can download its SDK as an extension for Unity, and immediately start coding.

3.3 Sony SmartEyeglass

Sony SmartEyeglass is primarily aimed at developers who want to experiment with the latest AR apps. It has an embedded camera, microphone, accelerometer, gyroscope, compass, and brightness sensors. A layer of monochrome green text appears on its binocular see-through lenses, providing the user with information. 

These glasses need to be paired with a smartphone to function. Sony has also released an SDK, enabling developers to experiment with some cool app ideas.

3.4 Vuzix

Vuzix has a range of wearable products including smart glasses, smart sunglasses, and video headphones. They can cater to both consumers and professionals alike, and can cover a vast array of applications such as industrial, medical, retail, remote help desk, and a lot more. Be sure to register on the developer website and start developing after downloading the SDK.

4. VR Headsets

While VR headsets might make the wearer look ridiculous to others, they offer a truly immersive user experience that no other wearable can provide. Currently, the most promising applications are entertainment apps such as games, but there are many areas that could be explored. 

One such area is training simulations. Employers might make use of VR headsets and simulated virtual tasks to be accomplished by trainees. This helps reduce cost and get effective feedback on performance too. Immersive educational content is also sure to become a killer app.

Current VR headsets are packed with tons of sensors related to spatial, magnetic, optical and thermal data of the user's environment. They are capable of presenting the wearer with a real-world view, virtual-world view, or a combination of both. This makes them really powerful devices that can have a great impact on everyone.

Here are some of the most popular VR headset platforms.

4.1 HTC Vive

HTC's Vive VR headset comes with a complete set of accessories that help create realistic VR spaces called play areas. Users need to set up their headsets together with the accessories and define the play areas before using them. If you want to publish VR apps, just register as a developer on Vive's app store, Viveport, and start building new worlds using the Viveport SDK. The SDK supports several OS and game engine platforms, so you can choose the version that fits you best. You can publish your VR games on the popular SteamVR app store too.

4.2 Oculus Rift

Another leading platform in the VR space, Oculus offers a great VR experience and user interaction. Its SDK is also available in several packages, including the Platform SDK and utilities for Unity game engine. The popular game engine Unreal also offers built-in support for developing Oculus apps. 

4.3 Samsung Gear VR

Samsung Gear VR is not a standalone VR headset, but just a device holder for compatible smartphones that provide a VR experience. Samsung has produced it in collaboration with Oculus, and it supports Samsung's flagship handsets. The headset device acts as the controller, providing the optics as well as head tracking mechanisms, etc. It connects to the smartphone via USB and must be calibrated before use. Although setting up the development environment can be somewhat time-consuming, it's worth it to become a developer for one of the latest tech platforms available today.

4.4 Google Daydream View

Daydream View is also similar to Gear VR, but this one's clad in fabric and weighs much less than Samsung's device. Google has recently started collaborating with Lenovo on building a standalone VR headset, but that's yet to arrive. For the meantime, Google offers four SDKs for developers so that they can choose Android, Unity, Unreal, or iOS as their main development platform.

4.5 Sony PlayStation VR

Sony's VR headset also competes head to head with other popular platforms such as Oculus, but becoming a developer is relatively difficult. You need to be physically located in certain select countries, have a static IP address to access developer support, and submit your employer's tax ID number. This means that only corporate developers are allowed.

4.6 Windows Mixed Reality

While most of the other VR headsets rely on external sensors for motion tracking, Windows Mixed Reality headsets have all the sensors built in. So there's no need to set up spaces such as play areas (as in the case of HTC Vive), but this means the tracking capabilities are relatively limited. 

There are several vendors that manufacture Windows Mixed Reality headsets. Lenovo, HP, Samsung, Acer, and Dell are among them. There are tons of articles and other resources on the Microsoft HoloLens developer website to help you get up and running.

4.7 Google Cardboard

This the most low-tech item in an ultra hi-tech list: Google's attempt to bring the VR experience to the masses at a very low cost. The Google Cardboard device is actually made of cardboard, and holds a smartphone and plastic lenses to provide a VR experience. Google has also published a complete manufacturer kit so that developers can start building everything from scratch. The only thing that they need to buy is a smartphone and the lenses.

5. Smart Rings

Smart rings are perhaps the next evolution of smartwatches. As wearables become smaller and smaller, interacting with them poses a real challenge for developers. However, with the help of some unconventional interaction methods, such as gesture control, these can be solved. Below are two of the latest smart ring platforms.

5.1 Talon

Talon rings can connect to a range of devices from smartphones to tablets and smart TVs. Not only that, they can also be used as remote controls to switch on or off smart lights. A whole new world opens up when you think of the apps that can be created. You can control other devices or enhance the user experience of other apps. So just register as a Talon developer and request SDK access. You'll be creating amazing, futuristic apps in no time.

5.2 NFC Ring

The NFC Ring has a broad range of applications such as access control, data transfer, and payments. Really creative developers are free to come up with the coolest ideas and convert them into apps using the SDKs and other tools.

Conclusion

In this article we took a brief look at the latest and emerging wearable development platforms that are going to replace smartphones in the future. The technology is changing so fast that it's impossible to tell which one of these will actually dominate. So get out there and start experimenting!

While you're here, check out some of our other posts on smartwatch and wearable app development.

• 
  Android
  Google I/O 2017 Aftermath: What's New for Android Wear?
  Jessica Thornsby
• 
  Mobile Development
  WWDC 2017 Aftermath: The Most Important Announcements
  Bart Jacobs
• 
  iOS
  An Introduction to the UserNotifications Framework
  Davis Allie

We also have complete courses that will show you how to create a wearable app from start to finish for the popular Android Wear or Apple watchOS platforms.

• 
  Android
  Develop Apps for Android Wear
  Paul Trebilcox-Ruiz
• 
  watchOS
  Code a watchOS App With Swift
  Derek Jensen

by Bala Durage Sandamal Siripathi via Envato Tuts+ Code

How to Cache Using Redis in Django Applications

One of the ways to relieve strain on a server is by caching data. This is done by caching data after it has been processed and then serving it from the cache the next time it is requested. This tutorial will give a detailed discussion of Redis, explaining how to install Redis and cache data in Python applications.

Introduction to Redis and Caching

Caching refers to storing the server response in the client itself, so that a client need not make a server request for the same resource again and again. A server response should have information about how caching is to be done, so that a client caches the response for a time period or never caches the server response.

A cache, on the other hand, is a hardware or software component that is used to store data so future requests for the same data can be served faster.

In this age where users expect results within a second, it is wise to serve requests by reading data from the cache, which is ultimately faster than reading from a slower data store; thus, the system performance depends on how many requests can be served from the cache.

Redis is an open-source, in-memory data structure store, used as a database, cache, and message broker. It works by storing data in a cache and providing it the next time it is requested, instead of querying the database every time.

Install Redis

The first step is to get Redis up and running locally on your machine. The simplest way to install Redis is via the operating system’s package manager like so:

sudo apt-get install redis-server

You can also follow the instructions from the official Redis site.

Download and extract Redis 4.0.6 tar as follows:

$ wget http://download.redis.io/releases/redis-4.0.6.tar.gz 
$ tar xzf redis-4.0.6.tar.gz 
$ cd redis-4.0.6 $ make

The binaries that are now compiled are available in the src directory. Run Redis with:

$ src/redis-server

You can interact with Redis using the built-in client:

$ src/redis-cli
redis set foo bar OK redis
get foo "bar"

To check if the redis server is running, issue the following command on the terminal:

$ sudo redis-server
* Ready to accept connections

Django API Example

Let's create our Django project. Our project will be able to cache all the products in a store, making it easy and fast to retrieve data in subsequent queries.

To make use of Redis in our app, we need to do the following:

1. Check if results for the current query exist in the cache.
2. If results exist in the cache, retrieve them.
3. If results don't exist, fetch them, store them in the cache, and then forward them to the requesting entity.
   

Requirements

• Django
• django-redis
  
• Redis
  
• loadtest
  

Create Your Project

Before we get started, create a directory and install a virtual environment. A virtual environment will let you install library versions required by your application.

mkdir myprojects

cd myprojects

Next, activate the virtual environment and install the project requirements.

 source venv/bin/activate
 
 pip install django==1.9
 
 pip install django-redis
 
 pip install djangorestframework

Create a Django Project

django-admin startproject django_cache

Create a new app called store, which will handle product management in our store.

cd django_cache

python manage.py startapp store

Add the store application and rest_framework to the list of installed apps in the settings.py file.

# settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'store', # add here
    'rest_framework', # add here too
]

Creating the Models

In store/models.py, we start by creating the Product model for storing the product details as follows:

from __future__ import unicode_literals
from django.db import models
import datetime

# Create your models here.


class Product(models.Model):

    name = models.CharField(max_length=255)
    description = models.TextField(null=True, blank=True)
    price = models.IntegerField(null=True, blank=True)
    date_created = models.DateTimeField(auto_now_add=True, blank=True)
    date_modified = models.DateTimeField(auto_now=True, blank=True)

    def __unicode__(self):
        return self.name

    def to_json(self):
        return {
            'id': self.id,
            'name': self.name,
            'desc': self.description,
            'price': self.price,
            'date_created': self.date_created,
            'date_modified': self.date_modified
        }

Migrations

Create an initial migration for our products model, and sync the database for the first time.

python manage.py makemigration store

python manage.py migrate

Create superuser

Create a superuser, log in to the admin panel, and populate your database with some sample data which we will use to do our tests.

python manage.py createsuperuser

Configuring Redis in Python Applications

In order to use Redis with a Django application, we need to set up Redis to store the application’s cache data. And the following to your settings.py file:

CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}

Next, we are going to create an endpoint that retrieves all the products from our database. We will first test the performance of the application in terms of how long it takes to retrieve data from the database without caching it. We will then implement another endpoint that retrieves data from a cache and compare the performance.

In store/views.py, add the following code which retrieves all the products present in the database.

from django.shortcuts import render
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status

# Create your views here.



@api_view(['GET'])
def view_books(request):

    products = Product.objects.all()
    results = [product.to_json() for product in products]
    return Response(results, status=status.HTTP_201_CREATED)

Configuring URLs

Create a file store/urls.py and add the following code.

# store/urls.py
from django.conf.urls import url
from .views import view_books


urlpatterns = [
    url(r'^$', view_books),
]

We also need to import URLs from the users application to the main django_cache/urls.py file.

# django_cache/urls.py

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^store/', include('store.urls'))
]

Let's do a test and see if we are on track. We will be using loadtest. If you are not familiar with loadtest, it's a tool for testing performance.

Installing loadtest as root is simple:

sudo npm install -g loadtest

$ loadtest -n 100 -k  http://localhost:8000/store/

# result
INFO Requests per second: 55

As seen from the above, 55 requests are processed per second.

Let's create another endpoint for retrieving data after caching with Redis. Edit users/views.py to match the following:

from rest_framework.decorators import api_view
from rest_framework import status
from rest_framework.response import Response
from django.core.cache import cache
from django.conf import settings
from django.core.cache.backends.base import DEFAULT_TIMEOUT

CACHE_TTL = getattr(settings, 'CACHE_TTL', DEFAULT_TIMEOUT)
from .models import Product


# Create your views here.


@api_view(['GET'])
def view_books(request):
    # rest of the code


@api_view(['GET'])
def view_cached_books(request):
    if 'product' in cache:
        # get results from cache
        products = cache.get('product')
        return Response(products, status=status.HTTP_201_CREATED)

    else:
        products = Product.objects.all()
        results = [product.to_json() for product in products]
        # store data in cache
        cache.set(product, results, timeout=CACHE_TTL)
        return Response(results, status=status.HTTP_201_CREATED)

The code above will check if the key product is present in the cache, and if found, the data represented will be returned to the browser. In the event that no data is present in the cache, we first retrieve the data from the database, store it in the cache, and then return the data queried to the browser.

Update store/urls.py as follows.

from django.conf.urls import url
from .views import view_books, view_cached_books


urlpatterns = [
    url(r'^$', view_books),
    url(r'^cache/', view_cached_books),

]

Let's carry out the tests.

$ loadtest -n 100 -k  http://localhost:8000/store/cache/

# results
INFO Requests per second: 233

The first time you hit the endpoint localhost:8000/store/cache, the application will query from the database and return data, but subsequent calls to the URL will bypass the database and query from the cache since the data is already available in the cache.

Conclusion

In this tutorial, we used Redis to give an application the illusion of speed. We leverage the use of RAM in Redis to store the results of queries and then return those results from the cache in subsequent queries rather than doing the round trip to the database.

There are other caching tools available, such as Memcached, which is similar to Redis. However, Redis is more popular than Memcached because it takes only a few minutes to set up and get working in applications. Redis has more sophisticated mechanisms as it has been described as a "data structure store", thus making it more powerful and flexible. Redis also has a larger advantage because you can store data in any form.

Hopefully, this tutorial has shown you how easy it is to add a caching layer to your application, hence improving performance. Caching must be something to consider when you need to reduce loading times and server costs.

by Esther Vaati via Envato Tuts+ Code

Simple Tweaks To Fix A Weak WiFi Signal - #infographic

In this digital age, the need to stay connected has garnered utmost importance. WiFi connectivity has turned out to be an amenity nowdays. Lost connections and poor loading times can be quite frustrating. Is your apartment Wifi causing trouble? Fortunately, a weak WiFi connection can be fixed with...

[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]

by Web Desk via Digital Information World

How to Sell More With Facebook Custom Audiences

Want more sales from your Facebook ads? Wondering which type of Facebook custom audience works best at each stage of the customer journey? In this article, you’ll discover how to pair Facebook custom audiences with different types of prospects to create an effective Facebook marketing funnel. Structure Your Facebook Campaigns for Maximum Return When you [...]

This post How to Sell More With Facebook Custom Audiences first appeared on .
- Your Guide to the Social Media Jungle

by Lauren Ahluwalia via

Active Theory v4

The fourth iteration of our portfolio featuring latest work, experiments, and products.
by via Awwwards - Sites of the day

11 Social Media Engagement Boosting Tactics That Actually Work - #infographic

For brands, social media engagement is just like having a car without tires. Everything is perfect, the engine, the gears, but still you’re not able to reach your destination. So, what exactly is the problem? Social media is just like a long-term relationship. The loyal and committed relationship...

[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]

by Web Desk via Digital Information World