Welcome!

Java Authors: Trevor Parsons, Peter Silva, Elizabeth White, Rex Morrow, Datical, Hovhannes Avoyan

Related Topics: Java

Java: Article

Dynamic Sorting With Java

A reusable implementation

Those familiar with the java.util.Comparator interface of the Java API realize its capabilities for sorting a collection of objects based on an attribute of the objects in the collection. This works well when there is only a single field in which sorting is required. When more complex sorting is necessary, the limitations of sorting on a single field become obvious. What about the situation in which a user desires the functionality to sort selectively on any field in object collection? This article describes an implementation of the Comparator interface that along with the reflection API allows an object to be sorted dynamically on any of its publicly accessible fields.

Problem Statement
Let's describe the problem a bit more specifically. A collection of employee Transfer Objects (EmployeeTO class) exists. (For a description of the Transfer Object design pattern consult a software design pattern book.) Each EmployeeTO in the collection is a data container object for a single employee's information. For this example, our simplified EmployeeTO object contains only three pieces of data - employee ID, last name, and salary.

A Human Resources application also exists that uses this collection to display a list of all employee data to HR application users. The users of this system have the following requirements:

  1. Allow sorting on any field on the report
  2. Allow control of the sort order
Simple Solution
Before delving into our dynamic sorting solution that allows sorting on any attribute, let's first look at a simple solution that supports sorting on a single attribute only. This will demonstrate the basic behaviors of Comparator and from this we'll be able to glean the improvements we wish to make. This solution utilizes the more common use of the Comparator interface. There are two classes required to implement this.

EmployeeTO - Simple Version
First, our EmployeeTO can be made sortable by implementing the Comparator interface as shown in Listing 1. In addition to the getters and setters for ID, last name, and salary, EmployeeTO must implement the compare() and equals() methods in order to meet the Comparator's requirements. These methods define how EmployeeTO is to be sorted. The compare() method takes two parameters, both of type Object. Note that compare() returns an int. This return value tells the sort engine the collating sequence equality of two attribute values from each of the object parameters passed to compare(), respectively. We need to write the code that performs this evaluation. The first step in compare() is to cast the two parameters' objects to EmployeeTO objects and extract the employee IDs by calling the getId() method on each object in turn. Now we can compare the values. There are really only three possible outcomes that can result from this comparison. Table 1 describes the results based on these outcomes.

The other method we must code is the equals() method. Although this method is not used for sorting, it must be implemented in order to meet the contract of the Comparator interface.

Sorting the Collection - Simple Version
The SimpleTest class in Listing 2 adds three EmployeeTO objects to a List, then performs a sort on that Collection. (Listings 2-5 can be downloaded from www.sys-con.com/java/sourcec.cfm.) Line 30 of SimpleTest calls the static sort() method of the Collections class to actually perform the sort as follows.

Collections.sort(elements, new EmployeeTO());

The first parameter passed to sort() is the collection object we wish to have sorted. The second parameter is an object of type Comparator that contains the customized sorting logic - in this case EmployeeTO, which implements the Comparator interface. We certainly could have passed any instance of EmployeeTO as the second parameter to the above method call. However, instead of reusing one of the three values initially added to the collection, I chose to pass a new instance of the class for purposes of clarity.

A quick note on encapsulation and responsibility assigning seems to be in order here. In this case, it makes sense to encapsulate the specific compare() method sorting logic within EmployeeTO. With the information we have thus far, EmployeeTO is the only class that requires the knowledge of how it should be sorted. Later, as a dynamic sorting solution is provided, we'll see this sorting logic moved out of the Transfer Object class as the sorting logic becomes less specific to any one particular Transfer Object implementation.

This implementation will run but falls short when it comes to meeting the user's requirements. Remember, we need to be able to sort on any one of the three fields in EmployeeTO based on a user's choice. And let's not forget about the ability to control the sort order.

Enhancement Options
Let's think about the options that are available to improve what we have and meet the requirements. One option is to code nested if/else statements in our compare() method to allow for sorting on any field in the object based on some field name parameter passed to EmployeeTO. The problem with this solution is that it's difficult to maintain and the code could get rather lengthy as well. If new fields are added to EmployeeTO, we must update compare() appropriately.

