﻿<!DOCTYPE html>
<html>

 <head>
	<meta charset="UTF-8">
	<title>OSBP - Technology Partners</title>

	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description"
		content="The website of Eclipse OSBP, an open-source no-code and low-code development platform for business and enterprise applications">
	<meta name="author" content="(c) Compex Systemhaus GmbH, Germnany">

	<!--  styles -->
	<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
	<!--[if lt IE 9]>
	  <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
	<![endif]-->

	<!-- Le fav and touch icons -->
	<link rel="shortcut icon" href="images/OS-logo-32x32.jpg">

	<link href="css/bootstrap.css" rel="stylesheet" type='text/css'>
	<link href="css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
	<link href="css/shield-responsive.css" rel="stylesheet" type='text/css'>
	<link href='css/fonts.css' rel='stylesheet' type='text/css'>
	<link href="css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
	<link href="css/prettify.css" type="text/css" rel="stylesheet"/>
	<link href="css/style.css" rel="stylesheet" type='text/css'>

	<!-- cover flow -->
	<link href="css/coverflow.css" rel="stylesheet" type='text/css'>
	<!--[if lt IE 9]>
	  <link href="css/iebugs.css" rel="stylesheet" type='text/css'>
	<![endif]-->
</head>


<body>

  <!-- Google Tag Manager --  >
	<noscript><iframe src="//www.googletagmanager.com/ns.html?id=GTM-TGDS5S"
	height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
	<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
	new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
	j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
	'//www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
	})(window,document,'script','dataLayer','GTM-TGDS5S');</script>
  <!-- End Google Tag Manager -->

<header class="site-header">
  <!-- Navbar -->
  <div class="navbar navbar-fixed-top">
    <div class="navbar-inner">
      <div class="container">
        <a class="btn btn-navbar" data-toggle="collapse"
          data-target=".nav-collapse"> <span class="icon-bar"></span> <span
          class="icon-bar"></span> <span class="icon-bar"></span>
        </a> <a class="brand" href="index.html"></a>

		<div class="nav-collapse collapse" style="height: 0px;">
          <ul class="nav">
            <!--li ><a href="news.html">News</a></li-->
			<li ><a href="index.html">Home</a></li>
			<li ><a href="download.html">Download</a></li>
            <li ><a href="documentation.html">Documentation</a></li>
            <li ><a href="community.html">Community</a></li>
			<li ><a href="OS-bea-WG.html">OS.bea Working Group</a></li>
            <li class="dropdown">
              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Support &amp; Training<span class="caret"></span></a>
              <ul class="dropdown-menu">
                <li><a href="http://www.osbee.org/services/" target="_blank">OS.bee</a></li>
                <li><a href="http://www.compex-commerce.com/en/services/" target="_blank">Compex</a></li>
              </ul>
            </li>
          </ul>
        </div>
        </div>
    </div>
  </div>
  <!-- Navbar End -->
</header>

<!--Container-->
<div id="header_wrapper">
  <div class="container image-slider">
    <div class="row">
      <h2>
        Technolgy Partners
      </h2>
      <p>OSBP is based on extensible frameworks, tools and runtime environments for building, deploying and magaging software
	  applications across the lifecycle of business software development. OSBP allows software factory users to take advantage
	  of built-in 30+ OS frameworks, covering practically all different aspects of engineering business applications: presentation,
	  business logic, security, and data management tasks.
	  </p>
	  <br>
    </div>
  </div>
