Free rube goldberg ides software for linux

Cobertura is a free Java tool that calculates the percentage of code accessed by tests.Cobertura project can be used to identify which parts of your Java program are lacking test coverage. It is based on jcoverage.
Main features:
- Can be executed from ant or from the command line.
- Instruments Java bytecode after it has been compiled.
- Can generate reports in HTML or XML.
- Shows percent of lines coveraged and branches coveraged for each class, package, and for the overall project.
- Shows the McCabe cyclomatic code complexity of each class, and the average cyclomatic code complexity for each package, and for the overall product.
- Can sort HTML results by class name, percent of lines covered, percent of branches covered, etc. And can sort in ascending or decending order.
Enhancements:
- Much improved branch coverage. Information on whether the true as well as the false of an if statement is collected. Also, information on the branches of a switch statement (including the default) is collected. (Jiri Mares)
- Assume Java source files are saved as UTF-8 instead of the computers default encoding.
- Write all HTML and XML reports in UTF-8 instead of the computers default encoding (Naoki Iwami).
- Fix a bug where the Cobertura ant tasks would not work correctly in Microsoft Windows when Cobertura was installed on a different drive than the drive from which youre running ant (Srivathsan Varadarajan).
- Added a "maxmemory" attribute to the instrument, merge and report ant tasks (Matt Cordes).
- Improve support for Maven and similar environments where control over system properties is difficult such as app servers, IoC containers, IDEs, etc. Setting the datafile location is difficult in these environments. To correct this, a cobertura.properties file located in the classpath is used to properly set the net.sourceforge.cobertura.datafile property. (Joakim Erdfelt)

DBG is a a full-featured php debugger, an interactive tool that helps you debugging php scripts.
It works on a production and/or development WEB server and allows you debug your scripts locally or remotely, from an IDE or console.
Main features:
- native debugger. Works transparently, neither script nor PHP engine modifications required.
- server part (dbg module) runs on all platforms where PHP itself runs.
- works transparently across the global network as well as locally.
- JIT. When enabled can start debugging Just In Time of error occurs.
- supports back-tracking, e.g. displays a list of all procedures with their local variables, the current execution position reached from. Also you can watch local variables or function parameters in all active and nested scopes.
- certainly, you can execute script in the debugger step by step (step-in, step-out, step-over...), evaluate any valid php expressions or complex variables, modify values of any variables on the fly and create any new ones. Breakpoints can be conditional, they also may skip entered number of hits.
- has embedded profiler, so now its easy to find out a bottleneck in the scripts.
- allows multiple debugger processes running simultaneously.
- compatible with php-4.0.6 and higher.
- has open COM interfaces for integration with win32-based 3rd party IDEs.
- Commercial version of DBG (2.16.x) is available with commercial version of PHPEd PHP IDE only, see review for details.
- Linux, BSD, SunOs, MacOs and Win32 platoforms are supported.
- Free version (2.11.x) is available on this site. It works with PHP Edit, PHP Coder and some other IDEs.
- Free dbg front-end (dbg-cli) for Linux/Unix can be used to debug scripts either directly or under DDD 3.3.9 (GNU debugger). Also see RedHat 7.3, YellowDog and Mandrake distributions at RPM Find site.
Enhancements:
- All php versions from 4.0.6 up to 4.3.10 and from 5.0.0 up to 5.0.3 are supported.
- Support for HARDENED php v0.2.6 added (4.3.9h, 4.3.10h and 5.0.3h).
- Command line interface (dbg-cli) improved.
- Tested with php 4.0.6, 4.1.0-4.1.2, 4.2.0-4.2.3, 4.3.0-4.3.10, 5.0.0-5.0.3.

Off-the-Record Messaging is a Pidgin plugin that allows you to have private conversations over instant messaging by providing:
Encryption
No one else can read your instant messages.
Authentication
You are assured the correspondent is who you think it is.
Deniability
The messages you send do not have digital signatures that are checkable by a third party. Anyone can forge messages after a conversation to make them look like they came from you. However, during a conversation, your correspondent is assured
the messages he sees are authentic and unmodified.
Perfect forward secrecy
If you lose control of your private keys, no previous conversation is compromised.
Enhancements:
- Translations for English, Dutch, Spanish, French, Slovak
- Added option to not log OTR conversations
- Large messages are now fragmented transparently instead of failing
- Removed "view secure session id" and "verify fingerprint" options from the OTR button menu. Added "authenticate buddy" option in its place. This new option allows you to authenticate your buddies by entering some secret that only the two of you know, rather than by using a long user-unfriendly sequence of hex characters. [The old "verify fingerprint" dialog is still available via an "Advanced..." button from the new "authenticate buddy" dialog.]

