The Scientific Religion

The Einstein’s unified field theory states

“a theory that describes two or more of the four interactions (electromagnetic, gravitational, weak, and strong) previously described by separate theories”

the above theory try’s to approach universal truth that everything in the world can be understood if we know one law, one truth, one perception, so one law gives equation and formula to derive anything, basis for all nature’s phenomena is it really gives such a higher law or truth to us, if we achieve that, electromagnetic, gravitational, astrophysics so nature unfolds many more mysteries of it, we can go beyond theories.

The Albert Einstein greatest scientist(saint) of our time, he took only 5 years to invent famous theory of relativity and concluded by giving mathematical formula but he took 40 years almost rest of his life spent in only defining the unified field theory not yet possible to give mathematical equation to it.  His main idea is to derive universal truth by knowing which we can know everything in this world but, he failed in his lifetime he was unable to put it in modern method of mathematical equation. The empty, zero, vacuum only can be able to felt, we cannot able to see, we can experience from our soul(atman), any instrument of physical existence cannot be able to reach it, from our feelings and experience we can add value to it, this is the reason where Einstein failed in his theory, he tried with physical instruments the greatest instrument and asset a man has, is his own soul(atman).

The zero, empty, vacuum what is the use of it, what is the meaning of this, a zero adds value to number just like before big bang theory everywhere only vacuum only emptiness there is no other number than zero what is the real meaning of zero here, it means one who sees which is not visible to physical eye which is not materialistic then alone can able to understand the mysteries of universe u cannot able to achieve those universal law without proper instrument, if tool is good, if real knowledge is present a beautiful car can able to design by an engineer.

We everybody know for a vacuum there is no value, no knowledge, then how big bang happened from vacuum, what is the force behind such a big blast in a empty space, in empty space how it is possible to create a particle that together formed a big core, from where these particles came together, why it came together, for everything there is a reason, who created these reasons, what is the motivation behind reason, who motivated or all these a theory only? why not science not able to create a single law, why different laws are there, modern science cannot able to give answers for it, is our great Einstein wasted 40 years of his lifetime in only proposing unified field theory he would had concentrated on something else which is more valuable to mankind.

The Einstein quoted,  “We owe to indian’s who thought to the world about counting without that most of the scientific discoveries would not be possible today”. The indian’s not only invented zero but they showed to the world how to use it in calculations, then it obvious that today’s number system derived from indian’s vedic literature, their contributions to the world are enormous. Then question arises how indians know about zero how they added value to it and how they used it in their mathematics, astrology, because they know about value of emptiness and vacuum they didn’t believe in materialistic world all they concentrated on internal world because of that they are able to reach the unknown mysteries of universe even 10,000 years ago they know earth was round and rotates around sun. With perfect instrument(Soul) they saw every inch of atom without any physical instrument this is the reason they didn’t even try to design a physical vehicle, spaceship’s and microscopes they knew materialistic world only destroys the earth, they knew the truth that earth is only made for knowing unified field theory or self realization, it is the platform for higher consciousness, through higher consciousness and knowledge of the self alone one can know the unified field theory by knowing one explain the phenomena of universe.

The Nikola Tesla quoted “Only through energy, frequency and vibrations we can unfold the mysteries of universe”. Another great scientist inventor of electricity and magnets in 19th century. The great scientist who followed Vedic literature followed its teaching with help of Swami Vivekananda  explored the real knowledge hidden in Vedic literature and upanishads he was so impressed that he started to speak in sanskrit words he was fellow human who wanted to give electricity free to the world on the basis that great wisdom of Veda itself is free then he has only a partical of that wisdom wanted to give his inventions to the world freely due to government his work forcibly taken and given credits to others. Why all major inventions of the world came in 19th century, the period British occupied most of the Indian subcontinent entire country was in the control of British. As west is west they are all materialist controlled its people, regions, wealth they failed to acquire the real wealth India possesses, so in the beginning on that period philosopher Arthur Schopenhauer declared vedas only for schoolboys and later in rest of life praised vedas for its wisdom. The British, to break this country they broke its education system and tradition of vedas later they wanted the fellow indians to ashame of its own country’s culture and systematically  stolen its inventions and vedic knowlege to western world. They feared about the power of Vedas will be so intensed that it will destroy their own beliefs and India will emerge as a super powerful country in the world.

