OWL API

http://owlapi.sourceforge.net/

The OWL API is a Java interface and implementation for the W3C Web Ontology Language OWL. The latest version of the API is focused towards OWL 2 which encompasses, OWL-Lite, OWL-DL and some elements of OWL-Full.

The OWL API is open source and is available under the LGPL License

The OWL API includes the following components:

An API for OWL 2 and an efficient in-memory reference implementation
RDF/XML parser and writer
OWL/XML parser and writer
OWL Functional Syntax parser and writer
Turtle parser and writer
KRSS parser
OBO Flat file format parser
Support for integration with reasoners such as Pellet and FaCT++
Support for black-box debugging
The original version of the API for OWL 1.0 was developed as part of the WonderWeb Project. The latest version of the OWL API for OWL 1.1 has been developed as part of the CO-ODE project.

Contributors
The OWL API is primarily maintained at the University of Manchester, but there have been significant contributions from various groups and companies:
Clark & Parsia LLC (Explanation code, Modularity code)
University of Ulm (KRSS2 syntax parser and renderer)

Java - Design Patterns

http://www.javacamp.org/designPattern/

What is the design pattern?
If a problem occurs over and over again, a solution to that problem has been used effectively. That solution is described as a pattern. The design patterns are language-independent strategies for solving common object-oriented design problems. When you make a design, you should know the names of some common solutions. Learning design patterns is good for people to communicate each other effectively. In fact, you may have been familiar with some design patterns, you may not use well-known names to describe them. SUN suggests GOF (Gang Of Four--four pioneer guys who wrote a book named "Design Patterns"- Elements of Reusable Object-Oriented Software), so we use that book as our guide to describe solutions. Please make you be familiar with these terms and learn how other people solve the code problems.

Do I have to use the design pattern?
If you want to be a professional Java developer, you should know at least some popular solutions to coding problems. Such solutions have been proved efficient and effective by the experienced developers. These solutions are described as so-called design patterns. Learning design patterns speeds up your experience accumulation in OOA/OOD. Once you grasped them, you would be benefit from them for all your life and jump up yourselves to be a master of designing and developing. Furthermore, you will be able to use these terms to communicate with your fellows or assessors more effectively.

Many programmers with many years experience don't know design patterns, but as an Object-Oriented programmer, you have to know them well, especially for new Java programmers. Actually, when you solved a coding problem, you have used a design pattern. You may not use a popular name to describe it or may not choose an effective way to better intellectually control over what you built. Learning how the experienced developers to solve the coding problems and trying to use them in your project are a best way to earn your experience and certification.

Remember that learning the design patterns will really change how you design your code; not only will you be smarter but will you sound a lot smarter, too.

How many design patterns?
Many. A site says at least 250 existing patterns are used in OO world, including Spaghetti which refers to poor coding habits. The 23 design patterns by GOF are well known, and more are to be discovered on the way.

Note that the design patterns are not idioms or algorithms or components.

What is the relationship among these patterns?
Generally, to build a system, you may need many patterns to fit together. Different designer may use different patterns to solve the same problem. Usually:

Some patterns naturally fit together
One pattern may lead to another
Some patterns are similar and alternative
Patterns are discoverable and documentable
Patterns are not methods or framework
Patterns give you hint to solve a problem effectively
References
Design Patterns -- Elements of Reusable Object-Oriented Software by GOF.

The Design Patterns, Java Companion -- by James W. Cooper

Category patterns

GlassFish

The GlassFish community is building open source, production-quality, enterprise software.


Announcing GlassFish v3 Prelude! GlassFish v3 Prelude is the next major release of the GlassFish application server and is currently under development by the GlassFish Community. GlassFish v3 Prelude provides a light weight and extensible core based on OSGi, a web and scripting container, an easy-to-use Admin Console for configuration and management, and Update Center connectivity.




https://glassfish.dev.java.net/

Dojo

