This is a continuation of my previous blog entry “MEAN Stack – A Gettting Started Guide” in which we shall learn to build our first  MEAN Stack Application. This article is intended for anyone with a beginner to a novice level of experience in working with the MEAN Stack, so experts feel free to skip the basics or even the whole article but your comments & suggestions will be highly appreciated.

What are we going to build?

The app that we will be building is a To-do App. It is a single page application and will have a list of tasks which the user can manage. We will be implementing the basic CRUD functionality to manage these tasks and will also be using REST-ful services for it.

I will be keeping this tutorial to the very minimum by including only the components that are an ultimate necessity and will not be adding any scaffolding tools like yeoman, bundlers like webpack or task runners like grunt or gulp or even bower which is a package manager for angular & similar front end components. But i strongly recommend you to check them out as they will be very useful in building complex and scalable web applications.

Setting up our Application

We can either install each of the components separately or use an available boilerplate for setting up our application.  There are a lot of boilerplates available which serves you a development ready MEAN application with a basic file structure bootstrapping, UI & CRUD functionality. A few of them like Mean.js, Mean.io, Meteor etc are really popular and is worth having a look. But i would like you to stick to the basics & understand what each of these components are and how to add them up together one by one. We will be doing that in this part of the getting started tutorial.

Pre-requisites

Like every project, before getting into the coding, we need to have an environment set up for our application to run. We will be needing the following components installed first.

1. Node JS & its npm package manager- download – installation docs
2. MongoDB – download – installation docs

Additional libraries we will be using

1. Mongoose.js – to add schema and model your data stored in Mongo DB for Node JS
2. Twitter Bootstrap – for some quick styling

Note-

Verify if node is properly installed by executing the command

node -v   //Which should give you the version of your Node.js installed

npm -v //version of the node package manager

Configuring Our Server

We will start with configuring our server using node & express. Let’s do this by creating a new directory with you project name, say ‘todo-app’.

1. Open the command prompt and navigate to this directory.
2. Create a new package.json file in it which will contain all of our required dependencies. We can either create it manually or use the generator for it by typing the following command in the directory
   npm init -y
This will generate the package.json file with some basic code as shown below.
   .
3. Install Express-
   Now let’s bring in express, a middle-ware for node,  to easily create our server. We will be installing it using the node package manager as a local dependency.
   
   Type:
   npm i -s express     // -i = install, -s = save to package.json

Now if you check your root directory, you will see a new directory named node_modules listed in it. What happened is, when we ran the command, npm installed express locally as a dependency in the node-modules directory. Whenever we are adding up local dependencies, node will install it in the node_modules directory and update the package.json with an entry of that dependency module. If you have a look at the package.json file, you should be able to see express listed under the dependencies. That’s all the basic stuff you need to set up a web server using node & express. Now lets write a hello world program to verify if everything is working.

Hello World using node and express

Create a file named server.js and add the following code into it.

var express = require('express');  //imports express into our application
var app = express(); //initialize our app

var PORT = process.env.PORT || 3000;

app.all('/*', function(req, res){

    res.send("Hello World!");

});

//Listen to the port
app.listen(PORT, function(){
    //callback function fired when the server is up and starts listening to the assigned port
    console.log('server running on port '+ PORT);
});

What it does is include express into our server.js file and initialize an app. Then we specify the ‘all’ method to handle any request send to the server.  The parameter ‘req’ stands for the request which contains all the request parameters send to the server & the parameter ‘res’ stands for the response to which we send the line of text “Hello World!”. Then the final step is to associate a port to this function to which it can listen for any incoming request. We are assigning the port 3000 for the server to listen. We are also adding a log to the console to know that the file was compiled successfully and our node server is running on the port assigned to, which is 3000.

Now lets run our server,

Open up the terminal window & navigate to our directory’s root. Then type

node server

You will see the following console output

Congratulations! You have set up your node server to output Hello World.  Now since our server is listening to the port 3000, open up a browser & run the below URL.

http://localhost:3000/

You will get

Note-
One thing to keep in mind is that every time you make some changes to your ‘server.js‘ file,  for the changes to reflect, you will have to restart your node server by closing it first using  “Ctrl + C” and then again starting it by running node server command.

Developing our MEAN Stack Application

Step 1. Instructing the server to server static files

1. Create a new folder in our app’s root directory called public & within that create a new file index.html.
2. Now open up the index.html file & add some content to it. I have added some content as below and i will not be focusing on any custom styles to my application as i intend to keep it simple, so I am including the twitter bootstrap CDN to quickly add up some basic styles to it.
   
