Hippo CMS is an open source information centered content management system. It's targeted at medium to large organisations managing content for multi-channel distribution like web sites and intranets. It facilitates an open and flexible way of using your information by following international accepted open standards.
myhttp is a basic web service engine for MySQL. It all you to perform basic HTTP method operations, like PUT, GET, and DELETE from MySQL as though it was a table. For example:
CREATE TABLE `d` (`a` varchar(125), b text, primary key(a)) ENGINE=HTTP DEFAULT CHARSET=latin1 CONNECTION="http://en.wikipedia.org/wiki/";
This would allow you to fetch pages from Wikipedia from SQL SELECT calls.
GenealogyJ is a viewer and editor for genealogic data, suitable for hobbyist, family historian and genealogy researcher. GenJ supports the Gedcom standard, is written in Java and offers family tree, table, timeline views and more. GenJ is free software so it can be redistributed and/or be modified under the terms of the GNU General Public Licence as published by the Free Software Foundation.
Ahnenblatt ist ein Programm zur Ahnenforschung bzw. Genealogie für Windows (kostenlos/Freeware), das die Eingabe von Ahnen, Datenaustausch und -export (GEDCOM, HTML, DOC, CSV, XML, ...), Druck von Listen/Tafeln und noch vieles mehr unter einer einfach zu bedienenden Oberfläche vereint.
SchemaCrawler is a command-line tool to output your database schema and data in a readable form. The output is designed to be diff-ed with previous versions of your database schema. SchemaCrawler is also an API that improves on the standard JDBC metadata.
Application Ermodeller is a free CASE tool for data modelling which is built in Java. This tool supports conceptual and logical data modelling and in the final step, it allows to create physical model that is specific for particular DBMS.
The basic idea is to support development of database via ER modelling in three levels of abstraction:
* conceptual
* logical
* physical
This separation allows to create database model independent on the particular database system. You may create conceptual model and logical model that are independent on any DBMS. Then, you may generate physical model for each DBMS you will use. Afterwards, physical models allows you to generate SQL data definition for your target DBMS.
There are a number of open-source unit testing tools available. So why another one?
Well, this one addresses a specific need - an easy way to test XML-based servers. If you have a server that communicates with clients via XML messages, you can end up putting a lot of effort into using one of the unit-testing frameworks to test all the messages. Just think of all the code needed to set up communications, construct messages, and verify responses.
A simple alternative is to document XML messages and expected responses, without having to write any code. Let XmlMessageTest send each XML message to the server, verify returned messages against expected results, and produce a simple report of test results.
XmlMessageTest is written in Java and should be able to run any Java-enabled platform. It's been tested on Windows XP and Linux. It can be easily integrated into your build process.
The Beryl XML GUI library was written to ease the development of graphical user interfaces using Swing on Java. It lets you store user interfaces as XML markup. This will help you avoid unnecessary clutter in your source - Swing code mixed with application logic can become a troublesome and hard to read mess as the application size increases. The library comes with a visual component builder, which makes development a breeze. The most important features are:
Tagonist is a laughably simple java web application framework.
Overview
Tagonist is an ultra-lightweight MVC webapp framework, similar in principle to Struts, WebWork, or Maverick. Like its cousins, Tagonist offers:
* Clean separation of code and content - no need for scriptlets
* Form processing by conveniently populating beans from the HTTP request attributes
However, unlike its cousins, Tagonist:
* Is trivial to learn and use. One look at the examples and you will understand how to write your webapp immediately. There are just two custom tags.
* Is trivial to configure. There no servlets to configure and no XML to muck with. Just drop the tagonist.jar in your WEB-INF/lib and start using the two tagonist custom tags in your JSPs.
* Integrates seamlessly into any JSP-based portal or even other webapp frameworks. Your JSP includes tagonist actions, not the other way around.
* Encourages development of fine-grained actions which can be composed arbitrarily on a page. You don't need to have one action class per screen.
* Allows many HTML developers to work on a project without fighting over checkouts for some sort of XML sitemap configuration file.
* Is composed of 8 java classes and less than 500 lines of code (including whitespace). Anyone can see how it works.
* An ant task called the "propertizer" that automatically generates getter and setter methods when you annotate fields with @Property
* is language-neutral: it will allow the writing of software libraries for communicating with JMS providers in any language that has libraries for communicating over HTTP.
* is RESTful: it provides a RESTful equivalent to all of the non-optional portions of the JMS API including
o registration of resources administered by the messaging provider
o connection and session management
o sending and receipt of all types of JMS message
Implementation overview
HJB
*
is deployed as a servlet (HJBServlet), that can run on any compliant Servlet specification 2.4 container.
*
will work with any messaging vendor that provides a JMS interface.
*
aims to do one thing well. Its role is to act as an HTTP gateway server for JMS resources. Other potentially useful features are deliberately excluded, e.g,
o HTTP session management
o authentication and authorization
Develop a java-based tool that manages the life-cycle of the database schema and generates code and documentation artifacts. The tool transforms an XML description of a database schema into an HTML data dictionary, SQL scripts to create the database, and Java data access code. The tool automatically updates the documentation, scripts, and code as the schema is changed and updated. The tool also provides a simple but powerful data access programming model and framework for developing custom data access code. The generated Java code conforms to the Data Access Object (DAO) and Value Object (AKA Data Transfer Object) patterns that are described in the J2EE Java Blueprints.
The Milyn Project is building Open-Source Java components for XML and non-XML Processing.
Smooks
Smooks is a Java framework for managing and performing Fragment Based XML Processing (Transformation/Analysis).
Smooks can be used in conjunction with or as an alternative to XSLT for XML Transformation.
Smooks gives you more control when performing XML Transformations and Analysis by giving you the freedom to use the tools and programming languages most appropriate to the type of transformation in question (or your skillset).
* Mix and Match different tools and languages in the process of transforming a single message/document e.g. it may be easier to transform one part of the document using pure Java and another part using XSLT.
* Simplify your XSLT and StringTemplate Templates by combining the power of the Smooks Javabean and Templating Cartiridges.
* Analyse/Read your XML and non-XML data into named Javabeans using the Smooks Javabean Cartiridge.
* more...
LiveTribe is a community effort to provide state-of-the-art management and monitoring tools, available for download and distribution under the open source Apache License 2.0.
The goal of the LiveTribe project is to simplify the life of the application developers and operational users, by eliminating the complexity and overhead of deploying and maintaining multiple management and monitoring tools (one for each application).
Instead, the LiveTribe project provides an easily customisable and extensible plug-in architecture where management and monitoring capabilities for the most commonly-used applications (such as Jetty , Tomcat , Geronimo , etc.) are provided, and where custom functionality can be added easily.
LiveTribe leverages the most popular standards for management/monitoring technologies, including JMX ( Java Management Extensions ), ARM ( Application Response Measurement ) and SLP ( Service Location Protocol ).
The LiveTribe project is composed of modules (see the list of modules on the left).
Each module implements the specific portion of the LiveTribe project and most of the time can be downloaded and used separately from other modules.
It is a content management system inspired by Ward Cunningham's Wiki idea. Whereas most wiki implementations (and there are hundreds) use a textarea in a web page for editing, with a command language for formatting, Cozmos uses a full installed 'Thick' application for editing and pushes back the pages using an extended web technology called WebDAV. Like Wikis, Cozmos separates content from presentation/style. Unlike Wikis the actual language of the content is HTML which is the language of the web itself.
WinRun4j is a java launcher for Windows. It provides an alternative to javaw.exe and provides the following benefits:
* Use of INI file for specifying classpath, main class, vm args, program args.
* Custom executable name that appears in task manager.
* Additional VM args for (eg.) more flexible memory use.
* Built-in icon replacer for custom icon.
WinRun4J is licensed under the Common Public License (CPL).
Artifactory is a Maven2 proxy repository with advanced features. It is based on JCR (using JackRabbit as the implementation), with a web UI based on Wicket, and embeded Jetty for quick start. All artifacts are stored in an embedded Derby DB.
Dependometer is a java based analysis tool for java projects.
Features are:
Use a logical architecture description in terms of Layers and Subsystems and their physical mapping (n Packages implement a Subsystem) and check logical architecture violations.
* Analyze the dependency architecture between Layers, Subsystems, Packages, Compilation Units (Java files) and Types (Classes and Interfaces)
* Calculate a bunch of metrics for all elements - this includes metrics from John Lakos, Robert C. Martin and Craig Larman
* Analyze cycles between elements
* Define thresholds and receive feedback upon their violation
Simulate via simple refactoring definitions and cutting unwanted dependencies changes to the physical structure possibly enhancing refactoring.
Create a complete HTML presentation via xslt. This provides browsing capabilities from Layer (logical element) to Compilation Unit (physical element) for a discussion which physical elements cause the logical architecture to break.
T. Yuan, G. Li, J. Lu, C. Liu, L. Li, and J. Xue. 2021 IEEE/ACM International Symposium on Code Generation and Optimization (CGO), page 187-199. Los Alamitos, CA, USA, IEEE Computer Society, (March 2021)