Skip to main content

ExtJS - Creating Development Standards in the Enterprise

Creating Development Standards in the Enterprise


Working with the Enterprise

Working at the enterprise-level can be both very cool and very frustrating. On the one hand, I get to build really challenging apps; but on the other hand, enterprise applications often target legacy browsers and are prohibited from using cutting-edge technologies.
Having said that, I am starting to see many of our enterprise customers rethinking their development strategies and IT infrastructures: workstations are being upgraded to modern versions of Windows, and workers are being given more choices for a web browser. In some cases support for IE6 and IE7 are being dropped completely!
More importantly, I am noticing that enterprises are standardizing their development platforms to create an ecosystem of applications that can be maintained by a diverse team of developers. Because Sencha tools and frameworks are becoming the preferred development platform in this ecosystem, the Professional Services team has been helping our customers define their internal policies, training procedures and best practices in order to facilitate a transition to this new standard.
Why Development Standards Matter

Why Development Standards Matter

As a consultant, I constantly preach the benefits of having maintainable code:
  • Applications are faster to produce
  • Applications are easier to debug
  • New features are easier to add
  • Code has fewer bugs
  • New developers can be trained quickly
We all know that time equals money, so applications that take less time to create and maintain cost less money. Ultimately this makes managers, executives and shareholders happy. Because enterprise companies have many applications in production (both internal and external), it is critical that each member of the development team be able to jump onto any project in order to deliver on time and stay under budget.
Enterprise development teams often employ many developers distributed across large areas and contain a wide variety of skill sets. By standardizing the training, tools and best practices enterprises hope to decrease development time and costs while increasing the quality and lifespan of their applications.
For Sencha customers, I recommend that a handful of onboarding procedures be clearly documented to lubricate this process:
  • Required development tools
  • The process for requesting network credentials
  • Standard development workflows
  • How to access the Sencha forums and support portal
  • What Sencha training opportunities are recommended/offered
It’s important to remember that while developers don’t need this information on a frequent basis they need to know how to access it.
Supported Platforms

Supported Platforms

One benefit of working in an enterprise is that developers usually know the exact specifications of the environments they need to support, but historically these environments have been troublesome for web applications.
As enterprises move forward with hardware and software upgrades, it is important that developers deliberately document their current list of supported environments. This list might include things like:
  • Browsers (e.g. IE8, Firefox)
  • Operating Systems (e.g. Windows XP,7)
  • Devices (e.g. Lenovo ThinkPad)