3. Add this directory to our node server by adding the following line to our function replacing the server.all() with the following lineapp.use(express.static(__dirname+'/public'));Now, the contents of our server.js will be
   

   //Server.js
   
   var express = require('express');  //imports express into our application
   var app = express(); //initialize our app
   
   var PORT = process.env.PORT || 3000;
   
   app.use(express.static(__dirname+'/public')); //Serve static files from the public directory
   
   //Listen to the port
   app.listen(PORT, function(){
       //callback function fired when the server is up and starts listening to the assigned port
       console.log('server running on port '+ PORT);
   });

4. Now close the node server using Ctrl+C & then start it again using the command ‘node server’.
5. Visit http://localhost:3000 and you will be able to see the contents of the html file we just added.

Okay, now let’s bring in angular to make the requests we need. We can do this by downloading the whole angular package and include the files into our index.html file or we can just include the CDN for it. I will be using the CDN here.

https://ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js

Step 2. Adding Angular JS and setting up our front end framework

To add Angular JS to the html, we will be including the following script to the end of our index.html, just above the closing body tag.

<script src=”https://ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js”></script>

Testing our Angular App

1. Add ng-app to the opening html tag, like <html ng-app>
2. Add a text box to the index.html body<input type=”text” ng-model=”testVar” />
3. Below it add
   {{testVar}}
4. Now refresh the browser & start typing in the textbox and you will see the content being updated as we input each characters.

Thus we have successfully tested if Angular is working by checking its two way binding. For those who are new to angular, two way binding is angular’s way of updating a variable from the front end view & the interesting thing is whenever a variable is getting updated, its updated value will be reflected in all the places it is being used almost immediately.

Step 3. Setting up the general layout for our App

1. Create a new directory within the public directory and name it controllers.
2. Add a new file controller.js
3. Add the following code to the controller.js file. This code contains some dummy data defined for our ToDo tasks that needs to be displayed in the html.
   

   /**
   * The angular app controller
   */
   var myApp = angular.module('myApp', []);
   myApp.controller('HomeCtrl', ['$scope', '$http', function($scope, $http) {
       console.log("Hello World from controller");
   
       var dummyData = [
           {todo:"Task 1", status:0},
           {todo:"Task 2", status:1},
           {todo:"Task 3", status:0},
           {todo:"Task 4", status:0},
           {todo:"Task 5", status:0},
           {todo:"Task 6", status:0},
       ];
   
       $scope.tasklist = dummyData;
   }]);

4. Now in the index.html file add the following script after the angular script
   <script src="controllers/controller.js"></script>
5. Change the ng-app attribute in the html tag to ng-app="myApp"
6. Now add ng-controller="HomeCtrl" to the container div. This will associate angular’s HomeCtrl controller which we defined in the controller.js to the body of our container div
7. Change the contents of the index.html’s container div to match the file given below. I have taken the liberty of adding up a basic layout for our app using a table
   

   <!DOCTYPE html>
   <html ng-app="myApp">
   <head>
       <!-- Latest compiled and minified CSS -->
       <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css"
        integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
       <!-- Optional theme -->
       <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap-theme.min.css"
        integrity="sha384-fLW2N01lMqjakBkx3l/M9EahuwpSfeNvV63J5ezn3uZzapT0u7EYsXMjQV+0En5r" crossorigin="anonymous">
       <title>My ToDo List</title>
   </head>
   <body>
       <div class="container" ng-controller="HomeCtrl">
           <h1>ToDo's</h1>
           <p>Manage your ToDo list here</p>
           <hr />
           <table class="table table-bordered table-striped">
               <thead>
                   <tr>
                       <th width="14">#</th>
                       <th>Tasks</th>
                       <th width="200">Actions</th>
                   </tr>
               </thead>
               <tbody>
                   <tr ng-repeat="task in tasklist">
                       <td>{{$index+1}}</td>
                       <td>
                           <s ng-if="task.status==1">{{task.todo}}</s><!--Adds a strikethrough & show it if status is true -->
                           <span ng-if="task.status==0">{{task.todo}}</span><!--show if status is false -->
                       </td>
                       <td></td>
                   </tr>
               </tbody>
           </table>
       </div>
   <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js"></script>
   <script src="controllers/controller.js"></script>
   </body>
   </html>

Now restart the server & refresh the location http://localhost:3000 in your browser and you will see the below output.

Thus we have successfully created a basic layout for our app with some dummy data of our task which is being displayed from the angular controller.

In the next part of this blog, i will introduce you to MongoDB and creating a RESTful API for fetching & storing data from it using node.

