We found this interesting article posted on the OMG (Object Management Group)website & thought it’s worth sharing.
The article was written by Leon Starr at Model Integration, LLC. It illustrates the platform independent timing and synchronization rules that modelers use and architects implement to support Executable UML® applications.
To read the full article, head over to the OMG website.
MicroFocus are pleased to announce the general availability of SilkCentral 12, their award winning test management solution. This new release focused on usability to increase user adoption and to drive testing efficiency.
The mission of SilkCentral is to control and manage software testing with an open and collaborative approach to test management. MicroFocus decided the way to achieve that mission is to increase user adoption by harnessing the power of SilkCentral’s technology within an easy to use interface that includes dashboards, graphs, and the ability to accomplish a task without redundant steps.
Prior to this release, SilkCentral excelled at unifying a variety of testing assets into a single source of truth so that customers have real time visibility into the status and results of tests. After meeting with key customers and analyzing the competitors, it became obvious that the user experience needed to change to truly unlock the power of SilkCentral.
SilkCentral 12 addresses these challenges and puts us in a position to attack our competitors with a simplified approach to test management.
You can read more about SilkCentral here.
Users of Enterprise Architect may be aware that it is possible to extend the functionality of Enterprise Architect via the creation and installation of Extensions (previously known as Add Ins)
This newsletter provides an overview of three such extensions which are available from third party providers.
These extensions are:
CaliberRM is a requirements management system produced and distributed by MicroFocus. This extension written and supplied by Dunstan Thomas provides a functionality similar to that of the DOORS MDG Integration supplied by Sparx Systems.
Two versions of the extension are available, one which supports CaliberRM 2008 and one which supports the latest version, namely, CaliberRM 10.1
The extension provides the following functionality:
The following system requirements are required for this extension;
The trial licence (30 days and limited to processing 50 requirements) is available to download free from the DT ALM CaliberRM / EA Integration web page.
The full licensed version is available from the DT ALM online shop.
AM|USE is an extension that provides UML/SysML model simulation, primarily for State Machines.
The extension provides the following functionality;
The trial version can be downloaded from our Plug-Ins page.
The full product is available for purchase from the DT ALM Online Shop.
eaDocX from Ability Engineering Ltd is an extension that provides documentation production by integrating Enterprise Architect and Microsoft Word.
The extension provides the following features;
The following system requirements are required for this extension:
eaDocX is available from the DT ALM Online Shop.
We have provided a quick overview of three selected extensions for Enterprise Architect. For further information regarding these extensions please refer to the relevant “Availability” sections of this post.
Details of many extensions currently available for Enterpise Architect may be found at http://www.sparxsystems.com/products/3rdparty.html
Dunstan Thomas ALM and one of their partners recently cemented a two year collaboration by working together to support a household name organisation to migrate from Waterfall to Agile SCRUM methodology and move its software development onto Microsoft Team Foundation Server (TFS). The results have been dramatic for the global client, kick-starting a full transition to Agile SCRUM which has already tripled the software development team’s productivity.
The transformation sees a 25-strong team moving from quarterly to monthly and eventually weekly release cycles; and from cumbersome, error-prone manual release processes to automated software builds and tests using the power of TFS and associated tools including Microsoft Test Manager and Coded UI.
Dunstan Thomas ALM provides training, consulting, products and tools for ALM, custom software development services and outsourced software support services. The company employs 35 staff at its headquarters in Portsmouth and has outsourced software development partners in Malta and Romania.
Dunstan Thomas ALM provides a comprehensive range of services to support the software development teams – helping companies optimise their valuable in-house software development resources. It also provide consultancy on best practices and assists businesses to outsource software development or IT support activities if required.
Dunstan Thomas ALM is renowned for being at the forefront of the software development industry and employs a mix of highly skilled, highly experienced staff that all have a track record of achievement within the industry.
Many of Dunstan Thomas ALM’s staff are certified practitioners across the major software development methodologies such as Agile SCRUM and the majority are also software developers trained and practising developers in a number of programming languages. As Dunstan Thomas ALM develops software for clients, it uses all of the tools that it promotes, to deliver a ‘best-of-breed’ approach for all clients – using tools from analysis and design through to quality testing.
Dunstan Thomas ALM consultants and trainers bring a wealth of practical experience to each of their projects. They understand the technical and business challenges that a project presents, whether this is transferring a software support process to an outsourced operation or developing new software. The business works with a range of clients from across a range of industry sectors with deep vertical knowledge in financial services, energy and telecoms.
Dunstan Thomas recently collaborated with partners on a training and consultancy assignment to support a 25-strong software development team within a global organisation, which offers workplace healthcare services. The results were impressive:
The organisation’s software development team has grown quickly from eight people when the company started in 2006 up to 25 staff today. THE COMPANY originally used the Waterfall methodology for building software along with Microsoft Visual Source Safe for source code control and Microsoft Test Track Pro for bug tracking and fixes.
However as the business grew regular quarterly software release cycles were increasingly being disrupted by additional requests from the business. The team found the Waterfall methodology was making it difficult to handle these hot fixes and emergency additions because of the absence of version control or branching capabilities within the process.
Luisa Partridge, director of sales at Dunstan Thomas ALM, explained:
“In order to make changes they had to roll back to earlier releases to fix code and then roll forward to the latest version of code. It was time-consuming and fiddly work. They also found that Test Track Pro was not well suited to collecting user stories that would allow us to proactively search out bugs to fix.”
The client’s software development team also had to do a great deal of manual processing of code releases. This exposed the team to human error in the process of capturing code changes and then putting them into the next release. All developers, once they had finished making their code changes, had to summarise them in release notes written in Microsoft Word files which were sent onto the release engineer with links to other files. This engineer then had to go through literally hundreds of these release notes and apply them to the build.
The software build phase as a result could take up to five days and was beset by errors. If a developer forgot to attach a file in his release note this would often throw up exceptions which further delayed the release. It could then take several more weeks to complete the testing and fixing phase. Altogether it could easily take two months to complete each quarterly release. This meant that building and testing had become a serious bottleneck in the software development process. They needed a new methodology to enable faster, more efficient software development and meet changing business requirements.
After exploring a full range of options for software methodology and toolsets, the organisation selected Microsoft’s Visual Studio and Team Foundation Server (TFS) and the Agile SCRUM. It was clear that the team would need support to make the transition from the Waterfall methodology to the Agile SCRUM and from its existing requirements gathering and testing tools to the new TFS-based ones.
Because the software development team operated on both sides of the Atlantic and was at that time managed from London it made sense to find a UK-based TFS specialist IT consultancy to partner with. Dunstan Thomas ALM was selected in the middle of 2011 and training and consultancy requirements were scoped before delivery from December.
When Dunstan Thomas ALM’s team arrived the transition to TFS was already underway and all code had been ported to three build servers on Virtual Machines.
Luisa Partridge explained the initial task that Dunstan Thomas ALM’s TFS and Agile SCRUM specialist team took on:
“Initially we worked with the client to teach them how to better manage the release management process using branching, TFS’s version management system. This works by organising code into a number of branches which makes it easier to isolate and fix code changes without having to roll back the whole platform to make those changes. We then helped the client to automate this branching process.”
Once the release management process had been optimised and the goal of automating builds had been reached Dunstan Thomas ALM’s team , worked with the organisation’s business analysts and project managers, to capture requirements in the form of ‘user stories’ in Agile 5.0 format.
User stories are considered a much more efficient and proactive way of capturing user requirements as they help eliminate any mismatch between what the business wants and the actual user experience that the technology delivers. Dunstan Thomas ALM trainers also completed in-depth TFS administration training on the configuration, customisation and optimisation of TFS.
Dunstan Thomas ALM trainers went on to mentor the firm’s IT team on how to manage sprints and run shorter release cycles in accordance with Agile SCRUM methodology. The company was then able to begin the transition from quarterly to monthly release cycles.
Dunstan Thomas then brought in a partner to deliver further training on testing the company’s software once built. The partner’s training covered the use of Microsoft’s testing and automation tools, notably Microsoft Test Manager, Coded UI, performance and load testing.
The partner firm also worked alongside Dunstan Thomas’ training and consulting team to ensure that TFS had been configured and deployed properly so that the test team could use TFS and the features of Microsoft’s testing tools to collaborate effectively with the client’s developers using the new methodology.
The partner firm also provided training and mentoring to the developers and testers of the client’s 25-strong software development team on the use of these testing tools so that they became proficient in the use of the tools going forward.
The Director of the partner firm explains the value of mastering Microsoft’s testing tools:
“The testing tools inside TFS are revolutionising the way software is developed – reducing project timescales but also improving communication between the software development team and project sponsors within the business.”
“Testing can add huge value within the ALM process but for this to work to its full potential, testing tools need to be there to support it. Microsoft is leading the charge by providing a true ALM tool which integrates with assets created by developers and business analysts while fully supporting agile development processes. Total traceability from requirements, through code to testcases and bugs bugs can be delivered by TFS today. Continuous integration with code, test and deploy being automated has never been easier.”
He added:
“TFS can now effectively spot and highlight the lines of codes which contain bugs. This can be exported and relevant developers alerted. The developer can right click to look at the code and attach it for sending on if necessary. This is unique to TFS.”
Previously the client was taking up to two months to complete release cycles. Now that TFS is fully embedded in this client’s software development team it is able to complete monthly update cycles in less than two weeks. Efficiencies have been found at every stage from requirement gathering using user stories; through automated release management, build, testing and fixing before completion and go live.
The head of the client’s software development team summarised:
“Thanks to our work with Dunstan Thomas ALM and their partner we’ve been able to move from quarterly to monthly release cycles and are planning towards weekly cycles. We can now deploy new releases in a couple of hours – it used to take over a week before we moved to TFS. Taken together with our migration from Waterfall to the Agile SCRUM methodology and moving from Test Track Pro to Microsoft Test Manager has engendered a night and day difference in terms of my team’s productivity.”
“We’ve gone from a largely manual software development system to one where the sweat is taken out of it. We think productivity levels have already tripled and that’s before all the benefits of Agile SCRUM have been fully realised. We can now focus on really adding value to the business.”
The team has used these productivity gains to use its spare capacity to get closer to the business, proactively searching out business requirements which it can then meet by delivering updated software much faster. It is also able to report back quickly on the progress of software development activity to product and marketing managers. TFS provides out of the box reports which track defect fix rates, code churn, progress on user stories and, as SCRUM becomes applied more rigorously, sprint progress and burn-down charts.
Greater transparency on progress and timings for new releases has led to greater confidence in the team across the business. Expectations are now being managed more effectively and the software development team is rarely fire fighting as it often was before. Reporting capability has been further improved through the deployment of management information tool Telerik Teampulse which integrates with TFS to provide executives with a high-level view of the progress of software development projects in a language they understand.
“This client plans to port requirements and test cases into TFS to increase efficiencies in testing further. They are not raising rich-actionable bugs yet but this is a declared objective for this client’s software development team by the end of 2012. Once the company’s testing process is fully mature then continuous integration, with nightly builds and automated tests, will become a reality.” Partner Director.
The company is also moving rapidly towards widespread application of Agile SCRUM which will see its development and testing teams working even more closely than they are today. Release cycles will be able to move from monthly to weekly cycles as sprints become the key forum for running software development projects.
Greater automation in the build and testing stages will create further efficiencies and ensure that the team can continue to cope with a workload that is currently expanding month on month.
Following the success of this joint engagement Dunstan Thomas ALM are looking for new opportunities to work with their partners.
The Team Foundation Server 2010 upgrade wizard and its documentation are sufficient for many differing upgrade scenarios and configurations. The standard upgrade paths are applicable in almost all cases where there is no limit on hardware resource and the aim is upgrade/replace rather than parallel running. During a recent in house upgrade where hardware resource was tight and the user requirements for the upgrade included minimal downtime and a parallel running phase the standard paths were a bad fit. This newsletter documents the way these limitations were tackled and brings together several elements that were required to complete this type of upgrade. It includes details of the procedure to move Team Foundation Server databases from one server to another and reconnect the application-tier and specifics on running both 2008 and 2010 using shared SQL database and SharePoint servers.
This information found here is not meant to be a detailed overview of Team Foundation Server upgrade process as a whole and some knowledge of the technical architecture of both Team Foundation Server 2008 and 2010 is assumed. The main focus of this article is to cover the specific scenario encountered during the subject upgrade and collect together the information required for anyone that may attempt this type of upgrade in the future.
We recently needed to upgrade our 2008 implementation of Team Foundation Server to 2010. Normally this would follow one of two standard patterns covered by the Microsoft upgrade documentation, either an in place upgrade or a migration upgrade. But due to lack of hardware resource the eventual solution would be a mix of both options with a few undocumented steps thrown in.
An in place upgrade involves upgrade Team Foundation Server on the same hardware that was running the earlier version. This path requires the un-installation of old version, followed by the install of 2010. The upgrade wizard is then run. Post upgrade (if all goes well) you have a shiny new Team Foundation Server 2010 installation with new upgraded databases and your old Team Foundation Server 2008 implementation is no longer accessible.
You can also perform a migration upgrade by copying your data to different hardware running SQL server. Then installing Team Foundation Server 2010 and running the upgrade wizard. By using separate hardware in this way you have the opportunity to parallel run both versions for a while to allow confirmation that the upgrade was successful before turning off the 2008 server.
The main requirements for live operations during the proposed upgrade were as follows;
Initially this looks like a migration upgrade as these requirements immediately rule out the first option of an ‘In-Place upgrade’. Mainly because 2008 must remain available throughout the process and post upgrade for a parallel run period. That leaves the ‘Migration upgrade’ option but the main requirement for that path, is separate hardware for the new servers. As this resource was not available a third solution was required to allow the upgrade to continue. The main problem posed by the requirements was the need to use the existing SQL server for 2010 as well as the already running 2008. The interesting part then was not going to be the actual upgrade but attempting to get both 2008 and 2010 running on the same database server in parallel. This configuration is not covered in any installation or upgrade documentation I have come across and extensive Googling came up with no real help or guidance. Before describing the solution that was used an understanding of both the existing and target production environments is required.
A description of the Team Foundation Server 2008 implementation that existed prior to the upgrade taking place. The Team Foundation Server application tier is hosted by the (WAGNER). The data-tier and databases for Report Server and SharePoint are hosted by (BACH). The TFS 2008 build service is hosted by (BIZET). All Team Foundation Server SharePoint project portals are hosted on (TOCH) under MOSS 2007.
In order to keep 2008 up and running and unaffected, the upgrade would have to take place in isolation so the following solution was proposed. Create three virtual machines one for the data-tier one for the application tier and another for the build server. The data-tier would only be temporary and used to host the 2008 databases for the upgrade only and then thrown away. The application-tier and build VM’s would eventually become production servers hosting the 2010 services. The virtual upgrade environment is shown below. Eventually the upgraded databases will be moved from the temporary server (DYSON) to the existing live data-tier (BACH) and the new application tier (TIPPET) will be re-pointed to the live data-tier server (BACH).
The diagram below shows the production environment hosting both Team Foundation Server 2008 (blue circle) and Team Foundation Server 2010 (green circle). Both TOCH the SharePoint server and BACH the database server are shared between 2008 and 2010. Note the addition to the existing live environment of the two virtual machines TIPPET and BINGEN.
The actual upgrade run in the VM environment went without any problems. The databases were exported from BACH overnight and imported onto the temporary server DYSON. Team Foundation Server 2010 was installed on TIPPET along with SQL Server reporting services. The Team Foundation Server 2010 upgrade wizard was run against the databases on DYSON which resulted in a fresh set of 2010 databases. At this point we now have two sets of databases, the 2008 versions of the databases in use on the live server and the new 2010 databases ready for export/import.
The structure of the database in Team Foundation Server 2010 has been completely reworked due to the introduction of the Team Project Collection database type. Effectively, the Team Project Collection database now encompasses all of the data held in the 2008 databases with the exception of ‘TfsWarehouse’. This allows this multiple Team Project Collection’s to be hosted on the same server. The two sets of databases can be seen below side by side, these lists do not include databases used by SQL Report Server or SharePoint.
| TFS 2008 Databases (BACH) | TFS 2010 Databases (DYSON) |
| TfsActivityLogging | Tfs_Configuration |
| TfsBuild | Tfs_DefaultCollection |
| TfsIntegration | Tfs_Warehouse |
| TfsVersionControl | |
| TfsWarehouse | |
| TfsWorkItemTracking | |
| TfsWorkItemTrackingAttachments | |
| TFS 2008 Analysis Database | TFS 2010 Analysis Database |
| TfsAnalysis | Tfs_Analysis |
Note the addition of the underscore character in the 2010 databases, this is important as the database names must not clash when hosted on the same server. Check there are no clashes with your database names at this point.
Now comes the tricky part! Once the TFS 2010 upgrade is complete the upgraded databases need to be moved from the temporary database server DYSON to the production server BACH. This needed to be done with care as BACH also hosts the TFS 2008 databases and these must be available throughout the upgrade process and post upgrade for a period of parallel running.
An existing MSDN article covers the processes of moving the databases. However, the described move is to a new server instance and not an existing instance that already hosts another version of TFS. The steps below include a summary of the information on MSDN and extra or modified steps to allow the co-existence of the databases for both 2008 and 2010 on the same instance.
These commands need to be run on the 2010 application tier.
(2) Backup databases on DYSON
Backup the following databases on DYSON and move/copy the backups to your live database server i.e. BACH.
Database Engine
Analysis Services
(3) Restore Databases to BACH
The restoration of the databases differs for the Database Engine and Analysis services.
Database Engine
Analysis Services
<Restore xmlns=”http://schemas.microsoft.com/analysisservices/2003/engine”>
<DatabaseName>Tfs_Analysis</DatabaseName>
<File>E:\SQL_Analysis_Data\MSAS10_50.MSSQLSERVER\OLAP\Backup\Tfs_Analysis.abf</File>
</Restore>
Some preparation must be carried out on BACH to allow the TFS 2010 application tier to access the moved databases.
The following commands need to be run on the 2010 application tier.
Open a command prompt and run the following commands;
cd “%programfiles%\Microsoft Team Foundation Server 2010\Tools”
TFSConfig PrepSQL /SQLInstance:BACH
TFSConfig Accounts /ResetOwner /SQLInstance:BACH /DatabaseName:Tfs_Configuration
TFSConfig RemapDBs /DatabaseName:BACH;TfS_Configuration /SQLInstances:BACH /AnalysisInstance:BACH
TfsConfig registerDB /SQLInstance:BACH /DatabaseName:Tfs_Configuration
These commands need to be run on the 2010 application tier.
Start a command prompt on app tier
cd “%programfiles%\Microsoft Team Foundation Server 2010\Tools”
TFSServiceControl unquiesce
Luckily both reports and SharePoint portals were not in use under 2008, so these needed be recreated manually post upgrade. Reporting services was installed on TIPPET and new databases were created on BACH for use with Team Foundation Server 2010. These were named differently than those currently in use by 2008. The SharePoint server TOCH (MOSS 7) did host a site for 2008 web portals but was not currently used, a new SharePoint site was created for 2010. Post upgrade both project reports and web portals would need to be recreated using command line tools available in Team Foundation Server 2010 Power Tools. See the tools and documentation for more information if required
The upgraded database schema no longer works with reports created in previous versions. A new set of Agile 5.0 based reports can be deployed with TFS 2010 power tools using the following command line;
tfpt.exe addprojectreports /collection:http://tippet:8080/tfs/DefaultCollection /teamproject:”ProjectName”
/processtemplate:”MSF for Agile Software Development v5.0″ /force
Possible error message and fix see; Cannot create project (TF30225: xp_sqlagent_notify)
To take advantage of the new dashboard features project portals need to be recreated. To achieve this;
tfpt.exe addprojectportal /collection:http://tippet:8080/tfs/DefaultCollection /teamproject:” ProjectName” /processtemplate:”MSF for Agile Software Development v5.0″
The final step of the upgrade was to start the Team Foundation Server 2010 services in parallel with the already running 2008 services. A period of verification testing followed and the version control and work item tracking of both the original and upgraded databases could be compared. Once all was ready clients where switched to the upgraded application tier and normal was resumed. At this point the temporary SQL Server (DYSON) could be decommissioned leaving the live server (BACH) to host both 2008 and 2010 databases.
During the entire upgrade process the original 2008 version remained available for operational work and can now continue to run alongside the 2010 upgraded clone of itself. The Build services on both BIZET(2008) and BINGEN(2010) are running on separate servers accessing separate application tiers that use the same SQL server database instance and share the same SharePoint server.
In this newsletter we have discussed the two standard upgrade paths documented by Microsoft for Team Foundation Server. A third undocumented path has been outlined that involves temporary upgrade environments and moving databases between servers. We have also shown that both Team Foundation Server 2008 and a cloned set of databases upgraded to 2010 can be run on the same server allowing parallel running of both versions with the same data.
When working on large diagrams modellers often need to identify certain elements that are of particular interest to them.
Some examples of element selection are:
Diagram Filters is new functionality added for Enterprise Architect version 8.0 that provides this facility. Currently the Diagram Filters function only operates on Elements that are visible on a diagram (but the same Diagram Filters can be applied to diagrams of different types). They work by using a slimmed down version of the Search Filters already built-into Enterprise Architect, but instead of returning a list as a result of the search, the appearance of the Elements on the diagram can be changed.
There are four effects that can be applied when Diagram Filters are in use on a diagram, these are:
Initially the above seems confusing, but when you see the Diagram Filters in action, the effects described above will become more intuitive. It must be noted that any one of the four effects can be applied with any Diagram Filter, that is to say, the effect is not part of the Diagram Filter but rather it controls how the filter is applied to the diagram.
A simple example should clarify matters. It is common modelling practice that all Elements on a diagram be elaborated with a textual description, captured in the Notes property of an Element within Enterprise Architect.
Some modellers add these notes as they create elements whereas others do not, so if we imagine a project team working collaboratively, how can each member of the team identify which elements have notes and which do not? Although there are many possible solutions to this problem, this example will illustrate a simple solution using Diagram Filters.
The following images illustrate the application of the Diagram Filter for each of the four effects.
Fade out those elements that do have a description leaving those elements that need a description
Colour grey out those elements that do have a description leaving those elements that need a description
Hide those elements that do have a description leaving those elements that need a description
Select these elements that do need a description leaving those elements that have a description unselected.
The modeller is able to identify quickly and easily those elements that require a description to be added.
For some diagrams with many different element types, a filter setting for a particular Object Type could be added to the filter testing for the empty Notes property. Currently, Diagram Filters cannot use a search term, so a separate Diagram Filter would have to be created for each element type.
In this newsletter we have described how use Diagram Filters to “fine tune” the appearance of diagrams. Diagram Filters are a potentially valuable aid to modellers, particularly those who work in a collaborative modelling environment.
© Dunstan Thomas 2012
