I created this glossary of terms while learning JBoss Seam. It covers a lot of different topics. Thought someone else might find it useful. Most of it is copied from the wikipedia and other reference material.

Terms Glossary

Design Patterns

Factory pattern        (aka Abstract factory pattern): a software design pattern that provides a way to encapsulate a group of individual factories that have a common them. The client does not know (or care) about which concrete objects it gets from each of these internal factories since it uses only the generic interfaces of their products. This pattern separates the details of implementation of a set of objects from its general usage.

Factory Method pattern    an object-oriented design pattern (specifically, a creational pattern). It deals with the problem of creating objects without specifying the exact cloass of objct that will be created. The pattern handles the problem by defining a separate method for creating the objects, whose subclasses can then override to specify the derived type of product that will be created. The term factory method is often used to refer to any method whose main purpose is the creation of objects.

Singleton pattern               a design pattern that is used to retrict instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system.

Prototype pattern    a creational design pattern used when the type of object to create is determined by a prototypical instance, which is cloned to produce new objects.

Domain model pattern       a web of interconnected objects, where each object represents some meaningful individual, whether as large as a corporation or as small as a single line on an order form.

Software Concepts

Persistence               refers to the characteristic of data that outlives the execution of the program that creatied it. Without this capability, data only exists in RAM, and will be lost when the memory loses power. Achieved in practice by storing data in non-volatile storage such as a file system or relational database. Design patterns which solve the persistence problem are container based persistence, component based persistence, and the Data Access Object model. Java examples include using serialization to store Objects on disk or using JEE to store EJBs in a relational database.

Serialization    (aka deflating, marshalling): the process of converting an object into a sequence of bits so that it can be stored on a storage medium (such as a file or memory buffer) or transmitted across a network connection link. When the resulting series of bits is reread according to the serialization format, it can be used to create an identical clone of the original object. The opposite operation is called deserialization, inflating and unmarshalling.

DAO       Data Access Object: an object that provides an abstract interface to some type of database or persistence mechanism, providing some specific operations without exposing details of the database. This pattern separates the public interface of the DAO (application data objects and data types) from the implementation (DBMS, schema, …)

DI          Dependency injection: the process of supplying an external dependency to a software component. It is a specific form of Inversion of Control (IOC) where the concern being inverted is the process of obtaining the needed dependency. DI promotes loose coupling and convenient unit testing. There are three ways an oject can get a reference to an external module: 1) interface injection, the exported module provides an interface that its users must implement in order to get the dependencies at runtime, 2) setter injection, the dependent modue exposes a setter method which the framework uses to inject the dependency, and 3) constructor injection, the dependencies are provided through the class constructor.

IOC        Inversion of Control: an abstract principle describing an aspect of some software architecture designs in which the flow of control of a system is inverted in comparison to the traditional architecture of software libraries. Examples include event driven programming, or the use of call-back methods to allow the caller of a method to determine specific procedures.

AOP       Aspect Oriented Programming: is a programming paradigm that increases modularity by allowing the separation of cross-cutting concerns, forming a basis for Aspect-oriented software development. Logging is the archetypal example of a crosscutting concern because a logging strategy necessarily affects every single logged part of the system. Logging thereby crosscuts all logged classes and methods.

Domain Model a conceptual model of a system which describes the various entities involved in that system and their relationships. The domain model is created in order to document the key concepts, and the domain-vocabulary of the system being modelled. The model identifies the relationships among all major entities within the system, and usually identifies their important methods and attributes.

Layered architecture         Layering is a way of organizing an application’s classes by concern. Layers communicate from top to bottom and a layer is unaware of any other layers except for the one just below it. A typical layered architecture uses three layers: presentation, business logic, persistence.

RELATIONAL DATABASE Concepts

Data independence  the principle that a relational database is not specific to a particular application. Data lives longer than any application does.

DDL        Data Definition Language: subset of the SQL language consisting of CREATE and ALTER statements for creating a database schema.

DML       Data Manipulation Language: a subset of the SQL language consisting of manipulation operations including insertions, updates, and deletions.

UDT        User Defined Types: a concept in SQL databases allowing for users to define new non-trivial datatypes for use as database columns. UDT support is one of a number of object-relational extensions to traditional SQL. However, in practice, UDT is an obscure feature of most RDBMS and is not portable between systems.

Surrogate key          a primary key column with no meaning to the user; i.e. a key that isn’t presented to the user and is only used for identification of data. The main purpose of a surrogate key is to eliminate any of the row’s data columns from serving as the key to the row’s identity. Attaching the row’s identity to a field makes it difficult to change the value of the field since it might be referenced as a foreign key by another table.