Having this knowledge clearly defined before starting new projects (and while maintaining legacy applications) helps to improve the accuracy of the delivered products. It also allows developers time to request any new hardware/software for testing.
It is also important to document the specific products or platforms being used in the development process. This list might include:
  • Frameworks (e.g. Ext JS 4.1.x, ASP.NET MVC 4)
  • 3rd party libraries or components (e.g. other charting packages)
  • Supporting technologies (e.g. SASS)
  • Workarounds (e.g. using JSONP

Internal Best Practices

Development teams should also decide on a list of best practices, so all developers can contribute code without compromising maintainability.
The list of best practices can be short and high-level or long and detailed; the choice often depends on the size of your team and how the developer roles are organized.
For example, some high-level best practices might include:
  • Overall architectural decisions (e.g. namespacing, file structure)
  • Security implementations
  • Error handling
  • Shared libraries and custom components (UX)
  • Documentation
  • Testing, builds and deployment
...while some low-level best practices might include:
  • Whitespace usage
  • Commit practices
  • Console usage
  • Browser Strict vs quirks mode
In my experience, enforcing the low-level best practices is difficult to do without mandatory code reviews. While code reviews are a fantastic way to teach junior developers, maintain code quality and stimulate creativity, it’s not something typically done in most enterprises.

You might look into a tool named “Siesta” made by Bryntum. It automates integration tests in a similar manner to Selenium, but it works much better with the Sencha frameworks for specifically the reasons you mention.
In terms of “best practices” for automated testing, the first thing you need to do is decide what your goals are. Testing can accomplish many things - but I always warn that automated tests should never completely replace physical QA testing.
Example for proof of concepts developed using ExtJS API

-          Intranet Employee portal
-          Storage space management Utility App
-          Biometric App for Medicine documentation
-          Retail store-item management App
-          Stocks/Account management App
-          Form digitization from Excel templates
-          Own business setup/approval  process App
-          Own business Employee/customer Mgt App
-          Product search /Deal promotion App
-          Item/store/demand/supply Mgt App
-          Music store / Library Mgt App
-          Insurance / Banking /Account Mgt App

References:
http://blogs.walkingtree.in/category/sencha-extjs/
http://www.sencha.com/blog/integrating-ext-js-with-3rd-party-libraries/
http://www.sencha.com/blog/introducing-ext-js-4-2/

 http://www.sencha.com/blog/sencha-ext-js-spotlight-marketo/
http://www.sencha.com/blog/implementation-spotlight-marketo
http://www.sencha.com/blog/customer-spotlight-incentrak/

Automation Testing:
https://www.sencha.com/blog/testing-ext-js-ext-gwt-applications-with-selenium/
http://www.sencha.com/blog/automating-unit-tests
https://www.sencha.com/blog/ui-testing-a-sencha-app

Sencha support team suggest Siesta (3rd party tool) for Automation testing.

https://www.sencha.com/blog/introducing-siesta-a-testing-tool-for-ext-js/

 Spring MVC with ExtJS
http://myxaab.wordpress.com/page/2/

 LintRoller- Sencha tool : LintRoller is a Node.js module that recursively dives into a directory and lints your JavaScript files.
https://market.sencha.com/extensions/lintroller





            Comments

            Post a Comment

            Popular posts from this blog

            ExtJS - Grid panel features

            What can we do with ExtJS GridPanel? I have to develop a lot of applications in my web app and I see that grid component of ExtJS may fit in. However, I am not aware of what all things I can do with the - off the shelf available framework pieces - available plug-ins in the marketplace and - custom development through my own developers This is a typical question that we hear from the business users who wants to design an application by keeping the framework’s capability in perspective. In this article I have tried to put the list of stuff you can do with grid and hopefully that shall enable you to take advantage of the beauty of ExtJS. Pre-requisites This article assumes that you are familiar with basics of ExtJS What are the available options? In this section I will be taking you through some of the commonly seen usage of ExtJS grid panel. While covering all the capabilities of grid may not be possible, I am sure it will be helpful for the business users who want to...
            8 comments
            Read more

            ExtJS 4 with Spring MVC Example

            Introduction When developing a brand new application for the company I work for, one of the first thing I implement is "authentication". Not only is this process generally a prerequisite to access many other functions but it is also very simple and covers every layer of an application, from GUI to the database. So instead of another minimalistic "Hello World" tutorial, here is a "Login/Password" example, using 2 famous technologies : Spring MVC and ExtJS 4.   Prerequisites Because this tutorial is quite long, I won't go into the details of each technology I used but I will mainly focus on how ExtJS and Spring can be nicely used together. So here are the things you should know before continuing : Spring framework (good knowledge) Spring MVC (basic knowledge. See  Spring MVC Official Documentation  for details) ExtJS "application architecture" (see  Sencha Docs  for details) Eclipse IDE + Tomcat 6 (or any other web container) You a...
            16 comments
            Read more

            Ext4 Apply Store Filtering

            In extjs4.1: There are many way for store filtering . Some of code i give here Filtering by single field: store . filter ( 'eyeColor' , 'Brown' );   Alternatively, if filters are configured with an  id , then existing filters store may be  replaced by new filters having the same  id . Filtering by single field: store . filter ( "email" , /\.com$/ );   Using multiple filters: store . filter ([ { property : "email" , value : /\.com$/ }, { filterFn : function ( item ) { return item . get ( "age" ) > 10 ; }} ]);   Using  Ext.util.Filter  instances instead of config objects (note that we need to specify the root config option in this case): store . filter ([ Ext . create ( ' Ext.util.Filter ' , {   property : "email" , value : /\.com$/ , root : 'data' }),   Ext . create ( ' Ext.util.Filter ' , {   filterFn : function ( item ) {   return item . get ( ...
            Post a Comment
            Read more