Some of the Vedic knowlege as listed below:

Mathematics – Number system – BhaskaraCharya.
Sulabha Sutras – Pythogores theorem.
Aeronautics – Aeroplane(Vimana) – Subbarya Shastry – vimanika sutras.
Medicine – Ayurveda
Value of Zero – Aryabhata
Electromagnetisam – Nikola Tesla disciple of Vivekananda’s help studied veda and contributed to the modern science.
Einstien’s E=mC2 – Idea came to Vivekananda later explained to Tesla for deriving a mathematical equation later derived by Einstien.
Value of Pi – Bhagavad Gita Shloka

Above a small listing for proving the greatness of Vedas.

Instead of seeing our world in terms of various religion all holy books leads to one truth, the presentations are different some are more scientific, some are religious orientated, some depends on facts, some depends on proofs and some depends on persons for example if Vedas presents only beauty of one universal law that is why it is accurately possible to derive so many modern inventions in ancient India only, the broad understanding of Vedas depends only on the person who’s self realized through process of systematic understanding of his soul, only proper instrument is required to unfold the mysteries of universe, this is unified field theory, this is universal law.

Only Alphabets in AngularJS

The Directive for only alphabets.

The input type text in a HTML5 app allows only text during form submission event, if we try to enter any other character it considers the form invalid and try to show a default respective browser style invalid message, of course we can change the style of message display using a directive.

The below directive completely transforms the input type text to accept only text other characters are restricted.

onlyAlphabets.directive('onlyAlphabets', function () {
    return {
        restrict: 'A',
        require: '?ngModel',
        link: function (scope, element, attrs, ngModel) {
            if (!ngModel) {
                return;
            }
            ngModel.$parsers.unshift(function (inputValue) {
                var alphabets = inputValue.split('').filter(function (s) {
                    return (isALetter(s));
                }).join('');
                ngModel.$viewValue = alphabets;
                ngModel.$render();
                return alphabets;
            });
        }
    };

    function isALetter(charVal)
    {
        if( charVal.toUpperCase() != charVal.toLowerCase() ) {
            return true;
        }
        else {
            return false;
        }
    }
});

The above directive ngModel is required through which we are controlling the rendering of characters which is required to display in input text field, the function isALetter logic detects the char entered in input field is alphabets or not.

The ngModel variable contains the function $viewValue which sets the new value to the input text field and $render renders view to display.

Dynamic and Static Broadcast Recievers

As usual broadcast receivers can be configured in the manifest fileAndroidManifest.xml. A BroadcastReceiver that is configured in this way is called statically registered.

You can register your receiver in the manifest file by using the <receiver>element:

<receiver
   android:name=".ConnectivityChangeReceiver">
   <intent-filter>
      <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
   </intent-filter>
</receiver>

The nested element is used to specify the event the receiver should react to.

Dyanmic Broadcast Recievers

As an alternative you can register your BroadcastReceiver implementation dynamically in your code. You just need to call the registerReceiver() method on your Context object.

The registerReceiver() method takes two parameters:

The arguments of the registerReceiver() method

Argument	Meaning
receiver	The BroadcastReceiver you want to register
filter	The IntentFilter object that specifies which event your receiver should listen to.

When you register your receiver in this way, it lives for as long as the component livesand Android sends events to this receiver until the creating component itself gets destroyed.

It’s your task to handle the lifecycle correctly. Thus when you add a receiver dynamically, take care to unregister the same receiver in the onPause() method of your Activity!

I suggest to register the receiver in the onResume() method of your Activity and to unregister it in your onPause() method:

@Override
protected void onPause() {
   unregisterReceiver(mReceiver);
   super.onPause();
}

@Override
protected void onResume() {
   this.mReceiver = new ConnectivityChangeReceiver();
   registerReceiver(
         this.mReceiver, 
         new IntentFilter(
               ConnectivityManager.CONNECTIVITY_ACTION));
   super.onResume();
}

When to use which method to register

Which method to use for registering your BroadcastReceiver depends on what your app does with the system event. I think there are basically two reasons why your app wants to know about system-wide events:

• Your app offers some kind of service around these events
• Your app wants to react graciously to state changes