Object Oriented Concepts

Object/relational paradigm mismatch: the idea that object-oriented programming objects and relational database structures are fundamentally different and the clash between the two negatively affects productivity. The mismatch incudes the following problems:

Granularity Problem: Java allows any number of different levels of granularity of Classes, for example, coarse-grained Users, fine-grained Addresses, and POJO String Zip Code. In contrast an RDBMS provides only two levels of granularity: tables and columns.

Inheritance Problem: SQL does not provide a means of defining supertables and subtables, hence there is no straightforward way to duplicate the Java concept of inheritance from superclasses to subclasses

Polymorphism Problem:  A related problem is that of polymorphism. The Java concept is that an object may be defined to have a reference to a superclass and be able to reference any of the subclasses at runtime. SQL does not provide a means of writing polymorphic queries. A database foreign key cannot refer to multiple tables.

Identity Problem: Java’s definition of sameness differs from SQL’s. In Java, two objects have the same identity if they occupy the same memory location (a == b) or if their values are equal (a.equals(b)). In SQL, a row’s identity in a table is determined by the primary key.

Association Problem: Association mapping and the management of entity associations are central concepts in any object persistence solution. Java represents associations using object references, but in a relational database, an association is represented as a foreign key column.Object references are navigational and inherently directional. Foreign key associations are not directional. There is no concept of relational navigation because you can create arbitrary associations with table joins. Java associations can have many-to-many multiplicity. In a relational database, multiplicity is one-to-one or one-to-many, unless you create a link table to facilitate a many-to-many association.

Navigation Problem: In Java, you walk the object network to navigate from an object to associated data (aUser.getBillingDetails().getAcctNum()). In a relational database, you attempt to minimize the number of SQL queries to improve performance, so typically you navigate by retrieving all data then navigating to the rows you want. In Java, you locate the specific instance and then retrieve the data.

Modeling Problem: If you design a Java application to match the limitations imposed by a relational database, you lose some of the advantages of object orientation. However, as we’ve seen, there is often no practical way to design a relational database schema to mirror an existing object oriented application.

 

ORM       Object-relational mapping (aka O/RM, O/R mapping): programming technique for converting data between incompatible type systems in relational databases and object-oriented programming languages

Factory object          In an object-oriented programming language, a Factory object is an object for creating other objects. It is an abstraction of a constructor and can be used to implement various allocation schemes, such as the singleton pattern. A factory object typically has a method for every kind of object it is capable of creating. These methods optionally accept parameters defining how the object I created, and then return the created object.

Polymorphism          a programming language feature that allows values of different data types to be handled using a single uniform interface. In object-oriented programming, polymorphism is a concept wherein a name may denote instances of many different classes as long as they are related by some common super class.

OODB     Object Oriented Database Systems (OODBMS): Object oriented databases were an attempt to eliminate the object relational paradigm mismatch by designing a database to fit the object-oriented model. Object oriented databases have not been widely adopted and it is not likely they wll be, mostly due to predefined deployment environments and the common requirement for data independence.

Software Platforms & Applications

Web Server              a computer program that is responsible for accepting HTTP requests from clients (such as web browsers) and serving them HTTP responses along with optional data contents (such as HTML documents and linked objects). Top 5 web servers are Apache, MS IIS, Google GWS, lighttpd, nginx, and Oversee.

Application Server    a server that hosts an API to expose business logic and business processes for use by third-party applications. Sometimes used to refer to a Java EE application server, including JBoss (Red Hat), WebSphere Application Server (IBM), Sybase Enterprise Application Server (Sybase), WebLogic Server (BEA), Jrun (Adobe), Apache Geronimo (Apache Software Foundation), Oracle OC4J (Oracle), Sun Java System Application Server (Sun), SAP Netweaver AS (SAP), and Glassfish Application Server (based on the Sun Java System Application Server). Microsoft’s contribution to application servers is the .NET Framework.

Servlet Container (aka Web Container, Web Engine): a specialized web server that supports Servlet execution, combining the basic functionality of a web server with certain Java/Servlet specific optimizations and extensions, and the ability to translate specific URLs into Servlet requests. Servlet containers include: Apache Tomcat (ASF), Jetty, BEA WebLogic Server (aka WebLogic Express), Borland Enterprise Server, GlassFish, Java System Application Server (Sun), JBoss, JRun (Adobe), LiteWebServer, Oracle Application Server, Orion Application Server (IronFlare), WebObjects (Apple), WebSphere (IBM), Netweaver (SAP).

