Free proguard ant software for linux

ProGuard is a free Java class file shrinker, optimizer, and obfuscator. ProGuard project can detect and remove unused classes, fields, methods, and attributes. It can then optimize bytecode and remove unused instructions.
Finally, it can rename the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
More compact jar files also means smaller storage requirements, faster transfer of applications across networks, faster loading, and smaller memory footprints.
ProGuards main advantage compared to other Java obfuscators is probably its compact template-based configuration. A few intuitive command line options or a simple configuration file are usually sufficient. For instance, the following configuration option preserves all applets in a jar:
-keep public class * extends java.applet.Applet
The user manual explains all available options and shows more examples of this powerful configuration style.
ProGuard is fast. It only takes seconds to process programs and libraries of several megabytes. The results section presents actual figures for a number of applications.
ProGuard is a command-line tool with an optional graphical user interface. It also comes with plugins for Ant and for the J2ME Wireless Toolkit.
ProGuard is a Java class file shrinker, optimizer, and obfuscator. The shrinking step detects and removes unused classes, fields, methods, and attributes. The optimization step analyzes and optimizes the bytecode of the methods. The obfuscation step renames the remaining classes, fields, and methods using short meaningless names. The resulting jars are smaller and harder to reverse-engineer.
ProGuard can also be used to list unused fields and methods in an application, and to print out the internal structure of class files.
ProGuard typically reads the input jars (or wars, ears, zips, or directories). It then shrinks, optimizes, and obfuscates them. It then writes the results to one or more output jars (or wars, ears, zips, or directories). The input jars can optionally contain resource files. ProGuard copies all non-class resource files from the input jars to the output jars. Their names and contents remain unchanged.
ProGuard requires the library jars (or wars, ears, zips, or directories) of the input jars to be specified. It can then reconstruct class hierarchies and other class dependencies, which are necessary for proper shrinking, optimization, and obfuscation. The library jars themselves always remain unchanged. You should still put them in the class path of your final application.
In order to determine which code has to be preserved and which code can be discarded or obfuscated, you have to specify one or more entry points to your code. These entry points are typically classes with main methods, applets, midlets, etc.
- In the shrinking step, ProGuard starts from these seeds and recursively determines which classes and class members are used. All other classes and class members are discarded.
- In the optimization step, ProGuard further optimizes the code. Among other optimizations, classes and methods that are not entry points can be made final, and some methods may be inlined.
- In the obfuscation step, ProGuard renames classes and class members that are not entry points. In this entire process, keeping the entry points ensures that they can still be accessed by their original names.
Any classes or class members of your code that are created or invoked dynamically (that is, by name) have to be specified as entry points too. It is generally impossible to determine these cases automatically, but ProGuard will offer some suggestions if keeping some classes or class members appears necessary. For proper results, you should at least be somewhat familiar with the code that you are processing.
ProGuard does handle Class.forName("SomeClass") and SomeClass.class constructs automatically. The referenced classes are preserved in the shrinking phase, and the string arguments are properly replaced in the obfuscation phase. With variable string arguments, it is generally impossible to determine their possible values (they might be read from a configuration file, for instance).
However, as mentioned, ProGuard will note constructs like "(SomeClass)Class.forName(variable).newInstance()". These might be an indication that the class or interface SomeClass and/or its implementations may need to be preserved. You can then adapt your configuration accordingly.
Whats New in 3.9 Stable Release:
- This release fixes a number of bugs.
- Notably, ".class" constructs compiled in Java 6 are now handled correctly.
- The optimization step now avoids a possible division by 0 and correctly processes local variables with indices larger than 255.
- The documentation and examples have been updated.
Whats New in 4.0 Beta Development Release:
- Added preverifier for Java 6 and Java Micro Edition, with new option -dontpreverify.
- Added new option -target to modify java version of processed class files.
- Made -keep options more orthogonal and flexible, with option modifiers allowshrinking, allowoptimization, and allowobfuscation.
- Added support for configuration by means of annotations.
- Improved shrinking of unused annotations.
- Added check on modification times of input and output, to avoid unnecessary processing, with new option -forceprocessing.
- Added new options -flattenpackagehierarchy and -repackageclasses (replacing -defaultpackage) to control obfuscation of packages names.
- Added new options -adaptresourcefilenames and -adaptresourcefilecontents, with file filters, to update resource files corresponding to obfuscated class names.
- Now respecting naming rule for nested class names (EnclosingClass$InnerClass) in obfuscation step, if InnerClasses attributes or EnclosingMethod attributes are being kept.
- Added new inter-procedural optimizations: method inlining and propagation of constant fields, constant arguments, and constant return values.
- Added optimized local variable allocation.
- Added over 250 new peephole optimizations.
- Improved making classes and class members public or protected.
- Now printing notes on suspiciously unkept classes in parameters of specified methods.
- Now printing notes for class names that dont seem to be fully qualified.
- Added support for uppercase filename extensions.
- Rewritten class file I/O code.
- Updated documentation and examples.

Brockman is an information radiator for monitoring Ant builds. Brockman project is useful for Agile software teams that practice continuous integration.
Brockman consists of:
- An Ant listener written in Java that outputs that status of your build, in xml
- A Freemarker template that specifies the format of the outputted xml file
- An AJAX front end that renders the xml file

Magnant is an epic real-time strategy game spanning in the Ant world. Players are managing the growth of anthills.

Starting with minimal resources, players are challenged to build new units, new buildings and collect resources. Players can then build various armies of Ants and slaughter their enemies.

Magnant brings a new concept which may change Real time strategy games concept! Players can collect cards, which enable them to create new units, building or give them special powers.

Players may have different cards and so different abiliites when they play online against opponents. In fact, Magnant is a Trading Card Game where players can fight over a real time strategy environment.