What we would really like to do is invoke any given getter method of our Transfer Object at runtime without having to specifically hard code each possible method call in the compare() method. If we could do this, we could use the results of those method calls to dynamically determine equality. In addition, it would be desirable if this dynamic sorting could be reused for any Transfer Object. The good news is that this functionality can be achieved by leveraging the reflection API and the flexibility of the Collections.sort() method.

Reflection
The java.lang.reflect.Method class provides the ability to invoke a method of a given object based on the value of a string. For example, using a string containing the value "getId", the method getId() of EmployeeTO can be dynamically invoked at runtime. This string value can then be changed as we wish to cause any of the methods of EmployeeTO to be called.

The reflection API provides a variety of interesting features including the ability to pass parameters to methods and the ability to determine method return types. (For a complete list of these capabilities, consult the Java API Javadoc.) We will need the latter capability as the three getter methods of EmployeeTO return different types and it will thus be necessary to be aware of which type we have when doing the comparison in the compare() method. For example, we'll need to code a different sort of equality test on an int return value as opposed to a string.

java.util.Collections.sort()
A dynamic solution will also need to take advantage of the flexibility of the Collections.sort() method. Recall that in our simple sorting solution we passed an instance of an object that implemented the Comparator interface as the second parameter to Collections.sort(). In that case, it was the EmployeeTO object that contained the sorting logic. This worked great for what we needed it to do. Now, however, we want something a bit more sophisticated and flexible. What if we were to create a class that implemented Comparator, which was separate from each Transfer Object? In it we could place our dynamic sorting code and simply pass an instance of this new class as the second parameter to Collections.sort().

Doing this would cause several desirable results. First, we'll have completely decoupled any sorting logic from our Transfer Objects. This is highly desirable as it decreases not only the size of each Transfer Object by essentially eliminating the need for sorting code, but also removes the need for coding individual field comparison logic. Second, we'll have created a reusable utility class that can be used in many different situations where sorting is required. While reusability is not a specifically stated user requirement for our design, it is certainly desirable.

Dynamic Solution
Figure 1 is a UML diagram (with attribute and method details omitted) that shows how the components of both the simple and the dynamic sorting solutions fit together. Really, the only portion that has changed since our simple solution is where the Comparator interface gets implemented. In the first example, EmployeeTO implemented Comparator directly. Now DynamicComparator implements Comparator and contains an intelligent implementation of the compare() method that can be used by any class that requires a collection of objects to be sorted.

DynamicComparator
Listing 3 shows the completed code listing for DynamicComparator. There are a number of interesting things about this class. First, note the class signature. The class implements two interfaces - Comparator and Serializable. Comparator should come as no surprise since that interface is the essence of the sorting capabilities we desire. Also, although not a requirement, the API docs recommend that any class implementing Comparator implement Serializable as well.

Second, look at the static sort() method. Classes wishing to utilize DynamicComparator will call this method rather than Collections.sort(). I've decided to make sort() static to mimic the Collections.sort() method. Although the DynamicComparator.sort() method is called statically, internally DynamicComparator creates an instance of itself. This is necessary in order for it to provide access to the nonstatic compare() and equals() methods of the Comparator interface that it supports. Next note how this method takes three parameters. The first is the collection object to be sorted. The second is a string that defines the field of each object in the collection on which sorting should be performed. The last parameter is a Boolean specifying the sort order. These three parameters are used as arguments to create a new instance of DynamicComparator that is the second parameter passed to the Collections.sort() method.

Third, take a look at the compare() method. This is where the reflection code really kicks in. One of the first things we need to obtain is a reference to a method object at line 43. We'll use this reference to call methods dynamically. This task is done using the getMethod() helper method, which obtains this value via reflection. Next, we need to determine the return type of the methods we are about to call. Remember that we will need to compare the attribute values of the two objects passed into compare(). If the return type is an int, for instance, we'll certainly have to write different code to do the comparison than if the return type is a string. Once we have the return type, we examine it and, based on its value, dynamically perform the actual method invocation and resulting comparison of the two values.

Note that currently there are three separate "if" test blocks - one each for string, int, and double. The implementation requires comparison logic for any method return type we expect to encounter. For the range of return types in our EmployeeTO example, these three are sufficient. However, additional code would need to be added to DynamicComparator if comparisons of other types are required - short, java.util.Date, java.math.BigDecimal, etc. Coding for each specific return type here is unavoidable as there is no way to dynamically cast Java objects. Similarly, Java-supplied nonobject data types like int, long, and double use entirely different comparison operators than do first-class object types like String or Date.