http://dojotoolkit.org/

The Dojo Toolkit is an open-source JavaScript toolkit for building great web applications. It shortens the time between idea and implementation by providing a well conceived API and set of tools for assisting and fixing the issues experienced in everyday web development. It is lightning fast, extremely robust, and supplies a solid set of tools for DOM manipulation, Animations, Ajax, Event and keyboard normalization, Internationalization (i18n) and Accessibility (a11y). The Base of Dojo is a single, lightweight entity (26KB "across the wire"). Dojo is completely free, liberally licensed (AFL or BSD), and transparently developed by an active group of developers with a strong community presence.

No matter the size of your projects, Dojo is the ultimate scalable solution to your development woes. The built-in package system ends the headache of tracking dependencies, the build system combines and shrinks optimized "layers" of code for deployment, and D.O.H. makes unit and regression testing a breeze.

SWT - Standard Widget Toolkit

SWT is an open source widget toolkit for Java designed to provide efficient, portable access to the user-interface facilities of the operating systems on which it is implemented.

http://www.eclipse.org/swt/

Boost

Boost provides free peer-reviewed portable C++ source libraries.

We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.

We aim to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries are already included in the C++ Standards Committee's Library Technical Report (TR1) as a step toward becoming part of a future C++ Standard. More Boost libraries are proposed for the upcoming TR2.

www.boost.org

SSH

Secure Shell or SSH is a network protocol that allows data to be exchanged using a secure channel between two networked devices. [1]

Used primarily on Linux and Unix based systems to access shell accounts, SSH was designed as a replacement for TELNET and other insecure remote shells, which sent information, notably passwords, in plaintext, leaving them open to interception.[2] The encryption used by SSH provides confidentiality and integrity of data over an insecure network, such as the Internet.

http://en.wikipedia.org/wiki/Secure_Shell

jQuery

http://jquery.com/

jQuery is a new type of JavaScript library.
jQuery is a fast, concise, JavaScript Library that simplifies how you traverse HTML documents, handle events, perform animations, and add Ajax interactions to your web pages. jQuery is designed to change the way that you write JavaScript.

"You start with 10 lines of jQuery that would have been 20 lines of tedious DOM JavaScript. By the time you are done it's down to two or three lines and it couldn't get any shorter unless it read your mind." - Dave Methvin

Cactus

http://jakarta.apache.org/cactus/index.html

Project Description
Cactus is a simple test framework for unit testing server-side java code (Servlets, EJBs, Tag Libs, Filters, ...).

The intent of Cactus is to lower the cost of writing tests for server-side code. It uses JUnit and extends it.

Cactus implements an in-container strategy, meaning that tests are executed inside the container.

UML

www.uml.org

The Unified Modeling Language™ - UML - is OMG's most-used specification, and the way the world models not only application structure, behavior, and architecture, but also business process and data structure.

UML, along with the Meta Object Facility (MOF™), also provides a key foundation for OMG's Model-Driven Architecture®, which unifies every step of development and integration from business modeling, through architectural and application modeling, to development, deployment, maintenance, and evolution.

OMG is a not-for-profit computer industry specifications consortium; our members define and maintain the UML specification.

JUnit

www.junit.org

This site is dedicated to software developers and testers using the JUnit testing framework. In addition to the latest news and download links for JUnit, you can find answers to questions about automated testing, tools and extensions for JUnit, and articles on Test Driven Development and other testing topics.

NUnit

www.nunit.org

What Is NUnit?
NUnit is a unit-testing framework for all .Net languages. Initially ported from JUnit, the current production release, version 2.4, is the fifth major release of this xUnit based unit testing tool for Microsoft .NET. It is written entirely in C# and has been completely redesigned to take advantage of many .NET language features, for example custom attributes and other reflection related capabilities. NUnit brings xUnit to all .NET languages.

