Software:AnthillPro

From HandWiki
Revision as of 13:56, 9 February 2024 by Jslovo (talk | contribs) (fix)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Short description: Software tool
AnthillPro
Developer(s)IBM
Stable release
5.0.0 / September 2013 (2013-09)
Written inJava
Operating systemCross-platform
TypeContinuous Integration, Continuous Delivery, Application lifecycle management (ALM), Application release automation, DevOps
LicenseProprietary

AnthillPro is a software tool originally developed and released as one of the first continuous integration servers. AnthillPro automates the process of building code into software projects and testing it to verify that project quality has been maintained. Software developers are able to identify bugs and errors earlier by using AnthillPro to track, collate, and test changes in real time to a collectively maintained body of computer code.

AnthillPro was released in 2001. In 2006, AnthillPro expanded into an enterprise integration and delivery[1][2] automation platform supporting continuous integration,[3]:59 deployment automation,[3]:126 application lifecycle management (ALM),[4] and the emerging DevOps methodology.[5]

AnthillPro supports distributed and cross-platform builds in .NET, Java, C/C++ and other programming languages. AnthillPro had over 400 enterprise customers worldwide as of 2009.[6] UrbanCode was bought by IBM in April 2013.[7]

On August 28, 2017, it was announced that AnthillPro is being retired and will no longer be supported after October 31, 2018.[8] It is replaced in the market by IBM UrbanCode Build and IBM UrbanCode Deploy.

Historical perspective

Continuous integration

In software development organizations that use Source Configuration Management (SCM), developers first analyze and remove code from the "main code line," which is the main body of code. The developers then change the removed code and embed the altered code back into the main code line, which is a process referred to as "checking in." After the code is checked in, the entire project can then be built and tested.

If there are no errors generated during the build process, the build is deployed to a test environment and unit tested to ensure that the quality of the project has not decreased since the previous build. This process of "build, deploy, unit test" for every occasion of checked-in code is referred to as continuous integration (CI).[citation needed]

The original Anthill software tool, released in 2001, was a simple continuous integration server and is still available today. Along with tools such as CruiseControl, Anthill contributed to the establishment of standard tools for continuous integration practices.[3]

Build/integration cycles become more frequent

Originally, the term "build" referred to the process of compiling and linking source code into executable code. Typically, these executable codes would be stand-alone applications, such as Microsoft Word or Adobe Photoshop. During the 1990s, the typical release cycle for applications (such as the Microsoft Windows operating system) was 12 to 24 months.[9]

In traditional software development at that time, developers would typically check in code once a day, and would run a "nightly build" after all the code was checked in.[10] If the code built successfully, they would run a series of unit tests and general functions tests, commonly referred to as "smoke tests." If any of the tests failed, the build was considered a failure and had to be fixed immediately. If the tests passed, then the build might be deployed to a test system for further testing.[11]

Build/integration of applications becomes more complex

With the advent of multi-tier architectures, beginning with client-server and progressing to service-oriented architecture, a build became much more complex than simply compiling and linking code. Builds included many other types of activities, such as applying database changes, loading static content from a content management system, configuring software components, and deploying all or part of the build.[12]:4

UrbanCode released the original Anthill OS as a free tool intended for build management.[13]:397–401[14]:275–278 Due to the popularity of Anthill OS, UrbanCode created AnthillPro as a commercial product.[12]:360 UrbanCode released the first commercial edition of AnthillPro in 2002. Unlike CruiseControl, which at the time was focused purely on providing developers feedback about the health of their builds, AnthillPro was focused on build management and using the results of one project's build as a dependency for other projects.[15]

Application release cycles shrink - Build cycles become more frequent

In addition to the growing complexity of the build/release cycle, the typical release cycle for software projects continues to shrink radically.[16] As agile methodologies have become more commonly practiced, the pace of integration and build has changed from once a day to every time there is a code change. According to agile software development, the main line of code should be ready to ship at any time; it may not be feature complete, but it must be of sufficient quality to be releasable.[12]:49

AnthillPro supports such methodologies[citation needed] by monitoring the organization's various source control systems and triggering a build when a developer commits to a change. The build provides the first (and usually the most critical) test that verifies the integration. Once the build is complete, AnthillPro captures the build product for further testing and deployment. As additional tests are executed on the build, the team can gain greater confidence in the integration of the new code.

