|By York Davis||
|August 5, 2004 12:00 AM EDT||
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.
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:
- Allow sorting on any field on the report
- Allow control of the sort order
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.
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.
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.
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.
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.
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.
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).
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.
|Java 04/09/08 09:42:59 AM EDT|
Refer below link for code
|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|
public final class DynamicComparator implements Comparator
// Object Members
// Private Constructor
// Sort invocation starts here
// Compare for Collections.sort here
// Invoke method to gather two comparable objects
// Sort order getter
EmployeeTO e2 = new EmployeeTO();
EmployeeTO e1 = new EmployeeTO();
EmployeeTO e3 = new EmployeeTO();
DynamicComparator.sort(elements, "getLastName", true);
final Iterator li = elements.iterator();
|sMyles 08/11/04 03:14:36 PM EDT|
It is important to note that invoke() returns an Object, not a primitive.
Knowing this, compare() should do the following:
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:
|Ceri 08/10/04 05:07:56 PM EDT|
Sorry, formatting seems to have been stripped from my previous message.
|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();
|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?
Sensor-enabled things are becoming more commonplace, precursors to a larger and more complex framework that most consider the ultimate promise of the IoT: things connecting, interacting, sharing, storing, and over time perhaps learning and predicting based on habits, behaviors, location, preferences, purchases and more. In his session at @ThingsExpo, Tom Wesselman, Director of Communications Ecosystem Architecture at Plantronics, will examine the still nascent IoT as it is coalescing, including what it is today, what it might ultimately be, the role of wearable tech, and technology gaps stil...
May. 23, 2015 06:00 AM EDT Reads: 4,340
One of the biggest impacts of the Internet of Things is and will continue to be on data; specifically data volume, management and usage. Companies are scrambling to adapt to this new and unpredictable data reality with legacy infrastructure that cannot handle the speed and volume of data. In his session at @ThingsExpo, Don DeLoach, CEO and president of Infobright, will discuss how companies need to rethink their data infrastructure to participate in the IoT, including: Data storage: Understanding the kinds of data: structured, unstructured, big/small? Analytics: What kinds and how responsiv...
May. 23, 2015 06:00 AM EDT Reads: 4,449
Today’s enterprise is being driven by disruptive competitive and human capital requirements to provide enterprise application access through not only desktops, but also mobile devices. To retrofit existing programs across all these devices using traditional programming methods is very costly and time consuming – often prohibitively so. In his session at @ThingsExpo, Jesse Shiah, CEO, President, and Co-Founder of AgilePoint Inc., discussed how you can create applications that run on all mobile devices as well as laptops and desktops using a visual drag-and-drop application – and eForms-buildi...
May. 23, 2015 06:00 AM EDT Reads: 5,385
Advanced Persistent Threats (APTs) are increasing at an unprecedented rate. The threat landscape of today is drastically different than just a few years ago. Attacks are much more organized and sophisticated. They are harder to detect and even harder to anticipate. In the foreseeable future it's going to get a whole lot harder. Everything you know today will change. Keeping up with this changing landscape is already a daunting task. Your organization needs to use the latest tools, methods and expertise to guard against those threats. But will that be enough? In the foreseeable future attacks w...
May. 23, 2015 05:00 AM EDT Reads: 5,658
17th Cloud Expo, taking place Nov 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA, will feature technical sessions from a rock star conference faculty and the leading industry players in the world. Cloud computing is now being embraced by a majority of enterprises of all sizes. Yesterday's debate about public vs. private has transformed into the reality of hybrid cloud: a recent survey shows that 74% of enterprises have a hybrid cloud strategy. Meanwhile, 94% of enterprises are using some form of XaaS – software, platform, and infrastructure as a service.
May. 23, 2015 05:00 AM EDT Reads: 2,399
Cloud is not a commodity. And no matter what you call it, computing doesn’t come out of the sky. It comes from physical hardware inside brick and mortar facilities connected by hundreds of miles of networking cable. And no two clouds are built the same way. SoftLayer gives you the highest performing cloud infrastructure available. One platform that takes data centers around the world that are full of the widest range of cloud computing options, and then integrates and automates everything. Join SoftLayer on June 9 at 16th Cloud Expo to learn about IBM Cloud's SoftLayer platform, explore se...
May. 23, 2015 04:45 AM EDT Reads: 3,084
15th Cloud Expo, which took place Nov. 4-6, 2014, at the Santa Clara Convention Center in Santa Clara, CA, expanded the conference content of @ThingsExpo, Big Data Expo, and DevOps Summit to include two developer events. IBM held a Bluemix Developer Playground on November 5 and ElasticBox held a Hackathon on November 6. Both events took place on the expo floor. The Bluemix Developer Playground, for developers of all levels, highlighted the ease of use of Bluemix, its services and functionality and provide short-term introductory projects that developers can complete between sessions.
May. 23, 2015 04:00 AM EDT Reads: 6,224
The 3rd International @ThingsExpo, co-located with the 16th International Cloud Expo – to be held June 9-11, 2015, at the Javits Center in New York City, NY – is now accepting Hackathon proposals. Hackathon sponsorship benefits include general brand exposure and increasing engagement with the developer ecosystem. At Cloud Expo 2014 Silicon Valley, IBM held the Bluemix Developer Playground on November 5 and ElasticBox held the DevOps Hackathon on November 6. Both events took place on the expo floor. The Bluemix Developer Playground, for developers of all levels, highlighted the ease of use of...
May. 23, 2015 04:00 AM EDT Reads: 3,380
The explosion of connected devices / sensors is creating an ever-expanding set of new and valuable data. In parallel the emerging capability of Big Data technologies to store, access, analyze, and react to this data is producing changes in business models under the umbrella of the Internet of Things (IoT). In particular within the Insurance industry, IoT appears positioned to enable deep changes by altering relationships between insurers, distributors, and the insured. In his session at @ThingsExpo, Michael Sick, a Senior Manager and Big Data Architect within Ernst and Young's Financial Servi...
May. 23, 2015 04:00 AM EDT Reads: 4,803
In the consumer IoT, everything is new, and the IT world of bits and bytes holds sway. But industrial and commercial realms encompass operational technology (OT) that has been around for 25 or 50 years. This grittier, pre-IP, more hands-on world has much to gain from Industrial IoT (IIoT) applications and principles. But adding sensors and wireless connectivity won’t work in environments that demand unwavering reliability and performance. In his session at @ThingsExpo, Ron Sege, CEO of Echelon, will discuss how as enterprise IT embraces other IoT-related technology trends, enterprises with i...
May. 23, 2015 03:00 AM EDT Reads: 4,269
Enthusiasm for the Internet of Things has reached an all-time high. In 2013 alone, venture capitalists spent more than $1 billion dollars investing in the IoT space. With "smart" appliances and devices, IoT covers wearable smart devices, cloud services to hardware companies. Nest, a Google company, detects temperatures inside homes and automatically adjusts it by tracking its user's habit. These technologies are quickly developing and with it come challenges such as bridging infrastructure gaps, abiding by privacy concerns and making the concept a reality. These challenges can't be addressed w...
May. 23, 2015 02:45 AM EDT Reads: 6,661
We’re no longer looking to the future for the IoT wave. It’s no longer a distant dream but a reality that has arrived. It’s now time to make sure the industry is in alignment to meet the IoT growing pains – cooperate and collaborate as well as innovate. In his session at @ThingsExpo, Jim Hunter, Chief Scientist & Technology Evangelist at Greenwave Systems, will examine the key ingredients to IoT success and identify solutions to challenges the industry is facing. The deep industry expertise behind this presentation will provide attendees with a leading edge view of rapidly emerging IoT oppor...
May. 23, 2015 02:30 AM EDT Reads: 4,914
The industrial software market has treated data with the mentality of “collect everything now, worry about how to use it later.” We now find ourselves buried in data, with the pervasive connectivity of the (Industrial) Internet of Things only piling on more numbers. There’s too much data and not enough information. In his session at @ThingsExpo, Bob Gates, Global Marketing Director, GE’s Intelligent Platforms business, to discuss how realizing the power of IoT, software developers are now focused on understanding how industrial data can create intelligence for industrial operations. Imagine ...
May. 23, 2015 02:00 AM EDT Reads: 5,170
SYS-CON Events announced today that Liaison Technologies, a leading provider of data management and integration cloud services and solutions, has been named "Silver Sponsor" of SYS-CON's 16th International Cloud Expo®, which will take place on June 9-11, 2015, at the Javits Center in New York, NY. Liaison Technologies is a recognized market leader in providing cloud-enabled data integration and data management solutions to break down complex information barriers, enabling enterprises to make smarter decisions, faster.
May. 23, 2015 01:30 AM EDT Reads: 5,302
The 17th International Cloud Expo has announced that its Call for Papers is open. 17th International Cloud Expo, to be held November 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA, brings together Cloud Computing, APM, APIs, Microservices, Security, Big Data, Internet of Things, DevOps and WebRTC to one location. With cloud computing driving a higher percentage of enterprise IT budgets every year, it becomes increasingly important to plant your flag in this fast-expanding business opportunity. Submit your speaking proposal today!
May. 23, 2015 01:15 AM EDT Reads: 4,261
Collecting data in the field and configuring multitudes of unique devices is a time-consuming, labor-intensive process that can stretch IT resources. Horan & Bird [H&B], Australia’s fifth-largest Solar Panel Installer, wanted to automate sensor data collection and monitoring from its solar panels and integrate the data with its business and marketing systems. After data was collected and structured, two major areas needed to be addressed: improving developer workflows and extending access to a business application to multiple users (multi-tenancy). Docker, a container technology, was used to ...
May. 23, 2015 01:00 AM EDT Reads: 1,966
Hadoop as a Service (as offered by handful of niche vendors now) is a cloud computing solution that makes medium and large-scale data processing accessible, easy, fast and inexpensive. In his session at Big Data Expo, Kumar Ramamurthy, Vice President and Chief Technologist, EIM & Big Data, at Virtusa, will discuss how this is achieved by eliminating the operational challenges of running Hadoop, so one can focus on business growth. The fragmented Hadoop distribution world and various PaaS solutions that provide a Hadoop flavor either make choices for customers very flexible in the name of opti...
May. 23, 2015 12:30 AM EDT Reads: 3,750
For years, we’ve relied too heavily on individual network functions or simplistic cloud controllers. However, they are no longer enough for today’s modern cloud data center. Businesses need a comprehensive platform architecture in order to deliver a complete networking suite for IoT environment based on OpenStack. In his session at @ThingsExpo, Dhiraj Sehgal from PLUMgrid will discuss what a holistic networking solution should really entail, and how to build a complete platform that is scalable, secure, agile and automated.
May. 23, 2015 12:00 AM EDT Reads: 4,255
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, June 9-11, 2015, at the Javits Center in New York City. Learn what is going on, contribute to the discussions, and ensure that your enterprise is as "IoT-Ready" as it can be
May. 22, 2015 11:30 PM EDT Reads: 1,956
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! Internet of @ThingsExpo, taking place Nov 3-5, 2015, at the Santa Clara Convention Center in Santa Clara, CA, is co-located with 17th Cloud Expo and will feature technical sessions from a rock star conference faculty and the leading industry players in the world. The Internet of Things (IoT) is the most profound change in personal an...
May. 22, 2015 11:30 PM EDT Reads: 2,625