CushionTheBlow (구 BluemoonSoft)

A software framework is "the skeleton of an application that can be customized by an application developer". Like software libraries, it aids the software developer by containing source code that solves problems for a given domain and provides a simple API. However, while a code library acts like a servant to other programs, software frameworks reverse the maservant relationship. This reversal, called inversion of control, is the essence of software frameworks. Another software framework can help build compilers for different programming languages and target machines. Yet another might help build financial modeling applications or decision support systems. There are frameworks for multimedia, web applications, and even communicating between different systems.

Architecture
According to Pree, software frameworks consist of frozen spots and hot spots. On the one hand, frozen spots define the overall architecture of a software system, that is to say its basic components and the relationships between them. These remain unchanged (frozen) in any instantiation of the application framework. On the other hand, hot spots represent those parts where the programmers using the framework add their own code to add the functionality specific to their own project.

Software frameworks define the places in the architecture where adaptations for specific functionality should be made - the hot spots. In an object-oriented environment, a framework consists of abstract and concrete classes. Instantiation of such a framework consists of composing and subclassing the existing classes.

When developing a concrete software system with a software framework, the hot spots are specialized according to the specific needs and requirements of the system. Software frameworks rely on the Hollywood Principle: "Don’t call us, we’ll call you." This means that the user-defined classes (for example, new subclasses), receive messages from the predefined framework classes. These are usually handled by implementing superclass abstract methods.

List of general purpose frameworks
- BFC is a RAD framework for developing database-centric distributed computing applications in a .NET environment.
- CNI (Compiled Native Interface) is a software framework for the GNU GCJ compiler which allows Java code to call and be called by native applications (programs specific to a hardware and operating system platform) and libraries written in C++.
- Component-based Scalable Logical Architecture (CSLA) is a standard way to create robust object oriented programs using business objects, implemented using .NET.
- Java Native Interface (JNI) allows Java code running in the Java virtual machine (VM) to call and be called by native applications (programs specific to a hardware and operating system platform) and libraries written in other languages, such as C, C++ and assembly.
- Leonardi is an open source application framework for GUI applications
- Spring is an open source application framework for the Java platform.
- Symfony is a popular open source application framework for PHP Platform.
- Rails is a libre software application framework for the Ruby Platform.

Reference:
http://en.wikipedia.org/wiki/Software_framework

Leonardi is an open source, model-driven software framework that allows implementing graphical user interface oriented applications. Leonardi is the copyright of the French ISV Lyria.

Principles
Leonardi is a framework based on a model describing the information system. This model is enriched with both presentation specific information and data connectors. Next, business specific rules and behaviors can possibly be added using the Java language. Eventually, the application is deployed, either as a DHTML/Ajax GUI, an Eclipse (software) plug-in, an RCP or a Swing (Java) desktop application.

The originality of Leonardi is twofold. First, the framework applies the concepts of Model-driven engineering to the specific field of GUIs. Second, its execution engine allows dynamically generating, at run time, the screens requested by the end-user, based on the current status of the data that is dealt with.

The Leonardi business model contains connector specific configuration, which indicates where data persists and how to cache it. Standard connectors include flat files, various DBMS, Corba, EJB or LDAP. The model also includes the concept of display manager, that allows deploying the software in different types of graphical environments (Web Ajax, Swing, SWT, Eclipse RCP…).

On the one hand, Leonardi differs from 4GLs by offering richer functional features for user interface purposes, which allows it to be used in management systems as well as in technical applications. On the second hand, Leonardi is different from the traditional software environments that implement the MDA approach by not generating code. Instead, the engine executes the model on the fly, addressing the three MVC layers (Model, View and Control) classically dealt with in GUI applications.

Leonardi is often used as a RAD tool, but it also addresses the needs of application migration and modernization, by providing a technology independent approach. It can also be used in more complex projects. It is fully based on underlying Java and XML technologies and consists of an extensible environment. In its latest release (V4.0), Leonardi is licensed under the terms of the GNU General Public License (GPL).

Use
Leonardi fits various computer based information systems related contexts: RAD, application migration or complex projects. It is used in different sectors, including defense and security, transportation, energy, industry and telecommunications.

Leonardi is provided with a Studio tool that can be used to create the business model, or discover it from an existing structure. It can also generate specific DBMS schemas and includes, in release V4.0, a graphical builder.

Leonardi is licensed under the terms of the GNU General Public License. Lyria also sells value added packages of Leonardi.

Reference:
http://en.wikipedia.org/wiki/Leonardi_Framework