There are some other important points about this code. First, DynamicComparator fully supports null values. If either or both of the arguments passed to compare() are null, this method knows how to handle the situation accordingly. Second, look at each return statement within compare(). Remember the requirement that the user be able to control not only the sort field but also the sort order? This code supports the latter by essentially reversing the default sort order with a call to getSortOrder(). This is done if the user has decided to sort the result in descending order based on the Boolean value passed into the constructor from the sort() method. Third, the constructMethodName() method converts a Transfer Object attribute name string into a method name by prepending a "get" string and capitalizing the first character of the passed value. For instance, constructMethodName() would convert "salary" to "getSalary".

Last, the equals() method is needed to complete the interface requirements.

EmployeeTO - Enhanced Version
Listing 4 shows the enhanced version of EmployeeTO. The most obvious change is that EmployeeTO is now even simpler than before. Now that all of the sorting logic has been moved to DynamicComparator and the class no longer implements Comparator, we don't need to implement the compare() and equals() methods.

Sorting the Collection - Dynamic Version
Listing 5 is the code for DynamicTest. The only change between this class and SimpleTest is how the sort is called. Here we pass the three parameters to DynamicComparator.sort() (Collection Object, the decapitalized attribute name, and sort ascending flag) and let the DynamicComparator do the rest.

DynamicTest could just as easily have sorted on last name by passing "lastName" or on employee ID by passing "id" as the second parameter on line 29.

Solution Discussion
Building a class such as DynamicComparator has many benefits in an application that requires robust sorting capabilities. In this design, we have created a reusable, loosely coupled API that can be used to sort a collection of objects based on getter methods. The sort field is easily configurable and also allows control over the sort order.

This design, however, is not without trade-offs. Although using the reflection API allows us to do lots of cool things, using reflection can slow performance. This is particularly true in applications using pre-1.4 versions of Java. In addition, it's possible that applications wishing to sort very large collections may find DynamicComparator too slow.

Other inadequacies of DynamicComparator might become evident as well. Although it allows sorting on any one attribute of a collection of objects in an easily configurable manner, DynamicComparator does not address the potential need to sort by multiple fields - primary and secondary field sorts like that occur automatically with the ORDER BY clause in Structured Query Language (SQL).

Conclusion
This article introduced a reusable implementation of the Comparator interface that utilizes Java reflection to dynamically sort a collection of objects on any one of any number of fields within that object.

If your application or framework has a need for this specific functionality, perhaps this design will fit your needs.

More Stories By York Davis

York Davis is a senior managing consultant at Software Architects, Inc. With more than 12 years in the software development field, York has been using Java for more than five years and has extensive experience building enterprise application architectures.

Comments (13) View Comments

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


Most Recent Comments
Java 04/09/08 09:42:59 AM EDT

Refer below link for code
http://photos.sys-con.com/story/res/45837/source.html

Doug Bell 08/26/04 04:26:21 AM EDT

I meant to mention one other thing about the articles implementation that nobody else mentioned. The implementation and comment for the DynamicComparator.equals method illustrates confusion about the purpose of the method.

As implemented, the equals method breaks all contracts for equals, including the Comparator contract. It would be better to have left the default implementation of equals rather than override it with a method that always returns true.

The equals method is for comparing the DynamicComparator object to another object to see if two Comparators produce the same results. This would not be too difficult to properly implement by checking for equals between the method and sortAsc fields (and Comparator fields if my previous suggestion was implemented).

One final comment is that the Collection should not be passed to the DynamicComparator constructor. It is only needed by the sort method.

Doug Bell 08/26/04 04:11:27 AM EDT

sMyles has the right idea about how to fix the DynamicComparator class. (Some of the other comments and code suggestions missed the mark in one or more areas.) Certainly, you''d rather not have to keep modifying the DynamicComparator class to add new algorithms--this is not the correct design for "encapsulation and responsibility assignment" that the article discusses.

However, instead of sMyles suggestion for option 4, just overload sort() and the DynamicComparator constructor to accept a Comparator for comparing any two fields that don''t implement Comparable. This will also allow fields that do implement Comparable, such as String, to use alternate compare algorithms, such as compareToIgnoreCase.

