Ross Mason of Mulesoft recently blogged: "OSGi - no thanks". Ross is a smart guy and he usually has something interesting to say. In this case, I think Ross has made a lot of good points:

1. Ross is right - OSGi is a great technology for middleware vendors.
2. Ross is right - Developers shouldn't be forced to mess with OSGi.
3. Ross is wrong - You can make both of these work together.

At WSO2 we went through exactly the same issues. We simply came to a different conclusion - that we can provide the benefits of OSGi (modularity, pluggability, dynamic loading) without giving pain to end-users. In WSO2 Carbon, customers can deploy their systems in exactly the same way that worked pre-OSGi.

Why did we choose OSGi? We also looked at building our own dynamic loading schemes. In fact, we've had dynamic classloading capabilities in our platform from day one. The reasons we went with OSGi are:

• A structured and versioned approach to dynamic classloading
• An industry standard approach - hence better understood, better skills, better resources
• It solves more than just dynamic loading: as well as providing versions and dynamic loading, it also really gives proper modularity - which means hiding classes as much as exposing classes.
• It provides (through Equinox p2) a proper provisioning model.

Pete Farkas, Deepak Arora, and Derek Sharpe talk about the mission and focus of Oracle's Fusion Middleware A-Team.

Pete Farkas, Deepak Arora, and Derek Sharpe discuss the most common problems Oracle Fusion Middleware A-Team members encounter in the field.

Pete Farkas, Deepak Arora, and Derek Sharpe describe the interaction between Oracle Fusion Middleware A-Team and product teams, and the hazards of field assignments.

A panel of Oracle Middleware product managers discusses the current state of several middleware products in the lead-up to Oracle OpenWorld, and also highlights key OOW16 sessions, labs, and demos.

Middleware can be used to deliver broadcast content to portable devices through Wireless LAN/WiFi

A system and method can support a flooding mechanism using a multicast group in a middleware machine environment. The middleware machine environment can comprise a gateway instance that includes an external port for receiving one or more data packets from an external network. The middleware machine environment also comprises one or more host servers, each of which is associated with one or more virtual machines that can process the data packets. Furthermore, said host servers can provide virtual interfaces that belong to a virtual hub associated with the gateway instance. At least one said packet is a flooded packet that is specified with an unknown destination address when it is received at the external port. The gateway instance operates to send the flooded packet to the multicast group that operates to forward the flooded packet to one or more said host servers in the multicast group.

Systems and methods for retrieving service request messages stored in a messaging queue and received by a queue in real-time. The service request messages are retrieved using a plurality of threads that comprise at least one retrieval criteria. Service request messages may be retrieved from the message queue or retrieved as they are received by the message queue in real-time using criteria in addition to or instead of the arrival time of the service request message which may also be referred to as the put-time. Service request messages may be requested and retrieved in an iterative process wherein multiple threads execute consecutively, concurrently, or a combination of both, in order to retrieve service request messages requested by an application.

La participación de mercado de IBM (NYSE: IBM) en infraestructura de aplicaciones y de middleware es un 29.1 por ciento, lo que amplía la posición de liderazgo de la compañía por 14° año consecutivo sobrepasando a la competencia por más del doble, de acuerdo con la firma de análisis del mercado de TI Gartner, basado en los ingresos totales nivel mundial para 2014.

Several factors were key in this northeastern Kansas telephone company's decision to choose APMAX IPTV middleware from Innovative Systems. However, according to Tri-County Telephone Association's General Manager, Dale Jones, putting the customer experience first above everything else was their main goal in making the decision.

Jones stated, "The capabilities that the Innovative solution gives us to reach out and touch the customer from our back office to help them over the phone is critical in the customer experience. Without having to send out a service technician, which takes time and costs more, we are helping our customers in a timely manner and reducing our own operating costs."

Jones likes the fact that Innovative Systems is continually growing their products with new features to help the rural telco market stay on top of a very competitive market. Jones advises other telcos to look to companies that are thinking outside the box especially when it comes to video. Jones says, "Today's business is nothing like it was in the past, if you are going to attract and retain video customers you have to give them the technology that is going to drive that experience."

Integration software. Middleware is the term coined to describe software that connects other software together. In the early days of computing, each software system in an organization was a separate 'stovepipe' or 'silo' that stood alone and was dedicated to automating a specific part of the business or its IT operations. Middleware aims to connect those individual islands of automation, both within an enterprise and out to external systems (for example at customers and suppliers). For a long while, middleware has either been custom coded for individual projects or has come in the form of proprietary products or suites, most notably as enterprise application integration (EAI) software. The emergence of industry-agreed web services specifications is now enabling convergence on standards-based distributed middleware, which in theory should allow all systems to automatically connect together on demand.

After writing my post a few months ago on building your own redux app, I have been asked a couple times to write a guide on creating redux middleware and how it works. This will be a quick post on how you can acheive anything with your own middleware!

##Basic middleware

const customMiddleware = store => next => action => {
  if(action.type !== 'custom') return next(action)
  //do stuff!
}

Applying it:

import { createStore, applyMiddleware, } from 'redux'
import reducer from './reducer'
import customMiddleware from './customMiddleware'

const store = createStore(
  reducer,
  applyMiddleware(customMiddleware)
)

Whaaa? store => next => action => I know that looks confusing. Essentially you are building a chain of functions, it will look like this when it gets called:

//next looks something like this:
let dispatched = null
let next = actionAttempt => dispatched = actionAttempt 

const dispatch = customMiddleware(store)(next)

dispatch({
  type: 'custom',
  value: 'test'
})

All you are doing is chaining function calls and passing in the neccesary data. When I first saw this I was confused a little due to the long chain, but it made perfect sense after reading the article on writing redux tests.

So now that we understand how those chained functions work, let’s explain the first line of our middleware.

if(action.type !== 'custom') return next(action)

There should be some way to tell what actions should go through your middleware. In this example, we are saying if the action’s type is not custom call next, which will pass it to any other middleware and then to the reducer.

##Doing Cool stuff

The official guide on redux middleware covers a few examples on this, I’m going to try to explain it in a more simple way.

Say we want an action like this:

dispatch({
  type: 'ajax',
  url: 'http://api.com',
  method: 'POST',
  body: state => ({
    title: state.title
    description: state.description
  }),
  cb: response => console.log('finished!', response)
})

We want this to do a post request, and then call the cb function. It would look something like this:

import fetch from 'isomorphic-fetch'

const ajaxMiddleware = store => next => action => {
  if(action.type !== 'ajax') return next(action)
  
  fetch(action.url, {
    method: action.method,
    body: JSON.stringify(action.body(store.getState()))
  })
  .then(response => response.json())
  .then(json => action.cb(json))
}

It’s pretty simple really. You have access to every method redux offers in middleware. What if we wanted the cb function to have access to dispatching more actions? We could change that last line of the fetch function to this:

.then(json => action.cb(json, store.dispatch))

Now in the callback, we can do:

  cb: (response, dispatch) => dispatch(newAction(response))

As you can see, middleware is very easy to write in redux. You can pass store state back to actions, and so much more. If you need any help or if I didn’t go into detail enough, feel free to leave a comment below!

IEEE Computer Society

IEEE / Institute of Electrical and Electronics Engineers Incorporated

IEEE Computer Society

IEEE / Institute of Electrical and Electronics Engineers Incorporated

IEEE / Institute of Electrical and Electronics Engineers Incorporated