Examples for the first category are apps that need to work as soon as the device is booted or that must start some kind of work whenever an app is installed. Battery Widget Pro or App2SD are good examples for these kinds of apps. For this type you must register the BroadcastReceiver in the Manifest file.

Examples for the second category are events that signal a change to circumstances your app might rely on. Say your app depends on an established Bluetooth connection. You have to react to a state change – but only when your app is active. In this case there is no need for a statically registered broadcast receiver. A dynamically registered one would be more reasonable.

There are also a few events that you are not even allowed to statically register for. An example for this is the Intent.ACTION_TIME_TICK event which is broadcast every minute. Which is a wise decision because a static receiver would unnecessarily drain the battery.

 

Maximum character length in angularJS

Restricting characters to specified length directive.

We want a input field to restrict some characters from user, only allowing specified number of characters into the field
for this i have written a directive that satisfies the above requirement.

Below we can see code snippet and understanding of the snippet.

Minimum Requirement to understand the code: Must know Directive in AngularJS.
Usage:
input name=”name” type=”number”

myMaxlength.directive('myMaxlength', ['$compile', '$log', function($compile, $log) {
  return {
     restrict: 'A',
     require: 'ngModel',
     link: function (scope, elem, attrs, ctrl) {
           attrs.$set("ngTrim", "false");
           var maxlength = parseInt(attrs.myMaxlength, 10);
           ctrl.$parsers.push(function (value) {
           $log.info("In parser function value = [" + value + "].");
             if (value.length > maxlength)
             {
                  $log.info("The value [" + value + "] is too long!");
                  value = value.substr(0, maxlength);
                  ctrl.$setViewValue(value);
                  ctrl.$render();
                  $log.info("The value is now truncated as [" + value + "].");
              }
              return value;
            });
        }
    };
}]);

In the above code snippet we have control(ctrl) has method $parsers which gets called as soon as the value in the form input (number) is modified by the user, each value is pushed to array of character and length of the array is checked with specified maxlength value, if the array of input is greater than the maxLength value then control(ctrl) does not render to view else will be $setViewValue is called and $render will render the input to the view element.

Java Server Faces (JSF) Life Cycle

Phase 1 : Restore view

In the RestoreView phase, JSF classes build the tree of UI components for the incoming request.

• When a request for a JavaServer Faces page is made, such as when a link or a button is clicked, the JavaServer Faces implementation begins the restore view phase.
• This is one of the trickiest parts of JSF: The JSF framework controller uses the view ID (typically JSP name) to look up the components for the current view. If the view isn’t available, the JSF controller creates a new one. If the view already exists, the JSF controller uses it. The view contains all the GUI components and there is a great deal of state management by JSF to track the status of the view – typically using HTML hidden fields.
• If the request for the page is an initial request, the JavaServer Faces implementation creates an empty view during this phase. Lifecycle only executes the restore view and render response phases because there is no user input or actions to process.
• If the request for the page is a postback, a view corresponding to this page already exists. During this phase, the JavaServer Faces implementation restores the view by using the state information saved on the client or the server. Lifecycle continues to execute the remaining phases.
• Fortunately this is the phase that requires the least intervention by application code.

Phase 3 : Process validations

The Apply Validations phase triggers calls to all registered validators.

• The components validate the new values coming from the request against the application’s validation rules.
• Any input can be scanned by any number of validators.
• These Validators can be pre-defined or defined by the developer.
• Any validation errors will abort the request–handling process and skip to rendering the response with validation and conversion error messages.

 

Phase 4 : Update Model Values

The Update Model phase brings a transfer of state from the UI component tree to any and all backing beans, according to the value expressions defined for the components themselves.

• It is in this phase that converters are invoked to parse string representations of various values to their proper primitive or object types. If the data cannot be converted to the types specified by the bean properties, the life cycle advances directly to the render response phase so that the page is re-rendered with errors displayed.
• Note: The difference between this phase and Apply Request Values – that phase moves values from client–side HTML form controls to server–side UI components; while in this phase the information moves from the UI components to the backing beans.

Phase 5 : Invoke Application

The Invoke Application phase handles any application-level events. Typically this takes the form of a call to process the action event generated by the submit button that the user clicked.

• Application level events handled
• Application methods invoked
• Navigation outcome calculated

Phase 6 : Render Response