David Perelman-Hall 08/11/04 03:26:40 PM EDT

/*
This can be implemented in 3 very simple terms to capture anything that implements 1) Comparable or 2) Comparator or 3) is a primitive. I''ve rewritten the main function to see if the comparable objects retrieved by the "reflected method" implements one of these three concepts. Also stripped out the Serializable, because how likely are you to want to serialize a Comparator? And cut down on the class size by reducingnumber of methods by moving the getMethod and invoke methods back into the class itself. The idea guiding York''s original thinking is a wonderful idea.

--Dave
*/

import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;

public final class DynamicComparator implements Comparator
{
// Class Members
public static final int EQUAL = 0;
public static final int LESS_THAN = -1;
public static final int GREATER_THAN = 1;

// Object Members
private Collection collection;
private String methodName;
private boolean sortAsc;

// Private Constructor
private DynamicComparator(Collection collection, String methodName, boolean sortAsc)
{
this.collection = collection;
this.methodName = methodName;
this.sortAsc = sortAsc;
}

// Sort invocation starts here
public static void sort(List list, String methodName, boolean sortAsc)
{
Collections.sort(list, new DynamicComparator(list, methodName, sortAsc));
}

// Compare for Collections.sort here
public int compare(Object o1, Object o2)
{
int rv = 0;

try
{
// Determine the return type
Method method = o1.getClass().getMethod(methodName, null);
Class c = method.getReturnType();
System.out.println("return type is " + c);

// Invoke method to gather two comparable objects
java.lang.Object result1 = method.invoke(o1, null);
java.lang.Object result2 = method.invoke(o2, null);

if(c.isAssignableFrom(Class.forName("java.util.Comparator")))
{
System.out.println(c + " implements java.util.Comparator");
java.util.Comparator c1 = (java.util.Comparator) result1;
java.util.Comparator c2 = (java.util.Comparator) result2;
rv = c1.compare(c1,c2);
}
else if(Class.forName("java.lang.Comparable").isAssignableFrom(c))
{
System.out.println(c + "implements java.lang.Comparable");
java.lang.Comparable c1 = (java.lang.Comparable) result1;
java.lang.Comparable c2 = (java.lang.Comparable) result2;
rv = c1.compareTo(c2);
}
else if(c.isPrimitive())
{
System.out.println("c.isPrimitive");
long f1 = ((Number) result1).longValue();
long f2 = ((Number) result2).longValue();
if (f1 == f2) rv = EQUAL;
else if (f1 < f2) rv = LESS_THAN;
else if (f1 > f2) rv = GREATER_THAN;
}
else
{
throw new RuntimeException("DynamicComparator does not currently support ''" + c.getName() + "''!");
}
}
catch (Exception nsme)
{
System.out.println("Error " + nsme);
}
return rv * getSortOrder();
}

/**
* Not used for sorting. Only here to meet the requirements of the Comparator
interface.
*
* @param o The object for comparison
* @return boolean
*/
public boolean equals(Object o)
{
return true;
}

// Sort order getter
private int getSortOrder()
{
return sortAsc ? 1 : -1;
}

// Test
public static void main(String args[])
{
List elements = new ArrayList();

EmployeeTO e2 = new EmployeeTO();
e2.setId(2);
e2.setLastName("Nesler");
e2.setSalary(13000);
elements.add(e2);

EmployeeTO e1 = new EmployeeTO();
e1.setId(1);
e1.setLastName("Davis");
e1.setSalary(11000);
elements.add(e1);

EmployeeTO e3 = new EmployeeTO();
e3.setId(3);
e3.setLastName("Phachantry");
e3.setSalary(12000);
elements.add(e3);

DynamicComparator.sort(elements, "getLastName", true);

final Iterator li = elements.iterator();
EmployeeTO e = null;
while (li.hasNext())
{
e = (EmployeeTO) li.next();
System.out.println(e.toString());
}
}
}

sMyles 08/11/04 03:14:36 PM EDT

It is important to note that invoke() returns an Object, not a primitive.
Therefore, no extra code is required to compare primitives, since invoke() would return an instance of its wrapper class. All primitive wrappers implement Comparable.

