Evaluating AJAX Framework

Today building a new web application involves the essential step of evaluating AJAX frameworks and select an appropriate one. In this post I will detail the various criteria that should be considered while making a decision.

Adoption Criteria

This criteria is important for IT managers (or EA strategy) to decide if it would even be necessary for the development team to take a look and evaluate.

• Licensing Model: Under what license(s) is this product offered? How would that affect your organization?
• Cost: How much does the framework cost (upfront)? Also consider cost of development tools, support, consulting? How many free updates are there? If the framework is free, is there a PRO version? If so what are the benefits and cost?
• Frequency of Releases: What is the frequency of releases/updates? Is it adequate? This shows how active the framework is among the community?
• Technology Maturity: How long has the framework been around? How stable are the releases? What is the philosophy on backward computability? What is the product road map?
• Talent Pool: Is there talent pool available for this framework? What is the expected learning curve? Input from the developmental team is certainly helpful here.

Development Criteria

This criteria is will help the developers assess the framework viability.

• UI Components: Does the toolkit offer rich set of mature components? What is the future road map for new components? Are the components customizable?
• Programming Model: What kind of programming paradigm is supported? Is it strongly typed or dynamic? Is the model familiar to developers? If not what is the learning curve?
  
• Web Framework Integration: Are there web frameworks that provide some out-of-the-box support? Are there any conflicts (or challenges) in using this toolkit with web framework?
• Documentation Quality: Is there adequate good documentation available? Are there books available? If so what are the reviews?
• Browser Support: What browsers and versions are supported by the toolkit? What is the road map? Are the supported browsers sufficient for the requirements? What does the community say about this?
• IDE Support: Is there IDE support? How much do they cost? How do they fit in with currently used IDE?
• i18n: Is there support for multiple languages?
  
• Utilities: Frameworks provide utilities like Browser Manager(Back/Forward Button Support), Drag-n-Drop, Java-to-JavaScript Serialization (for example, DWR). Depending on specifics of the requirements this criteria should be considered.

Maintenance Criteria

This criteria helps to evaluate and foresee any maintenance challenges that may be encountered.

• Community Support: What is the size of the community using the product? How active and responsive are the online forums? Is the blog updated frequently?
• Hosting: Is there hosting support for the framework JS files? For example, Yahoo UI provides hosting support
• Profiling: Is there built-in profiling support? If no are there any external tools that can help? Are there browser related constraints in them?
• Beta Components: The frameworks tend to offer lot of Beta components. For these components its worthy to look at their known issues and assess the risk.
  

Conclusion

Analyzing and evaluating the frameworks using the above mentioned criteria will help make an informed decision and thereby will help avoid potential future issues. During the evaluation if a framework is missing a particular feature or component and is available in another toolkit you should look to ensure that there would be no integration issues and will peacefully co-exist. Please feel free to suggest perspective for improving the evaluation process.

Caching: Memcached and Terracotta

Applications are generally built with an expected user base but soon might be overwhelmed due to business demand. This is especially particularly true in the context of consumer facing applications. Caching is one of the most important aspect to improve application performance by storing object in Cache (memory) reducing database load.

Caching in a clustered environment requires a Distributed Caching solution which can support failover scenarios and data reliability. In this post I would like to explore the capabilities of Memcached and Terracotta as distributed caching solutions.

Memcached is a high-performance distributed object caching system with client APIs for Perl, PHP, Python, Ruby and Java. Here are some of its capabilities and limitations (using Java client API):

• Requires objects to be Serializable
• Object Identity is NOT preserved
• Supports cache expiration
• Does NOT handle failover scenarios
• For a given object selects a server from a pool of cache server based on hash of the key
• Easy to configure (through SockIOPool class)

Terracotta is an open-source Java based clustering solution for JVM. Distributed Caching can be achieved using Terracotta by using a java.util.HashMap or open-source caching solutions like EHCache, OSCache and JBoss TreeCache.

• Preserves Object identity
• Manages memory efficiently through Virtual Heap
• Declarative requirement for lock support
• Simple configuration file with Eclipse Tool support
• Good documentation, support and active development
• Due to the nature of its implementation certain classes are not Portable and hence cannot be used
• Hard to determine which third-party classes are portable
• Does NOT require classes to be serializable
• Easy to configure and get started!

Technorati tags: java, cache