Welcome to the Plugins Application Extensibility Framework community site

http://plugins.codeplex.com/SourceControl/ListDownloadableCommits.aspx

The Application Extensibility Framework is designed to make it easier to develop extensible applications using a service-oriented architecture approach. It can be used to create abstract core safely extended by user plugins extensions as application services.

Plugins Application Extensibility Framework is a new framework library in .NET designed for small .NET applications.
It allows development of fast, lightweight .NET applications for multi-processor systems.

Plugins targets:

Robustness
In any complex system, a failure in a sub-part of the system has the potential of bringing down the whole system. The reason is that a partial failure can lead to a catastrophic failure if it cannot be properly isolated, detected, and handled. Loose coupling is a design pattern that often is invoked as a way of limiting the impact of partial failures. However, in order to build loosely coupled systems, each component must be isolated from all other components as well as from the underlying runtime environment.

Composability
The requirement of robustness forces applications to become compositions of loosely coupled components. This raises the additional problem of how to identify, locate, and compose such components into a running application. Most traditional systems define an application as a single process and not as a composition of loosely coupled services working together leaving the task of composition to the application designer. Plugins provides runtime support for creating, managing, deploying, and running applications that are composed of loosely coupled services.

Asynchrony
When communicating between loosely coupled software components, like programs running across the network, or User Interface (UI) code communicating with the user input and the file I/O subsystem, asynchronous operations enable the code to scale better, be more responsive, and deal with failure across multiple operations. Asynchronous programming however, considerably reduces the readability of user code, since logic is often split between callbacks and the code that originates the operation. In addition, it is an almost impossible task to correctly handle failure across multiple outstanding operations.

Concurrency
Code that needs to better utilize multiple execution resources, must be split into independent logical segments, that can run in parallel, and communicate when necessary to produce results from the combined execution. Often, that logical segment is captured by the thread OS primitive, that is nothing more than a long lived iteration. Because of thread performance implications on thread startup, the thread stays active for long periods of time. This forces a particular pattern. Code is structured as long sequences that use blocking or synchronous calls, and only deals with one thing at a time. Further, threads assume that the primary communication between them is shared memory, forcing the programmer to use very explicit, error-prone methods to synchronize access to that shared memory.

Plugins framework library benefits:

• parallelizm
• extensibility
• configurability
• serialization

Plugins framework library supports:

• abstraction / utilization for high-level abstractions of an application (classes, interfaces)
• isolation / indirect processing of objects and services
• activation / deactivation for objects, hosts and services
• load / unload of application configuration using XML configuration files or API

Plugins Application Extensibility Framework is in development. The source available on this site. If you are downloading the source, consider it a preview of where we are at currently. I welcome any feedback you have on your experience.

Sincerely yours,
hack2root