Knowing this, compare() should do the following:
1. Cast the two return values to Comparable without checking, because if they''re not comparable, we can''t compare them anyway.
This is the behavior of Collections.sort() when no Comparator is specified. (See Arrays.mergeSort()).
Either that or use the logic described in the original method, by returning LESS_THAN.

2. Perform the null comparisons on val1 and val2 (without the introduction of val1Null and val2Null) and return the appropriate value * getSortOrder(), if applicable.

3. If it turns out neither return value is null, return val1.compareTo(val2) * getSortOrder()

4 (optional). Include a special case for String objects and return val1.compareToIgnoreCase(val2) * getSortOrder(). How compare() should treat case sensitivity could be specified as a parameter to sort().

Also of note:
An object is an instance of all interfaces its class implements, so the interfaces array and implementsComparable processing could be replaced by (f1 instanceof Comparable)
Additionally, the compare() method must either return an int or throw an exception. If implementsComparable is false, this method does neither.

Ceri 08/10/04 05:07:56 PM EDT

Sorry, formatting seems to have been stripped from my previous message.

Ceri

Ceri 08/10/04 05:06:17 PM EDT

The compare method needs to handle primitive types separately. All non-primitives that implement comparable can be easily grouped together into a single if block (to replace the String handling section of Listing 3):

Class[] interfaces = method.getReturnType().getInterfaces();
boolean implementsComparable = false;
for (int i = 0; i < interfaces.length; i++) {
if (interfaces[i].getName().equals("java.lang.Comparable")) {
implementsComparable = true;
break;
}
}
if (implementsComparable) {
Comparable f1 = (Comparable) invoke(method, o1);
method = getMethod(o2);
Comparable f2 = (Comparable) invoke(method, 02);
if (f1 != null && f2 != null) {
return f1.compareTo(f2) * getSortOrder();
}
if (f1 == null && f2 != null) {
return LESS_THAN * getSortOrder();
}
if (f1 != null && f2 == null) {
return GREATER_THAN * getSortOrder();
}
if (f1 == null && f2 == null) {
return EQUAL * getSortOrder();
}
}

Mike 08/10/04 12:16:23 PM EDT

York the method "public int compare(Object o1, Object o2)" is long and makes the class look cluddered(like it needs to be refactored), especially if more fields where added requiring more test to be implemented in this method. Wouldn''t separate class implementation for each sorting type help with this, but on second thought this would lead to class proliferation. Okay in the future, would sometype of generics in 1.5.0 work here for the comparing class in addition to the usage of reflection to stream line this code.

York 08/09/04 01:22:26 PM EDT

Source code now available for download!

S Opoku-Boadu 08/09/04 03:26:33 AM EDT

Cannot locate Listings 2 - 5

S Opoku-Boadu 08/09/04 03:25:52 AM EDT

Cannot locate Listings 2 - 5

Trevor Leach 08/09/04 12:38:46 AM EDT

The listings are not in the print version either. Perhaps we''ll get emailed when they are found?

D Polansky 08/05/04 05:41:40 PM EDT

Where are listings 3, 4, and 5 referenced in the article?