About Us
The NUnit development team currently consists of Charlie Poole, Jamie Cansdale and Gary Feldman. Past developers include James W. Newkirk, Alexei A. Vorontsov, Michael C. Two and Philip A. Craig. We would also like to thank the following people for their contributions and support: Doug de la Torre, David White, Ethan Smith, Al Gonzalez, Ron Jeffries, and Rob Jeffries. A special acknowledgment needs to be sent to Kent Beck and Erich Gamma because without their efforts none of this would have been possible. Site design by Anne Lewis.

CentOS

www.centos.org

CentOS is an Enterprise-class Linux Distribution derived from sources freely provided to the public by a prominent North American Enterprise Linux vendor. CentOS conforms fully with the upstream vendors redistribution policy and aims to be 100% binary compatible. (CentOS mainly changes packages to remove upstream vendor branding and artwork.) CentOS is free. CentOS is now accepting donations via PayPal, please click the button for more information.

CentOS is developed by a small but growing team of core developers. In turn the core developers are supported by an active user community including system administrators, network administrators, enterprise users, managers, core Linux contributors and Linux enthusiasts from around the world.

CentOS has numerous advantages over some of the other clone projects including: an active and growing user community, quickly rebuilt, tested, and QA'ed errata packages, an extensive mirror network, developers who are contactable and responsive, multiple free support avenues including IRC Chat, Mailing Lists, Forums, a dynamic FAQ. Commercial support is offered via a number of vendors.

This site makes use of Javascript. If your browser doesn't work with Javascript we recommend you use FireFox.

Infragistics

www.infragistics.com

Infragistics is the world leader in Presentation Layer Technology. We are committed to providing our customers the highest quality of reusable presentation layer development tools for Windows Forms, ASP.NET, Windows Presentation Foundation (WPF), Tablet PC, and Java environments. Our products and services empower our customers' software development teams to realize the potential of the presentation layer by accelerating their development cycles and improving usability for end users.

Company Information
Infragistics was formed specifically with the vision to provide world-class development tools forming the basic infrastructure for object-oriented corporate development. Starting with a new generation of presentation layer elements, now suited for both rich client as well as server-based, multiple client environments, Infragistics shaped a strategy to develop a comprehensive toolset of presentation layer elements built on a framework allowing developers to create interfaces with the look and feel of today's most popular applications, including Office® 2007 and Windows® Vista®. While today we have expanded our product offerings and services to cover user interface quality assurance testing and product training, our fundamental goal remains to provide presentation layer technology in a wide range of development environments to allow our customers the freedom of utilizing our products to answer each one of their development needs across their organization.