JDBCPersistence project is an Object Relational Mapping Framework. Designed for use in high volume online banking application the package delivers performance matching of that exhibited by hand written JDBC code.

The differentiating features of JDBCPersistence are a result of the focus placed first and foremost on performance followed by making programmer most effective by building on existing knowledge of SQL, JDBC APIs, IDEs and, at the same time, avoiding creation of dependencies on specific libraries, tools, IDEs.

The framework strikes a good balance in what it provides verses what it requires a programmer to do in order to use it, e.g. a programmer could quickly prototype value objects by specifying them as Java interfaces and asking the framework to provide implementation for these interfaces at runtime, thus allowing to go from specifying an interface to using it in no time.

On the other hand, recognizing that data relationships are governed by business rules much more complex than could be specified in a typical ORM configuration file, a programmer is required to maintain such relationships in code.

The focus of the framework is to provide ORM services while leaving other concerns, in particular, data caching, up to the developer to solve in the context of an application. Being aware that the caching requirements may be different in online vs. batch application, the framework does not prescribe a solution. Developer needs to decide on application specific caching policy and implement it in an architectural layer (DAO) designed to function in both contexts.

The framework does not add any behavior to the classes that comprise the application. Classes supplied by the developer are the classes that will be used by the application when it runs.

JDBCPersistence uses bytecode generation technique to create bytecode for classes that implement logic used for persisting the data. Such, for every, loosely speaking "Java Bean", that requires persistence, a persistor class that implements CRUD operations is created. As opposed to using reflection, the approach of generating bytecode is apt to further optimization by JVM.

JDBCPersistence takes bytecode generation a little further by providing a feature that allows generating complete implementation of a value object specified as an abstract class. Similar to generating full implementation for Java interface class that describes value object class, the framework can generate implementation for all abstract methods of an abstract class representing value object.

As all of the bytecode generation takes place at run time, there is no impact on development or build process. The approach of generating bytecode at runtime is also used by RMI implementation of the Java Platform starting with version 5.0.

The API of the framework builds on the existing JDBC APIs. JDBCPersistences public API adds four classes and three interfaces. As the framework uses SQL for queering the data a curve associated with learning framework specific query language is avoided.

In an attempt to "keep it simple" JDBCPersistence only dependency is ASM, which is used for bytecode generation. The footprint of the package is under 200K.

Domino Javadoc Generator project aims to create a documentation to the Lotus Notes API for Java in a standard format common in the Java comunity and accepted by the most IDEs for Java.

The Lotus Notes API is delivered as a Java archive together with the original documentation in the native format of a Domino database with the IBM Domino Designer. The documentation can be read only in the Lotus Notes. Java-oriented tools cannot use it to display a description of a Java class, to browse classes and their methods or to offer an automatic code insertion based on a Java object and its class.

The goal is to create a Javadoc documentation together with a pseudo-source code of the Lotus Notes API. The documentation can be viewed, indexed and integrated to IDEs. The pseudo-source code can be integrated to IDEs to support object browsing and automatic source code insertion.

JikesTM is a compiler that translates JavaTM source files as defined in The Java Language Specification into the bytecoded instruction set and binary format defined in The Java Virtual Machine Specification.

You may wonder why the world needs another Java compiler, considering that Sun provides javac free with its SDK. Jikes has five advantages that make it a valuable contribution to the Java community:

* Open source. Jikes is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative.
* Strictly Java compatible. Jikes strives to adhere to both The Java Language Specification and The Java Virtual Machine Specification as tightly as possible, and does not support subsets, supersets, or other variations of the language. The FAQ describes some of the side effects of this strict language conformance.
* High performance. Jikes is a high performance compiler, making it ideal for use with larger projects.
* Dependency analysis. Jikes performs a dependency analysis on your code that provides two very useful features: Incremental builds and makefile generation.
* Constructive Assistance. Jikes strives to help the programmer write better code in two key ways. Jikes has always strived to provide clear error and warning text to assist the programmer in understanding problems, and now with release 1.19 Jikes helps point out common programming mistakes as documented in Effective Java.