The post MEAN Stack Application Development appeared first on Reflections.

Robotic process automation (RPA) is the technology that allows employees in a company to configure computer software or a “robot” to capture and interpret existing applications for processing a transaction, manipulating data, triggering responses and communicating with other digital systems. Recurring jobs are fast vanishing with RPA….

Robotic Process Automation is a 10+ year old software technology which was re-architected by Blue Prism, Automation Anywhere, UiPath and others to perform work currently being done by financial, processing and administrative staff.

The ‘robotic software agents’ are a relatively new technology that is commonly termed Robotic Process Automation (RPA). Their objective is very straightforward – to carry out the business processes that would normally be done by human beings. This works best when the processes are repetitive, rules-based and frequent.

A robot is trained through a flow chart using the procedure to be automated. Once configured and trained, these software robots log into applications with valid credentials and perform specific rules based, on-screen, computer tasks, exactly as they are trained for. Jobs are generally executed round the clock and they never make human errors and can work at twice the speed of humans. Robots identify the objects on the ‘procedure under test’ and the underlying tasks using these objects are performed while running the corresponding procedure or process. Identified objects needs to be recognized uniquely by the system. Procedure that need to be followed during execution will be that of corresponding task workflow. Modern robotic systems come with fail over and recovery inbuilt into its core capabilities.

An industry that use humans more on recurring jobs is one that can be replaced with robots once they are trained specifically on that task. An example of using Robotic Process Automation: In a UK insurance firm, a team of just 4 people can process around 3,000 claim documents a day (of which around a quarter are on paper) – without RPA the team would need to be as many as twelve.

There are different types of Robots in the industry which include a) Task Bots -which is left unattended b) Meta Bots-the attended c) IQ Bots-Cognitive, makes decisions based on accumulated learning experience.

Below listed are vendors that provide Robotic Process Automation software

• BluePrism
• Automation Anywhere
• UI path
• IpSoft
• Infosys – AssistEdge
• IBM Watson

Gartner has recently recognized Blue Prism as one “Cool Vendor” since they have been making steady inroads in several markets that include: Financial Services, Energy, Telecom, BPO and Healthcare.

Blue Prism configuration is code-free, logical and highly visual. Processes are designed to be created, maintained and managed by business users, process excellence engineers and subject matter experts. Building blocks are designed for re-use and are interlinked to produce end to end processes.

Advantages of Robotic Process Automation (RPA):

Lower cost : Robotic process automation can create a 25-50% cost savings. Process automation enables 24/7/365 execution at a fraction of the cost of human equivalents.

Productivity & Efficiency : RPA offers an improved service delivery model by increasing production and accuracy, reducing cycle times and decreasing the need for ongoing training.

Higher Speed and Throughput : Can deliver proof-of-concept in a few months at first time;

Greater Performance & Quality : Out of every 100 steps, a human is likely to make 10 errors, even when carrying out somewhat redundant work. Robots are trustworthy, consistent and tireless.

Scalability : A robotic workforce can be as large or as small as you need it to be, and additional robots can be deployed quickly for no extra cost, or at worst minimal expenditure.

The post Robotic Process Automation appeared first on Reflections.

“MEAN” is an Open-Source full-stack JavaScript solution which uses MongoDB, Express, Angular and Node.js. The word Mean from MEAN stack is derived from the first letters of the four stack components and generically identifies the combined used of these technologies. Never call it a framework as there is no such a thing as “THE MEAN framework”.

Why MEAN Stack?

The major benefit of the MEAN stack web development is that it is extremely quick to prototype with. It has become a popular choice for creating dynamic websites.

It supports the MVC (Model View Controller) architecture. It has a simplified server layer and is relatively easy and flexible to understand and use. The components are open source and has a lot of community support.

Components

The Database

MongoDB is the database engine. It is a schemaless NoSQL database system which saves data in binary JSON format. The lack of a schema allows for fluid object definitions that don’t require extensive code changes, and by removing the need for highly complex structured queries, the system can often operate more efficiently than a similar architecture build over a relational database like MySQL.

In addition, the NoSQL nature of MongoDB allows you to quickly change and alter the data layer without having to worry about migrations, which is a very valuable attribute when you’re trying to build a product without clear specifications.

The Server

Node JS is the web server and server-side API. It is built on Google Chrome’s V8 JavaScript runtime, allowing us to use Javascript on the backend. Leveraging V8 allows Node to provide a server-side runtime environment that compiles and executes JavaScript at lightning speeds. The major speed increase is due to the fact that V8 compiles JavaScript into native machine code, instead of interpreting it or executing it as bytecode.