Finally, Render Response brings several inverse behaviors together in one process:

• Values are transferred back to the UI components from the bean. Including any modifications that may have been made by the bean itself or by the controller.
• The UI components save their state – not just their values, but other attributes having to do with the presentation itself. This can happen server–side, but by default state is written into the HTML as hidden input fields and thus returns to the JSF implementation with the next request.
• If the request is a postback and errors were encountered during the apply request values phase, process validations phase, or update model values phase, the original page is rendered during this phase. If the pages contain message or messages tags, any queued error messages are displayed on the page.

Process Events

In this phase, any events that occurred during the previous phase are handled.

• Each Process Events phase gives the application a chance to handle any events (for example, validation failures) that occurred during the previous phase.

Note: Sometimes, an application might need to redirect to a different web application resource, such as a web service, or generate a response that does not contain JavaServer Faces components. In these situations, the developer must skip the rendering phase (Render Response Phase) by calling FacesContext.responseComplete. This situation is also shown in the diagram, with ProcessEvents pointing to the response arrow.

 

AOP (Aspect-Oriented-Programming) in Spring

Definition:  Aspect-oriented programming entails breaking down program logic into distinct parts (so-called concerns, cohesive areas of functionality). Nearly all programming paradigms support some level of grouping and encapsulation of concerns into separate, independent entities by providing abstractions (e.g., functions, procedures, modules, classes, methods) that can be used for implementing, abstracting and composing these concerns. But some concerns defy these forms of implementation and are called crosscutting concerns because they “cut across” multiple abstractions in a program.

Logging exemplifies a crosscutting concern because a logging strategy necessarily affects every logged part of the system. Logging thereby crosscuts all logged classes and methods.

Motivation and Basic Concepts
Typically, an aspect is scattered or tangled as code, making it harder to understand and maintain. It is scattered by virtue of the function (such as logging) being spread over a number of unrelated functions that might use its function, possibly in entirely unrelated systems, different source languages, etc. That means to change logging can require modifying all affected modules. Aspects become tangled not only with the mainline function of the systems in which they are expressed but also with each other. That means changing one concern entails understanding all the tangled concerns or having some means by which the effect of changes can be inferred.

For example, consider a banking application with a conceptually very simple method for transferring an amount from one account to another:

void transfer(Account fromAcc, Account toAcc, int amount) throws Exception {
  if (fromAcc.getBalance() < amount)
      throw new InsufficientFundsException();
 
  fromAcc.withdraw(amount);
  toAcc.deposit(amount);
}

However, this transfer method overlooks certain considerations that a deployed application would require: it lacks security checks to verify that the current user has the authorization to perform this operation; a database transaction should encapsulate the operation in order to prevent accidental data loss; for diagnostics, the operation should be logged to the system log, etc.

A version with all those new concerns, for the sake of example, could look somewhat like this:

void transfer(Account fromAcc, Account toAcc, int amount, User user, Logger logger) throws Exception {
  logger.info("Transferring money…");
 
  if (!isUserAuthorised(user, fromAcc)) {
    logger.info("User has no permission.");
    throw new UnauthorisedUserException();
  }
 
  if (fromAcc.getBalance() < amount) {
    logger.info("Insufficient funds.");
    throw new InsufficientFundsException();
  }
 
  fromAcc.withdraw(amount);
  toAcc.deposit(amount);
 
  database.commitChanges();  // Atomic operation.
 
  logger.info("Transaction successful.");
}

In this example other interests have become tangled with the basic functionality (sometimes called the business logic concern). Transactions, security, and logging all exemplify cross-cutting concerns.

Now consider what happens if we suddenly need to change (for example) the security considerations for the application. In the program’s current version, security-related operations appear scattered across numerous methods, and such a change would require a major effort.AOP attempts to solve this problem by allowing the programmer to express cross-cutting concerns in stand-alone modules called aspects. Aspects can contain advice (code joined to specified points in the program) and inter-type declarations (structural members added to other classes). For example, a security module can include advice that performs a security check before accessing a bank account. The pointcut defines the times (join points) when one can access a bank account, and the code in the advice body defines how the security check is implemented. That way, both the check and the places can be maintained in one place. Further, a good pointcut can anticipate later program changes, so if another developer creates a new method to access the bank account, the advice will apply to the new method when it executes.