PMD is a Java source code analyzer. PMD finds unused variables, empty catch blocks, unnecessary object creation, and more. PMD project includes CPD, a tool to detect chunks of identical code
PMD scans Java source code and looks for potential problems like:
- Possible bugs - empty try/catch/finally/switch statements
- Dead code - unused local variables, parameters and private methods
- Suboptimal code - wasteful String/StringBuffer usage
- Overcomplicated expressions - unnecessary if statements, for loops that could be while loops
- Duplicate code - copied/pasted code means copied/pasted bugs
PMD is integrated with JDeveloper, Eclipse, JEdit, JBuilder, BlueJ, CodeGuide, NetBeans/Sun Java Studio Enterprise/Creator, IntelliJ IDEA, TextPad, Maven, Ant, Gel, JCreator, and Emacs.
Enhancements:
- Fixed bug 1697397 - fixed false positives in ClassCastExceptionWithToArray
- Fixed bug 1728789 - removed redundant rule AvoidNonConstructorMethodsWithClassName; MethodWithSameNameAsEnclosingClass is faster and does the same thing.

Kant project is a very simple python script for choosing graphically an ant task. Simply run the script with your ant file as arguments, and the task listed in the file (or in the files linked as imports) will be displayed. Just choose one, and it will run the task !

This script uses kdialog to build the dialog box.

For more conveniance, you can create a new file association in konqueror for file with the pattern "build.xml" to this script. Then, just click and run a task.

ANT is a desktop ISDN telephony application written for GNU/Linux. It supports OSS (Open Sound System) and I4L (ISDN4Linux). Its user interface was made for GTK+ 2.x (GIMP toolkit).
ANT directly interfaces OSS and ISDN devices, so there is no need to install extra software or hardware like PBX (Private Branch Exchange) or telephony cards, if youve got direct access to an audio capable ISDN card (teles or HiSax chipset, e.g. AVM Fritz Card) and a full duplex soundcard or two sound devices.
Main features:
- Dialing out, receiving calls and talking, of course :)
- Caller id monitor
- Vanity number dialing support
- Big / little endian support for processor architecture and sound card
- Different 8 and 16 bit audio formats supported
- Different sampling speeds supported (if sound device(s) dont support native ISDN sampling speed)
- Setting outgoing (identifying) MSN (Multiple Subscriber Number) and MSNs to listen on
- Line Level Checker
- Also works with ALSA (OSS emulation)
- Saved config files
- Saved Caller ID history
- Option to run an external command on incoming call (useful for external pagers), add %n in template for calling party number
- Command line option to make a running instance of ANT make a call to a specific number (useful for external address book applications)
- Live recording to files
- Popup on incoming calls
- Configurable preset buttons
- Isdnlog data import
- Tracking of unanswered calls
- Internationalization, native language support (NLS) for de, en, fr, nl, ro
Enhancements:
- An Italian translation has been added.

warichu bar provides a social annotation tool that sits on top of the web and allows everyone to discuss the webs content.

Warichu is a social annotation tool that sits on top of the web and allows everyone to discuss the webs content. You can think of the situation as being similar to that of an ant colony mapping out the terrain it lives in - all the ants investigate here and there, finding useful resources, remembering the details and telling their friends so they can use the resources too. In this analogy the web is the terrain, and we are the ants! We communicate on a layer that overlays the web - a layer just for collaborative communication of information. That layer is the Warichu.

With Warichu you can create various types of virtual sticky note and attach them to web pages. Whenever you go back to that page, your note will appear - and if you send the note to some friends it will appear on the page for them too. Different types of sticky note fulfill different requirements - some can be shared with other people, some are stored locally on your computer, some allow you to modify the web page you stick them to, others allow you to conglomerate snippets of text from a page..

An API is included that allows developers to create their own types of content notes (eg, page highlights, annotations, blogging tools)

Gump is Apaches continuous integration tool. Apache Gump is written in python and fully supports Apache Ant, Apache Maven and other build tools. Gump is unique in that it builds and compiles software against the latest development versions of those projects. This allows gump to detect potentially incompatible changes to that software just a few hours after those changes are checked into the version control system. Notifications are sent to the project team as soon as such a change is detected, referencing more detailed reports available online.

You can set up and run Gump on your own machine and run it on your own projects, however it is currently most famous for building most of Apaches java-based projects and their dependencies (which constitutes several million lines of code split up into hundreds of projects). For this purpose, the gump project maintains its own dedicated server.

How does Gump work?

With Traditional Gump, project definitions are converted from XML to scripts native to the platform on which you are running. With Python Gump the XML is mapped into in memory objects for processing. Scripts execute cvs or svn update commands for every module which contains a project being built, and invoke builds for each project in an order that ensures that dependencies are satisfied. Build outputs are processed and, if successful, dependent projects are then built on these outputs.

The commands use the actual build.xml files from the projects, but do not use the scripts or jar files checked into CVS/SVN. Instead, the CLASSPATH is set and properties are passed on the command line.

Note

Gump sets Ants build.sysclasspath to only and manages the system classpath:
To quote Ant: Only the system classpath is used and classpaths specified in build files, etc are ignored. This situation could be considered as the person running the build file knows more about the environment than the person writing the build file

The net effect is that every project is built every day with the latest version of every dependency - including the latest Ant, latest JUnit, latest XML parser.

The results are captured into html pages that largely are consistent with the style of the Jakarta project. An extensive amount of hypertext links are added to allow quick and easy navigation, and failures are color coded on the main build page.

A Perl script which is driven off of a naglist will optionally send e-mails to various newsgroups upon matching strings being found in the build output. This is typically used to alert developers of build failures.