The key attraction of Node.js is its Event Loop. To scale to large volumes of clients, all I/O intensive operations in Node.js are performed asynchronously, making it entirely a non-blocking and event-based structure allowing us in building highly scalable and concurrent applications rapidly.

The Web Framework

Express JS is a lightweight framework + routing engine which runs on top of Node JS. It provides a number of robust features for building single and multi page web application. Express.js serves as the controller layer, directing application flow and marshaling data for the UI. It is inspired by the popular Ruby framework, Sinatra.

Express provides us a variety of features like consistent routing to modules,sub routers, static file serving, view caching, middle-ware interface etc. With express, you can get the server up and running in no time. It also makes coding in Node JS a lot easier.

The Front End UI

AngularJS is a JavaScript framework developed by Google. Of course, most of you will be familiar with it as it provides some awesome features like the two-way data binding and handles data presentation.

It neatly organizes the front end code in a structured manner & is a complete solution for rapid and awesome front end development.

The Result

The figure shows how these components interact with each other. The Angular JS resides in the front end and performs request to the server layer comprising of Node JS & Express. The request will then be parsed over by Node & handed to the Express framework for performing logical operations & retrieving data from the database layer (MongoDB). Once the data is fetched and the required operations are done, Express will use Node to return the results which will be taken up by Angular JS & presented to the end user.

Now, here’s the cool thing about this combination.

Javascript all the way

MongoDB stores its data in JSON, Node JS, Express, and AngularJS are all JavaScript; so we don’t need to spend time formatting/transforming the data between them. This gives the added benefit of being entirely in one language which makes it simpler and readable.

Isomorphic code

If you want to move some code written in Node to AngularJS, you can easily do it without much hassles, thus offering flexibility in development. Also you don’t need to look for a front-end and a back-end developer as the same person can handle the entire stack components by just learning Javascript.

A few things you might want to consider before you jump in

 Even though Node.js has active plug-in development, the technology is not as mature as the existing ones like Apache. So you may need to write your own plug-ins to cover the areas where Node.js is missing functionality.

 Choosing Node.js locks all code on your web server into JavaScript. For new development this isn’t a major concern, but converting an existing back-end of significant complexity can be time consuming.

 If you are planning to migrate your existing SQL database to Mongodb. Translating the data requires a lot of work to eliminate unnecessary object attributes. But, once it is done the database will be much faster for data retrieval.

 It is not compulsory that you have to use all of these stack components and/or only these stack components together. MongoDB, Express, AngularJS, and Node.js works well together but others might work as well. Instead of MongoDB, some apps might only need Redis or perhaps instead of Angular, you may use Ember.js,Backbone.js, or just jQuery. So feel free to choose whichever combinations you seem comfortable with.

Finally, these technologies have a lot of community support behind them so finding answers to questions or hiring help is going to be easy.

Conclusion:
In this blog we focussed on introduction on Mean stack .
In part 2 of this blog, I will be covering the steps to create a sample app using MEAN. Watch this space.

The post MEAN Stack – A Gettting Started Guide appeared first on Reflections.

I was enjoying a beautiful spring day in Florida after a hectic week when my phone rang. It was a much awaited Saturday but as I guessed the call was from office. So much for my beautiful Saturday.

I had completed a production deployment the day before and users were complaining about the poor performance of the system. Now this is serious.

Reluctantly, I took my laptop, rolled up by sleeves and got down to investigate. After few hours I found the culprit – 4 lines of bad code. A variable was being set inside a ‘for loop’ and this involved a call to a remote db server. Yeah, this is too naive but rarely at least some of us do write such piece of code. Most times, we have too little time to think and we opt for quick wins with brute force approaches. We pay less or no thought to CPU cycles and memory which in most cases are taken for granted. The result is a working software with poor performance over time.

One must be extremely careful while using CPU and memory resources. Unknowingly we are paying a price for these resources. The more CPU cycles we use to perform an operation, the longer some other process has to wait. Every operation consumes a number of CPU cycles and memory which could have been used for more useful work.

How do we achieve it?

This can be achieved by many ways. Design or architecture of applications using right technology plays a major role. But however good the architecture is, the implementation has its stake. Keep in mind each line of code execution is having a cost associated with it.

Sometimes we keep on calculating some values which does not vary throughout the code. In most of the cases we could have declared an instance variable or a global variable which should have be initialized once and used multiple times instead of recalculating every time. Trust me this is an example of common carelessness programmers do.