Apache  Apache HTTP Server: an open source, free web server developed and maintained by an open community of developers under the name Apache Software Foudnation. The most popular HTTP server on the web, serving over 51% of all websites. http://www.apache.org.

JBoss     JBoss application server: a free, open source Java EE-based application server. The JBoss application server is cross-platform: usable on any OS that Java supports. http://www.jboss.org.

Tomcat  Apache Tomcat:  a servlet container deployed by the Apache Software Foundation. It implements the Java Servlet and JavaServer Pages (JSP) specifications, and provides a pure Java HTTP web server environment for Java code to run.

LAMP     Lamp web server application stack: Linux, Apache, MySQL/mSQL, Php/Perl/Python/Ruby.

AndroMDA       a tool that generates POJO source code from UML diagram-files.

Java

POJO     Plain Old Java Object: an ordinary Java Object, not a special object.

Reflection        the Java Reflection API allows a Java application to get the definition of classes and operate on them at runtime without having them available at compile time. That allows the easy creation of applications that wouldn’t otherwise be possible. For example, you can use the Reflection API to inspect objects, browse classes, and create callback methods, such as event handlers, without extending a specific class or implementing an interface. Hibernate uses reflection to create Java Objects that have been established as mapping to database entities.

Servlet   Java programming language objects that dynamically process requests and construct responses. Servlets are the Java counterpart to dynamic Web content technologies such as PHP, CGI, and ASP.NET. Servlets can maintain state across server transactions via HTTP cookies, session varialbes or URL rewriting. Compiling a JSP generates a Servlet.

SLF4J    Simple Logging Façade for Java: various logging APIs allowing the end-user to plug in the desired implementation at deployment tiem. Includes an advanced abstraction of various logging systems, including JDK 1.4 logging, log4j and logback. http://www.slf4j.org

J2ME      Java Platform, Micro Edition (aka Java ME): specification of a subset of the Java platform aimed at providing a certified collection of Java APIs for the development of software for tiny, small and resource-constrained devices (e.g. cell phones, PDAs, set-top boxes).

EJB         Enterprise JavaBean: managed, server-side component architecture for modular construction of enterprise applications. One of several Java APIs in the JEE, it is a server-side model that encapsulates the business logic of an application. It intends to provide a standard way to implement the back-end business code typically found in enterprise applications (as opposed to the front-end user-interface code). Enterprise JavaBeans were intended to handle such common concerns as persistence, transactional integrity, and security in a standard way, leaving programmers free to concentrate on the particular problem at hand.

EJB 3.0  Reinvention of EJB which eliminated virtually all complaints with the original version and EJB 2, and made EJB a practical alternative to Spring.

JPA        Java Persistence API: a Java programming language framework that allows developers to manager relational data in Java SE and Java EE applications.

JTA        Java Transaction API: one of the Java EE APIs allowing distributed transactions to be done across multiple XA resources. JTA provides for demarcation of transaction boundaries, and X/Open XA API allowing resources to participate in transactions.

JDBC      Java Database Connectivity API: how Java issues SQL statements to the database.

JNDI      Java Naming and Directory Interface: a Java API for a directory service that allows Java software clients to discover and look up data and objects via a name. The API provides a mechanism for binding an object to a name, a directory lookup interface that allows general queries, an event interface that allows clients to determine when directory entries have been modified, and LDAP extensions.

JMX        Java Management Extensions: a Java technology that supplies tools for managing and monitoring applications, system objects, devices and service-oriented networks. Those resources are represented by objects called MBeans (managed beans). In the API, classes can be dynamically loaded and instantiated.

Entity Bean     a type of Enterprise JavaBean (EJB3.0), a server-side Java EE component, that represents persistent data maintained in a database. An entity bean can manage its own persistence (Bean managed persistence) or can delegate this function to its EJB Container (Container managed persistence). An entity bean is identified by a primary key. If the container in which an entity bean is hosted crashes, the entity bean, its primary key, and any remote references survive the crash.

Session Bean  a type of Enterprise Bean. In the Java EE architecture, the other two types are Entity Beans and Message-driven beans. Contrary to Entity Beans which represent persistent data maintained in a database, a Session Bean implements a business task and is hosted by an EJB container. A Session Bean is created by a client and usually exists only for the duration of a single client-server session. A session bean performs operations, such as calculations or database access, for the client. Although a session bean can be transactional, it is not recoverable should a system crash occur. Session bean objects either can be stateless or can maintain conversational state across methods and transactions. If a session bean maintains state, then the EJB container manages this state if the object must be removed from memory. However, the session bean object itself must manage its own persistent data.

