Software Solutions Developed With
High Perfection & High Quality

Web 2.0 Frameworks

Web 2.0

Web 2.0 describes web sites that use technology beyond the static pages of earlier web sites. The term was coined in 1999 by Darcy DiNucci and was popularized by Tim O'Reilly at the O'Reilly Media Web 2.0 conference in late 2004. Although Web 2.0 suggests a new version of the World Wide Web, it does not refer to an update to any technical specification, but rather to cumulative changes in the way web pages are made and used.

A Web 2.0 site may allow users to interact and collaborate with each other in a social media dialogue as creators of user-generated content in a virtual community, in contrast to websites where people are limited to the passive viewing of content. Examples of Web 2.0 include social networking sites, blogs, wikis, folksonomies, video sharing sites, hosted services, web applications, and mashups.

Whether Web 2.0 is substantively different from prior web technologies has been challenged by World Wide Web inventor Sir Tim Berners-Lee, who describes the term as jargon. His original vision of the Web was "a collaborative medium, a place where we could all meet and read and write".


Web 2.0 websites allow users to do more than just retrieve information. By increasing what was already possible in "Web 1.0", they provide the user with more user-interface, software and storage facilities, all through their browser. This has been called "network as platform" computing. Major features of Web 2.0 include social networking sites, user created web sites, self-publishing platforms, tagging, and social bookmarking. Users can provide the data that is on a Web 2.0 site and exercise some control over that data. These site may have an "architecture of participation" that encourages users to add value to the application as they use it. Some scholars have put forth cloud computing as an example of Web 2.0 because cloud computing is simply an implication of computing on the Internet.

The concept of Web-as-participation-platform captures many of these characteristics. Bart Decrem, a founder and former CEO of Flock, calls Web 2.0 the "participatory Web" and regards the Web-as-information-source as Web 1.0

Web 2.0 offers all users the same freedom to contribute. While this opens the possibility for serious debate and collaboration, it also increases the incidence of "spamming" and "trolling" by unscrupulous or misanthropic users. The impossibility of excluding group members who don’t contribute to the provision of goods from sharing profits gives rise to the possibility that serious members will prefer to withhold their contribution of effort and free ride on the contribution of others. This requires what is sometimes called radical trust by the management of the website. According to Best, the characteristics of Web 2.0 are: rich user experience, user participation, dynamic content, metadata, web standards and scalability. Further characteristics, such as openness, freedom and collective intelligence by way of user participation, can also be viewed as essential attributes of Web 2.0