First and foremost we should understand the platform on which we are writing code to take maximum advantages offered by the platform for memory management and optimal execution of code. Every environment like JVM, CLR etc. has its own memory management, garbage collection techniques, so knowing them is essential to write optimal piece of code. Knowledge about how the data is represented in memory would also help us in managing the data movements between call stacks. For example it help us to decide if we have to pass value between functions as value or reference where second one passes only copies reference instead of huge class object.

Use of right data structures is another key factor deciding the complexity or cost associated with the operation you are performing. For example if we are using List instead of LinkedList we get different cost for different operations. List is array backed and we can access elements by index. The complexity or cost associated will be same irrespective to the size of List as elements are accessed by index but accessing elements by index will be costlier in LinkedList as it is a doubly linked list. However addition or removal of elements in between is faster in LinkedList.  Another example will be the use of HashTables for search operations where the complexity is constant irrespective of the size of the table.

Algorithms and logic used in the program also determine the performance of program. For example while sorting a list, quick sort or merge sort could be used instead of bubble sort. In the example below strlen(s) is called when a ‘for loop’ is executed every time.

For (i=0; i<strlen(s); ++i) {
  If (… s[i] …) …
}

If we could rewrite to

n=strlen(s);
For (i=0; i<n; ++i) {
  If (… s[i] …)…
}
then many CPU cycles will be saved by above simple operation.

A good programmer should also know when to use an abominable algorithm like bubble sort. For example, if the problem domain dictates there can never be more than five items (like the number of dice in a Yahtzee game), you know that you always have to sort at most five items. In that case, bubble sort might actually be the most efficient way to sort the items.

The post Demystifying Data Structures appeared first on Reflections.

Quick view on Microsoft SharePoint

SharePoint is a platform for intranets, document management, reporting and business collaboration. It has a lot of capabilities to meet most business needs. We can say that Microsoft SharePoint is one of the biggest productivity frameworks released during the last 15 years. These days, SharePoint is becoming more common in the enterprise world.

Central Administration

SharePoint Central Administration(SPCA) can be used for administrative tasks. SPCA is used to configure servers in SharePoint.

The main areas/features of SPCA are

• Application Management
• Monitoring
• Security
• System Settings
• Upgrade and Migration
• Configuration Wizards
• Back Up Restore

Fig 1 : SharePoint Hierarchy

SharePoint Farm is actually a set of servers which have different roles and responsibilities. Main server roles in SharePoint are:

• Front End web servers
• Application servers
• Database servers

Using SPCA, we can create web applications and under each web application- site collections and under site collections – sites and under sites – libraries, lists etc.

Key Factor

Using SharePoint websites, we can store and manage our data in a more flexible way. Document management is one of the key reasons behind why SharePoint is used in business collaboration sites. By providing a unique user experience, SharePoint helps to share content, applications and data. We can customize sites by changing their appearance and by adding functionalities without writing a single line of code. That’s the power of SharePoint.

Main Capabilities

• Sites: Site is the most visible feature of SharePoint which includes the engine for building up websites, features etc.
• Composites: Composites include features such as external Data Connectivity, Open Work Flow Engine.
• Communities: Communities have many capabilities such as Social Networking, Blogging, Wiki pages, Feeds etc.
• Insights: Excel Services, Visio Services, MSQL Reporting Services, Access Services
• Search: One of the important feature of SharePoint is its Search engine. It supports high volumes of contents and searches.
• Content: Supports Record Management features, Multimedia content etc.

Fig 2 : SharePoint Server Object Model Hierarchy

Object Model

SharePoint offers structured object model. With the help of this model we can use SharePoint objects to achieve many features in SharePoint.

Namespace: Microsoft.SharePoint

Site collection object–

SPSite siteCollectionObject = SPContext.Current.Site;

Current web site object –

SPWeb webSiteObject = SPContext.Current.Web;

The post Quick view on Microsoft SharePoint appeared first on Reflections.

My experiments with ISO 9001:2015!

ISO had published the latest revision of their popular Quality Management System Standard in September 2015. There were a lot of discussions/presentations/trainings etc. on the implementation/changes of the new standard, and are still going on….

I had the experience of providing for one of the companies in Technopark, consultation services for implementing ISO 9001:2015. The certification audit was conducted by TÜV Rheinland and the company was recommended for certification.

Here I am briefing some key changes of the new standard.

New structure:

Easier from an implementer’s point of view. For those who are dealing with multiple standards/management systems, their life is going to be easy.

Documentation:

Throw away the old concepts of QMS documentation before approaching this new international standard. Omission of Quality Manual is a very welcome move. But like the TUV auditor rightly pointed out, maintaining a presentation/excel sheet with a small description of the clause by clause implementation would be a very good reference for the internal audience.