Infragistics' diverse product line is currently used worldwide in nearly every Fortune 2000 Company. Our complete product line is developed using best practices, which is why Infragistics holds the most industry, editors', and readers' choice awards over the last decade - over 220. Our toolsets are products that corporations rely on to produce exceptional applications in-house as well as commercially. Some of the hundreds of thousands of applications built with Infragistics development tools include: Merrill Lynch’s main TGA trading application, serving over 10,000 brokers worldwide; the latest generation of Federal Express' internal shipping control application; Exelon’s electric power trading application; Great Plains (now Microsoft's) accounting solutions; and Verizon’s Viper application for allocating telecom resources efficiently and profitably.

Java MVC

http://java.sun.com/blueprints/patterns/MVC-detailed.html

Context
Application presents content to users in numerous pages containing various data. Also, the engineering team responsible for designing, implementing, and maintaining the application is composed of individuals with different skill sets.

Problem
Now, more than ever, enterprise applications need to support multiple types of users with multiple types of interfaces. For example, an online store may require an HTML front for Web customers, a WML front for wireless customers, a JavaTM (JFC) / Swing interface for administrators, and an XML-based Web service for suppliers



When developing an application to support a single type of client, it is sometimes beneficial to interweave data access and business rules logic with interface-specific logic for presentation and control. Such an approach, however, is inadequate when applied to enterprise systems that need to support multiple types of clients. Different applications need to be developed, one to support each type of client interface. Non-interface-specific code is duplicated in each application, resulting in duplicate efforts in implementation (often of the copy-and-paste variety), as well as testing and maintenance. The task of determining what to duplicate is expensive in itself, since interface-specific and non-interface-specific code are intertwined. The duplication efforts are inevitably imperfect. Slowly, but surely, applications that are supposed to provide the same core functionality evolve into different systems.

Forces

The same enterprise data needs to be accessed when presented in different views: e.g. HTML, WML, JFC/Swing, XML


The same enterprise data needs to be updated through different interactions: e.g. link selections on an HTML page or WML card, button clicks on a JFC/Swing GUI, SOAP messages written in XML


Supporting multiple types of views and interactions should not impact the components that provide the core functionality of the enterprise application

Solution
By applying the Model-View-Controller (MVC) architecture to a JavaTM 2 Platform, Enterprise Edition (J2EETM) application, you separate core business model functionality from the presentation and control logic that uses this functionality. Such separation allows multiple views to share the same enterprise data model, which makes supporting multiple clients easier to implement, test, and maintain.

Structure
The following diagram represents the Model-View-Controller pattern:



Participants & Responsibilities
The MVC architecture has its roots in Smalltalk, where it was originally applied to map the traditional input, processing, and output tasks to the graphical user interaction model. However, it is straightforward to map these concepts into the domain of multi-tier enterprise applications.


Model - The model represents enterprise data and the business rules that govern access to and updates of this data. Often the model serves as a software approximation to a real-world process, so simple real-world modeling techniques apply when defining the model.
View -The view renders the contents of a model. It accesses enterprise data through the model and specifies how that data should be presented. It is the view's responsibility to maintain consistency in its presentation when the model changes. This can be achieved by using a push model, where the view registers itself with the model for change notifications, or a pull model, where the view is responsible for calling the model when it needs to retrieve the most current data.
Controller - The controller translates interactions with the view into actions to be performed by the model. In a stand-alone GUI client, user interactions could be button clicks or menu selections, whereas in a Web application, they appear as GET and POST HTTP requests. The actions performed by the model include activating business processes or changing the state of the model. Based on the user interactions and the outcome of the model actions, the controller responds by selecting an appropriate view.
Strategies
Web-based clients such as browsers. JavaServer PagesTM (JSPTM) pages to render the view, Servlet as the controller, and Enterprise JavaBeansTM (EJBTM) components as the model. The Java Pet Store sample application illustrates this strategy.

Centralized controller. Instead of having multiple servlets as controllers, a main Servlet is used to make control more manageable. The Front Controller pattern describes this strategy in more detail.

Wireless clients such as cell phones. The Smart Ticket sample application illustrates this strategy.

Consequences
Re-use of Model components. The separation of model and view allows multiple views to use the same enterprise model. Consequently, an enterprise application's model components are easier to implement, test, and maintain, since all access to the model goes through these components.

Easier support for new types of clients. To support a new type of client, you simply write a view and some controller logic and wire them into the existing enterprise application.

Increased design complexity. This pattern introduces some extra classes due to the separation of model, view, and controller.

J2EE

http://java.sun.com/javaee/

Java Platform, Enterprise Edition (Java EE) builds on the solid foundation of Java Platform, Standard Edition (Java SE) and is the industry standard for implementing enterprise-class service-oriented architecture (SOA) and next-generation web applications. The SDKs contain Sun GlassFish Enterprise Server, previously named Sun Java System Application Server, and provide support for Java EE 5 specifications.

EJB

http://java.sun.com/products/ejb/

Enterprise JavaBeans (EJB) technology is the server-side component architecture for Java Platform, Enterprise Edition (Java EE). EJB technology enables rapid and simplified development of distributed, transactional, secure and portable applications based on Java technology.

EJB 3.0 Specification Final Release
This specification defines the new simplified EJB API targeted at ease of development. It also includes the new Java Persistence API for the management of persistence and object/relational mapping with Java EE and Java SE.

Java Persistence API
The Java Persistence API is the standard API for the management of persistence and object/relational mapping. It provides an object/relational mapping facility for application developers using a Java domain model to manage a relational database. The Java Persistence API is part of the Java EE platform. It can also be used in Java SE environments.

EJB 2.1 specification
This spec, created under the Java Community Process (JCP), enhances EJB architecture with support for Web services, making it easier to implement and deploy Web services applications based on Java technology.

Spring Framework

www.springframework.org

Spring is a layered Java/J2EE application framework, based on code published in Expert One-on-One J2EE Design and Development by Rod Johnson (Wrox, 2002).

Spring includes:

The most complete lightweight container, providing centralized, automated configuration and wiring of your application objects. The container is non-invasive, capable of assembling a complex system from a set of loosely-coupled components (POJOs) in a consistent and transparent fashion. The container brings agility and leverage, and improves application testability and scalability by allowing software components to be first developed and tested in isolation, then scaled up for deployment in any environment (J2SE or J2EE).

A common abstraction layer for transaction management, allowing for pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Generic strategies for JTA and a single JDBC DataSource are included. In contrast to plain JTA or EJB CMT, Spring's transaction support is not tied to J2EE environments.

A JDBC abstraction layer that offers a meaningful exception hierarchy (no more pulling vendor codes out of SQLException), simplifies error handling, and greatly reduces the amount of code you'll need to write. You'll never need to write another finally block to use JDBC again. The JDBC-oriented exceptions comply to Spring's generic DAO exception hierarchy.

Integration with Toplink, Hibernate, JDO, and iBATIS SQL Maps: in terms of resource holders, DAO implementation support, and transaction strategies. First-class Hibernate support with lots of IoC convenience features, addressing many typical Hibernate integration issues. All of these comply to Spring's generic transaction and DAO exception hierarchies.

AOP functionality, fully integrated into Spring configuration management. You can AOP-enable any object managed by Spring, adding aspects such as declarative transaction management. With Spring, you can have declarative transaction management without EJB... even without JTA, if you're using a single database in Tomcat or another web container without JTA support.

A flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework, like Struts, WebWork, or Tapestry.
You can use all of Spring's functionality in any J2EE server, and most of it also in non-managed environments. A central focus of Spring is to allow for reusable business and data access objects that are not tied to specific J2EE services. Such objects can be reused across J2EE environments (web or EJB), standalone applications, test environments, etc without any hassle.

Spring's layered architecture gives you a lot of flexibility. All its functionality builds on lower levels. So you can e.g. use the JavaBeans configuration management without using the MVC framework or AOP support. But if you use the web MVC framework or AOP support, you'll find they build on the configuration framework, so you can apply your knowledge about it immediately.

Perl

www.perl.org

Perl Facts
Perl is a stable, cross platform programming language.
It is used for mission critical projects in the public and private sectors.
Perl is Open Source software, licensed under its Artistic License, or the GNU General Public License (GPL).
Perl was created by Larry Wall.
Perl 1.0 was released to usenet's alt.comp.sources in 1987
PC Magazine named Perl a finalist for its 1998 Technical Excellence Award in the Development Tool category.
Perl is listed in the Oxford English Dictionary.
Supported Operating Systems
Unix systems
Macintosh - (OS 7-9 and X) see The MacPerl Pages.
Windows - see ActiveState Tools Corp.
VMS
And many more...
Perl Features
Perl takes the best features from other languages, such as C, awk, sed, sh, and BASIC, among others.
Perls database integration interface (DBI) supports third-party databases including Oracle, Sybase, Postgres, MySQL and others.
Perl works with HTML, XML, and other mark-up languages.
Perl supports Unicode.
Perl is Y2K compliant.
Perl supports both procedural and object-oriented programming.
Perl interfaces with external C/C++ libraries through XS or SWIG.
Perl is extensible. There are over 500 third party modules available from the Comprehensive Perl Archive Network (CPAN).
The Perl interpreter can be embedded into other systems.
Perl and the Web
Perl is the most popular web programming language due to its text manipulation capabilities and rapid development cycle.
Perl is widely known as " the duct-tape of the Internet".
Perl's CGI.pm module, part of Perl's standard distribution, makes handling HTML forms simple.
Perl can handle encrypted Web data, including e-commerce transactions.
Perl can be embedded into web servers to speed up processing by as much as 2000%.
mod_perl allows the Apache web server to embed a Perl interpreter.
Perl's DBI package makes web-database integration easy.

PHP

www.php.net

PHP is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. If you are new to PHP and want to get some idea of how it works, try the introductory tutorial. After that, check out the online manual, and the example archive sites and some of the other resources available in the links section.

REST

Representational state transfer (REST) is a style of software architecture for distributed hypermedia systems such as the World Wide Web. The terms “representational state transfer” and “REST” were introduced in 2000 in the doctoral dissertation of Roy Fielding,[1] one of the principal authors of the Hypertext Transfer Protocol (HTTP) specification. The terms have since come into widespread use in the networking community.

REST strictly refers to a collection of network architecture principles which outline how resources are defined and addressed. The term is often used in a looser sense to describe any simple interface which transmits domain-specific data over HTTP without an additional messaging layer such as SOAP or session tracking via HTTP cookies. These two meanings can conflict as well as overlap. It is possible to design any large software system in accordance with Fielding’s REST architectural style without using HTTP and without interacting with the World Wide Web.[citation needed] It is also possible to design simple XML+HTTP interfaces which do not conform to REST principles, and instead follow a model of remote procedure call. The difference between the uses of the term “REST” therefore causes some confusion in technical discussions.

Systems which follow Fielding’s REST principles are often referred to as “RESTful”.

http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm

Struts Framework

http://struts.apache.org/

Apache Struts is a free open-source framework for creating Java web applications.

Web applications differ from conventional websites in that web applications can create a dynamic response. Many websites deliver only static pages. A web application can interact with databases and business logic engines to customize a response.

Web applications based on JavaServer Pages sometimes commingle database code, page design code, and control flow code. In practice, we find that unless these concerns are separated, larger applications become difficult to maintain.

One way to separate concerns in a software application is to use a Model-View-Controller (MVC) architecture. The Model represents the business or database code, the View represents the page design code, and the Controller represents the navigational code. The Struts framework is designed to help developers create web applications that utilize a MVC architecture.

The framework provides three key components:

A "request" handler provided by the application developer that is mapped to a standard URI.
A "response" handler that transfers control to another resource which completes the response.
A tag library that helps developers create interactive form-based applications with server pages.
The framework's architecture and tags are buzzword compliant. Struts works well with conventional REST applications and with nouveau technologies like SOAP and AJAX.

Ruby on Rails

www.rubyonrails.org

Rails is a full-stack framework for developing database-backed web applications according to the Model-View-Control pattern. From the Ajax in the view, to the request and response in the controller, to the domain model wrapping the database, Rails gives you a pure-Ruby development environment. To go live, all you need to add is a database and a web server.

Hibernate

www.hibernate.org

Hibernate is a powerful, high performance object/relational persistence and query service. Hibernate lets you develop persistent classes following object-oriented idiom - including association, inheritance, polymorphism, composition, and collections. Hibernate allows you to express queries in its own portable SQL extension (HQL), as well as in native SQL, or with an object-oriented Criteria and Example API.

Unlike many other persistence solutions, Hibernate does not hide the power of SQL from you and guarantees that your investment in relational technology and knowledge is as valid as always. The LGPL open source license allows the use of Hibernate and NHibernate in open source and commercial projects.