Component-based Scalable Logical Architecture (CSLA) is a software framework created by Rockford Lhotka that provides a standard way to create robust object oriented programs using business objects. Business objects are objects that abstract business entities in an object oriented program. Some examples of business entities include sales orders, employees, or invoices.

CSLA was originally targeted toward Visual Basic 6 in the book Visual Basic 6.0 Business Objects by Lhotka ISBN 1-86100-107-X. With the advent of Microsoft .NET, CSLA was completely rewritten from the ground up, with no code carried forward, and called CSLA.NET. This revision took advantage of Web Services and the fully object oriented languages that came with Microsoft .NET (in particular, Visual Basic.NET and C#).

CSLA.NET was expounded in Expert C# Business Objects ISBN 1-59059-344-8 and Expert One-on-One Visual Basic .NET Business Objects ISBN 1-59059-145-3, both written by Lhotka. (Although CSLA itself is free to download, the only documentation Lhotka provides is through his books.) Although CSLA and CSLA.NET were originally targeted toward Microsoft programming languages, most of the framework can be applied to most object oriented languages.

Reference:
http://en.wikipedia.org/wiki/Component-based_Scalable_Logical_Architecture

The GNU Compiler for Java (GCJ or gcj), a free-software compiler for the Java programming language, forms part of the GNU Compiler Collection. It can compile Java source code to either Java Virtual Machine bytecode, or directly to machine code for any of a number of CPU architectures. It can also compile class files containing bytecode or entire JARs containing such files into machine code. Almost all of the runtime-libraries used by gcj come from the GNU Classpath project (but compare the libgcj library). As of gcj 4.3, gcj integrates with ecj, the Eclipse Compiler for Java.

As of 2007 a lot of work has gone in to getting GNU Classpath to support Java's two graphical APIs: AWT and Swing. The programmers have almost achieved full support for both AWT and Swing, and it seems that soon users will no longer have to use the runtime provided by Sun Microsystems in order to run AWT/Swing applications.

CNI (Compiled Native Interface)
The CNI (Compiled Native Interface, previously Cygnus Native Interface), a software framework for the gcj, allows Java code to call and be called by native applications (programs specific to a hardware and operating-system platform) and libraries written in C++.

CNI closely resembles the Java Native Interface (JNI) framework which comes as standard with various Java virtual machines. However the CNI authors claim various advantages over JNI:

“ We use CNI because we think it is a better solution, especially for a Java implementation that is based on the idea that Java is just another programming language that can be implemented using standard compilation techniques. Given that, and the idea that languages implemented using Gcc should be compatible where it makes sense, it follows that the Java calling convention should be as similar as practical to that used for other languages, especially C++, since we can think of Java as a subset of C++. CNI is just a set of helper functions and conventions built on the idea that C++ and Java have the *same* calling convention and object layout; they are binary compatible. (This is a simplification, but close enough.) ”

CNI depends on Java classes appearing as C++ classes. For example, given a Java class,

public class Int {
   public int i;
   public Int (int i) { this.i = i; }
   public static Int zero = new Int(0);
}

one can use the class thus:

#include <gcj/cni.h>
#include <Int>
 
Int* mult(Int* p, jint k)
{
  if (k == 0)
    return Int::zero;  // Static member access.
  return new Int(p->i * k);
}

Reference:
http://en.wikipedia.org/wiki/GCJ

In formal language theory, a context-free grammar (CFG) is a grammar in which every production rule is of the form

V → w

where V is a single nonterminal symbol, and w is a string of terminals and/or nonterminals (possibly empty). The term "context-free" expresses the fact that nonterminals can be rewritten without regard to the context in which they occur. A formal language is context-free if some context-free grammar generates it.

Context-free grammars play a central role in the description and design of programming languages and compilers. They are also used for analyzing the syntax of natural languages.

Reference:
http://en.wikipedia.org/wiki/Context_free_grammar

A framework is a basic conceptual structure used to solve or address complex issues. This very broad definition has allowed the term to be used as a buzzword, especially in a software context.

Software framework
A software framework is a re-usable design for a software system (or subsystem). A software framework may include support programs, code libraries, a scripting language, or other software to help develop and glue together the different components of a software project. Various parts of the framework may be exposed through an API.

Reference:
http://en.wikipedia.org/wiki/Framework

Jini (pronounced like genie and also called Apache River) is a network architecture for the construction of distributed systems in the form of modular co-operating services.

Originally developed by Sun, responsibility for Jini is being transferred to Apache under the project name River.

Reference:
http://en.wikipedia.org/wiki/Jini