There are documents mandated by the new standard, but very reasonable. Except the documents mandated by the standard, rest can be decided by the organization considering certain factors. Do not document anything which is not value adding, that is the key.

Risk Based thinking:

Among the major changes, I feel this is the most important one – implementing risk based thinking. A Challenging but interesting concept for implementation. If done effectively, it will resolve hell lot of challenges faced by any organization.

Risk based thinking should not end up with just another multi colored Excel sheet like a Risk Register. Develop the culture of risk based thinking from planning to all other areas of operation. This is a concept incorporating preventive action mentioned in the previous versions of the standard.

Role of Leadership:

Now the leadership can’t vanish after appointing an MR/Quality Manager for QMS implementation. A more proactive and engaging role is required from the leadership for the effective implementation and maintenance of the QMS.

Service friendly:

New standard has more clarity on service based operations. I can confirm this based on the implementation of the standard in an IT company.

To summarize, the new standard is engaging for leadership, easier for implementers, challenging for auditors, good for the organization and a terminator for traditional MRs !

The post Reflections Process Consulting appeared first on Reflections.

Here at Reflections, we are excited with the Apple’s new TVOS release. We are looking at the potential of this new platform and it’s ability to change the way you interact with your television. Moreover, the opportunity we have into this world, and thereby the excitement we offer our iOS customers.

tvOS is derived from iOS but is a distinct OS, including some frameworks that are supported only on tvOS. We find that the familiarity of iOS development, combined with support for a shared, multi user experience, opens up areas of possibilities for app development that are not available on iOS devices. You can create new apps or use your iOS code as a starting point for a tvOS app. Either way, TVOS needs tools (Xcode) and languages (Objective-C, Swift, and JavaScript) that we’re already familiar with.

Apple TV Hardware

The new Apple TV has the following hardware specifications :

– 64-bit A8 processor

– 32 GB or 64 GB of storage

– 2 GB of RAM

– 10/100 Mbps Ethernet

– WiFi 802.11a/b/g/n/ac

– 1080p resolution

– HDMI

– New Siri Remote / Apple TV Remote

User Interactions

As Apple says, “Apple TV does not have a mouse that allows users to directly select and interact with an app, nor are users able to use gestures and touch to interact with an app. Instead, they use the new Siri Remote or a game controller to move around the screen.”

A siri remote is shown here with its controls:

1. Touch surface. Swipe to navigate. Press to select. Press and hold for contextual menus.
2. Menu. Press to return to the previous menu.
3. Siri/Search. Press and hold to talk in those countries that have the Siri Remote. In all other countries, press to open the onscreen search app.
4. Play/Pause. Play and pause media.
5. Home. Press to return to the Home screen. Press twice to view open apps. Press and hold to sleep.
6. Volume. Control TV volume.
7. Lightning connector. Plug-in for charging.

Challenge :

Taking care of the user-interface and user-flow is going to be the main challenge when porting an existing app for TVOS. Since there is no hardware keyboard or big touch screen, inputting text feels challenging and less immersive.

The second challenge you are going to face is Local memory. You can no more download images and videos and run them locally whenever needed.

Apple Says : “The maximum size of an Apple TV app is limited to 200 MB. Moreover, your app can only access 500 KB of persistent storage that is local to the device (using the NSUserDefaults class). Outside of this limited local storage, all other data must be purgeable by the operating system when space is low.”

You can never guarantee the files you downloaded are available in your local. Your files are trashed the next second your app goes to background if your user is a good game player or a movie lover.

Apple also warns : “Do not use the entire cache space as this can cause unpredictable results.”

Apple has a new solution to data usage for TVOS named “On-Demand Resource”. On-demand resources are app contents that are hosted on the App Store and are separate from the related app bundle that you download. They enable smaller app bundles, faster downloads, and richer app content. The app requests sets of on-demand resources, and the operating system manages downloading and storage. The app uses the resources and then releases the request.

New tvOS Frameworks

Apple tvOS introduces the following new frameworks that are specific to tvOS. This opens up a space for non iOS developers to use the TVOS. Javascript again. It’s ruling the world.

1. TVMLJS. Describes the JavaScript APIs used to load the TVML pages that are used to display information in client-server apps.
2. TVMLKit. Provides a way to incorporate JavaScript and TVML elements into your app.
3. TVServices. Describes how to add a top shelf extension to your app.

Developing Apps !

Apps should be developed for tvOS. Apple TV was previously running on iOS and the new tvOS is built upon iOS and shares many of the technologies and frameworks.

Tools