So for the above example implementing logging in an aspect:

aspect Logger {
  void Bank.transfer(Account fromAcc, Account toAcc, int amount, User user, Logger logger)  {
    logger.info("Transferring money…");
  }
 
  void Bank.getMoneyBack(User user, int transactionId, Logger logger)  {
    logger.info("User requested money back.");
  }
 
  // Other crosscutting code.
}

One can think of AOP as a debugging tool or as a user-level tool. Advice should be reserved for the cases where you cannot get the function changed (user level)^[6] or do not want to change the function in production code (debugging).

Join Point Models
The advice-related component of an aspect-oriented language defines a join point model (JPM). A JPM defines three things:

1. When the advice can run. These are called join points because they are points in a running program where additional behavior can be usefully joined. A join point needs to be addressable and understandable by an ordinary programmer to be useful. It should also be stable across inconsequential program changes in order for an aspect to be stable across such changes. Many AOP implementations support method executions and field references as join points.

2.  A way to specify (or quantify) join points, called pointcuts. Pointcuts determine whether a given join point matches. Most useful pointcut languages use a syntax like the base language (for example, AspectJ uses Java signatures) and allow reuse through naming and combination.

3. A means of specifying code to run at a join point. AspectJ calls this advice, and can run it before, after, and around join points. Some implementations also support things like defining a method in an aspect on another class.

Join-point models can be compared based on the join points exposed, how join points are specified, the operations permitted at the join points, and the structural enhancements that can be expressed.

 

Beans in Spring World

General Way: Spring beans are just object instances that are managed by the Spring container, namely, they are created and wired by the framework and put into a “bag of objects” (the container) from where you can get them later.

The “wiring” part there is what dependency injection is all about, what it means is that you can just say “I will need this thing” and the framework will follow some rules to get you the proper instance.

Technical Way: Central to the Spring Framework is its inversion of control container, which provides a consistent means of configuring and managing Java objects using reflection. The container is responsible for managing object lifecycles of specific objects: creating these objects, calling their initialization methods, and configuring these objects by wiring them together.

Objects created by the container are also called managed objects or beans. The container can be configured by loading XML files or detecting specific Java annotations on configuration classes. These data sources contain the bean definitions which provide the information required to create the beans.

Objects can be obtained by means of either dependency lookup or dependency injection. Dependency lookup is a pattern where a caller asks the container object for an object with a specific name or of a specific type. Dependency injection is a pattern where the container passes objects by name to other objects, via either constructors, properties, or factory methods.

You have to tailor the beans according to your need and inform Spring container to manage it when required, by using a methodology populalrly known as IoC (Inversion of Control) coined by Martin Fowler, also known as Dependency Injection (DI).

You wire the beans in a way, so that you do not have to take care of the instantiating or evaluate any dependency on the bean. This is popularly known as Hollywood Principle.

9-Patch image and its Use.

NinePatch: defines one stretchable area with the left and top lines and the drawable area with the bottom and right lines. In the top image, the dotted grey lines identify the regions of the image that will be replicated in order to stretch the image. The pink rectangle in the bottom image identifies the region in which the contents of the View are allowed. If the contents don’t fit in this region, then the image will be stretched so that they do.

Usage:  NinePatchDrawable graphic is a stretchable bitmap image, which Android will automatically resize to accommodate the contents of the View in which you have placed it as the background. An example use of a NinePatch is the backgrounds used by standard Android buttons — buttons must stretch to accommodate strings of various lengths. A NinePatch drawable is a standard PNG image that includes an extra 1-pixel-wide border. It must be saved with the extension .9.png, and saved into the res/drawable/ directory of your project.

Spring MVC Web App Configuaration