</div>


	<div id="zoo" class="container">
		<table class="table table-striped table-condensed">
  	        <thead>
  	        <tr>
  	          <th>Name</th>
  	          <th>Description</th>
  	        </tr>
			</thead>

  	        <tbody>
				<tr>
				  <td><a href="http://www.osbee.org/">Eclipse IDE</a></td>
				  <td><strong>
					Eclipse's ecosystem is building the base for the Open Standard business platform (OSBP). The Eclipse
					integrated development environment (IDE) is an open-source, robust, fully featured, commercial-quality industry platform
					for the development of highly integrated tools and applications. It contains a basic workspace and an extensible
					plug-in system for customizing the environment.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">OSGi Dynamic Module System </a></td>
				  <td><strong>
					OSBP offers modular architecture, based on the Open Service Gateway initiative (OSGi) uniform component model.
					From the complete set of available OSGi specifications, we selected the ones relevant to the business domain. The chosen
					composites provide high-level capabilities (packages, services, extenders, etc.) composed by modules upon which
					business applications can be built.
					<br>
					OSBP provides the developers with resources necessary to take advantage of OSGi's platform independence and dynamic
					code-loading capability. This helps to easily develop services for business applications that can be deployed on a large scale.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Equinox OSGi </a></td>
				  <td><strong>
					The Equinox project provides the OSGi-based runtime on which all of Eclipse is based, and allows developers to implement
					an application as a set of "bundles" using common services and infrastructure.
					Technically, Equinox is an implementation of the OSGi core framework specification, a set of bundles that implement
					various optional OSGi services and other infrastructure for running OSGi-based systems within Eclipse IDE.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">EMF Modeling Framework </a></td>
				  <td><strong>
					The EMF project is a modeling framework and code generation facility for building tools and other applications based on
					a structured data model. The core EMF framework includes a meta model (Ecore) for describing models and runtime support
					to produce Java classes for a model. EMF delivers the basis for model-driven software development with OSBP.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Xtext, Xtend, Xbase <br>Domain Specific Languages </a></td>
				  <td><strong>
					Xtext delivers the basis for model-driven software development with OSBP. It's an open-source framework for building
					structural domain-specific languages (DSL), developed as part of the Eclipse Modeling Framework (EMF) Project.
					<br><br>Xtext provides a powerful syntax-driven editor for editing grammars as well as compiler components including such
					things as the parser, the type-safe abstract syntax tree (AST), the serializer and code formatter, the scoping framework
					and the linking, compiler checks and static analysis aka validation and last but not least a code generator or
					interpreter. It comes with Xbase as a library of reusable methods and Xtend as a general-purpose language for the Java
					Virtual Machine which is built on top of this library.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Vaadin UI Components & Mobile </a></td>
				  <td><strong>
					Vaadin delivers a large collection of UI components for OSBP. It gives a great experience to users in their desktop
					browsers as well as on mobile or any other device, increases productivity and the ergonomics of your applications.
					<br><br>Vaadin is a web application framework for creating rich and interactive applications in Java that run in the browser,
					without any additional plug-ins. In contrast to JavaScript libraries and browser-plugin-based solutions, it features a
					server-side architecture, which means that the majority of the logic runs on the server. Ajax technology is used at the
					browser-side to ensure a rich and interactive user experience. On the client-side, Vaadin is built on top of and can be
					extended with the Google-Web-Toolkit.
					<br>Vaadin TouchKit is used to create the mobile UI supporting many special mobile browser features, such as geolocation, context-
					specific input fields, or offline mode.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Sirius Graphical Modeling  </a></td>
				  <td><strong>
					Sirius is an Eclipse project which allows to easily create own graphical modeling workbench by leveraging the Eclipse Modeling technologies.
					A modeling workbench created with Sirius is composed of a set of Eclipse editors (diagrams, tables and trees) which allow the users to
					create, edit and visualize EMF models.
					<br><br>The editors are defined by a model which defines the complete structure of the modeling workbench, its behavior and all the edition
					and navigation tools. This description of a Sirius modeling workbench is dynamically interpreted by a runtime within the Eclipse IDE.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Mondrian <br>(by Pentaho) Business Intelligence  </a></td>
				  <td><strong>
					Mondrian is an Open Source Business Analytics engine that enables organizations of any size to give business users
					access to their data for interactive analysis. It allows multidimensional analysis of large and complex amounts of
					data in real-time.<br><br>
					With Mondrian as Online Analytical Processing (OLAP) engine, OSBP provides Business Intelligence features, enabling
					multidimensional queries against business data, using the powerful MDX query language.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Apache Shiro Security  </a></td>
				  <td><strong>
					Apache Shiro is a powerful and easy-to-use Java security framework that performs authentication, authorization,
					cryptography and session management in OSBP. It enables to quickly and easily secure any application – from the
					smallest mobile applets to the largest web and enterprise applications.
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">BIRT Report Generator  </a></td>
				  <td><strong>
					The Business-Intelligence-and-Reporting-Tools (BIRT) is an open source software project that provides reporting
					and business-intelligence capabilities for rich-client and Web applications. BIRT is a top-level software project
					within the Eclipse Foundation, an independent, not-for-profit consortium of software industry vendors and the
					open-source community. In OSBP BIRT is used to address a wide range of reporting needs within a typical
					application, ranging from operational or enterprise reporting to multi-dimensional online analytical processing (OLAP).
				  </strong>
				  <br><br>
				  </td>


				</tr>

				<tr>
				  <td><a href="http://www.osbee.org/">Eclipse link Persistence  </a></td>
				  <td><strong>
					The EclipseLink project delivers a comprehensive, open-source Java persistence solution addressing relational,
					XML and database Web services. The EclipseLink Java Persistence API (JPA) provides support for leading relational
					databases and Java containers.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Gemini OSGi persistence services  </a></td>
				  <td><strong>
					OSBP utilizes Eclipse Gemini project for modular Java EE implementations. This project is a collection of
					implementations of some of the OSGi Enterprise specifications. Several sub-projects are used to provide unique functionality.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Gemini Naming Data Sources </a></td>
				  <td><strong>
					Gemini Naming is a subproject of the Gemini project, which provides a suite of enterprise technology modules.
					The Gemini Naming project implements support for using the Java Naming and Directory Interface™ (JNDI) within
					an OSGi environment. It provides a common framework for publishing JNDI providers as OSGi services, and
					then allows JNDI clients to easily consume these providers.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Gemini JPA </a></td>
				  <td><strong>
					The Gemini JPA project is about modular implementations of Java Persistence API technology. This project
					currently provides the integration with the EclipseLink JPA provider to support the OSGi JPA specification
					approach that clients can use to get JPA support in an OSGi framework.
				  </strong>
				  <br><br>
				  </td>



				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Apache ActiveMQ Messaging Service </a></td>
				  <td><strong>
					Apache ActiveMQ™ is the most popular and powerful open source messaging and Integration Patterns server,
					fully implementing Java Message Service (JMS).
					It enables distributed communication of application components that is loosely coupled, reliable, and
					asynchronous. ActiveMQ is fast, supports a variety of cross language clients and protocols, and comes with easy
					to use enterprise integration patterns and many advanced features.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Smooks Data Integration </a></td>
				  <td><strong>
					Smooks is an extensible framework for processing structured data (XML and non XML, such as CSV, EDI, Java, etc).
					It supports binding of Java Object Models from any data source, message splitting & routing and huge message
					processing. With Smooks OSBP provides data interchange functionality in order to extract, transform and load data (ETL).
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">UOMo Units of Measurement  </a></td>
				  <td><strong>
					UOMo adds units of measurement support for IT systems and services both to language and data. With UOMo developers
					do not need to understand the mathematics of units, how to convert between systems, and how to format and parse
					string representations of units. It’s all delivered automatically with OSBP.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">TapiJI Internationalization (I18N)  </a></td>
				  <td><strong>
					TapiJI represents a set of smart tools that integrate OSBP with the goal to reduce effort of internationalization.
					This is accomplished by creating a productive environment for building multilingual applications. TapiJI tools, recently
					contributed to Eclipse Babel project, provide a rich set of smart and context-aware I18N aids in Eclipse, assisting
					developers in performing internationalization as part of their day-to-day work.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">mxGraph Graph Visualization  </a></td>
				  <td><strong>
					mxGraph is the market leading JavaScript graph visualization component. It provides all the commonly required functionality
					to draw, interact with and associate a context with a diagram. In OSBP it enables application developers to display
					interactive diagrams and graphs.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Jetty Application Server </a></td>
				  <td><strong>
					OSBP comes with the embedded web server and servlet container – Eclipse Jetty. It has been designed to have a small
					memory footprint, which is an excellent basis for performance and scalability of applications created with OSBP. Jetty
					is full-featured and standards-based, it offers support for HTTP/2, WebSocket, OSGi, JMX, JNDI, JAAS and many other integrations.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">jFairy by Codearte Mock Data Generator </a></td>
				  <td><strong>
					jFairy is used to generate real-looking test data for load testing and faster application development. Meaningful data
					generated based on predefined rules make it easy to start with OSBP and create better applications.
				  </strong>
				  <br><br>
				  </td>


				</tr>
				<tr>
				  <td><a href="http://www.osbee.org/">Opal SWT Widgets  </a></td>
				  <td><strong>
					The Opal Project delivers new widgets for the SWT API. In OSBP image selector widget is implemented.
				  </strong>
				  <br><br>
				  </td>


				</tr>
			</tbody>
		  <tfoot></tfoot>
		 </table>
	</div>



