Category/Program-build-automation

Broaden your selection: Main Page

Category/Program-build-automation

• make-related

Program-build-automation (156)

ACDK

ACDK is a development framework with a similar target of Microsoft's .NET or Sun's ONE platform, but instead of using Basic/C# or Java as programming language, it bases C++ as core implementation language. ACDK implements the standard library packages, including acdk::lang, acdk::lang::reflect, acdk::util, acdk::io, acdk::text (including regexpr), acdk::net, acdk::sql, acdk::xml and more, as well as technologies like flexible Allocator/Garbage Collection, Threading and Unicode. With the extensions of ACDK C++ objects are available for reflection, serialization, aspect oriented class attributes and [D]ynamic [M]ethod [I]nvocation. This DMI act as an universal object oriented call interface to connect C++ with scripting languages (Java, Perl, Tcl, Python, Lisp, Visual Basic, VBScript) and standard component technologies (CORBA, COM+).

Aap

The Aap program executes recipes. It is a kind of super-make program. In a recipe you describe how to perform a certain task. Like a Makefile it contains dependencies and build commands. Additionally, many powerful features are included, so that you can use a recipe to:

• Build a program by just specifying the program name and the source files
• Maintain a web site (the A-A-P site is generated and uploaded with a recipe)
• Download the latest version of files
• Distribute files to several servers at once
• Obtain a module from CVS
• Commit changes to CVS; add and remove files automatically
• Generate and filter files
• Build several variants and on multiple platforms with little effort

Agide

The A-A-P GUI IDE is a framework in which separate tools can work together. Like any other Integrated Development Environment it supports:

• Creating a project
• Building and executing a program
• Browsing files
• Debugging a program while displaying source code
• Framework Agide is not a monolitic application. Separate tools can be plugged in. Thus you are not forced to use one editor. Each tool implements part of the plugin interface. This interface makes it possible for a tool to communicate with other tools, without the need to know how the other tools work. For example, an editor can set a breakpoint in a file, without knowing what kind of debugger is being used. And the debugger can show the PC position in a source file, without knowing what editor is being used.

Alexis Makes (amake)

AMake is a make tool which uses powerful pattern transformation enabling a single makefile to automatically handle the compilation of any level of directory hierachy and have the possibility to add files in a project without having to modify even a character of the makefile thus saving a lot of time.

Anise

Anise helps you to implement a common mechanism for executing all automated tasks for all your software projects. The usage scenario is a developer (or a team) working on many different projects with different frameworks and different tools. Anise can streamline such a chaos of tools. Typical tasks you would add to an anise-aware project can be: - generating documentation - creating packages - handling version information, e.g. print it in the manual - creating a homepage automatically built from the available version information, the packages, the documentation and so on - deploying this homepage to a web server - unit testing - ... or whatever your project needs Anise provides a Python based infrastructure, while you will need to implement some parts in order to adapt the behavior to your project's needs. Anise contains some ready-to-use implementations for some tasks (like building binaries via qmake, debian and some other packages, svn interaction, doxygen, ...), so you can directly use it without non-trivial additional coding to do all kinds of stuff, including generating documentations, packages and a homepage. However, chances are good that you will have to help out with some own implementations. Your part as a project developer is to create a *project description* file, which contains all project metadata and custom implementations of some tasks, and add this file to your project.

Ant

Ant is a Java based build tool, similar to make, but with better support for the cross platform issues involved with developing Java applications. Instead of a model where the tool is extended with shell based commands, it is extended using Java classes. Instead of writing shell commands, the configuration files are XML based calling out a target tree where various tasks get executed. Each task is run by an object which implements a particular Task interface.

Asdf

ASDF is the de facto standard build facility for Common Lisp. It's a tool for specifying how systems of Common Lisp software are made up of components (sub-systems and files), and how to operate on these components in the right order so that they can be compiled, loaded, tested, etc. NB. ASDF is not a tool for library and system installation; it plays a role like make or ant, not like a package manager.

Asdf-vm

From README: asdf is a CLI tool that can manage multiple language runtime versions on a per-project basis. It is like gvm, nvm, rbenv & pyenv (and more) all in one! Simply install your language's plugin! Ballad of asdf Once upon a time there was a programming language There were many versions of it So people wrote a version manager for it To switch between versions for projects Different, old, new. Then there came more programming languages So there came more version managers And many commands for them I installed a lot of them I learnt a lot of commands Then I said, just one more version manager Which I will write instead So, there came another version manager asdf version manager - https://github.com/asdf-vm/asdf A version manager so extendable for which anyone can create a plugin To support their favourite language No more installing more version managers Or learning more commands

AutoCodeGenerator

AutoCodeGenerator is a tool which is able to generate other programs that insert, delete, or update database records for a number of different database programs. Programs can be generated in Python, bash, ksh, Java, C, or other languages; the package also generates code for various database servers via a plain text file.

Autobuild

'Autobuild' processes output from building software, primarily focused on packages using Autoconf and Automake, and generates HTML summaries. The output includes project name, version, build host types, build host name, and indication of success or failure. The output is indexed in many ways to simplify browsing.

... further results