You’ll need xcode 7.1 or later for developing apps for Apple TV. This include support for tvOS and tvOS Simulator.

How to get Started ?

There are two methods you can develop apps for Apple TV.

1. TVML Apps – apps are developed using TVML, TVJS and TVML kit.
2. Custom apps – the conventional way of making apps with familiar iOS frameworks and concepts like Storyboard, UIKit , Auto layout etc.

TVML is Television Markup Language, which is nothing but a form of XML. TVJS is set of JavaScript APIs which provide you with the means to display apps created with TVML. TVML kit combines TVML, Javascript and the native tvOS application.

If you want to present your users with some content that is hosted on a server , then you may want to choose the TVMLKit. There are so many reusable templates provided by Apple. You can have a look at the templates provided by Apple here.

To view each template in action, you can simply run the TVML Catalog Sample app which is available here.

If you want to present your users with a unique kind of custom design, you may choose to develop a custom tvOS app. You can create tvOS apps with your iOS skills in UIKit, Auto Layout, Core Graphics etc. Apart from many of the iOS frameworks , more tvOS specific things are available. You can have a look at the added and removed features for tvOS from iOS here.

How Apple TV could have been better

1. Typing in the apple TV with the SIRI remote is a pain point.
2. A little bit more of internal storage access for apps for at least a minimal caching.
3. Siri support for developers.
4. When it comes to Television, the screen is larger and so is the space for multitasking. Apple could support multitasking on Apple TV apps. They do support for iTunes channels.

Latest Updates

There’s a new software update awaiting Apple TV 4 as Apple released a small point update for all users early this year. tvOS 9.1.1 likely includes bug fixes and performance improvements without adding any major feature changes. The update, however, does include the new Podcasts app that first appeared in tvOS 9.2 beta.

The bigger update coming in the future also includes channel folders, Bluetooth keyboard support and more. You can update your Apple TV 4 through the Settings channel from the Home screen.

While tvOS 9.1.1 is available to all users, tvOS 9.2 is currently limited to testing by developers and expected to be released later this year.

With the latest version of Apple’s Remote app for iPhone and iPad, you can control your Apple TV over your home’s WiFi network with a higher degree of control. Plus, search is a snap because you can type stuff on your device’s keyboard. The free app is available for iPhone and iPad. Download it here.

We have tried few prototypes. We will be back with a next blog with more on development details.

The post Apple TV – Words of a developer appeared first on Reflections.

The basics

The traditional internet application systems are designed by implementing entire functionality in one box and rest of the non functional requirements like scalability/availability and performance are achieved by increasing the capacity or repeating such instances.

Availability

Cost, Business requirements and other decisions, factors into the the capacity of the backup machine (adding one more machine which is a copy of the original ,which comes online when primary is down – with a content management switch). A less capacity failover environment can lead to degraded performance during the small window of failover but with better cost propositions.

Performance

The active redundant element with same capacity can be changed from just a backup to always online entity. The request then can be routed to both the servers to take care of performance. With an active redundant solution, the content switch can load balance between the active and redundant element. It identifies the more busy system and directs the requests accordingly.

Sessions and Synchronization

As soon as multiple boxes are introduced, anticipate the issues with sessions. In order to achieve optimum performance of the hardware, the customer’s current session needs to be moved between servers. To achieve this, session is to be put in a common area where both the server can share and see, may be a common persistent store or repository. This can be in the app server, or more efficiently in a database state storage server. It can also be in a separate box for storing sessions and further improved to active redundant or load balanced state storage.

Active redundant or load balanced system needs to do data replication. Most of the time database takes care of it. More complex scenarios occurs in the case of storage networking or synchronization between data centres.

The Azure Cloud

If you apply the thought process discussed in previous segments, the redundancy is applicable for your firewalls, routing switches etc. A risk management process needs to be conducted to identify the single point of failure for redundancy planning. But we don’t need to travel in that direction always – Microsoft Azure is a good suggestion for hosting and datacenter needs.

If you choose Azure – Availability, Performance, Synchronization, Sessions etc. can be configured in the way you want and a customer can focus their thoughts on application features and selling them to customers.

All Azure services have SLA of around 99.9% for uptime and connectivity. To enable the SLA offered by Azure, use the Availability Sets in cloud deployments. Once Availability Sets, are used in VM’s the services are placed into separate fault domains and therefore separate racks to ensure 99.9% availability.

Autoscaling is a key feature of Windows Azure. During the first deployment of Azure service, the size can be specified with number of instances required. Scaling up (size) or scaling out (instances) can be achieved either manually or by configuration. Same can be done for scaling down when the demand decreases.

