Sunday, August 19, 2012

Architecture for Multi-device Applications: Part 3 - Consumption Channel

In Part 1, we discussed about the bare-bore design.
In Part 2, we discussed about the high-level implementation structure.
In Part 3, we now explode the box #1 - "Browser or Custom App". We look at various consumption channels and how they affect the implementation and technology choices.

At a broad level, there are these four channels for consuming any application data[1]:
  • Native application for desktops
    • Operating system dependent (Windows, Mac, Linux, Solaris)
    • Extreme choices of GUI libraries available (MFC, Cocoa, GTk, Qt etc) - a bunch of them cross-platform
    • A large set of libraries has bindings for multiple languages (Java SWT, GTk#, Tcl/Tk etc)
    • Has access to maximum hardware and other resources of the machine
    • Data format and protocol choice is completely under your control - from binary data over custom protocol to XML/JSON data over HTTP
  • Native application for tables and mobiles
    • Again, OS dependent
    • Limited choice of GUI libraries available - mostly platform dependent (iOS, Android, Symbian, Blackberry, Windows Phone etc)
    • Has limited, but sufficiently large, access to the hardware and other resources of the device
    • Message and transport protocols are under your control
  • Browser based applications
    • Choice of programming language is restricted to JavaScript, except for native browser plugins (that I won't consider)
    • Choice of formatting and rendering language is restricted to HTML
    • Choice of styling metadata is restricted to CSS
    • Open standards based, cross-browser, cross-platform development can be powerful as well as tricky
    • Plethora of frameworks and toolkits available (jQuery, YUI, Dojo, GWT etc)
    • Transport protocol is strictly HTTP/S, message protocol is typically in JSON / HTML and, at times, XML though not generally preferred because of performance
  • 3rd party applications
    • Choice of data format not really under your control - typically, would be either XML or JSON. You want it to be portable across applications
    • Transport protocol will typically be HTTP/S
    • Endpoints will typically be RESTful, though not necessary or mandatory
    • Don't have to worry about the end user interface - left to the final application

Question: Can we come up with one choice for transport protocol, message format?
Answer: I guess yes. HTTP/S should be the de-facto choice for transport protocol. And this choice shouldn't require any second thought. These protocols are, probably, the only ones that are invariably allowed by all firewalls - be it wi-fi modem at your home or the one at your office. Corner cases are different issues.

What about the message protocol / format? XML or JSON? And I am pretty sure, the world may be divided on this. I will always get down to choice only between these two for the reasons of portability across languages and platforms - we have parsers and serializers across the board. Both of them have their own pros and cons. Lately, I have started favouring JSON. Even my Java / PHP applications now use JSON format - even the configuration files that I use are in JSON format.

Question again is - is JSON my personal choice or is there a logical reasoning behind it?

Well, it's my personal choice that I can support with logical reasoning. Apart from other reasons, there are two prominent ones:
  1. If needed, I can pass-on the data (complete or partial) into the browser where processing JSON is at least multiple times faster than XML. I once did a benchmark and found JSON parsing 100x-250x faster. That's logical. And I live in a world where it's all about web. That's personal.
  2. I can move my application to Node server and there - it's all about JavaScript. Refer to reason #1 for more details after this. :)
    Moving to Node is personal choice but if the application is web based, it's a logical choice.
Summary:
Use HTTP as the transport protocol and JSON as the message format.

Addendum: If possible, use JavaScript runtime. These days, you can create applications using HTML5 and wrap it using embedded browser.

[1]: The reason why I use the term "application data" and not "application" is that several times, we may send out raw data for application mashup while at other times the application itself is the end-consumer of the data.

Sunday, August 5, 2012

Processing Shortcodes in a post in Minow

Minow can now process short-codes. Well, it started doing so almost a month back... just that I never got time to update my blog.

As of now, the short-code processor has been encapsulated in a simple interface that does the processing of a short-code with attributes. At http://minow-web.appspot.com/, you may notice YouTube videos embedded in the posts. They are not hard-coded HTML but processed using the YouTube short-code processor.


I still need to model and design the administration part of all the plugins, widgets, short-code processors and other extensions. There are few challenges that I have at my hand:
  • Give extension the ability to define the configurable attributes and their default values, if applicable
  • Give extension the ability to create a fancy, easy to use and portable-across-devices user interface to use the configuration
  • The question, however, is - should it user-interface be verbose using Freemarker templates or an easy-to-define view with default / advanced renderers or a mix of the two (most complex to define and implement)?
Let me ponder over it... hopefully, something should be ready soon.

Anyway, here is how the sample website looks like presently.



Sunday, July 15, 2012

Architecture for Multi-device Applications: Part 2 - Implementation

Part 1 of the series on "Architecture for Multi-Device Applications" focussed on the bare-bore design.

In Part 2, we look at high-level implementation structure - a slightly more detailed version of the design discussed in Part 1, before we start opening the individual boxes.

One of the key aspects that we discussed in Part 1 was the separation between the "Application Server" and "Web Server" layer and argued that most of the applications that we come across in real world, daily life, don't really separate them... or rather we find them difficult to separate because of the choices that we have or we are "taught" in our life.

The diagram below summarizes what I am talking about...

Oh! Damn... doesn't this diagram look horribly close to the earlier one? Where's the difference / value-add?

Ok.... I heard you. As I said, this is still a high-level diagram but let's look at now the options available within each box:
  1. Application Consumption: Desktop Browser, Mobile / Tablet (Browser or Wrapped Browser), Internet TV, Mobile/Tablet Native applications.
  2. User Interface Servers: Also known as the frontend servers and preferably generates cross-browser / cross-device HTML5 / CSS3 based user interface, unless it's a native application for desktops / mobiles.
  3. Biz-Logic Access Layer: Also known as the backend servers. They provide controlled access (read: authentication / authorization) to the data from the store (as is or processed). The access, preferably, is RESTful - this, however, is not mandatory. This layer, typically, is very thin - parses the incoming data, passes on to the biz-logic layer and serves back the response.
  4. Biz-Logic Layer: Typically, they are no different than the Biz-Logic Access Layer in physical deployment topology. However, in terms of implementation, it may be libraries that are consumed by the backend (access) servers.
  5. NoSQL Access: I could have just called the data-tier as persistence layer but I strongly choose NoSQL because that where you really are able to get the scale. If you are writing an otherwise application, replace this box with data-access layer.
  6. NoSQL Store: The actual store of the data.
  7. Client-side Data Cache: You may need that for long-activities or offline access or otherwise.
  8. External Modules (Frontend): If your application provides UI-integration with other servers (say, Facebook / Twitter / Pinterest Social Integration or otherwise).
  9. Server-side Data Cache: I don't think there is any need to talk about its usefulness. Having said that, you may not always use it.
  10. External Systems (Backend): For any API-based integration with 3rd party systems (say, Facebook / Twitter data access and processing that may require application secret key etc)
I hope the structure is now clear. In subsequent parts, we shall dissect open each box and explore:
  1. What is it all about in detail
  2. External forces or uncontrolled parameters (e.g.: Browser etc)
  3. The options available
  4. Comparative study of the options - to decide when to use what
Keep watching...

Saturday, July 14, 2012

Architecture for Multi-device Applications: Part 1 - Definition

One of the questions that keeps coming to me over and over again is - what is an ideal architecture for multi-device applications or rather applications that cater to multiple devices like desktop, mobiles, tablets, internet-TVs and what not?

This is quite interesting and exciting as more and more frameworks get developed. We started the multi-device world with native apps and soon realized that the model doesn't scale. There came HTML apps (or what people naively refer to as HTML5). I won't call them as really HTML5 (HTML5 only) apps... since you can live with HTML4 and CSS2 for most of the purposes unless you want features specific to HTML5 - most common being using audio/video since Flash is unavailable on iOS (iPhone, iPad etc).

Cross-mobile HTML apps gave birth to fantastic mobile UI frameworks like Sencha Touch, jQuery Mobile. And to access device-specific capabilities without having to maintain multiple codebases, we have amazing stuff like Phonegap and Titanium.

Great. Now that we have some great frameworks, how can we leverage them to design our application architecture?

A very common architecture that we come across, doesn't matter how old it is - yet it is valid, is:

Notice how carefully the Web Server is separated from the Application Server. But do we really get that? Most of the applications (read: enterprise) have the Web and Application stacks on the same server... and that's not a good idea.

Why? Well... we can't scale the web (frontend, browser facing) servers as they tend to be heavier. Additionally, it gets harder to do a lot more of the stuff:
  1. Redirecting based on the origin of request - device-based (e.g. m. for mobile, www. for standard), region-based (e.g. /hi-IN for India based, /en-US for elsewhere) etc
  2. Caching - suddenly you start mixing the global-data (non-user specific), user-specific, module-specific (if the frontend is properly modularized) etc
  3. Security - Ouch! All your data-calls are made from the "common server" and a compromise there can leave you at bigger risk than otherwise
  4. And a lot more...
Basic rule is to ensure that the "backend servers" are separate from "frontend servers".

So, the question now that gets in - how do I implement this in real world? And how do these new frontend (read: UI) frameworks help... let's explore that in Part 2 of the article.

References:
  1. Sencha Touch: http://www.sencha.com/products/touch/
  2. jQuery Mobile: http://jquerymobile.com/
  3. PhoneGap: http://phonegap.com/
  4. Titanium: http://www.appcelerator.com/platform
  5. The architecture of Web applications: http://www.ibm.com/developerworks/ibm/library/it-booch_web/

Friday, June 15, 2012

Minow now has multiple themes

Yesterday, I tested the Minow framework with another theme that I personally like because of simplicity and card-layout - Shaken Grid. As earlier, I am not the owner or maintainer of the theme, I just ported it to Minow.
I did this experiment to identify theme-requirements early (lean methodology) with minimum efforts and resources.
The result is some changes in the Minow Engine to serve images, CSS and JavaScript content with appropriate content-type from the template folder noting that the actual theme template should not be accessible directly (read: raw).
To summarize what's available as of now is:
  • Theme, with templates based on Freemarker.
    As of now, the choice of template is based on query string (as PoC). Eventually, it will be configurable.
  • Localization, with locales based on ISO-639 and ISO 3166-1 alpha-2 codes.
And the results are available at:
Screenshot of what's working:


Wednesday, June 13, 2012

Update on Minow Progress

Minow (Minow Is Not Wordpress) Engine can now read data from data-store. It's not generic enough though - right now hard-coded to Google App Engine, but nevertheless.

Here's what I've done since last push:
  • Model for localized content is ready
  • Basic logic to retrieve content for a given locale (not parent, no fallback) is ready. For example, if the language is "hi_IN" (Hindi-India), it - as of now - can get you the content for "hi" and/or fallback to "en_US" / "en".
    As of now, the language is a query-parameter... will enhance to parse "accept-languages" header with priority (q=0.3 etc)
  • Nest theme has been updated to use the "real" data
  • Implementation exists to lazy load data from the store - don't load the posts until they're really required. A lot of Wordpress templates do not have blog on their landing page
  • And of course, a piece of code generate sample data ;-)
The code is live at its usual location - http://minow-web.appspot.com/. However, try also: http://minow-web.appspot.com/?lang=hi to the "sample content" in Hindi.

Screenshot of what's working:



Monday, June 11, 2012

Wordpress on Google App Engine

I think this is a dream for almost every blogger... well, at least my and at least hundreds of thousands of others.

Most of the other results that you'll find on search engines relating to Wordpress and Google App Engine are about running Wordpress on GAE/J by using Caucho Quercus - a bridge between PHP and Java. However, if running / simulating PHP on Java was that easy, PHP on GAE would not have been most starred issue.

And that made me think... how about creating, may be, yet another blog engine for GAE. And what better than taking clues from Wordpress.

So, that gave birth of Minow, acronym for Minow Is Not Wordpress. Yes, it's a recursive acronym - see http://en.wikipedia.org/wiki/Recursive_acronym for what I mean.

I just got a basic, brute forced, version of Minow up and running on GAE. It's available at http://minow-web.appspot.com/.

(Thanks to YChong for the Wordpress Nest Theme that I've gotten started with as a PoC).

Screenshot of what's working:


Saturday, June 9, 2012

Friday, June 8, 2012

Yahoo! Mojito on standard Node Server/Cloud

Getting started with Yahoo! Mojito is pretty straightforward. The only catch is, you must issue a mojito start command.

The problem that we get into is that most of the public Node.js clouds have no idea about this new command. All they know to do is node server.js

Recently I tried my hands with Nodester (www.nodester.com). Standard mojito code failed since server.js only instantiated an HTTP server but did not listen.

With inputs from Terry on making the server listen, I was able to run Mojito application on Nodester.
The original discussion between Terry and myself is at http://groups.google.com/group/nodester/browse_thread/thread/e35c7eb3b122ff01

The running application is provisioned at http://gvtestapp.nodester.com/@HelloMojit/index

UPDATE: The application is now available at http://gvtestapp.nodester.com/

Monday, May 28, 2012

Yahoo! Mojito: Part 2 – Enhanced Hello World!

This is Part 2 of the "Hello World" article. In this followup article, we enhance our code to:
  1. Render a form on the landing page which asks user to enter his/her name
  2. Process the data on the submitted form
  3. Say "Hello {user}" rather than "Hello World"
What we will learn through all this is:
  1. One of the various possible options to accept data to the server
  2. Process incoming data
  3. Apply business logic and create the data to be rendered
Let's get started with customizing the view to create a form...

Sunday, May 27, 2012

Yahoo! Mojito: Part 1 - Hello World!

Yahoo! Mojito is, now, watched officially by 1027 developers (as of writing this article) on Github (see https://github.com/yahoo/mojito/watchers) and is actively contributed by developers across the board (see https://github.com/yahoo/mojito/network). And I'm pretty sure, there will be several others who would have downloaded, installed and tried.

Before getting into this detailed Hell World tutorial, I assume that you've already installed Yahoo! Mojito using the instructions given at https://github.com/yahoo/mojito README. I preferred an npm-install to ensure that I get a stable version.

Defining the "Hello World" application:
  1. The first step will be to create an application with defaults, no customization, and get it running.
  2. Next, we'll make the application run at port 80 and ensure that the content is available at "/" rather than a strange but intuitive default path.
  3. Subsequently, we'll change the default contents to reflect "Hello World" in the message
  4. And finally, we'll make the application interactive by creating a simple form that will accept user's name and say hello to him/her rather than to the whole world ;)
And here's some vocabulary before we deep dive:
  1. Yahoo! Mojito: MVC framework for JavaScript based application.
  2. Mojito Application: An application based on Mojito framework.
  3. Mojit: A mojito widget - with its own model, view, controller and binder.
We call this application - "HelloWorldApp" and the mojit as "HelloMojit".

Friday, May 11, 2012

Wordpress for Google App Engine?

I love WordPress. A big fan. But then I once-upon-a-time used to be a huge fan of PHP, and then I've grown up. I know people will kill me for that statement. ;-)

But the fact of the matter is PHP still has serious issues. And most recently, I can't use it to run WordPress at Google App Engine, something that's amazingly great for the starters who want to setup quick-and-not-so-dirty app.

I thought... would it be good to have Wordpress for GAE? I came across Vosao - Open Source CMS for GAE/J. And I loved it immediately. Has a long way to go, and I do not see any active development on the same... surprised, what happened to the team.

StackOverflow has a question - What CMS runs on Google App Engine, but I personally didn't like any of them.

And then I thought again... how about writing my own CMS with persistence in a Non-Relational Store with plug-in model so that I can run it on any store, be it GAE's Data Store, MongoDB or Amazon DynamoDB or whatever.

Let me see if I can hold on my thoughts and really get on with it... At the moment, no promises! :-)

Yahoo! Mojito - Web Developers' Dream

I've started to love HasGeek forum more than others... and there are reasons, mainly the audience and quality - of speakers, planning and execution. I was happily surprised to note that the guys used NFC cards, most probably during breaks. Probably because I had to leave after my session in the morning.

My session at MetaRefresh 2012 was on Yahoo! Mojito, which was recently open sourced at Github.
Below are the slides from the presentation...

Monday, April 9, 2012

Yahoo! Mojito - The Ultimate MVC Framework for Web Apps

Probably. Well, I feel it at least as of date.

More often than not, the web application developers end up in doing the following:
  1. Create a server side logic of the application with all code in PHP, Java, Python, Ruby, C# and what not languages
  2. Choose amazing server side frameworks like CodeIgniter, Struts / JSF, Django, RoR, ASP.Net MVC and what not amazing (MVC or otherwise) frameworks
  3. Create a client side view of the application using HTML / JavaScript / CSS for web, Java for Android, Objective C for iOS etc
  4. Create a middleware for client-server transaction, typically using JSON / XML as content format and serializers and deserializers on either sides in corresponding language (server / client sides)
The issues that typically arise are:
  1. Ensure that the server and client sides of the middleware are always in sync in terms of their contracts
  2. Ensure that the end-points are correctly defined and both the sides are kept in sync
  3. Ensure that the end-points are correctly registered in web.xml, web.config, routes.rb, appropriate Python / PHP files etc
  4. Ensure that if multiple requests are fired to the server to retrieve data, you manage the responses appropriately (this is relatively easier because of jQuery / YUI structures)
I am pretty confident, there are a lot more problems pertaining to client <=> server interaction and state maintenance but these are some of the important ones. I'd love to hear about more crucial issues...

Wouldn't it be great if it would be possible to answer "YES" for the following...
  1. Can I just do a MyModel.getData(myCallbackFunction) and don't worry if the piece of code is called on the server or the client?
  2. Can I just call a business operation doWork and don't worry if it needs data which may have to be retrieved from the server or the client?
  3. Can I just call an operation doWork and don't worry if it actually gets called on the client or the server?
Well, that's where - and for lot more reasons - Yahoo! Mojito framework comes into picture.

It seems I just can't wait to write about it... one piece at a time. btw, my enhancements to Mojito are available at Github at https://github.com/gvaish/mojito

Sunday, April 8, 2012

Speed of Light - in Vedas

[This article is reproduction of an exciting content found elsewhere.]

Speed of light in Rigveda: (Originally from http://on.fb.me/IpQAF2, a long commentary at http://bit.ly/I55raN)

Ancient Vedic science “Nimisharda” is a phrase used in Indian languages of Sanskrit origin while referring to something that happens/moves instantly, similar to the ‘blink of an eye’. Nimisharda means half of a Nimesa, (Ardha is half).

In Sanskrit ‘Nimisha’ means ‘blink of an eye’ and Nimisharda implies within the blink of an eye. This phrase is commonly used to refer to instantaneous events.

Below is the mathematical calculations of a research done by S S De and P V Vartak on the speed of light calculated using the Rigvedic hymns and commentaries on them.

The fourth verse of the Rigvedic hymn 1:50 (50th hymn in book 1 of rigveda) is as follows:

तरणिर्विश्वदर्शतो जयोतिष्क्र्दसि सूर्य | विश्वमा भासिरोचनम |
taraNir vishvadarshato jyotishkrdasi surya | vishvamaa bhaasirochanam ||

which means:
“Swift and all beautiful art thou, O Surya (Surya=Sun), maker of the light, Illumining all the radiant realm.”

Commenting on this verse in his Rigvedic commentary, Sayana who was a minister in the court of Bukka of the great Vijayanagar Empire of Karnataka in South India (in early 14th century) says:
" tatha ca smaryate yojananam. sahasre dve dve sate dve ca yojane ekena nimishardhena kramaman." which means “It is remembered here that Sun (light) traverses 2,202 yojanas in half a nimisha”

NOTE: Nimisharda= half of a nimisha.


In the vedas Yojana is a unit of distance and Nimisha is a unit of time.

Unit of Time: Nimesa.
The Moksha dharma parva of Shanti Parva in Mahabharata describes Nimisha as follows: 15 Nimisha = 1 Kastha.

30 Kashta = 1 Kala,
30.3 Kala = 1 Muhurta,
30 Muhurtas = 1 Diva-Ratri (Day-Night),
We know Day-Night is 24 hours So we get 24 hours = 30 x 30.3 x 30 x 15 nimisha, in other words 409050 nimisha.

We know 1 hour = 60 x 60 = 3600 seconds.
So 24 hours = 24 x 3600 seconds = 409050 nimisha.
409050 nimesa = 86,400 seconds,
1 nimesa = 0.2112 seconds (This is a recursive decimal! Wink of an eye=.2112 seconds!).
1/2 nimesa = 0.1056 seconds.

Unit of Distance:
Yojana Yojana is defined in Chapter 6 of Book 1 of the ancient vedic text “Vishnu Purana” as follows:-
10 ParamAnus = 1 Parasúkshma,
10 Parasúkshmas = 1 Trasarenu,
10 Trasarenus = 1 Mahírajas (particle of dust),
10 Mahírajas= 1 Bálágra (hair’s point),
10 Bálágra = 1 Likhsha,
10 Likhsha= 1 Yuka,
10 Yukas = 1 Yavodara (heart of barley),
10 Yavodaras = 1 Yava (barley grain of middle size),
10 Yava = 1 Angula (1.89 cm or approx 3/4 inch),
6 fingers = 1 Pada (the breadth of it),
2 Padas = 1 Vitasti (span),
2 Vitasti = 1 Hasta (cubit),
4 Hastas = a Dhanu,
1 Danda, or paurusa (a man’s height),
or 2 Nárikás = 6 feet,
2000 Dhanus = 1 Gavyuti (distance to which a cow’s call or lowing can be heard) = 12000 feet 4 Gavyutis = 1 Yojana = 9.09 miles

Calculation: So now we can calculate what is the value of the speed of light in modern units based on the value given as 2202 Yojanas in 1/2 Nimesa = 2202 x 9.09 miles per 0.1056 seconds = 20016.18 miles per 0.1056 seconds = 189547 miles per second !!

As per the modern science speed of light is 186000 miles per second ! And so I without the slightest doubt attribute the slight difference between the two values to our error in accurately translating from Vedic units to SI/CGS units. Note that we have approximated 1 Angula as exactly 3/4 inch. While the approximation is true, the Angula is not exactly 3/4 inch.

Friday, January 6, 2012

User Experience and Application on Google App Engine

So, we have been working on this application... web based, data driven, to be used in "social context". I think today there's nothing sexier than using the word social.

We designed this application nicely, fantastic by many ways. We were sure of putting this up on a public cloud, just that we were not sure of which one: EC2 or GAE. One of the most riskiest questions to keep open... but really, we were not sure. The only thing we were sure of was Java + jQuery + HTML5 (as much as possible).

EC2 gives you IaaS but then you must manage all the servers, load balancing, failovers. Even if you happen to choose BeanStalk, a lot of work has to be done, specifically database. Thankfully, we now have ElastiCache (launched around August 2011, IIRC) otherwise managing a cluster of Memcache was yet another task for the admins.

GAE provides you PaaS, so you don't need to worry about doing all the stuff in previous paragraph yourself. Except that you have strong restrictions... a very small subset of Java SE library - specifically, not threads or direct sockets, no JDBC and Datastore, though amazing, is not an easy meat to digest for those not used to. And above all, the server side execution must complete in 30 seconds (now on what are known are front-end servers).

So, we designed our own data-access abstraction so that we can switch EC2 <=> GAE without any hassles. It took a while, but it's a great thing that we have.

After writing core entities and business logic layer, it was time to start pushing it all up to the user interface. The dashboard - the landing page after login - has to get updates from various "components" in the system. All components worked great, except that the dashboard took somewhere around 1200ms to load for the first time. Note that most of the public resources (images, JavaScript, CSS) were loaded from GAE CDNs.

Just not acceptable!


So, what do we do? Except for one of the menus, all of the data is user specific, and may not be a good idea to cache it all. Above all, we had a restriction that GAE Memcache servers cannot have more than 1MB entity.

What we were damn sure about is that there's nothing much that we can do to reduce the time to compute. Efficient datastore retrieval, great entity structures, had denormalized and duplicated the data a lot for faster retrieval... nothing much you can do.

Ajax. Great! We'd already been using it. The first thing was obvious - can we just "loading..." components with Ajax calls on the dashboard and then fetch the data.

But then, how many hits to the server? One of the key things in network interactions is use of chunky messages rather than chatty messages. Additionally, HTTP/1.1 says the browsers should not open more than 2 simultaneous connections to the server. And what more... these components are completely independent of each other, how do we combine then?

So, we wrote a mini-layer: For Combine-Split-Execute-Combine-Split-Display Process.
  1. At the client, we'll combine two requests into one, send it to the server.
  2. On the server, the data will be split and two business operations will be executed. On GAE, I can't start Threads, no Futures... so, one limitation we hit there. But that's fine.
  3. Combine the results from the business operations and respond back to the client.
  4. Client will split the results and fire them off to the corresponding requesters.
  5. There were some more optimizations that we did on serialized data model (messaging model) besides putting off some operations in GAE Queue
Voila! The results of all this was that the landing page is now loaded in less than 18ms (sans network latency) and a much better user experience.

But it's not the end of the day yet... we're tuning the application further more.