The key features of Web 2.0 include :

    • Folksonomy; free classification of information
    • A rich user experience
    • A user as a contributor
    • Long tail
    • User participation
    • Basic trust
    • Dispersion

  • .

    Web 2.0 Frameworks :

    The client-side (web browser) technologies used in Web 2.0 development include Ajax and JavaScript frameworks such as YUI Library, Dojo Toolkit, MooTools, jQuery,Extjs and Prototype JavaScript Framework. Ajax programming uses JavaScript to upload and download new data from the web server without undergoing a full page reload.

    To allow users to continue to interact with the page, communications such as data requests going to the server are separated from data coming back to the page (asynchronously). Otherwise, the user would have to routinely wait for the data to come back before they can do anything else on that page, just as a user has to wait for a page to complete the reload. This also increases overall performance of the site, as the sending of requests can complete quicker independent of blocking and queueing required to send data back to the client.

    The data fetched by an Ajax request is typically formatted in XML or JSON (JavaScript Object Notation) format, two widely used structured data formats. Since both of these formats are natively understood by JavaScript, a programmer can easily use them to transmit structured data in their web application. When this data is received via Ajax, the JavaScript program then uses the Document Object Model (DOM) to dynamically update the web page based on the new data, allowing for a rapid and interactive user experience. In short, using these techniques, Web designers can make their pages function like desktop applications. For example, Google Docs uses this technique to create a Web based word processor.

    Adobe Flex is another technology often used in Web 2.0 applications. Compared to JavaScript libraries like jQuery, Flex makes it easier for programmers to populate large data grids, charts, and other heavy user interactions. Applications programmed in Flex are compiled and displayed as Flash within the browser. As a widely available plugin independent of W3C standards (the World Wide Web Consortium is the governing body of web standards and protocols), Flash is capable of doing many things that were not possible pre-HTML5, the language used to construct web pages. Of Flash's many capabilities, the most commonly used in Web 2.0 is its ability to play audio and video files. This has allowed for the creation of Web 2.0 sites where video media is seamlessly integrated with standard HTML. With the introduction of HTML5 in 2010, the role of Flash is decreasing. HTML5 video has been proven to decrease the amount of computer resources required, compared to Adobe’s Flash: Apple Inc. demonstrated that the use of Flash on mobile devices decreases battery lifespan significantly. In November 2011, Adobe announced that they will no longer publish future public versions of the mobile Flash plugin.

    In addition to Flash and Ajax, JavaScript/Ajax frameworks have recently become a very popular means of creating Web 2.0 sites. At their core, these frameworks use the same technology as JavaScript, Ajax, and the DOM. However, frameworks smooth over inconsistencies between web browsers and extend the functionality available to developers. Many of them also come with customizable, prefabricated 'widgets' that accomplish such common tasks as picking a date from a calendar, displaying a data chart, or making a tabbed panel.

    On the server side, Web 2.0 uses many of the same technologies as Web 1.0. Languages such as PHP, Ruby, Perl, Python, as well as JSP, and ASP.NET, are used by developers to output data dynamically using information from files and databases. What has begun to change in Web 2.0 is the way this data is formatted. In the early days of the Internet, there was little need for different websites to communicate with each other and share data. In the new "participatory web", however, sharing data between sites has become an essential capability. To share its data with other sites, a website must be able to generate output in machine-readable formats such as XML (Atom, RSS, etc.) and JSON. When a site's data is available in one of these formats, another website can use it to integrate a portion of that site's functionality into itself, linking the two together. When this design pattern is implemented, it ultimately leads to data that is both easier to find and more thoroughly categorized, a hallmark of the philosophy behind the Web 2.0 movement.


    Web 2.0 can be described in three parts :

    Rich Internet application (RIA) - defines the experience brought from desktop to browser whether it is from a graphical point of view or usability point of view. Some buzzwords related to RIA are Ajax and Flash.

    Web-oriented architecture (WOA) - is a key piece in Web 2.0, which defines how Web 2.0 applications expose their functionality so that other applications can leverage and integrate the functionality providing a set of much richer applications. Examples are feeds, RSS, Web Services, mash-ups.

    Social Web - defines how Web 2.0 tends to interact much more with the end user and make the end-user an integral part.

    As such, Web 2.0 draws together the capabilities of client- and server-side software, content syndication and the use of network protocols. Standards-oriented web browsers may use plug-ins and software extensions to handle the content and the user interactions. Web 2.0 sites provide users with information storage, creation, and dissemination capabilities that were not possible in the environment now known as "Web 1.0".

    Web 2.0 websites include the following features and techniques, referred to as the acronym SLATES by Andrew McAfee :

    Search :
    Finding information through keyword search.

    Links : Connects information together into a meaningful information ecosystem using the model of the Web, and provides low-barrier social tools.

    Authoring :
    The ability to create and update content leads to the collaborative work of many rather than just a few web authors. In wikis, users may extend, undo and redo each other's work. In blogs, posts and the comments of individuals build up over time.

    Tags :
    Categorization of content by users adding "tags" - short, usually one-word descriptions - to facilitate searching, without dependence on pre-made categories. Collections of tags created by many users within a single system may be referred to as "folksonomies" (i.e., folk taxonomies).

    Extensions :
    Software that makes the Web an application platform as well as a document server. These include software like Adobe Reader, Adobe Flash player, Microsoft Silverlight, ActiveX, Oracle Java, QuickTime, Windows Media, etc.

    Signals :
    The use of syndication technology such as RSS to notify users of content changes.

    While SLATES forms the basic framework of Enterprise 2.0, it does not contradict all of the higher level Web 2.0 design patterns and business models. In this way, a new Web 2.0 report from O'Reilly is quite effective and diligent in interweaving the story of Web 2.0 with the specific aspects of Enterprise 2.0. It includes discussions of self-service IT, the long tail of enterprise IT demand, and many other consequences of the Web 2.0 era in the enterprise. The report also makes many sensible recommendations around starting small with pilot projects and measuring results, among a fairly long list.

    Web-based applications and desktops

    AJAX has prompted the development of websites that mimic desktop applications, such as word processing, the spreadsheet, and slide-show presentation. In 2006 Google, Inc. acquired one of the best-known sites of this broad class, Writely. WYSIWYG wiki and blogging sites replicate many features of PC authoring applications.

    Several browser-based services have emerged, including EyeOS and YouOS.(No longer active.) Although named operating systems, many of these services are application platforms. They mimic the user experience of desktop operating-systems, offering features and applications similar to a PC environment, and are able to run within any modern browser. However, these so-called "operating systems" do not directly control the hardware on the client's computer.

    Numerous web-based application services appeared during the dot-com bubble of 1997 - 2001 and then vanished, having failed to gain a critical mass of customers. In 2005, WebEx acquired one of the better-known of these,, for $45 million.

    Distribution of media
    XML and RSS

    Many regard syndication of site content as a Web 2.0 feature. Syndication uses standardized protocols to permit end-users to make use of a site's data in another context (such as another website, a browser plugin, or a separate desktop application). Protocols permitting syndication include RSS (really simple syndication, also known as web syndication), RDF (as in RSS 1.1), and Atom, all of which are XML-based formats. Observers have started to refer to these technologies as web feeds.

    Specialized protocols such as FOAF and XFN (both for social networking) extend the functionality of sites and permit end-users to interact without centralized websites.

    Web APIs

    Web 2.0 often uses machine-based interactions such as REST and SOAP. Servers often expose proprietary Application programming interfaces (API), but standard APIs (for example, for posting to a blog or notifying a blog update) have also come into use. Most communications through APIs involve XML or JSON payloads.

    REST APIs, through their use of self-descriptive messages and hypermedia as the engine of application state, should be self-describing once an entry URI is known. Web Services Description Language (WSDL) is the standard way of publishing a SOAP API and there are a range of web service specifications.

    Web 3.0 Frameworks :
    Web 3.0

    Definitions of Web 3.0 vary greatly. Some believe its most important features are the Semantic Web and personalization. Focusing on the computer elements, Conrad Wolfram has argued that Web 3.0 is where "the computer is generating new information", rather than humans.

    Andrew Keen, author of The Cult of the Amateur, considers the Semantic Web an "unrealisable abstraction" and sees Web 3.0 as the return of experts and authorities to the Web. For example, he points to Bertelsmann's deal with the German Wikipedia to produce an edited print version of that encyclopedia. CNN Money's Jessi Hempel expects Web 3.0 to emerge from new and innovative Web 2.0 services with a profitable business model.

    Futurist John Smart, lead author of the Metaverse Roadmap, defines Web 3.0 as the first-generation Metaverse (convergence of the virtual and physical world), a web development layer that includes TV-quality open video, 3D simulations, augmented reality, human-constructed semantic standards, and pervasive broadband, wireless, and sensors. Web 3.0's early geosocial (Foursquare, etc.) and augmented reality (Layar, etc.) webs are an extension of Web 2.0's participatory technologies and social networks (Facebook, etc.) into 3D space. Of all its metaverse-like developments, Smart suggests Web 3.0's most defining characteristic will be the mass diffusion of NTSC-or-better quality video to TVs, laptops, tablets, and mobile devices, a time when "the internet swallows the television." Smart considers Web 3.0 to be the Semantic Web and in particular, the rise of statistical, machine-constructed semantic tags and algorithms, driven by broad collective use of conversational interfaces, perhaps circa 2020. David Siegel's perspective in Pull: The Power of the Semantic Web, 2009, is consonant with this, proposing that the growth of human-constructed semantic standards and data will be a slow, industry-specific incremental process for years to come, perhaps unlikely to tip into broad social utility until after 2020.

    According to some Internet experts, Web 3.0 will enable the use of autonomous agents to perform some tasks for the user. Rather than having search engines gear towards your keywords, the search engines will gear towards the user.

    The current Research & Development Focus of the United States - Department of Defense's Advanced Distributed Learning (ADL) Initiative describes these autonomous agents as the personal assistants to the Next Generation Learner in the Next Generation Learner Environment. The Personal Assistant for Learning (PAL) is a long-term focus of ADL's R&D endeavors over the next 10 - 15 years. The goal of this research is to create a capability that anticipates learner needs, seamlessly integrates yet-to-be available information, and provides ubiquitous access to effective, personalized learning content and/or job performance aids that can be accessed from multiple non-invasive devices and platforms.

    WebWork :

    WebWork was a Java-based web application framework developed by OpenSymphony that merged into the current Struts2 framework. It was developed with the specific intention of improving developer productivity and code simplicity. WebWork is built on top of XWork, which provides a generic command pattern framework as well as an Inversion of Control container.

    WebWork provides support for building reusable UI templates, such as form controls, UI themes, internationalization, dynamic form parameter mapping to JavaBeans, client and server side validation, etc.

    Design goals and overview

    This article appears to be written like an advertisement. Please help improve it by rewriting promotional content from a neutral point of view and removing any inappropriate external links. (May 2008)

    In a standard Java EE web application, the client will typically submit information to the server via a web form. The information is then either handed over to a Java Servlet which processes it, interacts with a database and produces an HTML-formatted response, or it is given to a JavaServer Pages (JSP) document which intermingles HTML and Java code to achieve the same result. Both approaches are often considered inadequate for large projects because they mix application logic with presentation and make maintenance difficult.

    WebWork attempts to understand existing frameworks' limitations and works to eliminate them. It supports type conversion, continuations, and interceptors. WebWork also supports multiple-view technologies like JSP, velocity, and FreeMarker.

    Ultimately, WebWork has been designed and implemented with a specific set of goals, that are very important for its users. They are as follows:

    • Web Designer never has to touch Java code
    • Create multiple "Web Skins" for an application
    • Change Look and Feel
    • Change Layout on a given Web Page
    • Change Flow among Web Pages
    • Move *existing* data elements from one page to another
    • Integrate with various backend infrastructures
    • Reuse components
    • Perform internationalization (i18n) of a web application
    • Keep the API small and to the point
    • Ability to learn WebWork fast, by making all the fancier features optional
    • Allow the developer to choose how to implement as much as possible, while providing default implementations that work well in most cases

  • .

    WebWork Lifecycle

    The architecture of WebWork is based on the MVC, Command, and Dispatcher patterns and the principle of Inversion of Control. The life cycle of a WebWork request begins when the servlet container receives a new request. The new request is passed through a set of filters called the filter chain and sent to the FilterDispatcher. The FilterDispatcher forwards the request to the ActionMapper to determine what needs to be done with the request. If the request requires an action, it sends an ActionMapping object back to the FilterDispatcher. If not, ActionMapper returns a null object, indicating that no action needs to be taken. The FilterDispatcher forwards the request and the ActionMapper object to the ActionProxy for further action. The ActionProxy invokes the Configuration File manager to get the attributes of the action, which is stored in the xwork.xml file and creates an ActionInvocation object. The ActionInvocation object contains attributes like the action, invocation context, result, result code, etc. The configuration file manager has access to these configuration files and is used by the ActionProxy as a gateway to the configuration files. The ActionInvocation object also has information about Interceptors that need to be invoked after or before an action is executed.

    ActionInvocation invokes all the interceptors listed in the ActionInvocation object and then invokes the actual action. When the action is completed, ActionInvocation gets the action result code from the execution. It uses the action result code to look up the appropriate result, which is usually a JSP page, a velocity template or a freemarker template associated with the result code. ActionInvocation also executes the interceptors again in the reverse order and returns the response as a HttpServletResponse.

    Joomla Mvc :

    Joomla is a free and open source content management system (CMS) for publishing content on the World Wide Web and intranets and a model-view-controller (MVC) Web application framework that can also be used independently.

    Joomla is written in PHP, uses object-oriented programming (OOP) techniques (since version 1.5) and software design patterns, stores data in a MySQL, MS SQL (since version 2.5), or PostgreSQL (since version 3.0) database, and includes features such as page caching, RSS feeds, printable versions of pages, news flashes, blogs, polls, search, and support for language internationalization.

    As of March 2012, Joomla has been downloaded over 30 million times. Over 6,000 free and commercial extensions are available from the official Joomla! Extension Directory, and more are available from other sources. It is estimated to be the second most used CMS on the Internet after WordPress.


    Like many other popular web applications, Joomla can be run on a LAMP stack. Many web hosts have control panels that allow for automatic installation of Joomla. On Windows, Joomla can be installed using the Microsoft Web Platform Installer, which automatically detects and installs any missing dependencies, such as PHP or MySQL.

    Joomla enjoys strong support on the web from hosts that specialize in or support it. Many web sites provide information on installing and maintaining Joomla sites.

    Joomla Templates

    A Joomla template is a multifaceted Joomla extension which is responsible for the layout, design and structure of a Joomla powered website. While the CMS itself manages the content, a template manages the look and feel of the content elements and the overall design of a Joomla driven website. The content and design of a Joomla template is separate and can be edited, changed and deleted separately. The template is where the design of the main layout for a Joomla site is set. This includes where users place different elements (components, modules, and plug-ins), which are responsible for the different types of content. If the template is designed to allow user customization, the user can change the content placement on the site, e. g., putting the main menu on the right or left side of the screen. There are many paid and free templates available on the internet.

    Template components

    Layout :
    The template is the place where the design of the main layout is set for a Joomla site. This includes where users place different elements (components, modules, and plug-ins), which are responsible for different types of content.

    Color Scheme :
    Using CSS within the template design, users can change the colors of the backgrounds, text, links or just about anything that they could using (X)HTML code.

    Images and Effects :
    Users can also control the way images are displayed on the page and even create flash-like effects such as drop-down menus.

    Fonts :
    The same applies to fonts. The designs for these are all set within the template's CSS file(s) to create a uniform look across the entire site, which makes it easy to change the whole look just by altering one or two files rather than every single page.

    Joomla Extensions

    Joomla extensions help extend the Joomla websites' ability. There are five types of extensions for Joomla!: Components, Modules, Plugins, Templates, and Languages. Each of these extensions handles a specific function.

    Components: The largest and most complex extensions of them all; they can be seen as mini-applications. Most components have two parts: a site part and an administrator part. Every time a Joomla page loads, one component is called to render the main page body. Components are the major portion of a page because a component is driven by a menu item and every menu item runs a component.

    Plugins: These are more advanced extensions and are, in essence, event handlers. In the execution of any part of Joomla, a module or a component, an event can be triggered. When an event is triggered, plugins that are registered with the application to handle that event execute. For example, a plugin could be used to block user-submitted articles and filter out bad words.

    Templates: Describe the main design of the Joomla website and are the extensions that allow users to change the look of the site. Users will see modules and components on a template. They are customizable and flexible. Templates determine the style of a website.

    Modules: Rendering pages flexibly in Joomla requires a module extension, which is then linked to Joomla components to display new content or new images. Joomla modules look like boxes - like the search or login module. However, they don’t require html to Joomla to work.

    Languages: Very simple extensions that can either be used as a core part or as an extension. Language and font information can also be used for PDF or PSD to Joomla conversions.

    Ruby on Rails :
    Ruby on Rails

    Ruby on Rails, often simply Rails, is an open source web application framework which runs on the Ruby programming language. It is a full-stack framework: it allows creating pages and applications that gather information from the web server, talk to or query the database, and render templates out of the box. As a result, Rails features a routing system that is independent of the web server.

    Ruby on Rails emphasizes the use of well-known software engineering patterns and principles, such as active record pattern, convention over configuration (CoC), don't repeat yourself (DRY), and model-view-controller (MVC).

    Technical overview

    Like many web frameworks, Ruby on Rails uses the Model-View-Controller (MVC) pattern to organize application programming.

    In a default configuration, a model in the Ruby on Rails framework maps to a table in a database, and a Ruby file. For example, a model class User will usually be defined in the file user.rb in the app/models directory, and is linked to the table users in the database. Developers can choose any model name, file name or database table name. But this is not common practice and usually discouraged according to the "convention over configuration" philosophy.

    A controller is a component of Rails that responds to external requests from the web server to the application by determining which view file to render. The controller may also have to query one or more models directly for information and pass these on to the view. A controller may provide one or more actions. In Ruby on Rails, an action is typically a basic unit that describes how to respond to a specific external web-browser request. Also note that the controller/action will be accessible for external web requests only if a corresponding route is mapped to it. Rails encourages developers to use RESTful routes, which include actions such as: create, new, edit, update, destroy, show, and index. These mappings of incoming requests/routes to controller actions can be easily set up in the routes configuration file.

    A view in the default configuration of Rails is an erb file, which is converted to HTML at run-time. Many other templating systems can be used for views.

    Ruby on Rails includes tools that make common development tasks easier "out of the box", such as scaffolding that can automatically construct some of the models and views needed for a basic website. Also included are WEBrick, a simple Ruby web server that is distributed with Ruby, and Rake, a build system, distributed as a gem. Together with Ruby on Rails, these tools provide a basic development environment.

    Ruby on Rails is most commonly not connected to the Internet directly, but through some front-end web server. Mongrel was generally preferred over WEBrick in the early days, but it can also run on Lighttpd, Apache, Cherokee, Hiawatha, nginx (either as a module - Phusion Passenger for example - or via CGI, FastCGI or mod_ruby), and many others. From 2008 onwards, the Passenger web server replaced Mongrel as the most-used web server for Ruby on Rails.

    Ruby on Rails is also noteworthy for its extensive use of the JavaScript libraries Prototype and for Ajax. Ruby on Rails initially utilized lightweight SOAP for web services; this was later replaced by RESTful web services. Ruby on Rails 3.0 uses a technique called Unobtrusive JavaScript to separate the functionality (or logic) from the structure of the web page. jQuery is fully supported as a replacement for Prototype and is the default JavaScript library in Rails 3.1, reflecting an industry-wide move towards jQuery. Additionally, CoffeeScript was introduced in Rails 3.1 as the default Javascript language.

    Since version 2.0, Ruby on Rails offers both HTML and XML as standard output formats. The latter is the facility for RESTful web services.
    Rails 3.1 introduced Sass as standard CSS templating.
    By default, the server uses Embedded Ruby in the HTML views, with files having an html.erb extension. Rails supports swapping-in alternative templating languages, such as HAML and Mustache.
    Ruby on Rails 3.0 has been designed to work with Ruby 1.8.7, Ruby 1.9.2, and JRuby 1.5.2+; earlier versions are not supported.
    Rails 3.2 series is the last series to support Ruby 1.8.7.

    Framework structure

    Ruby on Rails is separated into various packages, namely ActiveRecord (an object-relational mapping system for database access), ActiveResource (provides web services), ActionPack, ActiveSupport and ActionMailer. Prior to version 2.0, Ruby on Rails also included the Action Web Service package that is now replaced by Active Resource. Apart from standard packages, developers can make plugins to extend existing packages. Rails 3.2 deprecates the old plugins Rails 2-3-stable style in which plugins are to be placed under vendor/plugins, in favor of packaged gems.


    Ruby on Rails is often installed using RubyGems, a package manager which is included with current versions of Ruby. Many free Unix-like systems also support installation of Ruby on Rails and its dependencies through their native package management system.

    Ruby on Rails is typically deployed with a database server such as MySQL or PostgreSQL, and a web server such as Apache running the Phusion Passenger module.

    There are many Ruby on Rails web hosting services such as Heroku, Engine Yard and TextDrive.

    Philosophy and design

    Ruby on Rails is intended to emphasize Convention over Configuration (CoC), and the rapid development principle of Don't Repeat Yourself (DRY). "Convention over Configuration" means a developer only needs to specify unconventional aspects of the application. For example, if there is a class Sale in the model, the corresponding table in the database is called sales by default. It is only if one deviates from this convention, such as calling the table "products sold", that the developer needs to write code regarding these names. Generally, Ruby on Rails conventions lead to less code and less repetition.

    "Don't repeat yourself" means that information is located in a single, unambiguous place. For example, using the ActiveRecord module of Rails, the developer does not need to specify database column names in class definitions. Instead, Ruby on Rails can retrieve this information from the database based on the class name.

    "Fat models, skinny controllers" means that most of the application logic should be placed within the model while leaving the controller as light as possible.

    Apache Struts :
    Apache Struts

    Apache Struts is an open-source web application framework for developing Java EE web applications. It uses and extends the Java Servlet API to encourage developers to adopt a model - view - controller (MVC) architecture. It was originally created by Craig McClanahan and donated to the Apache Foundation in May, 2000. Formerly located under the Apache Jakarta Project and known as Jakarta Struts, it became a top-level Apache project in 2005.

    Design goals and overview

    In a standard Java JEE web application, the client will typically call to the server via a web form. The information is then either handed over to a Java Servlet which interacts with a database and produces an HTML-formatted response, or it is given to a JavaServer Pages (JSP) document that intermingles HTML and Java code to achieve the same result. Both approaches are often considered inadequate for large projects because they mix application logic with presentation and make maintenance difficult.

    The goal of Struts is to separate the model (application logic that interacts with a database) from the view (HTML pages presented to the client) and the controller (instance that passes information between view and model). Struts provides the controller (a servlet known as ActionServlet) and facilitates the writing of templates for the view or presentation layer (typically in JSP, but XML/XSLT and Velocity are also supported). The web application programmer is responsible for writing the model code, and for creating a central configuration file struts-config.xml that binds together model, view, and controller.

    Requests from the client are sent to the controller in the form of "Actions" defined in the configuration file; if the controller receives such a request it calls the corresponding Action class that interacts with the application-specific model code. The model code returns an "ActionForward", a string telling the controller what output page to send to the client. Information is passed between model and view in the form of special JavaBeans. A powerful custom tag library allows it to read and write the content of these beans from the presentation layer without the need for any embedded Java code.

    Struts is categorized as a request-based web application framework.

    Struts also supports internationalization by web forms, and includes a template mechanism called "Tiles" that (for instance) allows the presentation layer to be composed from independent header, footer, menu navigation and content components.

    Struts2 features
    • Simple POJO-based actions
    • Simplified testability
    • Thread safe
    • AJAX support
    • jQuery plugin
    • Dojo Toolkit plugin (deprecated)
    • Ajax client-side validation
    • Template support
    • Support for different result types
    • Easy to extend with plugins
    • REST plugin (REST-based actions, extension-less URLs)
    • Convention plugin (action configuration via Conventions and Annotations)
    • Spring plugin (dependency injection)
    • Hibernate plugin
    • Support in design
    • JFreechart plugin (charts)
    • jQuery plugin (Ajax support, UI widgets, dynamic table, charts)
    • Rome plugin

  • .

    Competing MVC frameworks

    Although Struts is a well-documented, mature, and popular framework for building front ends to Java applications, there are other frameworks categorized as "lightweight" MVC frameworks such as Spring MVC, Stripes, Wicket, Play!, and Tapestry. The new XForms standards and frameworks may also be another option to building complex web form validations with Struts in the future.

    The WebWork framework spun off from Apache Struts aiming to offer enhancements and refinements while retaining the same general architecture of the original Struts framework. However, it was announced in December 2005 that Struts would re-merge with WebWork. WebWork 2.2 has been adopted as Apache Struts2, which reached its first full release in February 2007.

    In 2004, Sun launched an addition to the Java platform, called JavaServer Faces (JSF). Aside from the original Struts framework, the Apache project previously offered a JSF-based framework called Shale, which was retired in May 2009.

    Other MVC frameworks that are JVM-based include Grails.

    JavaServer Faces :
    JavaServer Faces

    JavaServer Faces (JSF) is a Java specification for building component-based user interfaces for web applications. It was formalized as a standard through the Java Community Process and is part of the Java Platform, Enterprise Edition.

    JSF 2 uses Facelets as its default templating system. Other view technologies such as XUL can also be employed. In contrast, JSF 1.x uses JavaServer Pages (JSP) as its default templating system.

    How it Works ?

    JavaServer Faces is based on a component-driven UI design model, using XML files called view templates or Facelets views. Requests are processed by the FacesServlet, which loads the appropriate view template, builds a component tree, processes events, and renders the response, typically in the HTML language, to the client. The state of UI components and other objects of scope interest, is saved at the end of each request in a process called stateSaving (note: transient true), and restored upon next creation of that view. Objects and states can be saved either on the client or server side.

    JSF and Ajax

    JSF is often used together with Ajax, a Rich Internet application technology. Ajax is a combination of technologies that make it possible to create rich user interfaces. The user interface components in Mojarra (the JSF reference implementation) and Apache MyFaces were originally developed for HTML only, and Ajax had to be added via JavaScript. This has changed, however:

    Because JSF supports multiple output formats, Ajax-enabled components can easily be added to enrich JSF-based user interfaces. The JSF 2.0 specification provides built in support for Ajax by standardizing the Ajax request lifecycle, and providing simple development interfaces to Ajax events, allowing any event triggered by the client to go through proper validation, conversion, and finally method invocation, before returning the result to the browser via an XML DOM update.

    JSF 2 includes support for graceful degradation when JavaScript is disabled in the browser.

    Ajax-enabled components and frameworks :

    The following companies and projects offer Ajax-based JSF frameworks or component libraries :

    • JBoss RichFaces (derived from and replaces Ajax4jsf), Ajax-enabled JSF components for layout, file upload, forms, inputs and many other features.
    • ICEfaces, open-source, Java JSF extension framework and rich components, Ajax without JavaScript
    • PrimeFaces Ajax framework with JSF components
    • Oracle ADF Faces Rich Client, Oracle Application Development Framework
    • Backbase Enterprise Ajax - JSF Edition, Ajax framework
    • IBM Notes - XPages
    • Apache MyFaces, The Apache Foundation JSF implementation with Ajax components
    • Sun Java BluePrints AJAX Components
    • ZK Ajax framework with JSF components

  • .

    Latest developments

    Facelets (which was designed specifically for JavaServer Faces) was adopted as the official view technology for JSF 2.0. This eliminates the life-cycle conflicts that existed with JSP, forcing workarounds by Java developers. Facelets allows easy component/tag creation using XML markup instead of Java code, the chief complaint against JSF 1.x.

    The new JSF developments also provide wide accessibility to Java 5 annotations such as @ManagedBean, @ManagedProperty and @FacesComponent which removes the need for faces-config.xml in all cases except framework extension. Navigation has been simplified, removing the need for faces-config.xml navigation cases. Page transitions can be invoked simply by passing the name of the desired View/Facelet.

    Addition of Partial State Saving and DOM updates are part of the built in standardized Ajax support.

    The latest JSF release has built-in support for handling resources like images, CSS and Javascript, allowing artifacts to be included with component libraries, separated into JAR files, or simply co-located into a consistent place within the web-application. Includes logical naming and versioning of resources.

    JSF 2.0 also includes a number of other changes like adding support for events, separate development, staging, and production modes, similar to RAILS_ENV in Ruby on Rails, and significantly expanding the standard set of components.

    Spring Mvc Framework :
    Spring Framework

    The Spring Framework is an open source application framework and inversion of control container for the Java platform.

    The first version was written by Rod Johnson, who released the framework with the publication of his book Expert One-on-One J2EE Design and Development in October 2002. The framework was first released under the Apache 2.0 license in June 2003. The first milestone release, 1.0, was released in March 2004, with further milestone releases in September 2004 and March 2005. The Spring 1.2.6 framework won a Jolt productivity award and a JAX Innovation Award in 2006 Spring 2.0 was released in October 2006, Spring 2.5 in November 2007, Spring 3.0 in December 2009, and Spring 3.1 in December 2011. The current version is 3.2.3, which was released in May 2013. Spring Framework 4.0 is expected by the end of 2013, with plans to support Java SE 8, Groovy 2, some aspects of Java EE7, and WebSockets.

    The core features of the Spring Framework can be used by any Java application, but there are extensions for building web applications on top of the Java EE platform. Although the Spring Framework does not impose any specific programming model, it has become popular in the Java community as an alternative to, replacement for, or even addition to the Enterprise JavaBean (EJB) model.


    The Spring Framework includes several modules that provide a range of services:

    Inversion of Control Container: configuration of application components and lifecycle management of Java objects, done mainly via dependency injection

    Aspect-oriented programming: enables implementing cross-cutting concerns.

    Data Access: working with relational database management systems on the Java platform using JDBC and object-relational mapping tools and with NoSQL databases

    Transaction Management : unifies several transaction management APIs and coordinates transactions for Java objects

    Model-View-Controller : an HTTP- and servlet-based framework providing hooks for extension and customization for web applications and RESTful web services.

    Remote Access Framework: configurative RPC-style marshalling of Java objects over networks supporting RMI, CORBA and HTTP-based protocols including web services (SOAP)

    Convention over Configuration : a rapid application development solution for Spring-based enterprise applications is offered in the Spring Roo module

    Authentication and Authorization : configurable security processes that support a range of standards, protocols, tools and practices via the Spring Security sub-project (formerly Acegi Security System for Spring).

    Remote management : configurative exposure and management of Java objects for local or remote configuration via JMX

    Messaging : configurative registration of message listener objects for transparent message-consumption from message queues via JMS, improvement of message sending over standard JMS APIs

    Testing : support classes for writing unit tests and integration tests

    Model-view-controller Framework

    The Spring Framework features its own MVC web application framework, which wasn't originally planned. The Spring developers decided to write their own web framework as a reaction to what they perceived as the poor design of the (then) popular Jakarta Struts web framework, as well as deficiencies in other available frameworks. In particular, they felt there was insufficient separation between the presentation and request handling layers, and between the request handling layer and the model.

    Like Struts, Spring MVC is a request-based framework. The framework defines strategy interfaces for all of the responsibilities which must be handled by a modern request-based framework. The goal of each interface is to be simple and clear so that it's easy for Spring MVC users to write their own implementations if they so choose. MVC paves the way for cleaner front end code. All interfaces are tightly coupled to the Servlet API. This tight coupling to the Servlet API is seen by some as a failure on the part of the Spring developers to offer a high-level abstraction for web-based applications. However, this coupling makes sure that the features of the Servlet API remain available to developers while offering a high abstraction framework to ease working with said API.

    The DispatcherServlet class is the front controller of the framework and is responsible for delegating control to the various interfaces during the execution phases of a HTTP request.

    The most important interfaces defined by Spring MVC, and their responsibilities, are listed below:

    HandlerMapping : selecting objects that handle incoming requests (handlers) based on any attribute or condition internal or external to those requests

    HandlerAdapter: execution of objects that handle incoming requests

    Controller: comes between Model and View to manage incoming requests and redirect to proper response. It acts as a gate that directs the incoming information. It switches between going into model or view.

    View: responsible for returning a response to the client. Some requests may go straight to view without going to the model part; others may go through all three.

    ViewResolver : selecting a View based on a logical name for the view (use is not strictly required)

    HandlerInterceptor : interception of incoming requests comparable but not equal to Servlet filters (use is optional and not controlled by DispatcherServlet).

    LocaleResolver : resolving and optionally saving of the locale of an individual user

    MultipartResolver : facilitate working with file uploads by wrapping incoming requests

    Each strategy interface above has an important responsibility in the overall framework. The abstractions offered by these interfaces are powerful, so to allow for a set of variations in their implementations, Spring MVC ships with implementations of all these interfaces and together offers a feature set on top of the Servlet API. However, developers and vendors are free to write other implementations. Spring MVC uses the Java java.util.Map interface as a data-oriented abstraction for the Model where keys are expected to be string values.

    The ease of testing the implementations of these interfaces seems one important advantage of the high level of abstraction offered by Spring MVC. DispatcherServlet is tightly coupled to the Spring inversion of control container for configuring the web layers of applications. However, web applications can use other parts of the Spring Framework - including the container - and choose not to use Spring MVC.

    Spring Web Flow :
    Spring Web Flow

    Spring Web Flow (SWF) is the sub-project of the Spring Framework that focuses on providing the infrastructure for building and running rich web applications. The project tries to solve 3 core problems facing web application developers:

    • How do you express page navigation rules ?
    • How do you manage navigation and conversational state ?
    • How do you facilitate modularization and reuse ?

  • .

    In Spring Web Flow, a web flow answers all of the above questions: it captures navigational rules allowing the Spring Web Flow execution engine to manage a conversation and the associated state. At the same time, a web flow is a reusable web application module.

    Since version 2.0, Spring Web Flow also introduces other additional features supporting the construction of rich web applications, such as AJAX support and tight integration with JavaServer Faces.


    The Spring Web Flow project started as a simple extension to the Spring Web MVC framework providing web flow functionality, developed by Erwin Vervaet in 2004. In 2005 the project was introduced into the Spring portfolio by Keith Donald and grew into the official Spring sub-project it is now. The first production ready 1.0 release was made on 2006-10-26. Version 2.0, first released on 2008-04-29, saw a major internal reorganization of the framework to allow better integration with JavaServer Faces.

    ZK (Framework) :
    ZK (framework)

    ZK is an open-source Ajax Web application framework, written in Java, that enables creation of rich graphical user interfaces for Web applications without the application developer having to write JavaScript (despite the J in Ajax acronym standing for JavaScript) and with little required programming knowledge.

    The core of ZK consists of an Ajax-based event-driven mechanism, over 123 XUL and 83 XHTML-based components, and a markup language for designing user interfaces. Programmers design their application pages in feature-rich XUL/XHTML components, and manipulate them upon events triggered by end user's activity. It is similar to the programming model found in desktop GUI-based applications.

    ZK takes the so-called server-centric approach that the content synchronization of components and the event pipelining between clients and servers are automatically done by the engine and Ajax plumbing codes are completely transparent to web application developers. Therefore, the end users get the similar engaged interactivity and responsiveness as a desktop application, while programmers' development retains a similar simplicity to that of desktop applications.

    Meanwhile, with the so-called server+client fusion, the optional client-side customization allows the developer to leverage the client-side resources, to custom the look and feel and to reduce the Ajax traffic.

    In addition to component-based programming in a manner similar to Swing, ZK supports a markup language for rich user interface definition called ZUML.

    • ZUML is designed for non-programmer developers to design user interfaces intuitively.
    • ZUML allows developers to meld different markup languages, such as Mozilla XUL language and XHTML, seamlessly into the same page.
    • ZUML allows developers to embed scripts in pure Java language (interpreted by BeanShell) and use EL expressions to manipulate the components and access data.

  • .


    Simply Java. ZK is renowned for its "Ajax without JavaScript" approach, enabling developers to build rich internet applications transparently without any knowledge of Ajax and JavaScript.

    Over 100 Ajax components offer UI designers a variety of feature rich components to meet the demands of enterprise Ajax applications. ZUML makes the design of rich user interfaces similar to authoring HTML pages. ZUML is a variant of XUL inheriting all features available to XML, and separates the UI definition from the run-time logic.

    • Event-driven component-based model (similar to desktop programming models).
    • Support for Model-View-Controller (MVC) decoupling View, Model and Controller for easy to develop and maintain.
    • Support for Model-View-Presenter and Model-View-ViewModel (MVVM) design patterns that decouples the controller furthermore to minimize the code required and to maximize the maintainability.

  • .

    Databinding capability via in-ZUML-page annotations that transparently automates CRUD and state synchronization between UI view and the data and POJO.

    Application components, such as spreadsheet, pivot table, and calendar.

    Embedding scripting support with Java (Beanshell). This is an important benefit as you can use a unified programming language for both user interface and backend programming. Optional support for other serverside Java scripting in other languages such as JavaScript (Rhino), Ruby (JRuby), Python (Jython) and Groovy.

    Support for integrating with existing web frameworks via a JSP custom tag library, JSF support, Portlet, and a Servlet Filter. Has support for Spring and Hibernate.

    Extensible in that programmers can create new custom UI controls. Groups of controls can be re-used as a macro component.

    Differences from XUL

    ZK is a server side framework which emits HTML and thus does not depend on client side presence of Gecko making it portable to any browser. ZK takes ZUML (xul and xhtml) serverside pages as input and outputs dhtml for the browser.

    ZK processes user interface logic on the server in Java. This increases choice in the scripting engines and application libraries that can be used to create logic. Presentation effects can be delegated to the browser using the Client-side Actions feature to reduce server load for dhtml effects. Running the application logic on the server in a single application container reduces the amount of cross browser and browser version testing when compared to extensively programming the DOM at the browser.

    While ZK and XUL have an overlapping subset of components, ZK has its own unique component sets. The component library can be extended with custom components. Macro components can be defined that are composites of components.

    ZK provides serverside databinding annotations to declaratively bind UI components to serverside data. Look and Feel differences.

    • ZUML (ZK User Interface Markup Language) is a markup language for rich user interfaces definition.
    • ZUML is designed for non-programmers to design user interfaces efficiently with the ZUML markup
    • ZUML allows developer to meld different markup languages, such as Mozilla XUL language and XHTML, seamlessly into the same page.
    • ZUML allows developers to embed script in pure Java language (interpreted by BeanShell) and use EL expressions to manipulate the components and access data.
    • ZUML is supported by ZK.

  • .

    Client-Side Technologies

    ZK is a server-centric framework. Technically you don't need to know about the implementation at the client side. It is how ZK Mobile running on Java Mobile VM is done. Since ZK 5.0, the so-called Server+client Fusion architecture is introduced. Developers are allowed to access the client-side widgets directly if they want to. ZK Client Engine is based on jQuery. Technically you can use jQuery-compliant libraries and widgets.

    Stripes Framework :
    Stripes (framework)

    Stripes is an open source web application framework based on the model - view - controller (MVC) pattern. It aims to be a lighter weight framework than Struts by using Java technologies such as annotations and generics that were introduced in Java 1.5, to achieve "convention over configuration". This emphasizes the idea that a set of simple conventions used throughout the framework reduce configuration overhead. In practice, this means that Stripe applications barely need any configuration files, thus reducing development and maintenance work.

    Features :
    • Action based MVC framework
    • No configuration files
    • POJOs
    • Annotations replace XML configuration files
    • Flexible and simple parameter binding
    • Search engine friendly URLs
    • Runs in J2EE web container
    • JUnit integration
    • Easy internationalization
    • Wizard support
    • JSP layouts
    • JSP or freemarker templates as View
    • Spring integration
    • JPA support
    • AJAX support
    • Fileupload support
    • Compatible with Google App Engine
    • Open-source
    • Lightweight

  • .

    Apache Wicket :
    Apache Wicket

    Apache Wicket, commonly referred to as Wicket, is a lightweight component-based web application framework for the Java programming language conceptually similar to JavaServer Faces and Tapestry. It was originally written by Jonathan Locke in April 2004. Version 1.0 was released in June 2005. It graduated into an Apache top-level project in June 2007.


    Traditional model-view-controller (MVC) frameworks work in terms of whole requests and whole pages. In each request cycle, the incoming request is mapped to a method on a controller object, which then generates the outgoing response in its entirety, usually by pulling data out of a model to populate a view written in specialised template markup. This keeps the application's flow-of-control simple and clear, but can make code reuse in the controller difficult.

    In contrast, Wicket is closely patterned after stateful GUI frameworks such as Swing. Wicket applications are trees of components, which use listener delegates to react to HTTP requests against links and forms in the same way that Swing components react to mouse and keystroke events. Wicket is categorized as a component-based framework.


    Wicket uses plain XHTML for templating (which enforces a clear separation of presentation and business logic and allows templates to be edited with conventional WYSIWYG design tools). Each component is bound to a named element in the XHTML and becomes responsible for rendering that element in the final output. The page is simply the top-level containing component and is paired with exactly one XHTML template. Using a special tag, a group of individual components may be abstracted into a single component called a panel, which can then be reused whole in that page, other pages, or even other panels.

    Each component is backed by its own model, which represents the state of the component. The framework does not have knowledge of how components interact with their models, which are treated as opaque objects automatically serialized and persisted between requests. More complex models, however, may be made detachable and provide hooks to arrange their own storage and restoration at the beginning and end of each request cycle. Wicket does not mandate any particular object-persistence or ORM layer, so applications often use some combination of Hibernate objects, EJBs or POJOs as models.

    In Wicket, all server side state is automatically managed. You will never directly use an HttpSession object or similar wrapper to store state. Instead, state is associated with components. Each server-side page component holds a nested hierarchy of stateful components, where each component’s model is, in the end, a POJO (Plain Old Java Object)

    Wicket is all about simplicity. There are no configuration files to learn in Wicket. Wicket is a simple class library with a consistent approach to component structure

    Apache Tapestry :
    Apache Tapestry

    Apache Tapestry is an open-source component-oriented Java web application framework conceptually similar to JavaServer Faces and Apache Wicket. Tapestry was created by Howard Lewis Ship, and was adopted by the Apache Software Foundation as a top-level project in 2006.

    Tapestry emphasizes simplicity, ease of use, and developer productivity. It adheres to the Convention over Configuration paradigm, eliminating almost all XML configuration. Tapestry uses a modular approach to web development, by having a strong binding between each user interface component (object) on the web page and its corresponding Java class. This component-based architecture borrows many ideas from WebObjects.

    Notable Features

    Live Class Reloading : Tapestry monitors the file system for changes to Java page classes, component classes, service implementation classes, HTML templates and component property files, and it hot-swaps the changes into the running application without requiring a restart. This provides a very short code-save-view feedback cycle that is claimed to greatly improve developer productivity.

    Component-based : Pages may be constructed with small nestable components, each having a template and component class. Custom components are purportedly trivial to construct.

    Convention over configuration : Tapestry uses naming conventions and annotations, rather than XML, to configure the application.

    Spare use of HTTPSession : By making minimal use of the HTTPSession, Tapestry is designed to be highly efficient in a clustered, session-replicated environment.

    Post/Redirect/Get : Most form submissions follow the Post/Redirect/Get (PRG) pattern, which reduces multiple form submission accidents and makes URLs friendlier and more bookmarkable, along with enabling the browser Back and Refresh buttons to operate normally.

    Inversion of Control (IOC) : Tapestry is built on a lightweight Inversion of Control layer with similarities to Google Guice but designed to make nearly all aspects of Tapestry's behavior configurable and replaceable.

    Apache Velocity :
    Apache Velocity

    Apache Velocity is a Java-based template engine that provides a template language to reference objects defined in Java code. It is an open source software project directed by the Apache Software Foundation and aims to ensure clean separation between the presentation tier and business tiers in a Web application (the model-view-controller design pattern).

    Uses :

    Some common types of applications that use Velocity are:

    Web applications: Web designers create HTML pages with placeholders for dynamic information. The page is processed with VelocityViewServlet or any of a number of frameworks which support Velocity.

    Source code generation : Velocity can be used to generate Java source code, SQL, or PostScript, based on templates. A number of open source and commercial development software packages use Velocity in this manner.

    Automatic Emails: Many applications generate automatic emails for account signup, password reminders, or automatically sent reports. Using Velocity, the email template can be stored in a text file, rather than directly embedded in Java code.

    XML transformation : Velocity provides an Ant task, called Anakia, which reads an XML file and makes it available to a Velocity template. A common application is to convert documentation stored in a generic "xdoc" format into a styled HTML document.

    Quality Service

    Quality in a service or product is not what you put into it. It is what the client or customer gets out of it.
    -Peter Drucker

    Intelligent Quotes

    A solid working knowledge of productivity software and other IT tools has become a basic foundation for success in virtually any career. Beyond that, however, I don't think you can overemphasise the importance of having a good background in maths and science.....
    "Every software system needs to have a simple yet powerful organizational philosophy (think of it as the software equivalent of a sound bite that describes the system's architecture)... A step in thr development process is to articulate this architectural framework, so that we might have a stable foundation upon which to evolve the system's function points. "
    "All architecture is design but not all design is architecture. Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change"
    "The ultimate measurement is effectiveness, not efficiency "
    "It is argued that software architecture is an effective tool to cut development cost and time and to increase the quality of a system. "Architecture-centric methods and agile approaches." Agile Processes in Software Engineering and Extreme Programming.
    "Java is C++ without the guns, knives, and clubs "
    "When done well, software is invisible"
    "Our words are built on the objects of our experience. They have acquired their effectiveness by adapting themselves to the occurrences of our everyday world."
    "I always knew that one day Smalltalk would replace Java. I just didn't know it would be called Ruby. "
    "The best way to predict the future is to invent it."
    "In 30 years Lisp will likely be ahead of C++/Java (but behind something else)"
    "Possibly the only real object-oriented system in working order. (About Internet)"
    "Simple things should be simple, complex things should be possible. "
    "Software engineering is the establishment and use of sound engineering principles in order to obtain economically software that is reliable and works efficiently on real machines."
    "Model Driven Architecture is a style of enterprise application development and integration, based on using automated tools to build system independent models and transform them into efficient implementations. "
    "The Internet was done so well that most people think of it as a natural resource like the Pacific Ocean, rather than something that was man-made. When was the last time a technology with a scale like that was so error-free? The Web, in comparison, is a joke. The Web was done by amateurs. "
    "Software Engineering Economics is an invaluable guide to determining software costs, applying the fundamental concepts of microeconomics to software engineering, and utilizing economic analysis in software engineering decision making. "
    "Ultimately, discovery and invention are both problems of classification, and classification is fundamentally a problem of finding sameness. When we classify, we seek to group things that have a common structure or exhibit a common behavior. "
    "Perhaps the greatest strength of an object-oriented approach to development is that it offers a mechanism that captures a model of the real world. "
    "The entire history of software engineering is that of the rise in levels of abstraction. "
    "The amateur software engineer is always in search of magic, some sensational method or tool whose application promises to render software development trivial. It is the mark of the professional software engineer to know that no such panacea exist "

    Core Values ?

    Agile And Scrum Based Architecture

    Agile software development is a group of software development methods based on iterative and incremental development, where requirements and solutions evolve through collaboration.....


    Core Values ?

    Total quality management

    Total Quality Management / TQM is an integrative philosophy of management for continuously improving the quality of products and processes. TQM is based on the premise that the quality of products and .....


    Core Values ?

    Design that Matters

    We are more than code junkies. We're a company that cares how a product works and what it says to its users. There is no reason why your custom software should be difficult to understand.....


    Core Values ?

    Expertise that is Second to None

    With extensive software development experience, our development team is up for any challenge within the Great Plains development environment. our Research works on IEEE international papers are consider....


    Core Values ?

    Solutions that Deliver Results

    We have a proven track record of developing and delivering solutions that have resulted in reduced costs, time savings, and increased efficiency. Our clients are very much ....


    Core Values ?

    Relentless Software Testing

    We simply dont release anything that isnt tested well. Tell us something cant be tested under automation, and we will go prove it can be. We create tests before we write the complementary production software......


    Core Values ?

    Unparalled Technical Support

    If a customer needs technical support for one of our products, no-one can do it better than us. Our offices are open from 9am until 9pm Monday to Friday, and soon to be 24hours. Unlike many companies, you are able to....


    Core Values ?

    Impressive Results

    We have a reputation for process genius, fanatical testing, high quality, and software joy. Whatever your business, our methods will work well in your field. We have done work in Erp Solutions ,e-commerce, Portal Solutions,IEEE Research....



    Why Choose Us ?

    Invest in Thoughts

    The intellectual commitment of our development team is central to the leonsoft ability to achieve its mission: to develop principled, innovative thought leaders in global communities.

    Read More
    From Idea to Enterprise

    Today's most successful enterprise applications were once nothing more than an idea in someone's head. While many of these applications are planned and budgeted from the beginning.

    Read More
    Constant Innovation

    We constantly strive to redefine the standard of excellence in everything we do. We encourage both individuals and teams to constantly strive for developing innovative technologies....

    Read More
    Utmost Integrity

    If our customers are the foundation of our business, then integrity is the cornerstone. Everything we do is guided by what is right. We live by the highest ethical standards.....

    Read More