Session management can be achieved in Windows Azure using any of the below options.

1. Azure Table Storage
2. Azure SQL
3. Azure Cache (In-role Cache)
4. Azure Cache Service

The post The this that of a Data Centre planning VS Azure Cloud appeared first on Reflections.

Last Sunday I took part in Trivandrum city’s first ever Cyclathon event. I competed in the champions’ category by riding 40 kms. The time limit was 2 hrs and I finished the ride in about 1 hr 50 minutes. Although this is good pace by my own standards, I was probably the slowest of riders in the category since the top 10 finished in under 1 hr 25 mins. Looking back, I’m no newbie to cycling having ridden for last 4 years and some of my longest rides being in the 100 km mark. But yet I was one of the slowest. Why? Of course, physical strength, stamina and practise matters in events like these but there is one key factor – the equipment; the bike. Majority of the top riders were on road bikes which only weighed around a quarter of my MTB, and they also had higher gear ratios. This meant for lesser or same energy spent, the road bikes would achieve much greater speeds and travel longer distances.

Using this as an analogy, I like to state the importance of using the right equipment / tool on a day to day basis as a software solutions provider. Be it software development or testing, the right tool will always give us an edge over our competitors. Take for example the case of software testing. It is very common for test scenarios, scripts, execution summary and defects to be maintained in Microsoft Excel and word documents. I mean no disgrace to these tools, being a big fan of them myself. However my preference would always be to use tools like Quality Centre, Redmine or TestCase DB which are tools built for the purpose. Just like how road bikes are built for the road and speed, these tools are built for purpose of software test management and so, make teams highly productive by removing overheads which tools like Word or excel bring into the test management process.

Moving higher up the software dev pyramid, the whole software management in many cases are done using spread sheets and documents. Although this may work for small organization with tiny teams, it will be inefficient for large teams. Tools like Trello, Jira, Zoho and Basecamp to name a few are built for these purpose and are highly effective in various stage of software dev lifecycle. These tools work in increasing the productivity and efficiency of large distributed teams by removing overheads of collaboration and software management.

I only aimed to participate in cyclathon, and so was content with my equipment/bike and performance. However as a software solutions provider, developer or tester, we should always strive to have the right equipment or tool even if it needs an investment. It will only be a matter of time before the benefits of the tool outweigh the investment and put us ahead of the competition.

I got the medal in picture for completing the ride and it is not gold.

The post Riding, coding or testing – equipment matters! appeared first on Reflections.

I have come across a lot of developers who are really good at C# programming who end up writing amateur stored procedures contrary to expectations.

When writing a query involving table joins, from that moment on start visualizing how the data in tables start merging together and spread out to form a large living creature. Imagine the data rows hand-holding each other, bridging tables, the null rows born out of left joins, the expected and unexpected duplication, if any! There should be a meaning to this final object that gets created in memory which gives sense to its existence.

When picturing this formation, just spend a couple of minutes to analyse how fast the tables will attract the correct rows to each other. For example, if there is no natural clustered index or man-made indexes on the join condition, the participating rows would frantically run to find their beloved! Technically this would be called “a scan”, and in Bollywood it is a 3-hour movie. Do we want that kind of performance? No! So pick the right columns to join or add the right indexes. Selecting the “right” index demands a story of its own.

We need to think whether this huge object in memory is really worth its size. Just imagine an obese guy competing a lean and healthy chap to the door. Who would get out, first? To see this in SQL Server’s own eyes, take the estimation plan for a slow running query. Taking this cue, break up a SELECT statement if it contains a lot of joins. Think about the size of the individual tables involved too. Create JOINS so that the join itself act as a filter and only the necessary rows from the larger tables participate in the join.

Avoid usage of functions unless it’s existence really makes sense. Imagine the function being called the number of times, the rows in the table are repeated. Scary isn’t it? This could dangerously slow down your procedure’s execution time if the function itself is made up of a few table joins inside it. And such a function may look so innocently deceiving from outside like dbo.WhyWouldYouThinkIBurnYourCPUorIO(int yourSweetheartId)

Once you have a picture of this in your mind, think how the information you initially sought for can be extracted. Is it – a Group by? a Distinct? a Windowing function like Rank Over Partition? OR just a Where clause in the end?

Having said that, the secret to write the best possible query is to understand the individual tables in hand itself. You should KNOW THE DATA so as to CREATE INFORMATION out of it.

Inspire “SET based” thinking to write the most efficient and correct query. Stop thinking one row at a time. Viola! Welcome to SQL Server Engine (Heartbeat)

The post Do you think SET based? appeared first on Reflections.