In 2006, UrbanCode released the third generation of AnthillPro.[17] This release was a complete rewrite that extended AnthillPro's capabilities beyond continuous integration into automated deployments. Unlike most CI servers, which were build-centric, this new version of AnthillPro used the build only as an initial test. After the build was complete, AnthillPro created binary artifacts that were then tested, deployed and promoted through a lifecycle on their way to production release. This version of AnthillPro included many new features, such as enriched reporting, release management, enhanced security, and the ability to execute workflow steps in remote machines.

Reporting

AnthillPro can gather any reports generated by a build or test process and display them on the AnthillPro server's web interface for review by developers, testers or management.[18]

Release management

AnthillPro is designed to support the release management team's efforts.[19] AnthillPro provides an audit trail linking a build back to its source code and to every deployment and test executed against that build. The audit feature helps a release manager evaluate the readiness of a build to enter production.[20] AnthillPro encourages teams to use a similar automated process for production deployments, thus lowering the risk in a deployment.[21]

Automated deployment

AnthillPro supports automated deployment of a build to a user-configured environment.[22] Administrators can set up gates between each environment, requiring manual user intervention and providing an audit trail.[3]:255 Role-based security can be set up to control what roles (and thus what users) can deploy to which environment.

Integration with external systems

As AnthillPro transitioned from a continuous integration server to an automation framework capable of complex deployments,[12]:264–266 UrbanCode began expanding AnthillPro's capability to integrate with third-party tools straight out of the box. AnthillPro version 3.8, released in February 2012, integrates with over sixty[citation needed] third-party products, including J2EE servers, databases, build systems, infrastructure, and the Microsoft Platform. Additionally, AnthillPro supports external plugins that extend its automation framework to accommodate virtually any software that can be driven from the command line.[23]

Release history

The original Anthill was a simple continuous integration server released in 2001 and is still available today. In 2002, UrbanCode released the first commercial edition of AnthillPro. In 2006, UrbanCode released the third generation of AnthillPro, a complete rewrite which added support for distributed builds and control over the post-build lifecycle.[17]

AnthillPro version 3.6 (released in 2008) extended the tool-set to Application lifecycle management (ALM)[24] using centrally-managed automation for build, deploy, and test. This release added integration for numerous third party ALM point solutions, such as artifact repositories, SCM, issue-tracking, test-automation, change management systems and project management systems.[18] Other new features supporting this consolidation included detailed review of historical test results, flexible resource locking, and preflight builds.[25]

AnthillPro version 3.7 (released in 2009) increased AnthillPro's ability to integrate with other point tools in continuous integration, build automation, and ALM space. New features added integration plugins for seven of the most widely used source code analysis tools. This release introduced a new plug-in API that allows users to create their own custom integration plug-ins.[26] This release also introduced the AHP Tool, which allows users to create script actions from the command line and access data in the AnthillPro repository; and it introduced Agent User Impersonation, which gives administrators greater control over scripts run by agents.[23]

Competitors

