Introduction
Siebel projects that are crossing over to Open UI, will soon realise the immediate need to implement standards around the development and deployment of the external resources in Open UI. Unlike traditional Siebel development, where source code is checked into a database and compiled into a SRF with a proprietary IDE, Open UI is based on text files that can be edited using Notepad.
Managing external files is not new to Siebel development, but it has never been mainstream, and the processes for managing these resources are not as mature. This article is aimed at Siebel development managers looking to incorporate best practice from file based development environments, and integrating them with Open UI.
Traditional Vs Modern Siebel Development
A traditional Siebel development cycle involves the developer checking out and locking a project/object, the developer performs the modification, and checks it back in. The Siebel repository stores the source code, and allows projects manage a single code base.
Parallel development can be achieved by establishing a second repository, and managing the code promotion through a separate environment path.
Merging the code bases can be performed through exporting and importing SIFs. Siebel provides a decent merge tool for configuration changes, but merging code is always a risky affair, due to the inability to perform a line by line merge.
Open UI development is very much like web development, files can be edited freely in your code editor of choice, your application can be easily debugged from any browser, and you have the flexibility to pick and choose your add-on web technologies. There is no longer a dependency on the Siebel way to build your application.
Building your Application
Do you use XSLTs, Client side business services, custom images/JS/CSS, customized web templates? Then you need a build process. A build process allows projects to automate the production of artifacts for deployment with the following advantages
* Resources are deployed in a consistent manner
* Automated quality checks, and enforcement
* Files are optimised for Production
* Automatic documentation
* Integration with Source Control
* Automated unit testing
To achieve the above tasks, we’ll need to establish the build process, procure the required toolset, and develop the necessary automation.
Establishing a Process
Projects need a formal strategy to manage the migration of files from source to deployment. Fundamentally this process should address how files are tracked, changed, merged and deployed, across multiple parallel development streams. This shouldn’t be new territory, so projects don’t have to go shopping for a new process, unless it is broken. Existing HI file deployment processes can be carried over, and augmented to incorporate the some of the best practices from modern web development.
* Integrated Source control
* Continuous Integration
* Automated test cases
SCM (Source Control)
The concept of building an application requires that we have a source. For traditional Siebel development, this source is the Siebel repository, in Open UI, the source should also be in a repository, but it is more likely to be a file repository rather than a database repository.
There are many solutions in the market that offer Software Configuration Management (SCM), but it is up to each project to choose the appropriate solution for their needs. The most obvious place to look is within your own organization to discover what SCM software is available, and used by other IT sections. This allows you to take advantage of the licensing agreements, and leverage the existing support arrangements that are already in place. Open source/free SCM sounds great, but it is risky to introduce it into an Enterprise, unless you have the expertise to maintain/support it yourself, otherwise prepare to negotiate for the support arrangements.
Build Automation
Automation tools allow projects to enforce, a standard build process to a set of source files, package and prepare it for deployment into its destination. This destination could be a developers local machine, or a server environment, but the build process should be consistent and reliable.
Many projects schedule the automatic compilation of the SRF, generating browser scripts, and deployment of the SRF into development environments. The same process should also be extended to deploy Open UI resources into the same environment, providing Continuous Integration for the entire build process.
Here are some examples of automation that can be applied to Open UI resources before deployment
* Add standard headers such as revision, organization details, release information, disclaimers to all files
* Strip comments from files
* Compress JS/CSS files through minification
* QA JS files with JSHint/JSLint
* Consolidate common JS Files to reduce HTTP requests
* Extract metadata from JS files, and produce documentation
Are you using a build process for HI? The same principles can be used in HI for other external resources.
Here are some ideas
* Automatically turn of XSLT indenting
* Generating XSLT documentation
* Extracting eScript from the repository and validating it
* Run interface test cases
Code Editors
While Notepad and other standalone editors are sufficient, it is recommended that you choose an editor that has the capability to detect JS language errors, integrate with your SCM, and automation tools.
Siebel Tools has this capability built in to an extent, but in Open UI, if you miss a closing bracket, and it is loaded via a common file, your application could fail silently, and pin pointing it to its exact source might not be fun. Code editors can perform the role of QA, by ensuring that your code is free from syntax errors before it is run against more stringent QA checks by programs like JSHint/JSLint
Automated Test Cases
Automated test cases are used as part of Continuous Integration to ensure that changes from multiple developers, work coherently and doesn’t break the application. The challenge is that developing automated test cases for the UI isn’t easy, at least not for traditional HI UIs. Open UI promises to be open, and exposes a new set of APIs for browser automation tools to interact with.
Until Oracle provides an Open UI automation client (for developers), conceptually, a project could achieve Open UI automation testing using a combination of the following tools
* Selenium
* Watir
* Ruby
* Custom JS OUI automation API
Selenium provides the browser automation, Watir is a ruby library that provides a nice abstraction onto of Selenium, and a custom JS interface provides the API bridge between Ruby, and the Open UI client.
Toolchain
Your build process will be dependent on the tools that’s supported by your organisation. The best tools for the job, are dependent on a variety of factors, like cost, availability, familiarity, features, and support. There isn’t a standard set of tools for everyone, however the main tools in your arsenal should be the IDE, SCM, and Automation tools
* List of source code editors
* List of build automation software
* List of SCM software
Other tools to investigate
* JS minification
* JS/CSS consolidation
* JSHint/JSLint
* JS Documentation
Conclusion
Establishing a build process isn’t something that is restricted to large teams, it just important to have this process in place for a single developer working offline. Having source code control becomes critical for working in Open UI, so gone are the days where it is acceptable to modify files directly on the web server, or on the Siebel dedicated client for the same reason.
A build process can ensure that your application remains stable throughout the iterative development process, or alternatively without one, your project can become a cowboy arena, where developers go in, make adhoc changes, send off different file revisions for deployment via emails, and break at every deploy. The choice is pretty clear.
Further reading
* Why use source control
* Setting up a JS Build Process
* Siebel Continuous Integration Setup
* Branching, Merging concepts with Git
Some customers will have more mature processes than others, so what build tools are you using in your project?
To kick this off, here’s what works for me
* ANT (Build automation)
* ClearCase (SCM)
* Eclipse (IDE) + ClearCase Plugin
* Eclipse JSHint integration via RhinoJS
* YUI Compressor (JS minification)
* + Selenium & Ruby for some UI automation fun
Siebel projects that are crossing over to Open UI, will soon realise the immediate need to implement standards around the development and deployment of the external resources in Open UI. Unlike traditional Siebel development, where source code is checked into a database and compiled into a SRF with a proprietary IDE, Open UI is based on text files that can be edited using Notepad.
Managing external files is not new to Siebel development, but it has never been mainstream, and the processes for managing these resources are not as mature. This article is aimed at Siebel development managers looking to incorporate best practice from file based development environments, and integrating them with Open UI.
Traditional Vs Modern Siebel Development
A traditional Siebel development cycle involves the developer checking out and locking a project/object, the developer performs the modification, and checks it back in. The Siebel repository stores the source code, and allows projects manage a single code base.
Parallel development can be achieved by establishing a second repository, and managing the code promotion through a separate environment path.
Merging the code bases can be performed through exporting and importing SIFs. Siebel provides a decent merge tool for configuration changes, but merging code is always a risky affair, due to the inability to perform a line by line merge.
Open UI development is very much like web development, files can be edited freely in your code editor of choice, your application can be easily debugged from any browser, and you have the flexibility to pick and choose your add-on web technologies. There is no longer a dependency on the Siebel way to build your application.
Building your Application
Do you use XSLTs, Client side business services, custom images/JS/CSS, customized web templates? Then you need a build process. A build process allows projects to automate the production of artifacts for deployment with the following advantages
* Resources are deployed in a consistent manner
* Automated quality checks, and enforcement
* Files are optimised for Production
* Automatic documentation
* Integration with Source Control
* Automated unit testing
To achieve the above tasks, we’ll need to establish the build process, procure the required toolset, and develop the necessary automation.
Establishing a Process
Projects need a formal strategy to manage the migration of files from source to deployment. Fundamentally this process should address how files are tracked, changed, merged and deployed, across multiple parallel development streams. This shouldn’t be new territory, so projects don’t have to go shopping for a new process, unless it is broken. Existing HI file deployment processes can be carried over, and augmented to incorporate the some of the best practices from modern web development.
* Integrated Source control
* Continuous Integration
* Automated test cases
SCM (Source Control)
The concept of building an application requires that we have a source. For traditional Siebel development, this source is the Siebel repository, in Open UI, the source should also be in a repository, but it is more likely to be a file repository rather than a database repository.
There are many solutions in the market that offer Software Configuration Management (SCM), but it is up to each project to choose the appropriate solution for their needs. The most obvious place to look is within your own organization to discover what SCM software is available, and used by other IT sections. This allows you to take advantage of the licensing agreements, and leverage the existing support arrangements that are already in place. Open source/free SCM sounds great, but it is risky to introduce it into an Enterprise, unless you have the expertise to maintain/support it yourself, otherwise prepare to negotiate for the support arrangements.
Build Automation
Automation tools allow projects to enforce, a standard build process to a set of source files, package and prepare it for deployment into its destination. This destination could be a developers local machine, or a server environment, but the build process should be consistent and reliable.
Many projects schedule the automatic compilation of the SRF, generating browser scripts, and deployment of the SRF into development environments. The same process should also be extended to deploy Open UI resources into the same environment, providing Continuous Integration for the entire build process.
Here are some examples of automation that can be applied to Open UI resources before deployment
* Add standard headers such as revision, organization details, release information, disclaimers to all files
* Strip comments from files
* Compress JS/CSS files through minification
* QA JS files with JSHint/JSLint
* Consolidate common JS Files to reduce HTTP requests
* Extract metadata from JS files, and produce documentation
Are you using a build process for HI? The same principles can be used in HI for other external resources.
Here are some ideas
* Automatically turn of XSLT indenting
* Generating XSLT documentation
* Extracting eScript from the repository and validating it
* Run interface test cases
Code Editors
While Notepad and other standalone editors are sufficient, it is recommended that you choose an editor that has the capability to detect JS language errors, integrate with your SCM, and automation tools.
Siebel Tools has this capability built in to an extent, but in Open UI, if you miss a closing bracket, and it is loaded via a common file, your application could fail silently, and pin pointing it to its exact source might not be fun. Code editors can perform the role of QA, by ensuring that your code is free from syntax errors before it is run against more stringent QA checks by programs like JSHint/JSLint
Automated Test Cases
Automated test cases are used as part of Continuous Integration to ensure that changes from multiple developers, work coherently and doesn’t break the application. The challenge is that developing automated test cases for the UI isn’t easy, at least not for traditional HI UIs. Open UI promises to be open, and exposes a new set of APIs for browser automation tools to interact with.
Until Oracle provides an Open UI automation client (for developers), conceptually, a project could achieve Open UI automation testing using a combination of the following tools
* Selenium
* Watir
* Ruby
* Custom JS OUI automation API
Selenium provides the browser automation, Watir is a ruby library that provides a nice abstraction onto of Selenium, and a custom JS interface provides the API bridge between Ruby, and the Open UI client.
Toolchain
Your build process will be dependent on the tools that’s supported by your organisation. The best tools for the job, are dependent on a variety of factors, like cost, availability, familiarity, features, and support. There isn’t a standard set of tools for everyone, however the main tools in your arsenal should be the IDE, SCM, and Automation tools
* List of source code editors
* List of build automation software
* List of SCM software
Other tools to investigate
* JS minification
* JS/CSS consolidation
* JSHint/JSLint
* JS Documentation
Conclusion
Establishing a build process isn’t something that is restricted to large teams, it just important to have this process in place for a single developer working offline. Having source code control becomes critical for working in Open UI, so gone are the days where it is acceptable to modify files directly on the web server, or on the Siebel dedicated client for the same reason.
A build process can ensure that your application remains stable throughout the iterative development process, or alternatively without one, your project can become a cowboy arena, where developers go in, make adhoc changes, send off different file revisions for deployment via emails, and break at every deploy. The choice is pretty clear.
Further reading
* Why use source control
* Setting up a JS Build Process
* Siebel Continuous Integration Setup
* Branching, Merging concepts with Git
Some customers will have more mature processes than others, so what build tools are you using in your project?
To kick this off, here’s what works for me
* ANT (Build automation)
* ClearCase (SCM)
* Eclipse (IDE) + ClearCase Plugin
* Eclipse JSHint integration via RhinoJS
* YUI Compressor (JS minification)
* + Selenium & Ruby for some UI automation fun
0 comments :
Post a Comment