@ThingsExpo Stories
Software AG helps organizations transform into Digital Enterprises, so they can differentiate from competitors and better engage customers, partners and employees. Using the Software AG Suite, companies can close the gap between business and IT to create digital systems of differentiation that drive front-line agility. We offer four on-ramps to the Digital Enterprise: alignment through collaborative process analysis; transformation through portfolio management; agility through process automation and integration; and visibility through intelligent business operations and big data.
There will be 50 billion Internet connected devices by 2020. Today, every manufacturer has a propriety protocol and an app. How do we securely integrate these "things" into our lives and businesses in a way that we can easily control and manage? Even better, how do we integrate these "things" so that they control and manage each other so our lives become more convenient or our businesses become more profitable and/or safe? We have heard that the best interface is no interface. In his session at Internet of @ThingsExpo, Chris Matthieu, Co-Founder & CTO at Octoblu, Inc., will discuss how these devices generate enough data to learn our behaviors and simplify/improve our lives. What if we could connect everything to everything? I'm not only talking about connecting things to things but also systems, cloud services, and people. Add in a little machine learning and artificial intelligence and now we have something interesting...
Last week, while in San Francisco, I used the Uber app and service four times. All four experiences were great, although one of the drivers stopped for 30 seconds and then left as I was walking up to the car. He must have realized I was a blogger. None the less, the next car was just a minute away and I suffered no pain. In this article, my colleague, Ved Sen, Global Head, Advisory Services Social, Mobile and Sensors at Cognizant shares his experiences and insights.
We are reaching the end of the beginning with WebRTC and real systems using this technology have begun to appear. One challenge that faces every WebRTC deployment (in some form or another) is identity management. For example, if you have an existing service – possibly built on a variety of different PaaS/SaaS offerings – and you want to add real-time communications you are faced with a challenge relating to user management, authentication, authorization, and validation. Service providers will want to use their existing identities, but these will have credentials already that are (hopefully) irreversibly encoded. In his session at Internet of @ThingsExpo, Peter Dunkley, Technical Director at Acision, will look at how this identity problem can be solved and discuss ways to use existing web identities for real-time communication.
Can call centers hang up the phones for good? Intuitive Solutions did. WebRTC enabled this contact center provider to eliminate antiquated telephony and desktop phone infrastructure with a pure web-based solution, allowing them to expand beyond brick-and-mortar confines to a home-based agent model. It also ensured scalability and better service for customers, including MUY! Companies, one of the country's largest franchise restaurant companies with 232 Pizza Hut locations. This is one example of WebRTC adoption today, but the potential is limitless when powered by IoT. Attendees will learn real-world benefits of WebRTC and explore future possibilities, as WebRTC and IoT intersect to improve customer service.
From telemedicine to smart cars, digital homes and industrial monitoring, the explosive growth of IoT has created exciting new business opportunities for real time calls and messaging. In his session at Internet of @ThingsExpo, Ivelin Ivanov, CEO and Co-Founder of Telestax, will share some of the new revenue sources that IoT created for Restcomm – the open source telephony platform from Telestax. Ivelin Ivanov is a technology entrepreneur who founded Mobicents, an Open Source VoIP Platform, to help create, deploy, and manage applications integrating voice, video and data. He is the co-founder of TeleStax, an Open Source Cloud Communications company that helps the shift from legacy IN/SS7 telco networks to IP-based cloud comms. An early investor in multiple start-ups, he still finds time to code for his companies and contribute to open source projects.
The Internet of Things (IoT) promises to create new business models as significant as those that were inspired by the Internet and the smartphone 20 and 10 years ago. What business, social and practical implications will this phenomenon bring? That's the subject of "Monetizing the Internet of Things: Perspectives from the Front Lines," an e-book released today and available free of charge from Aria Systems, the leading innovator in recurring revenue management.
The Internet of Things will put IT to its ultimate test by creating infinite new opportunities to digitize products and services, generate and analyze new data to improve customer satisfaction, and discover new ways to gain a competitive advantage across nearly every industry. In order to help corporate business units to capitalize on the rapidly evolving IoT opportunities, IT must stand up to a new set of challenges.
There’s Big Data, then there’s really Big Data from the Internet of Things. IoT is evolving to include many data possibilities like new types of event, log and network data. The volumes are enormous, generating tens of billions of logs per day, which raise data challenges. Early IoT deployments are relying heavily on both the cloud and managed service providers to navigate these challenges. In her session at 6th Big Data Expo®, Hannah Smalltree, Director at Treasure Data, to discuss how IoT, Big Data and deployments are processing massive data volumes from wearables, utilities and other machines.
All major researchers estimate there will be tens of billions devices – computers, smartphones, tablets, and sensors – connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades. With major technology companies and startups seriously embracing IoT strategies, now is the perfect time to attend @ThingsExpo in Silicon Valley. Learn what is going on, contribute to the discussions, and ensure that your enterprise is as "IoT-Ready" as it can be!
P2P RTC will impact the landscape of communications, shifting from traditional telephony style communications models to OTT (Over-The-Top) cloud assisted & PaaS (Platform as a Service) communication services. The P2P shift will impact many areas of our lives, from mobile communication, human interactive web services, RTC and telephony infrastructure, user federation, security and privacy implications, business costs, and scalability. In his session at Internet of @ThingsExpo, Erik Lagerway, Co-founder of Hookflash, will walk through the shifting landscape of traditional telephone and voice services to the modern P2P RTC era of OTT cloud assisted services.
While great strides have been made relative to the video aspects of remote collaboration, audio technology has basically stagnated. Typically all audio is mixed to a single monaural stream and emanates from a single point, such as a speakerphone or a speaker associated with a video monitor. This leads to confusion and lack of understanding among participants especially regarding who is actually speaking. Spatial teleconferencing introduces the concept of acoustic spatial separation between conference participants in three dimensional space. This has been shown to significantly improve comprehension and conference efficiency.
The Internet of Things is tied together with a thin strand that is known as time. Coincidentally, at the core of nearly all data analytics is a timestamp. When working with time series data there are a few core principles that everyone should consider, especially across datasets where time is the common boundary. In his session at Internet of @ThingsExpo, Jim Scott, Director of Enterprise Strategy & Architecture at MapR Technologies, will discuss single-value, geo-spatial, and log time series data. By focusing on enterprise applications and the data center, he will use OpenTSDB as an example to explain some of these concepts including when to use different storage models.
SYS-CON Events announced today that Gridstore™, the leader in software-defined storage (SDS) purpose-built for Windows Servers and Hyper-V, will exhibit at SYS-CON's 15th International Cloud Expo®, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. Gridstore™ is the leader in software-defined storage purpose built for virtualization that is designed to accelerate applications in virtualized environments. Using its patented Server-Side Virtual Controller™ Technology (SVCT) to eliminate the I/O blender effect and accelerate applications Gridstore delivers vmOptimized™ Storage that self-optimizes to each application or VM across both virtual and physical environments. Leveraging a grid architecture, Gridstore delivers the first end-to-end storage QoS to ensure the most important App or VM performance is never compromised. The storage grid, that uses Gridstore’s performance optimized nodes or capacity optimized nodes, starts with as few a...
The Transparent Cloud-computing Consortium (abbreviation: T-Cloud Consortium) will conduct research activities into changes in the computing model as a result of collaboration between "device" and "cloud" and the creation of new value and markets through organic data processing High speed and high quality networks, and dramatic improvements in computer processing capabilities, have greatly changed the nature of applications and made the storing and processing of data on the network commonplace. These technological reforms have not only changed computers and smartphones, but are also changing the data processing model for all information devices. In particular, in the area known as M2M (Machine-To-Machine), there are great expectations that information with a new type of value can be produced using a variety of devices and sensors saving/sharing data via the network and through large-scale cloud-type data processing. This consortium believes that attaching a huge number of devic...
Innodisk is a service-driven provider of industrial embedded flash and DRAM storage products and technologies, with a focus on the enterprise, industrial, aerospace, and defense industries. Innodisk is dedicated to serving their customers and business partners. Quality is vitally important when it comes to industrial embedded flash and DRAM storage products. That’s why Innodisk manufactures all of their products in their own purpose-built memory production facility. In fact, they designed and built their production center to maximize manufacturing efficiency and guarantee the highest quality of our products.
All major researchers estimate there will be tens of billions devices - computers, smartphones, tablets, and sensors - connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades. Over the summer Gartner released its much anticipated annual Hype Cycle report and the big news is that Internet of Things has now replaced Big Data as the most hyped technology. Indeed, we're hearing more and more about this fascinating new technological paradigm. Every other IT news item seems to be about IoT and its implications on the future of digital business.
Can call centers hang up the phones for good? Intuitive Solutions did. WebRTC enabled this contact center provider to eliminate antiquated telephony and desktop phone infrastructure with a pure web-based solution, allowing them to expand beyond brick-and-mortar confines to a home-based agent model. Download Slide Deck: ▸ Here
BSQUARE is a global leader of embedded software solutions. We enable smart connected systems at the device level and beyond that millions use every day and provide actionable data solutions for the growing Internet of Things (IoT) market. We empower our world-class customers with our products, services and solutions to achieve innovation and success. For more information, visit www.bsquare.com.
With the iCloud scandal seemingly in its past, Apple announced new iPhones, updates to iPad and MacBook as well as news on OSX Yosemite. Although consumers will have to wait to get their hands on some of that new stuff, what they can get is the latest release of iOS 8 that Apple made available for most in-market iPhones and iPads. Originally announced at WWDC (Apple’s annual developers conference) in June, iOS 8 seems to spearhead Apple’s newfound focus upon greater integration of their products into everyday tasks, cross-platform mobility and self-monitoring. Before you update your device, here is a look at some of the new features and things you may want to consider from a mobile security perspective.