Managing.NET Development with NAnt
|
|
- Matilda Knight
- 8 years ago
- Views:
Transcription
1 Managing.NET Development with NAnt Abstract: Visual Studio.NET is the most powerful, complete IDE Microsoft has ever released. Its support for writing code, organizing project files and compiling applications is superlative. However, it lacks tools for effectively managing distributed development, testing and deployment of the application. NAnt is an open source tool which fills in those gaps and provides powerful new tools for project management. Why NAnt Microsoft has released their most complete and powerful IDE yet in Visual Studio.NET. From the vast library of project templates, to the incredibly easy to use WinForms designer, to solid tools for visually integrating databases, VS.NET provides an excellent environment for the individual developer. There is a lot more to creating an application than just writing and compiling code, however. Visual Studio.NET, for all its powerful features, cannot be all things to all developers. Specifically, Visual Studio.NET provides little support for: Customized deployment scenarios Distributed team development Centralized integration and compilation Automated testing and reporting Source control tools, other than Visual Source Safe Automated pre- and post-processing of project files For example, let s say you are working on a project with 9 other programmers. Five of you are in Los Angeles, and five in Boston. The SourceSafe server is in Chicago, as is the staging server. When you want to work on a single code file, it s as easy as checking it out, editing it, and checking it in. But what if you need to do a sanity check of your file as part of the build? Well, then you have to go through the SourceSafe database and check out all the different project trees, and build them (in the correct order) just to make sure your component compiles ok. Then, if you want to run unit tests, you have to fire up NUnit and walk through all the test libraries manually. Your job as the build engineer is even more difficult. Somehow, you have to find a way to check out the full version of the project every night at midnight, build everything (in the correct order), run the unit tests, the
2 compile and test results to every member of the team, and if everything else went ok, zip the binaries up and ftp them to the distribution server. Visual Studio provides some of the support for the first scenario (developer on a team) and almost none for the second (build engineer). If you have to execute these tasks manually, you open yourself to a slew of errors (missed files in the checkout, forgotten test libraries, mistyped commands). These repetitive tasks cry out for automation. Historically, this kind of automation was handled with tools like make and nmake. These tools rely on a propriety syntax for writing a build file which executes a series of commandline tools to build your project. NAnt is an open source alternative to make. NAnt is easy to learn, stable, efficient, and best of all, free. It stands above other build tools because it uses XML for its file structure, which is more easily readable by humans and manipulated by code. Additionally, there is a robust mechanism for testing the success of each individual build step and halting the process upon failure. For an individual developer, NAnt is an important tool for managing a project; for a distributed team, NAnt is essential. An Introduction to NAnt NAnt is deceptively simple. A NAnt build file is comprised of four kinds of items: tasks, targets, properties and projects. Everything that can be done with NAnt is done with one of these four types. All are represented in a standard XML syntax. Tasks Tasks are the NAnt version of commands. Most NAnt tasks come with NAnt itself, though NAnt is extensible through third-party command libraries or writing your own. Tasks can represent simple shell commands (copy, delete, touch), complex system commands (zip, unzip, mail, cvs),.net-specific commands (csc, vbc, tlbimp), and miscellaneous commands (nunit, regex). NAnt also has tasks that make it operate somewhat like a declarative language: tasks like if, foreach, and script allow you to insert flowcontrol and looping structures, as well as arbitrary executable script statements into the build file. A task is a specifically named XML element, with standardized attributes and sub-elements that make up the options for the represented command. For example, to make a backup copy of an important file, you would use the copy task:
3 <copy file= importantfile.cs tofile= importantfile.bak /> or, to send an , you would use the mail task: <mail from= subject= Nightly build results mailhost= smtp.mycompany.com > <attachments> <includes name= *report.txt /> </attachments> </mail> The full list of standard tasks is available at The NAntContrib project ( provides a wide variety of additional tasks, from reporting project statistics (codestats) to interacting with IIS (mkiisdir, deliisdir) to executing SQL statements (SQL). Targets Targets are named collections of tasks. Think of tasks as individual commands, and targets as named methods. Executing a target causes each task contained in that target to execute, in the order they are found. <target name= prepare description= creates folders: bin, src, doc > <mkdir dir= bin /> <mkdir dir= src /> <mkdir dir= doc /> Targets can depend on other targets to execute. Using the depends attribute, you can specify one or more other targets that must execute prior to the current target. The depends attribute takes a comma-separated list of target names as its value; the targets listed will be executed in order from left to right. It is an immutable rule of NAnt that a target is executed only once during a given build event. Even if multiple executing targets depend on one shared target, the shared target will execute only once (when the first dependent target is executed). Subsequent dependent targets will see that the requested target has executed already.
4 <target name= clean > <del dir= src /> <del dir= bin /> <del dir= doc /> <target name= prepare depends= clean > <mkdir dir= src /> <mkdir dir= bin /> <mkdir dir= doc /> Whenever the prepare target executes, NAnt will verify that clean has already run. If it has, prepare is allowed to continue; if it has not, clean is run first, then prepare. Keep in mind that regardless of how many targets depend on the same target, each target is executed only once. Properties Properties are named data storage for a given build file. Though you can think of them as variables, that isn t technically correct since property values can be set exactly once; thereafter, a property value is immutable. Properties can be supplied a default value in the build file, or can be read from an external file or have their values supplied by arguments on the command that launched the build. NAnt supplies a series of default properties available to any project, from nant-specific information (like nant.version, nant.filename) to.netspecific information (like nant.settings.defaulframework and nant.settings.defaultframework.sdkdirectory). You can create your own properties by supplying a name and optional default value. <property name= host.name value= relevancellc.com /> <property name= ftp.target.site value= ftp.relevancellc.com /> Projects A project is a collection of properties, targets and tasks. A project can reside in a single XML (build) file, or can span multiple files. It defines the collection of targets and properties needed to manage your development project. <project name= myproject > <property name= project.author value= Justin Gehtland /> <target name= clean > <del dir= src />
5 <del dir= bin /> <target name= prepare depends= clean > <mkdir dir= src /> <mkdir dir= bin /> <!-- etc. --> </project> Projects have three attributes that you can modify: name, default, and basedir. Name is an identifying string (see above example). Default is the name of the target to execute if none is otherwise supplied. Basedir is the location to use as the root of any relative file system operations; if you do not supply a value for basedir, NAnt will use the folder containing the executing build file. Running Projects To run a project, invoke nant.exe and pass in the name of the build file using the /f flag: C:>nant /f:default.build If you omit the build file name, NAnt uses the following algorithm to determine what to execute: 1. Search the current folder for a build file. 2. If no build file is found, return an error. 3. If only one build file is found, execute it. 4. If more than one build file is found: a. If one is called default.build, execute it. b. If none are called default.build, return an error. In addition to build file, you can pass in a variety of other information to nant, including the target framework version, a log file to output to, whether or not to display debug information in the output, etc. Perhaps most important, you can pass in values for properties in the build file using the D flag. For instance, to run myproject above and override the default value of project.author, you could issue the following command: C:>nant /f:myproject.build D:project.author= Albert Einstein
6 In addition, you can specify a target to execute. If you do not specify one, the value of the default attribute of the project will be used. To specify a different target, just append the target names you desire in a list as the final arguments on the nant command: C:>nant D:project.author= Albert Einstein clean prepare NAnt and the Visual Studio Project File A very common use for a build file is to compile a project;.net developers commonly use Visual Studio.NET to compile their project, but can also use the command-line compilers (csc.exe, vbc.exe, etc.). Visual Studio.NET manages the complexities of compilation, such as external references and output types. Using the command-line compilers requires managing those complexities yourself. Inside the Visual Studio Project File The Visual Studio.NET project file (i.e. *.csproj) is an XML file describing the files and settings that make up a given project. Inside the root <VisualStudioProject> element is an element describing the type of project file; <CSHARP> or <VisualBasic>, for instance. Beneath this element are two sections: Build and Files. Files is a simple list of all associated files and how to treat them. <File RelPath= Form1.cs SubType= Form BuildAction= Compile /> <File RelPath= App.ico BuildAction= Content /> Build contains two further subsections: Settings and References. Settings captures all the information you can set in the Project Properties dialog, including global settings plus anything specific to the Debug or Release builds. References lists all the external assemblies that this project depends upon. <Reference Name= System AssemblyName= System HintPath=..\..\WINDOWS\Microsoft.NET\Framework\v \System.dll /> <Reference Name= nunit.framework AssemblyName= nunit.framework HintPath= \Program Files\NUnit V2.1\\bin\nunit.framework.dll /> Together, Visual Studio.NET uses all of this data to create the appropriate compilation command to create your project. Avoid Executing Devenv.exe Many beginning NAnt users make the mistake of piggy-backing on Visual Studio.NET (devenv.exe) to compile their projects. Since the Visual Studio.NET project file already contains all the necessary data about the project, it
7 is easy to invoke devenv.exe using the exec task and point it at the project file. There are two significant drawbacks to this style of compilation: 1) The overhead cost of running Visual Studio.NET is quite large. Any process that invokes it is going to drain a lot of system resources. An automated script (like a NAnt build file) that may be invoked often, can quickly run into resource problems. 2) Not all machines that need to build the project will have Visual Studio.NET installed. Any central build-and-test server, in fact, should NOT have it installed. Avoid using devenv.exe to compile your projects. Instead, use NAnt s builtin csc and vbc tasks. Doing so means that build machines need only have the.net Framework installed (a given for.net projects) and use the much more efficient command-line compilers to do their work. The problem with this approach is the complexity of the csc and vbc tasks once your project expands beyond a simple HelloWorld. Not only do the tasks have 21 possible attributes you can, and in some cases must, set, but it has sub-elements for: Search paths for referenced assemblies The referenced assemblies themselves Embedded resources All source files And any other arbitrary arguments to the compile command As your project changes over time, you have to keep your build file in synch with the current state. This is tedious, and doing it manually is error-prone. Using SLiNgshoT Luckily, there are other options for keeping the build file in synch with the project file. The NAntContrib project comes with a tool called SLiNgshoT which will parse the project file and create a skeleton build file for you. The resulting file contains fully formatted csc (or vbc) tasks as appropriate, in addition to a variety of other default targets which you can modify to your liking. SLiNgshot does a good job of quickly creating skeletal build files for you; however, it is difficult to use SLiNgshoT with a project that changes often, since it regenerates the entire build file. Any edits you made to the last version are lost; you have to copy them back in yourself, which is again tedious and error prone. In addition, regardless of how correct the resulting
8 build file is, you are stuck with the structure it provides (unless you undertake significant editing). Using a Custom Transform A more powerful alternative is to use a custom XSLT transform to create the compilation task for you automatically. It can be used to either create a stand-alone build file, or to modify the existing build-file by simply replacing the existing compile statements. Gordon Weakliem has an excellent entry on this topic on his blog ( dnant.html). Using the Solution task (NAnt or later) Starting in release rc1, the NAnt core tasks include <solution>. This task processes a given solution file, compiling the project(s) contained within. The <solution> task recognizes inter-project dependencies and compiles them in the correct order. The <solution> task does not invoke devenv.exe, but rather parses the solution file and invokes the command-line compiler. The <solution> task allows you to provide specific build information on a per-configuration basis (different arguments for debug vs. release). You can limit which projects in the solution to build by passing in a list of projects in a <projects> element, or a list of projects to exclude in <excludeprojects>. If the projects in your solution depend on the output of another project (from a different solution) you can make them depend on its output via the <referenceprojects> element. This allows you to specify any number of project files that need to be fully compiled before your solution file can itself be compiled. NAnt will check to see if the referenced projects binary output is up-to-date; if so, the target solution will reference the existing assemblies. Otherwise, the referenced projects are compiled first. Additionally, you can control the search paths for referenced assemblies using the <assemblyfolders> element. Use this task when your target solution relies on third-party assemblies that exist only in binary format. This element allows you to provide the compiler hints about where referenced assemblies may be found on the file system. The <solution> task is the easiest solution for integrating with Visual Studio.NET project files, but it requires that your project have an actual solution file (.sln) instead of just a project file (.csproj,.vbproj). If you require more
9 control over the build parameters than is provided by this task, you are better off writing a custom transform as in the previous section. NAnt and the Distributed Team NAnt is very useful for single-developer projects. You can easily control everything from building deliverables to creating documentation to deployment from a single build file. However, as the development team grows and the complexity of the application increases, NAnt becomes even more useful. Integrated development environments like Visual Studio.NET simply can t manage all aspects of such a project. NAnt, as a tool and an extensible framework, offers the perfect platform for controlling the complexity. Enterprise-level applications are often a collection of interrelated subprojects. They typically contain some kind of client application, a database, and any number of layers of code in between the two. Individual developers may work on a single subproject, or might be required to work in any or all of them depending on project need. NAnt provides a mechanism for ensuring that all developers work with the right files and perform the right pre- and post-build actions to keep in synch with the rest of the team. Standardized Build Files In order to effectively use NAnt across multiple related projects, your developer team must define a standard set of targets that make up a build file, suitable to your team s goals and the type of application you are developing. The canonical set of primary targets for a build file (see Hatcher and Loughrin s Java Development with Ant) are: Init: prepares your environment for a successful build (creates folders, copies initial files, etc.) Build: actually compile the application, creating any distributable application files Docs: create any documentation Test: run the unit tests Dist: distribute the final artifacts (binary application, source code, documentation) Clean: remove any build artifacts, leaving just the source All: run all of these targets, in this order. Typically, all of these targets are part of a single dependency chain except Clean. So, Build depends on Init. Docs and Test depend on Build, and Dist depends on Docs and Test. Clean, however, should be able to be run on its own so that, at any point, a developer can eliminate any cruft that might
10 have built up in the development directories. The All target is then used to run all of the targets (assuming, of course, there are no failures). Projects might contain any number of specialized targets that enable these primary targets. Perhaps one project requires a series of specialized XSLT transforms to create the documentation (using the <style> task) while another one uses the <ndoc> task to accomplish the same thing. Each project might require a different set of supporting tasks to create the initial context for the unit tests. These specialized targets provide utility support for the primary targets common to all the projects that make up your application. Working with Parent and Child Projects Each subproject in your application will have its own build file. Thus, any project can be built in isolation from the rest of the project, making the development team and process as modular as possible. When the entire application needs to be built, tested and/or deployed, though, you don t want to have a completely different build file for managing each individual subproject. Instead, you create a parent build file which relies on the specific build files for each subproject to do the work. The <nant> task allows you to specify a build file and, optionally, a specific target in that build file to execute. Perhaps the most vital property of the <nant> task is the inheritall property. This specifies whether a child build launched from the parent will inherit all the property values defined in the parent (the property defaults to false). If you choose not to inherit the values, or the child build file has properties not defined in the parent, you can use the <properties> subelement to define any other property values for the child build. The best way to organize the parent build file is to create a new target for each subproject s build file. Then, create a dependency chain between the targets that mimics the dependencies between the subprojects. For instance, say your project consists of a library of business logic accessible by both a web service and a standard web site. Both the web service project and the web site project have a dependency on the business logic project. Therefore, your parent build file would look like: <project name= myapplication default= default > <target name= businesslogic > <nant buildfile= businesslogic/default.build inheritall= true /> <target name= webservice depends= businesslogic > <nant buildfile= webservice/default.build inheritall= true />
11 <target name= website depends= businesslogic > <nant buildfile= website/default.build inheritall= true /> <target name= default depends= businesslogic, webservice, website /> </project> Now, you can build the entire application by executing the default target of the parent build. Conversely, you can use the parent to build any single child project, respecting inter-project dependencies (since both webservice and website depend on businesslogic, the businesslogic project will always be built and its binaries available for the other two). To make it easier to clean up after the build, you will also want a global clean target in the parent build. <target name= clean > <nant buildfile= businesslogic/default.build target= clean /> <nant buildfile= webservice/default.build target= clean /> <nant buildfile= website/default.build target= clean /> Call this once to clean out all artifacts from all parts of the build tree. NAnt and Other Tools When the Core Tasks Aren t Enough NAnt comes with a wide assortment of built-in tasks. Combined with the tasks available from the NAntContrib project, and it might seem at first glance that there is not much NAnt can t do. There will come a time when you need to make use of some process, application or resource that isn t represented in the core tasks. It might be a new tool that you just purchased, or a script written by your team to perform a specific task. There are two standard tasks that can be used to do this: <exec> and <script>. <exec> wraps a shell command and its arguments in order to launch arbitrary applications. <script> wraps a block of script, which is executed by NAnt. The problem with both is that they are not conducive to reuse across projects; to accomplish the same task in two different projects, you would be forced to resort to copy-and-paste reuse. If, later, you discover a problem with the logic or data, you have to change it everywhere manually.
12 Fortunately, NAnt itself is extensible. The more reusable strategy is to create your own NAnt task. Creating one is simplicity itself. Simply create a new class which derives from NAnt.Core.Task (or one of the more specific base classes in NAnt.Core.Tasks, like ExternalProgramBase, which wraps calling an external program). Decorate your class with the TaskName attribute from the NAnt.Core.Attributes namespace; this determines what the XML name for your task will be. Next, you must define the properties of your task that will be available in the build file. Create public properties on your class and decorate them with the TaskAttribute attribute (also found in NAnt.Core.Attributes). This value will hook up XML attributes of the given name to this property of the class. Finally, override the ExecuteTask method of the base class to do the work. To report results back to the NAnt output stream, write them using System.Console.Write (or WriteLine). For example, you might want to create a task for encrypting a file. Such a task would, among other things, need to allow the build file author to specify the key and a salt value for the encryption. The task in a build would look like: <crypto key= SOME_KEY_VALUE salt= SOME_SALT_VALUE file= plaintext.txt /> The implementing class looks like this: using NAnt.Core; namespace Relevance.NAnt { [NAnt.Core.Attributes.TaskName("crypto")] public class CryptoTask : NAnt.Core.Task { private string _file; private string _key; private string _salt; [NAnt.Core.Attributes.TaskAttribute("file")] public string File { get { return _file; } set { _file = value; } } [NAnt.Core.Attributes.TaskAttribute("key")]
13 public string Key { get { return _key; } set { _key = value; } } [NAnt.Core.Attributes.TaskAttribute("salt")] public string Salt { get { return _salt; } set { _salt = value; } } protected override void ExecuteTask() { //Encrypt the file //... } } } //Report results System.Console.WriteLine("File: {0} encrypted.", _file); To install the tasks, your assembly s name must be in the form NAnt.xxx.Tasks.dll, where xxx is some descriptive name for your task(s). Drop this file into the same directory where nant.exe lives (or a folder called tasks beneath it) and your new task is available for builds. Authoring NAnt Build Files At the end of the day, a NAnt build file is an XML document. Visual Studio.NET currently has no support for authoring these build files other than the XML editor (which you will have to configure to treat.build files as XML). Some developers use XML editors like XMLSpy ( or TurboXML ( while others stick to the basics with Notepad or emacs. For developers who want more assistance writing and maintaining their build files, there is a (currently) free tool for visually authoring them called Nantpad ( Nantpad provides a standard tree-and-list view for editing the build files. The true value of Nantpad is that you can feed it any valid NAnt schema, and Nantpad they automatically provides the tasks available in that version of NAnt. Better still, the context menus then display available tasks for instertion, or sub-elements of existing tasks. If you are like this author, and believe that Intellisense is one of the best
14 things to ever happen to programmers, then Nantpad is definitely the way to author your build files. Continuous Integration with CruiseControl.NET Many development teams believe that regular integration builds are important. They create NAnt build scripts which live on the master build server and are scheduled to run every night, or they manually kick them off on Friday afternoon as everyone heads home for the weekend. While these regularly scheduled builds are quite useful, more useful still is the idea of continuous integration. Continuous integration is the Holy Grail of an agile development process. It is the idea that all code entered into the source control repository is integrated with existing code, built and tested as soon as possible after it is checked in. The process should be automatic, and produce a running log of builds and the results. Martin Fowler has written the canonical introduction to CI at It is not enough to have builds run every weekend or overnight; builds must happen as soon as check-ins occur. CruiseControl.NET ( is a server-based application that monitors your source code repository. As code is checked in, CruiseControl retrieves the whole project tree, executes a NAnt-based build, runs tests and files a report on a browser-accessible log. CruiseControl can also be configured to notify team members of build events via . The team monitors the results of the builds to keep track of the health of the application; broken builds are identified immediately, and the offending code can be addressed right away. Moving From nmake If you are working on a project with one or more nmake build files already, the easiest way to start moving to NAnt is to make a new.build file and call out to the existing nmake files as appropriate. For example, if you have a project consisting of five independent components, three of which already have nmake builds associated with them, you could make a NAnt build file that natively compiles the other two using <csc> or <vbc>, but uses <exec> to launch the three existing nmake builds. You can then layer in tasks for unit testing, deployment, documentation, etc. as needed. Later, as time permits, you can go back and translate the nmake builds into native NAnt format. Looking Ahead to MSBuild Let it never be said that Microsoft has difficulty recognizing a good thing. NAnt (and its progenitor, Ant) have proven to be industry-changing
15 technologies. The functionality offered by NAnt is a superset of the build control features available in Visual Studio, and the XML format of the build scripts is infinitely more manageable and flexible than the Project Properties available inside the IDE. In the upcoming release of Visual Studio (codenamed Whidbey ) a new tool called MSBuild will be available. XML-based build files, which are collections of properties, items, tasks and groups, will be executed by a console application called MSBuild.exe. Tasks are implemented as classes that extend MSBuild.Task in the MSBuild assembly. Visual Studio project files (.csproj,.vbproj) will abandon their proprietary XML vocabulary and instead become MSBuild scripts, which can then be extended by the developer to include other tasks besides compilation, just like a NAnt script. Although not available in current beta releases of Visual Studio.NET, we can expect visual designers for MSBuild files to appear by the time the final release is available.
Continuous Integration with CruiseControl.Net
Continuous Integration with CruiseControl.Net Part 3 Paul Grenyer CruiseControl.Net One of the first rules of writing is to write about something you know about. With the exception of the user guide for
More informationAuthoring for System Center 2012 Operations Manager
Authoring for System Center 2012 Operations Manager Microsoft Corporation Published: November 1, 2013 Authors Byron Ricks Applies To System Center 2012 Operations Manager System Center 2012 Service Pack
More informationImproving software quality with an automated build process
Software architecture for developers What is software architecture? What is the role of a software architect? How do you define software architecture? How do you share software architecture? How do you
More informationEngine: Using MSBuild and Team Foundation
Microsoft Inside the Microsoft* Build Engine: Using MSBuild and Team Foundation Build, Second Edition Sayed Hashimi William Bartholomew Table of Contents Foreword x'x Introduction x*1 Part I Overview 1
More informationCreating a Java application using Perfect Developer and the Java Develo...
1 of 10 15/02/2010 17:41 Creating a Java application using Perfect Developer and the Java Development Kit Introduction Perfect Developer has the facility to execute pre- and post-build steps whenever the
More informationContinuous integration for databases using Red Gate tools
Whitepaper Continuous integration for databases using Red Gate tools A technical overview Continuous Integration source control develop Dev Dev Dev build test Automated Deployment Deployment package Testing
More informationWe (http://www.newagesolution.net) have extensive experience in enterprise and system architectures, system engineering, project management, and
We (http://www.newagesolution.net) have extensive experience in enterprise and system architectures, system engineering, project management, and software design and development. We will be presenting a
More informationContinuous integration for databases using
Continuous integration for databases using Red Wie Sie Gate die tools Microsoft SQL An overview Continuous integration for databases using Red Gate tools An overview Contents Why continuous integration?
More informationTwo-Way Data Binding with WinJS By Marcin Kawalerowicz and Craig Berntson, authors of Continuous Integration in.net
1 Two-Way Data Binding with WinJS By Marcin Kawalerowicz and Craig Berntson, authors of Continuous Integration in.net One of the keys to improving applications and productivity is to automate some of the
More informationContinuous Integration
Continuous Integration Why and How to build a Continuous Integration Environment for the.net platform Document Version 1.0 Continuous Integration Guide and Reference Manual What this document is for: This
More informationNick Ashley TOOLS. The following table lists some additional and possibly more unusual tools used in this paper.
TAKING CONTROL OF YOUR DATABASE DEVELOPMENT Nick Ashley While language-oriented toolsets become more advanced the range of development and deployment tools for databases remains primitive. How often is
More informationNASA Workflow Tool. User Guide. September 29, 2010
NASA Workflow Tool User Guide September 29, 2010 NASA Workflow Tool User Guide 1. Overview 2. Getting Started Preparing the Environment 3. Using the NED Client Common Terminology Workflow Configuration
More informationGetting Started with the Ed-Fi ODS and Ed-Fi ODS API
Getting Started with the Ed-Fi ODS and Ed-Fi ODS API Ed-Fi ODS and Ed-Fi ODS API Version 2.0 - Technical Preview October 2014 2014 Ed-Fi Alliance, LLC. All rights reserved. Ed-Fi is a registered trademark
More informationJetBrains ReSharper 2.0 Overview Introduction ReSharper is undoubtedly the most intelligent add-in to Visual Studio.NET 2003 and 2005. It greatly increases the productivity of C# and ASP.NET developers,
More informationCRM Setup Factory Installer V 3.0 Developers Guide
CRM Setup Factory Installer V 3.0 Developers Guide Who Should Read This Guide This guide is for ACCPAC CRM solution providers and developers. We assume that you have experience using: Microsoft Visual
More informationXMLVend Protocol Message Validation Suite
XMLVend Protocol Message Validation Suite 25-01-2012 Table of Contents 1. Overview 2 2. Installation and Operational Requirements 2 3. Preparing the system 3 4. Intercepting Messages 4 5. Generating Reports
More informationDesktop, Web and Mobile Testing Tutorials
Desktop, Web and Mobile Testing Tutorials * Windows and the Windows logo are trademarks of the Microsoft group of companies. 2 About the Tutorial With TestComplete, you can test applications of three major
More informationSonatype CLM for Maven. Sonatype CLM for Maven
Sonatype CLM for Maven i Sonatype CLM for Maven Sonatype CLM for Maven ii Contents 1 Introduction 1 2 Creating a Component Index 3 2.1 Excluding Module Information Files in Continuous Integration Tools...........
More informationALM: Continuous Integration. José Almeida, Microsoft
ALM: Continuous Integration José Almeida, Microsoft Agenda Issues Addressed Getting Started What is CI? CI Practices About Continuous Integration What is Continuous Integration? CI is the thread that ties
More informationFirewall Builder Architecture Overview
Firewall Builder Architecture Overview Vadim Zaliva Vadim Kurland Abstract This document gives brief, high level overview of existing Firewall Builder architecture.
More informationTutorial 5: Developing Java applications
Tutorial 5: Developing Java applications p. 1 Tutorial 5: Developing Java applications Georgios Gousios gousiosg@aueb.gr Department of Management Science and Technology Athens University of Economics and
More informationIKAN ALM Architecture. Closing the Gap Enterprise-wide Application Lifecycle Management
IKAN ALM Architecture Closing the Gap Enterprise-wide Application Lifecycle Management Table of contents IKAN ALM SERVER Architecture...4 IKAN ALM AGENT Architecture...6 Interaction between the IKAN ALM
More informationSonatype CLM Enforcement Points - Continuous Integration (CI) Sonatype CLM Enforcement Points - Continuous Integration (CI)
Sonatype CLM Enforcement Points - Continuous Integration (CI) i Sonatype CLM Enforcement Points - Continuous Integration (CI) Sonatype CLM Enforcement Points - Continuous Integration (CI) ii Contents 1
More informationContinuous integration for databases using Redgate tools
Continuous integration for databases using Redgate tools Wie Sie die Microsoft SQL Server Data Tools mit den Tools von Redgate ergänzen und kombinieren können An overview 1 Continuous integration for
More informationBraindumps.C2150-810.50 questions
Braindumps.C2150-810.50 questions Number: C2150-810 Passing Score: 800 Time Limit: 120 min File Version: 5.3 http://www.gratisexam.com/ -810 IBM Security AppScan Source Edition Implementation This is the
More informationCode Estimation Tools Directions for a Services Engagement
Code Estimation Tools Directions for a Services Engagement Summary Black Duck software provides two tools to calculate size, number, and category of files in a code base. This information is necessary
More informationCreating XML Report Web Services
5 Creating XML Report Web Services In the previous chapters, we had a look at how to integrate reports into Windows and Web-based applications, but now we need to learn how to leverage those skills and
More informationVisual Studio.NET Database Projects
Visual Studio.NET Database Projects CHAPTER 8 IN THIS CHAPTER Creating a Database Project 294 Database References 296 Scripts 297 Queries 312 293 294 Visual Studio.NET Database Projects The database project
More informationCSE 70: Software Development Pipeline Build Process, XML, Repositories
CSE 70: Software Development Pipeline Build Process, XML, Repositories Ingolf Krueger Department of Computer Science & Engineering University of California, San Diego La Jolla, CA 92093-0114, USA California
More informationMicrosoft Windows PowerShell v2 For Administrators
Course 50414B: Microsoft Windows PowerShell v2 For Administrators Course Details Course Outline Module 1: Introduction to PowerShell the Basics This module explains how to install and configure PowerShell.
More informationHow To Develop A Project In A Production Environment
Open Source.NET Development Setting Up A Professional Development Environment Using Open Source Software (OSS) Morten Mertner Senior Consultant, Teknologisk Institut.NET Architect and Software Developer
More informationVisual Basic. murach's TRAINING & REFERENCE
TRAINING & REFERENCE murach's Visual Basic 2008 Anne Boehm lbm Mike Murach & Associates, Inc. H 1-800-221-5528 (559) 440-9071 Fax: (559) 440-0963 murachbooks@murach.com www.murach.com Contents Introduction
More informationCustom Tasks for SAS. Enterprise Guide Using Microsoft.NET. Chris Hemedinger SAS. Press
Custom Tasks for SAS Enterprise Guide Using Microsoft.NET Chris Hemedinger SAS Press Contents About This Book... ix About The Author... xiii Acknowledgments...xv Chapter 1: Why Custom Tasks... 1 Why Isn
More informationAgile Business Suite: a 4GL environment for.net developers DEVELOPMENT, MAINTENANCE AND DEPLOYMENT OF LARGE, COMPLEX BACK-OFFICE APPLICATIONS
Agile Business Suite: a 4GL environment for.net developers DEVELOPMENT, MAINTENANCE AND DEPLOYMENT OF LARGE, COMPLEX BACK-OFFICE APPLICATIONS In order to ease the burden of application lifecycle management,
More informationSoftware Development. COMP220/COMP285 Seb Coope Introducing Ant
Software Development COMP220/COMP285 Seb Coope Introducing Ant These slides are mainly based on Java Development with Ant - E. Hatcher & S.Loughran. Manning Publications, 2003 Introducing Ant Ant is Java
More informationVisual COBOL ASP.NET Shopping Cart Demonstration
Visual COBOL ASP.NET Shopping Cart Demonstration Overview: The original application that was used as the model for this demonstration was the ASP.NET Commerce Starter Kit (CSVS) demo from Microsoft. The
More informationForce.com Migration Tool Guide
Force.com Migration Tool Guide Version 35.0, Winter 16 @salesforcedocs Last updated: October 29, 2015 Copyright 2000 2015 salesforce.com, inc. All rights reserved. Salesforce is a registered trademark
More informationMeister Going Beyond Maven
Meister Going Beyond Maven A technical whitepaper comparing OpenMake Meister and Apache Maven OpenMake Software 312.440.9545 800.359.8049 Winners of the 2009 Jolt Award Introduction There are many similarities
More informationElixir Schedule Designer User Manual
Elixir Schedule Designer User Manual Release 7.3 Elixir Technology Pte Ltd Elixir Schedule Designer User Manual: Release 7.3 Elixir Technology Pte Ltd Published 2008 Copyright 2008 Elixir Technology Pte
More informationVersion Control Your Jenkins Jobs with Jenkins Job Builder
Version Control Your Jenkins Jobs with Jenkins Job Builder Abstract Wayne Warren wayne@puppetlabs.com Puppet Labs uses Jenkins to automate building and testing software. While we do derive benefit from
More informationContinuous Integration
Continuous Integration Collaborative development issues Checkout of a shared version of software ( mainline ) Creation of personal working copies of developers Software development: modification of personal
More informationEMC Documentum Composer
EMC Documentum Composer Version 6.5 User Guide P/N 300 007 217 A02 EMC Corporation Corporate Headquarters: Hopkinton, MA 01748 9103 1 508 435 1000 www.emc.com Copyright 2008 EMC Corporation. All rights
More informationCSE 70: Software Development Pipeline Version Control with Subversion, Continuous Integration with Bamboo, Issue Tracking with Jira
CSE 70: Software Development Pipeline Version Control with Subversion, Continuous Integration with Bamboo, Issue Tracking with Jira Ingolf Krueger Department of Computer Science & Engineering University
More informationLeveraging Rational Team Concert's build capabilities for Continuous Integration
Leveraging Rational Team Concert's build capabilities for Continuous Integration Krishna Kishore Senior Engineer, RTC IBM Krishna.kishore@in.ibm.com August 9-11, Bangalore August 11, Delhi Agenda What
More informationLast edited on 7/30/07. Copyright Syncfusion., Inc 2001 2007.
Enabling ClickOnce deployment for applications that use the Syncfusion libraries... 2 Requirements... 2 Introduction... 2 Configuration... 2 Verify Dependencies... 4 Publish... 6 Test deployment... 8 Trust
More informationPart III. Integrating.NET Open Source Projects in Your Development
Part III Integrating.NET Open Source Projects in Your Development C H A P T E R 9 ASpell.NET Case Study Nothing you can't spell will ever work. Will Rogers Introduction There are three excuses ever present
More informationGetting Started with STATISTICA Enterprise Programming
Getting Started with STATISTICA Enterprise Programming 2300 East 14th Street Tulsa, OK 74104 Phone: (918) 749 1119 Fax: (918) 749 2217 E mail: mailto:developerdocumentation@statsoft.com Web: www.statsoft.com
More informationv.2.5 2015 Devolutions inc.
v.2.5 Contents 3 Table of Contents Part I Getting Started 6... 6 1 What is Devolutions Server?... 7 2 Features... 7 3 System Requirements Part II Management 10... 10 1 Devolutions Server Console... 11
More informationO Reilly Media, Inc. 3/2/2007
A Setup Instructions This appendix provides detailed setup instructions for labs and sample code referenced throughout this book. Each lab will specifically indicate which sections of this appendix must
More informationNLUI Server User s Guide
By Vadim Berman Monday, 19 March 2012 Overview NLUI (Natural Language User Interface) Server is designed to run scripted applications driven by natural language interaction. Just like a web server application
More informationLibrarian. Integrating Secure Workflow and Revision Control into Your Production Environment WHITE PAPER
Librarian Integrating Secure Workflow and Revision Control into Your Production Environment WHITE PAPER Contents Overview 3 File Storage and Management 4 The Library 4 Folders, Files and File History 4
More informationEnterprise Service Bus
We tested: Talend ESB 5.2.1 Enterprise Service Bus Dr. Götz Güttich Talend Enterprise Service Bus 5.2.1 is an open source, modular solution that allows enterprises to integrate existing or new applications
More informationIntroduction to XML Applications
EMC White Paper Introduction to XML Applications Umair Nauman Abstract: This document provides an overview of XML Applications. This is not a comprehensive guide to XML Applications and is intended for
More informationAutomation of Flex Building and Unit Testing or Continuous Integration with Flex, FlexUnit, and Ant
Automation of Flex Building and Unit Testing or Continuous Integration with Flex, FlexUnit, and Ant Daniel Rinehart Software Architect Allurent, Inc. Current Build Process Is your build process like a
More informationTECHNICAL DOCUMENTATION SPECOPS DEPLOY / APP 4.7 DOCUMENTATION
TECHNICAL DOCUMENTATION SPECOPS DEPLOY / APP 4.7 DOCUMENTATION Contents 1. Getting Started... 4 1.1 Specops Deploy Supported Configurations... 4 2. Specops Deploy and Active Directory...5 3. Specops Deploy
More informationComposite C1 Load Balancing - Setup Guide
Composite C1 Load Balancing - Setup Guide Composite 2014-08-20 Composite A/S Nygårdsvej 16 DK-2100 Copenhagen Phone +45 3915 7600 www.composite.net Contents 1 INTRODUCTION... 3 1.1 Who should read this
More informationIntegrating with BarTender Integration Builder
Integrating with BarTender Integration Builder WHITE PAPER Contents Overview 3 Understanding BarTender's Native Integration Platform 4 Integration Builder 4 Administration Console 5 BarTender Integration
More informationInitializing SAS Environment Manager Service Architecture Framework for SAS 9.4M2. Last revised September 26, 2014
Initializing SAS Environment Manager Service Architecture Framework for SAS 9.4M2 Last revised September 26, 2014 i Copyright Notice All rights reserved. Printed in the United States of America. No part
More informationBackup and Recovery in Laserfiche 8. White Paper
Backup and Recovery in Laserfiche 8 White Paper July 2008 The information contained in this document represents the current view of Compulink Management Center, Inc on the issues discussed as of the date
More informationExtending XSLT with Java and C#
Extending XSLT with Java and C# The world is not perfect. If it were, all data you have to process would be in XML and the only transformation language you would have to learn would XSLT. Because the world
More informationTutorial: Packaging your server build
Tutorial: Packaging your server build This tutorial walks you through the steps to prepare a game server folder or package containing all the files necessary for your game server to run in Amazon GameLift.
More informationHP Operations Manager Software for Windows Integration Guide
HP Operations Manager Software for Windows Integration Guide This guide documents the facilities to integrate EnterpriseSCHEDULE into HP Operations Manager Software for Windows (formerly known as HP OpenView
More informationProfiling and Testing with Test and Performance Tools Platform (TPTP)
Profiling and Testing with Test and Performance Tools Platform (TPTP) 2009 IBM Corporation and Intel Corporation; made available under the EPL v1.0 March, 2009 Speakers Eugene Chan IBM Canada ewchan@ca.ibm.com
More informationDataDirect XQuery Technical Overview
DataDirect XQuery Technical Overview Table of Contents 1. Feature Overview... 2 2. Relational Database Support... 3 3. Performance and Scalability for Relational Data... 3 4. XML Input and Output... 4
More informationContent Management Implementation Guide 5.3 SP1
SDL Tridion R5 Content Management Implementation Guide 5.3 SP1 Read this document to implement and learn about the following Content Manager features: Publications Blueprint Publication structure Users
More informationDIABLO VALLEY COLLEGE CATALOG 2014-2015
COMPUTER SCIENCE COMSC The computer science department offers courses in three general areas, each targeted to serve students with specific needs: 1. General education students seeking a computer literacy
More informationSOFTWARE TESTING TRAINING COURSES CONTENTS
SOFTWARE TESTING TRAINING COURSES CONTENTS 1 Unit I Description Objectves Duration Contents Software Testing Fundamentals and Best Practices This training course will give basic understanding on software
More informationhttp://msdn.microsoft.com/en-us/library/4w3ex9c2.aspx
ASP.NET Overview.NET Framework 4 ASP.NET is a unified Web development model that includes the services necessary for you to build enterprise-class Web applications with a minimum of coding. ASP.NET is
More informationDeploying Web Applications in Enterprise Scenarios
Deploying Web Applications in Enterprise Scenarios Note: This PDF was created from a series of web-based tutorials, the first of which is located at the following URL: http://www.asp.net/webforms/tutorials/deployment/deployin
More informationScheduling in SAS 9.4 Second Edition
Scheduling in SAS 9.4 Second Edition SAS Documentation The correct bibliographic citation for this manual is as follows: SAS Institute Inc. 2015. Scheduling in SAS 9.4, Second Edition. Cary, NC: SAS Institute
More informationMarkLogic Server. Connector for SharePoint Administrator s Guide. MarkLogic 8 February, 2015
Connector for SharePoint Administrator s Guide 1 MarkLogic 8 February, 2015 Last Revised: 8.0-1, February, 2015 Copyright 2015 MarkLogic Corporation. All rights reserved. Table of Contents Table of Contents
More informationAbout This Document 3. Integration and Automation Capabilities 4. Command-Line Interface (CLI) 8. API RPC Protocol 9.
Parallels Panel Contents About This Document 3 Integration and Automation Capabilities 4 Command-Line Interface (CLI) 8 API RPC Protocol 9 Event Handlers 11 Panel Notifications 13 APS Packages 14 C H A
More informationContinuous Integration. CSC 440: Software Engineering Slide #1
Continuous Integration CSC 440: Software Engineering Slide #1 Topics 1. Continuous integration 2. Configuration management 3. Types of version control 1. None 2. Lock-Modify-Unlock 3. Copy-Modify-Merge
More informationBI xpress Product Overview
BI xpress Product Overview Develop and manage SSIS packages with ease! Key Features Create a robust auditing and notification framework for SSIS Speed BI development with SSAS calculations and SSIS package
More informationXcode Project Management Guide. (Legacy)
Xcode Project Management Guide (Legacy) Contents Introduction 10 Organization of This Document 10 See Also 11 Part I: Project Organization 12 Overview of an Xcode Project 13 Components of an Xcode Project
More informationBPM Scheduling with Job Scheduler
Document: BPM Scheduling with Job Scheduler Author: Neil Kolban Date: 2009-03-26 Version: 0.1 BPM Scheduling with Job Scheduler On occasion it may be desired to start BPM processes at configured times
More informationAutomatic promotion and versioning with Oracle Data Integrator 12c
Automatic promotion and versioning with Oracle Data Integrator 12c Jérôme FRANÇOISSE Rittman Mead United Kingdom Keywords: Oracle Data Integrator, ODI, Lifecycle, export, import, smart export, smart import,
More informationMoving the Web Security Log Database
Moving the Web Security Log Database Topic 50530 Web Security Solutions Version 7.7.x, 7.8.x Updated 22-Oct-2013 Version 7.8 introduces support for the Web Security Log Database on Microsoft SQL Server
More informationApplication. 1.1 About This Tutorial. 1.1.1 Tutorial Requirements. 1.1.2 Provided Files
About This Tutorial 1Creating an End-to-End HL7 Over MLLP Application 1.1 About This Tutorial 1.1.1 Tutorial Requirements 1.1.2 Provided Files This tutorial takes you through the steps of creating an end-to-end
More informationDynamic Decision-Making Web Services Using SAS Stored Processes and SAS Business Rules Manager
Paper SAS1787-2015 Dynamic Decision-Making Web Services Using SAS Stored Processes and SAS Business Rules Manager Chris Upton and Lori Small, SAS Institute Inc. ABSTRACT With the latest release of SAS
More informationEPiServer Operator's Guide
EPiServer Operator's Guide Abstract This document is mainly intended for administrators and developers that operate EPiServer or want to learn more about EPiServer's operating environment. The document
More informationGetting Started Guide
BlackBerry Web Services For Microsoft.NET developers Version: 10.2 Getting Started Guide Published: 2013-12-02 SWD-20131202165812789 Contents 1 Overview: BlackBerry Enterprise Service 10... 5 2 Overview:
More informationJenkins on Windows with StreamBase
Jenkins on Windows with StreamBase Using a Continuous Integration (CI) process and server to perform frequent application building, packaging, and automated testing is such a good idea that it s now a
More informationRedbooks Paper. Deploying Applications Using IBM Rational ClearCase and IBM Tivoli Provisioning Manager. Introduction
Redbooks Paper Edson Manoel Kartik Kanakasabesan Deploying Applications Using IBM Rational ClearCase and IBM Tivoli Provisioning Manager Introduction This IBM Redpaper presents a simplified customer environment
More informationCI:IRL. By Beth Tucker Long
CI:IRL By Beth Tucker Long Who am I? Beth Tucker Long (@e3betht) Editor in Chief php[architect] magazine Freelancer under Treeline Design, LLC Stay at home mom User group organizer Madison PHP Audience
More informationEmbarcadero DB Change Manager 6.0 and DB Change Manager XE2
Product Documentation Embarcadero DB Change Manager 6.0 and DB Change Manager XE2 User Guide Versions 6.0, XE2 Last Revised April 15, 2011 2011 Embarcadero Technologies, Inc. Embarcadero, the Embarcadero
More informationCLC Server Command Line Tools USER MANUAL
CLC Server Command Line Tools USER MANUAL Manual for CLC Server Command Line Tools 2.5 Windows, Mac OS X and Linux September 4, 2015 This software is for research purposes only. QIAGEN Aarhus A/S Silkeborgvej
More informationHow to Create a Delegated Administrator User Role / To create a Delegated Administrator user role Page 1
Managing user roles in SCVMM How to Create a Delegated Administrator User Role... 2 To create a Delegated Administrator user role... 2 Managing User Roles... 3 Backing Up and Restoring the VMM Database...
More informationHands-On Lab. Embracing Continuous Delivery with Release Management for Visual Studio 2013. Lab version: 12.0.21005.1 Last updated: 12/11/2013
Hands-On Lab Embracing Continuous Delivery with Release Management for Visual Studio 2013 Lab version: 12.0.21005.1 Last updated: 12/11/2013 CONTENTS OVERVIEW... 3 EXERCISE 1: RELEASE MANAGEMENT OVERVIEW...
More informationCompaq Batch Scheduler for Windows NT
Compaq Batch Scheduler for Windows NT Mainframe-Caliber Automated Job Scheduling Software for Windows NT This white paper addresses extending the capabilities of Windows NT to include automated job scheduling
More informationCreating a Domain Tree
156 Chapter 4 Installing and Managing Trees and Forests Using the Active Directory Installation Wizard, you can quickly and easily create new domains by promoting a Windows Server 2008 stand-alone server
More informationCopyright Notice. 2013 SmartBear Software. All rights reserved.
USER MANUAL Copyright Notice Automated Build Studio, as described in this on-line help system, is licensed under the software license agreement distributed with the product. The software may be used or
More informationSchematron Validation and Guidance
Schematron Validation and Guidance Schematron Validation and Guidance Version: 1.0 Revision Date: July, 18, 2007 Prepared for: NTG Prepared by: Yunhao Zhang i Schematron Validation and Guidance SCHEMATRON
More informationLOTUS to SharePoint Migration Services
LOTUS to SharePoint Migration Services Key Discussion Points StarSoft Value Proposition Microsoft Office SharePoint Server 2007 (MOSS) Lotus Notes: Current Marketplace Trends Migration Planning Questions:
More informationBusiness Insight Report Authoring Getting Started Guide
Business Insight Report Authoring Getting Started Guide Version: 6.6 Written by: Product Documentation, R&D Date: February 2011 ImageNow and CaptureNow are registered trademarks of Perceptive Software,
More informationGallio: Crafting a Toolchain. Jeff Brown jeff.brown@gmail.com
Gallio: Crafting a Toolchain Jeff Brown jeff.brown@gmail.com About Me Jeff Brown Lead Software Engineer at Yellowpages.com Creator of Gallio Open Source Project Lead of MbUnit Open Source Project Coding
More informationFioranoMQ 9. High Availability Guide
FioranoMQ 9 High Availability Guide Copyright (c) 1999-2008, Fiorano Software Technologies Pvt. Ltd., Copyright (c) 2008-2009, Fiorano Software Pty. Ltd. All rights reserved. This software is the confidential
More informationMicrosoft s Team Foundation Server (TFS) Canute Magalhaes Richland County (IT) SYSTEMS ANALYST / PROJECT LEAD 1
Microsoft s Team Foundation Server (TFS) Canute Magalhaes Richland County (IT) SYSTEMS ANALYST / PROJECT LEAD 1 Topics for this Presentation Why Richland County IT - Business Systems Division uses Team
More informationApp-V Deploy and Publish
App-V Deploy and Publish Tools from TMurgent Technologies Updated Aug 5, 2010 Version 1.8 Introduction: The deployment of Virtual Applications in the simplest way possible, without the need for complicated
More informationPractical Continuous Integration
Methods & Tools Practical Continuous Integration Kim Gräsman & Jonas Blunck, TAC AB Integration Merging your latest changes with the common code base Integration problems Forgetting to add a file Conflicting
More information