Abridged from a FAQ entry which was adapted from some material by Lou Grinzo for an article he wrote.

The fact that Jikes is a high-performance, highly compatible Java compiler that can be used on almost any computing platform makes it an interesting program and worth investigating for almost any Java programmer. But Jikes is also notable because it lies at the center of two events: the adoption of open source philosophy and practice by large corporations, and the continued growth of Java for Linux.

Its worth pointing out that Jikes is not, and is not intended to be, a complete development environment -- it is simply a command line compiler. It should not be considered a replacement for more complete tools, such as Source Navigator or IBMs VisualAge for Java which provide sophisticated graphical IDEs (Integrated Development Environments).

The Jikes compiler was released in binary form in April 1997 on the IBM alphaWorks site. Jikes for Linux was released on 15 July 1998. The response was overwhelming -- Jikes had more downloads in the three months after the announcement than in the fifteen months before the announcement.

Release of Jikes for Linux was soon followed by requests to open up the source. Many notes and comments from users suggested this would be a good idea. The source was released under a liberal license in December 1998 to make a very visible demonstration of IBMs commitment to open standards and to Java Technology, to make Jikes more reliable and accessible, to encourage more widespread use of Java Technology, to encourage standardization of Java Technology, and to gain some experience actually running an open source project. This marked the start of one of IBMs first efforts in the open source arena.

The original alphaWorks version of Jikes was written by Philippe Charles and Dave Shields of the IBM T. J. Watson Research Center. Since the release of the source they have continued to work on the compiler as contributors; however recently have officially been moved on to other projects within IBM. Today there are no IBMers who work on Jikes as part of their job description. Jikes survives today soley based on the free time contributions of members of the open source community.

The source code is available under IBMs Public License, which has been approved by the OSI (Open Source Initiative) as a fully certified open source license. The project provides access to the complete CVS development tree, which includes not only Jikes, but also the source for the Jacks Test Suite and the Jikes Parser Generator used to build Jikes. Jikes is included in many Open Source Operating Systems. The Jacks Test Suite is a replacement for the Jikestst package.

libgsf aims to provide an efficient extensible i/o abstraction for dealing with different structured file formats.

WebInject is a free tool for automated testing of web applications and services. It can be used to test individual system components that have HTTP interfaces (JSP, ASP, CGI, PHP, Servlets, HTML Forms, etc), and can be used as a test harness to create a suite of [HTTP level] automated functional, acceptance, and regression tests. A test harness, also referred to as a test driver or a test framework, allows you to run many test cases and collect/report your results. WebInject offers real-time results display and may also be used for monitoring system response times.

WebInject can be used as a complete test framework that is controlled by the WebInject User Interface (GUI). Optionally, it can be used as a standalone test runner (text/console application) which can be integrated and called from other test frameworks or applications.

WebInject uses an XML API (interface). This means you can use WebInject without ever seeing its internal implementation (no scripting or programming necessary to use it).

WebInject is written in Perl and can run on any platform that a Perl interpreter can be installed on (MS Windows, GNU/Linux, BSD, Solaris, MAC OS, and many more). Currently, binary executables of WebInject are only available for MS Windows. If you would like to run on other platforms, you must have a Perl interpreter and run it from the Perl source code.

Test cases are written in XML files, using XML tags and attributes, and passed to the WebInject engine for execution against the application/service under test. This abstracts the internals of WebInjects implementation away from the non-technical tester, while using an open architecture [written in Perl] for those that require more customization or modifications.

Result reports are generated in HTML (for viewing) and XML (for tranformation by external programs). These detailed results include pass/fail status, errors, response times, etc. Results are also displayed in a window on the User Interface if you are running the WebInject GUI, and are sent to the STDOUT channel if you are running the WebInject Engine as a standalone (console) application.

HTTP response times can be collected and monitored in real-time during test execution. Timer statistics are calculated and displayed in a monitor window during runtime. When used along with gnuplot (a plotting utility), a response time graph is generated and updated in real-time as the test runs. This is used to verify responses from the application/service under test are within an acceptable range (to meet your SLA or quality of service criteria). This also enables WebInject to be run as a performance probe for application/service monitoring.