References

  1. ↑ "Enterprise Continuous Delivery Maturity Model". UrbanCode. 2011. p. 14. Archived from the original on 2014-02-22. https://web.archive.org/web/20140222213325/https://s3.amazonaws.com/urbancode-downloads/whitepapers/Enterprise%2BContinuous%2BDelivery.pdf. Retrieved February 17, 2012. 
  2. ↑ Julius, Paul (September 11, 2009). "Enterprise CI Cultural Maturity". UrbanCode Blogs. UrbanCode. http://blogs.urbancode.com/continuous-integration/enterprise-ci-cultural-maturity/. Retrieved February 17, 2012. 
  3. ↑ 3.0 3.1 3.2 3.3 Humble, Jez; Farley, David (2010). Continuous Delivery: Reliable Software Releases Through Build, Test, and Deployment Automation (3rd ed.). Addison Wesley. p. 463. ISBN 978-0-321-60191-9. 
  4. ↑ Ellis Agência Web (July 19, 2018). "True Application Lifecycle Management With Urbancode" Retrieved July 19, 2022.
  5. ↑ "UrbanCode DevOps platform™". UrbanCode. http://www.urbancode.com/html/products/devops/default.html. Retrieved February 11, 2013. 
  6. ↑ "Urbancode's AnthillPro Reaches Milestone 400th Customer in Company's Strongest Quarter" (Press release). Cleveland, Ohio: UrbanCode. December 7, 2009. Retrieved February 10, 2012.
  7. ↑ "IBM Acquires UrbanCode to Help Businesses Rapidly Deliver Mobile, Cloud, Big Data and Social Software". IBM. http://www-03.ibm.com/press/us/en/pressrelease/40820.wss. Retrieved 6 August 2014. 
  8. ↑ "Retirement of AnthillPro". https://www.urbancode.com/2017/08/28/retirement-of-anthillpro/. Retrieved June 17, 2020. 
  9. ↑ MSDN (January 18, 2007). "PRJ: Microsoft Project for Windows Version History". Article ID: 98026 - Last Review: January 18, 2007 - Revision: 3.1. MSDN. http://support.microsoft.com/kb/98026. Retrieved March 14, 2012. 
  10. ↑ "Nightly Builds: the bleeding edge". mozilla. mozilla.org. February 1, 2011. Archived from the original on February 18, 2012. https://web.archive.org/web/20120218223801/http://www.mozilla.org/developer/. Retrieved March 1, 2012. 
  11. ↑ "Iteration Activities Rolling and Nightly Builds". MSDN Library. February 7, 2008. https://technet.microsoft.com/en-us/query/ee946845. Retrieved March 1, 2012. 
  12. ↑ 12.0 12.1 12.2 12.3 Duvall, Paul M.; Matyas, Steve; Glover, Andrew (June 2007). Continuous Integration: Improving Software Quality and Reducing Risk. Upper Saddle River, New Jersey: Addison-Wesley. p. 283. ISBN 978-0-321-33638-5. https://archive.org/details/continuousintegr00duva. 
  13. ↑ Hatcher, Erik; Loughran, Steve (2003). Java Development with Ant: How to automate your build, test and deployment processes. Greenwich, CT: Manning. pp. 634. ISBN 1-930110-58-8. https://archive.org/details/javadevelopmentw0000hatc/page/634. 
  14. ↑ Larman, Craig (2004). Agile & Iterative Development: A Managers Guide. Boston, MA: Addison-Wesley. pp. 342. ISBN 0-13-111155-8. 
  15. ↑ Clark, Mike (July 1, 2004). Pragmatic Project Automation: How to Build, Deploy, and Monitor Java Applications. USA: Pragmatic Bookshelf. p. 176. ISBN 978-0-9745140-3-1. 
  16. ↑ Bradley Holt (August 8, 2011). "The Case For Rapid Release Cycles". Bradley-Holt. http://bradley-holt.com/2011/08/the-case-for-rapid-release-cycles/. Retrieved March 14, 2012. 
  17. ↑ 17.0 17.1 Minick, Eric (October 26, 2006). "Urbancode announces AnthillPro 3.0, lifecycle automation server". TheServerSide.com. http://www.theserverside.com/news/thread.tss?thread_id=42801. Retrieved February 22, 2012. 
  18. ↑ 18.0 18.1 Dr. Dobb's Journal (January 27, 2008). "Urbancode Releases Continuous Integration Tool Upgrade". Dr. Dobb's. http://drdobbs.com/tools/212902758. Retrieved February 14, 2012. 
  19. ↑ "Release Management". Wikibooks. Retrieved February 10, 2012.
  20. ↑ Wyser, Della; Kurz, Jon (March 13, 2007). "Jolts 2007: Change and Configuration Management". Dr. Dobb's Journal. http://drdobbs.com/joltawards/20100140. Retrieved February 13, 2012. [yes|permanent dead link|dead link}}]
  21. ↑ Colville, Ronni J.; Brittain, Kris (2011). "Cool Vendors in Release Management, 2011". Gartner. Gartner. http://www.gartner.com/DisplayDocument?doc_cd=211698&ref=g_noreg. Retrieved February 23, 2012. [|permanent dead link|dead link}}]
  22. ↑ Sayko, Michael (September 15, 2008). "Using a Commercial Tool to Automate a Build and Deployment Process". CM Crossroads. Retrieved February 3, 2012.
  23. ↑ 23.0 23.1 Feinman, Jeff (October 9, 2009). "Command-line features added to AnthillPro". SD Times. http://www.sdtimes.com/link/33821. Retrieved February 14, 2012. 
  24. ↑ Rubinstein, David (November 4, 2011). "Agile processes adopted widely, study shows". SD Times. http://www.sdtimes.com/AGILE_PROCESSES_ADOPTED_WIDELY_STUDY_SHOWS/By_David_Rubinstein/About_AGILE/36079. Retrieved February 11, 2012. 
  25. ↑ Dr. Dobb's Journal (October 28, 2008). "UrbanCode Adds PreFlight Builds". Dr. Dobb's. Retrieved February 10, 2012.
  26. ↑ "AnthillPro 3.7 Released". Agile Journal. October 5, 2009. http://www.agilejournal.com/agile-news/2460-anthillpro-37-released. Retrieved February 14, 2012. 

External links



Retrieved from "https://handwiki.org/wiki/index.php?title=Software:AnthillPro&oldid=3465683"