<footer class="site-footer">
  <div id="extra">
    <div class="inner">
      <div class="container">
        <div class="row">
          <div class="span6">
            <h3 class="footer-links-header">Quick Links</h3>
            <ul class="footer-links clearfix">
              <li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a><br>
              <a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a><br>
              <a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a><br>
              <a href="http://www.eclipse.org/legal/">Legal</a></li>
            </ul>
          </div>
		  <div class="span6">
            <h3 class="footer-links-header">&nbsp;  </h3>

			<ul class="footer-links clearfix">
              <li><a href="http://www.eclipse.org">Eclipse Home</a><br>
              <a href="http://marketplace.eclipse.org/">Market Place</a><br>
              <a href="http://live.eclipse.org/">Eclipse Live</a><br>
              <a href="http://www.planeteclipse.org/">Eclipse Planet</a></li>
            </ul>

          </div>
       </div>
      </div>
    </div>
  </div>

  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>

  <!-- Le javascript
      ==================================================
      Placed at the end of the document so the pages load faster -->

  <script src="js/jquery-1.11.3.min.js"></script>
  <script src="js/bootstrap.min.js"></script>
  <script src="js/jquery.easing.1.3.js" type="text/javascript"></script>
  <script src="js/jquery.prettyPhoto.js" type="text/javascript"></script>
  <script src="js/twitter.js" type="text/javascript"></script>
  <script src="js/prettify.js" type="text/javascript"></script>
  <script src="js/lang-xtend.js" type="text/javascript"></script>
  <script src="js/lang-common.js" type="text/javascript"></script>
  <script src="js/custom.js" type="text/javascript"></script>
  <script src="https://apis.google.com/js/platform.js" async defer></script>

  <!--script type="text/javascript">
    var _gaq = _gaq || [];
      _gaq.push([ '_setAccount', 'UA-2429174-3' ]);
    _gaq.push([ '_trackPageview' ]);
    (function() {
      var ga = document.createElement('script');
      ga.type = 'text/javascript';
      ga.async = true;
      ga.src = ('https:' == document.location.protocol ? 'https://ssl'
          : 'http://www')
          + '.google-analytics.com/ga.js';
      var s = document.getElementsByTagName('script')[0];
      s.parentNode.insertBefore(ga, s);
    })();
  </script-->

  <script src="js/coverflow.min.js" type="text/javascript"></script>
  <script>
      $(function() {
        $('#coverflow').coverflow({
          active : 1,
          visibleAside: 2,
          overlap : 0.5,
          scale : 0.9,
          angle : 20,
          trigger : {
            "itemfocus" : true,
            "swipe" : true,
            "mousewheel" : false
          }
        });
        $('#coverflow :hidden').toggle();
        $(window).resize(function() {
          $('#coverflow').coverflow();
        });
      });

  </script>
</footer>


  </body>

</html>