EntityManager                    Interface used to interact with the persistence context. An EntityManager instance is associated with a persistence context. A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. Within the persistence context, the entity instances and their lifecycle are managed. This interface defines the methods that are used to interact with the persistence context. The EntityManager API is used to create and remove persistent entity instances, to find entities by their primary key, and to query over entities. The set of entities that can be managed by a given EntityManager instance is defined by a persistence unit. A persistence unit defines the set of all classes that are related or grouped by the application, and which must be colocated in their mapping to a single database.

JSF Navigation Rule Java Server Faces uses navigation rules established in the application configuration file to determine the page flow in the application. For simple applications Seam lets you return the JSF page name as the outcome of a method, eliminating the requirement for a navigation rule.

Facelets JavaServer Faces View Definition Framework: View page for a Seam application, an alternative to JSP – supports JSF.

Hibernate

Hibernate        a free, open source ORM library for Java, providing a framework for mapping an object oriented domain model to a traditional relational database. It replaces direct persistence-related database accesses with high-level object handling functions. Hibernate delivers database portability to all supported SQL databases with very little performance overhead. Some benefits of using ORM and Hibernate are:

Productivity: Hibernate eliminates the grunt work of repetitive and redundant SQL queries, allowing developers to focus on the business problems.

Maintainability: Fewer lines of code make a system more understandable and easier to refactor. Also, ORM provides a buffer between the object model and the relational model reducing the number of minor changes that must be made to each model to accommodate changes to the other.

Performance: Hibernate allows many optimzations to be used all the time across all database platforms without requiring hand-tuning optimization.

Vendor Independence: An ORM removes dependency on a specific database platform.

Hibernate Configuration File       typically an XML file named hibernate.cfg.xml which specifies database connection info, JDBC connection pool info, SQL variant (dialect), session context management, caching, mapping resource files, and other options. The file configures Hibernate’s SessionFactory – a global factory responsible for a particular database. Multiple databases require multiple <session-factory> configurations, usually in separate configuration files. The file needs to reside in the root of the classpath, on startup.

Hibernate Mapping File                typically an xml file which tells Hibernate what table in the database it has to access and what columns in that table it should use, along with the corresponding mappings to Java classes and variables. Usually there is a separate mapping file for each table/class. By convention, each mapping file is named <<Class>>.hbm.xml.

Hibernate Mapping Types  converter types within Hibernate that are not Java data types and not SQL database types. These types can translate from Java to SQL data types and vice versa. A mapping file may specify the type attribute for any given element. If an element does not have a type attribute, then Hibernate will try to determine the correct type conversion.

HQL       Hibernate Query Language: object-oriented query language for retrieval and management of data in Hibernate.

Open Session in View        a Hibernate pattern in which the Hibernate session is kept open until the application view has been rendered. This is one method of solving a typical web (JSP) view related issue: the view is rendered after the main logic of the action has been completed and the database transaction has ended, resulting in detached objects and unloaded collections (potentially leading to a closed-session LazyInitializationException).

Transient state         an object is transient if it has just been instantiated using the new operator and is not associated with a Hibernate Session. It has no persistence.

Persistent state       a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however it is in the scope of a Session. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes.

Detached state         a Hibernate Java object that has been persistent, but its Session has been closed. The reference to the object is still valid, and the detached instance might even be modified in this state. A detached instance can be reattached to a new Session a later point in time, making it persistent again. This feature enables a programming model for long running units of work that require user-think time.

Session  single-threaded nonshared object that represents a particular unit of work with the database. It has the persistence manager API you call to load and store objects.

Transaction     There are four options for a transaction API for setting transaction boundaries programmatically: Hibernate Transaction API, JDBC transaction demarcation, JTA interface, container-managed transactions with EJBs.

Query    The Query interface allows you to create queries, bind arguments to placeholders in the query, and execute the query in various ways.

Automatic dirty checking   a feature that saves the programmer the effort of explicitly asking Hibernate to update the database when the state of any object is modified inside a unit of work.

Cascading save        a feature that saves the programmer the effort of explicitly making a new obect persistent by calling save(), as long as it’s reachable by an already persistent interface.

Transacational write-behind       a sophisticated algorithm to determine an efficient ordering that avoids database foreign key constraint violations but is still sufficiently predictable to the user.

Spring

Spring Framework   open source application framework for the Java platform and .NET platform. It is popular in the Java community as a replacement for, alternative to, or addition to the Enterprise JavaBean (EJB3.0) model and was developed initially as a reaction against complexities of the original EJB.