Below is the basic web.xml configuration. All Spring contexts in /WEB-INF/spring and end in *-context.xml will be loaded into one context. The default context file specific to the simple-form servlet is overridden to not load anything (/WEB-INF/simple-form-servlet.xml would have been loaded otherwise, the name of of the DispatcherServlet plus ‘-servlet.xml’). The servlet-mapping for ‘simple-form’ is configured to handle all requests ending in ‘.html’. The ‘encoding-filter’ sets all requests to the encoding type of UTF-8.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0" metadata-complete="true">
                             
    <display-name>simple-form</display-name>
    
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/spring/*-context.xml
        </param-value>
    </context-param>

    <filter>
        <filter-name>encoding-filter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>encoding-filter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <servlet>
        <servlet-name>simple-form</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>simple-form</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

Spring MVC Request Life Cycle

Let’s see how Spring MVC handles a request. Figure 17-3 shows the main components involved in handling a request in Spring MVC. The figure is based on the one described in the Spring Framework 
forum (http://forum.springsource.org/showthread.php?21639-Spring-MVC-Request-Lifecycle-Diagram), with modifications. 

Figure 17-3. Spring MVC request life cycle

The main components and their purposes are as follows: 
• Filter: The filter applies to every request. Several commonly used filters and their purposes are described in the next section. 
• Dispatcher servlet: The servlet analyzes the requests and dispatches them to the appropriate controller for processing. 
• Common services: The common services will apply to every request to provide supports including i18n, theme, file upload, and so on. Their configuration is defined in the DispatcherServlet’s WebApplicationContext. 
• Handler mapping: This maps the request to the handler (a method within a Spring MVC controller class). Since Spring 2.5, in most situations the configuration is not 
required because Spring MVC will automatically register theorg.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping class that maps handlers based on HTTP paths expressed through the @RequestMapping annotation at the type or method level within controller classes. 
• Handler interceptor: In Spring MVC, you can register interceptors for the handlers for implementing common checking or logic. For example, a handler interceptor can check and ensure that only the handlers can be invoked during office hours. 
• Handler exception resolver: In Spring MVC, the HandlerExceptionResolver interface (under the packageorg.springframework.web.servlet) is designed to deal with unexpected exceptions thrown during request processing by handlers. 
By default, the DispatcherServlet registers the DefaultHandlerExceptionResolver class (under the packageorg.springframework.web.servlet.mvc.support). This resolver handles certain standard Spring MVC exceptions by setting a specific response status code. You can also implement your own exception handler by annotating a controller method with the @ExceptionHandler annotation and passing in the exception type as the attribute. 
• View Resolver: Spring MVC’s ViewResolver interface (under the package org.springframework.web.servlet) supports view resolution based on a logical name returned by the controller. There are many implementation classes to support various view resolving mechanisms. For example, the UrlBasedViewResolver class supports direct resolution of logical names to URLs. The ContentNegotiatingViewResolver class supports dynamic resolving of views depending on the media type supported by the client (such as XML, PDF, JSON, and so on). There also exists a number of implementations to integrate with different view technologies, such as FreeMarker (FreeMarkerViewResolver), Velocity (VelocityViewResolver), and JasperReports (JasperReportsViewResolver). 
These descriptions cover only a few commonly used handlers and resolvers. For a full description, please refer to the Spring Framework reference documentation and its Javadoc.

Quotes

You have to learn the rules of the game. And then you have to play better than anyone else.
– Albert Einstein

Success isn’t something that just happens – success is learned, success is practiced and then it is shared.

– Sparky Anderson

The moment you recognize what is beautiful in this world, you stop being a slave.
– Aravind Adiga

“Strength does not come from winning. Your struggles develop your strengths.”
–Arnold Schwarzenegger

“If you don’t build your dream, someone else will hire you to help them build theirs.”
–Dhirubhai Ambani

“What would life be if we had no courage to attempt anything.”
–Vincent Van Gogh

“Live as if you were to die tomorrow. Learn as if you were to live forever.”
–Mahatma Ghandi

“To be yourself in a world that is constantly trying to make you something else is the greatest accomplishment.”
–Ralph Waldo Emerson

“To Conquer oneself is the best and noblest victory;to be vanquished by one’s own nature is the worst and most ignoble defeat.”
–Plato

Android Videos

 

 

Android Splash screen size generator

XML to JSON Generator

Google Maps with JavaScript

Quick Bootstrap customized buttons

AngularJS with D3 Data Visualization

Http Status Codes

Crosswalk Android

Cordova for AngularJS

Screencasting for Android, iPhone and Windows

Ionic framework

Annotation based Android Development

Google based AngularJS libraries

Roboguice framework for android

Android opensource based libraries

Rest API Reference

JSON Object Viewer

CSSPre Convert

LessToCss,  LessToCssAnother