Scientists invent tool to improve usability of mobile devices

The rapid increase in mobile technology such as smart phones and watches, tablets and Google Glass, has resulted in the need for more research to ensure those devices work well.

But, says Wichita State assistant professor Jibo He, there are no good tools to properly test mobile devices. So He, along with WSU professor Barb Chaparro, invented a solution using the latest technology of Google Glass.

It’s called uSee Glass and is a software application that allows remote observers to conduct usability testing. This week, He and Chaparro filed for a patent on the software.

These are the ways it works:

Participant point of view: The user can wear Google Glass, which includes the uSee Glass software and a video camera. The uSee Glass will capture scenes from the participant’s point of view and stream it for remote observation.

Researcher point of view: The researcher can have the uSee Glass application installed in his or her Google Glass and capture scenes from the researcher’s point of view. The researcher can also have uSee Glass installed in an Android tablet or a smart watch and use the application to communicate with remote observers. Wearing Google Glass or a smart watch allows the researcher to receive a tactile notification when a new message from remote observers arrives. They can also tap on the touchpad of Google Glass to mark important events.

Remote observation: A researcher can observe the scene remotely from anywhere using a computer with an Internet browser. The remote observer can communicate with the researcher via an Android device.

“Currently there’s no good way to do mobile research,” He said. “You can use a web cam, but that’s not from the point of view of the user. USee Glass for Google Glass and smart watches provides a new tool for mobile research. ”

Widespread possibilities

Part of what stands out about this tool is that it allows the researcher the ability to text and communicate with the user while he/she is looking at and interacting with a device. It makes for more efficient research, Chaparro says.

uSee Glass will also help further research that He is conducting on Google Glass. He is one of only a few people in Wichita to have early access to Google Glass and is researching the safety of people using the device while they drive.

While He and Chaparro are focusing their research on Google Glass and other mobile devices, there are potential ramifications for all kinds of industries, such as science, health care, aviation and agriculture.

“The possibilities apply to really any domain,” Chaparro said.

Courtesy: NewsWise

Ten Things Your Next Firewall Must Do

Overview :

Without question, your network is more complex than ever before. Your employees are accessing any application they want, using work or personal devices. Often times, these applications span both personal and work related usage, but the business and security risks are often ignored. New prospective employees are asking about application usage policies before accepting their new job. Adding yet another layer of complexity is the underlying concern around the effectiveness of your cyber security posture. Is your business a target? Is it a question of when, as opposed to if? And are you as prepared as you could be?

WhitePaper : Free Download

courtesy : Paulo Alto Networks

Woocommerce Payment Gateway

Woocommerce Free Payment Gateway Integration, This plugin adds the Novalnet payment gateway to the woocommerce enabled wordpress website.  For download the plugin please click here “Woocommerce Payment Gateway by Novalnet” or directly get the plugin from wordpress repository. This plugin provides lot of payment method features with high range of services.  It’s designed with efficient coding techniques to minimize the plugin loading time.

p3-detailed-breakdown p3-plugin-run-time

To test the demo shop please check out this link  https://woocommerce.novalnet.de/

Dart Language

Dart is a new web programming language with libraries, a virtual machine, and tools. Dart helps developers build structured modern web apps. Dart compiles to JavaScript to run across the entire modern web. Dart is inspired by a range of languages such as Smalltalk, Strongtalk, Erlang, C#, and JavaScript.

Dart language

Dart web language chart sheet

Features of Dart Language:

  • Object oriented.  Everything is an object including primitives and nulls
  • Optionally typed.  You can add type annotations which static checking tools can use to help you find errors in your code, but you don’t have to use them.
  • Interpreted.  Dart is run in a VM, but it is not compiled first.  Round-trip time for making changes is very short.
  • Compatible with JavaScript.  You can compile your Dart code to JavaScript and run Dart applications in any modern browser.
  • FAST!  Dart is very fast, much faster than JavaScript in just about every test.
  • Mixins.  Instead of using inheritance, you can use a mixin to add functionality to a class without directly inheriting from another class.
  • Isolates.  Instead of threads, the Dart language uses isolates for concurrency.  Isolates can’t actually share any memory, they pass information though messages.  It is very hard to shoot yourself in the foot.
  • Simplified built-in types.  Numbers can be either int or double, and you can just use num, if you don’t care.  Lists and maps can be declared as literals.  An array is just a special case of a list.
  • Functions are first-class objects.  You can pass them around just like any other object.  There is even a lambda-like short-hand for creating a one-liner function.
  • Top level functions and variables.  Don’t want to put a function or variable in a class?  Good, you don’t have to.  In the Dart language, you can declare them anywhere you want.
  • Simplified classes.  There is short-hand for declaring constructors that assign parameters to class members.  Class members don’t have protected, private, public.  Member variables are automatically properties.
  • String interpolation.  No more string format methods, just use the $variableName in a string to have its value expanded.

Creating your first Dart language App

Step 1:

Go to File –> New Application.

Fill in your application name without space. (for ex: i used “helloworld”)

Leave “Generate sample content” checked.

Select “Web application.”

dart_helloworld_app

Step 2:

Open the helloworld.html file and clear out everything in the body element except for the two script tags at the bottom.

The first script tag imports our actual Dart file, just like you would use to add JavaScript to a page.

The second script adds Dart support to the browser.

Step 3:

Add the following HTML to the body tag in the helloworld.html file:

1
2
<button id="theButton" >Click Me</button>
<div id="resultDiv"></div>

This will just create a button and a div.  We are going to add some Dart code to respond to a button click and populate the div with some text.

dart_helloworld

Step 4:

Open the helloworld.dart file and clear out everything in main() and delete the reverseText function.

Notice that there are only two things we really will need in our .dart file.  Just an import ‘dart:html’, to import that html library for Dart, and the main function, which executes as soon the DOM content is loaded on the page.

Step 5:

Edit the helloworldweb.dart file to make it look like this:

1
2
3
4
5
6
7
8
9
10
11
import 'dart:html';
void main() {
  var button = query("#theButton");
  button.onClick.listen(addResult);
}
void addResult(Event e) {
  var resultDiv = query("#resultDiv");
  resultDiv.text = "You clicked the button";
}

This code simply gets the button using a CSS selector.  It uses the query function to do this.

dart_helloworld_apptips

Then we register the addResult function as an event handler for the onClick event for the button.

In the addResult function, we simply query for the resultDiv and change its text.

After you run this example, you should see a result like this:

helloworlddartop

Step 6:

Now change the Dart code to look like this:

1
2
3
4
5
6
7
8
import 'dart:html';
void main() {
  query("#theButton")
    .onClick.listen(
        (e) => query("#resultDiv").text = "You clicked the button!"
    );
}

< content @courtesy oreilly >

Dart is a source code VM

The Dart VM reads and executes source code, which means there is no compile step between edit and run. As with other popular scripting languages, it’s very quick to iterate with Dart. The Dart VM runs on the command line and servers, and can be embedded into browsers. Just point the VM at Dart source code and you’re up and running!

Dart is optionally typed

Dart understands that sometimes you just don’t feel like appeasing a ceremonial type checker. Dart’s inclusion of an optional type system means you can use type annotations when you want, or use dynamic when that’s easier.

For example, you can explore a new idea without having to first think about type hierarchies. Just experiment and use var for your types. Once the idea is tested and you’re comfortable with the design, you can add type annotations.

Here is a comparison between code that uses type annotations, and code that uses var for dynamic. Both of these code snippets have the same runtime semantics:

With type annotations:

  void advance(double dt) {
    double dx, dy, dz, distance, mag;
    int size = bodies.length;
    for (int i = 0; i < size; i++) {
        Body bodyi = bodies[i];
        // ...

Or, without type annotations:

  advance(dt) {
    var dx, dy, dz, distance, mag;
    var size = bodies.length;
    for (var i = 0; i < size; i++) {
        var bodyi = bodies[i];
        // …

Type annotations are great for the “surface area” of the code (such as method and function signatures), and the tools are getting good enough for you to consider using var inside methods and functions.

Dart supports collection literals

It’s easy to declare lists and maps with Dart. For example, here is a simple list:

var fruits = ['apples', 'oranges', 'pears'];

And here is a simple map:

var accounts = {'322532': new Account('Bob'), '43534345': new Account('Alice')};

Dart is purely object oriented

Dart’s language is clear: everything is an object. It is easy to explain how everything works without having to deal with primitives as a special case. Even calling + on two numbers is modeled as a method call. Numbers, booleans, and even null are all objects.

Dart supports top-level functions and variables

Not everything must live inside of a class. Dart’s libraries can contain top-level functions and variables. You can write whole programs without ever using a class.

Here is a simple Dart library:

library louder;

String shout(String msg) => msg.toUpperCase();

Using this library is easy:

import 'louder.dart';

main() {
  print(shout('Dart is fun!'));  // DART IS FUN!
}

Dart’s main function is terse

No more public-static-void-main-String[]-args just to start a program! Dart’s simple top-level main()function is all you need.

Here is an example:

main() {
  print('Hello, Dart!');
}

All Dart programs start at the main() function.

Dart lets you put any number of public classes into a file

Organize your project’s files and contents the way you want to. You are not forced to name the file the same as the class, and you aren’t forced to place only one public class in a file. Go ahead, put two classes into one file. Whatever works for you!

Dart has closures and lexically scoped functions

Create functions that can naturally access variables in their enclosing scope, without having to write verbose anonymous inner classes.

Here is an example of a closure in action. The makeAdder function returns a function that closes aroundmakeAdder‘s parameter.

makeAdder(int x) {
  adder(int y) => x + y;
  return adder;
}

main() {
  var add2 = makeAdder(2);
  var result = add2(3);
  print(result); // 5
}

You can use simplify makeAdder by returning an anonymous function:

makeAdder(int x) {
  return (int y) => x + y;
}

Dart has mixins

No need to pollute the inheritance hierarchy with utility classes. Use Dart’s mixins to slide in functionality that is clearly not an is-a relationship.

Classes that extend object, don’t have constructors, and don’t call super can be a mixin. Here is an example:

abstract class Persistable {
  save() { ... }
  load() { ... }
  toJson();
}

class Hug extends Object with Persistable {
  Map toJson() => {'strength':10};
}

main() {
  var embrace = new Hug();
  embrace.save();
}

Dart has operator overriding

You can add operators to your class. Here is an example:

class Point {
  num x, y;
  Point(this.x, this.y);

  Point operator +(Point other) => new Point(x+other.x, y+other.y);
}

main() {
  var p1 = new Point(1, 1);
  var p2 = new Point(2, 2);
  var p3 = p1 + p2;
}

Dart has string interpolation

It’s very easy to build a string from variables or expressions. Here is an example of implementing toString()and including the x and y fields in the output.

// Dart
class Point {
  num x, y;
  Point(this.x, this.y);

  String toString() => 'X: $x, Y: $y';
}

Dart has noSuchMethod

A class can implement noSuchMethod to handle methods that don’t explicitly exist on the class.

In the following example, the LoggingProxy logs all method calls before they are delegated. The code uses mirrors for run-time reflection and delegation, and noSuchMethod to capture the calls.

import 'dart:mirrors';

class LoggingProxy {
  InstanceMirror mirror;
  LoggingProxy(delegate)
    : mirror = reflect(delegate);

  noSuchMethod(Invocation invocation) {
    var name = invocation.memberName;
    print('${name} was called');
    return mirror.delegate(invocation);
  }
}

You can use the above code like this:

class Greeter {
  hello() => print("hello!");
}

void main() {
  var greeter = new LoggingProxy(new Greeter());
  greeter.hello();
}

// Output is:
// Symbol("hello") was called  (from the proxy)
// hello!  (from the delegate Greeter)

< content @courtesy oreilly >

Reference:
1) http://www.dartlang.org/#get-started

2) http://pluralsight.com/training/Courses/TableOfContents/introduction-building-web-applications-dart

3) http://www.dartlang.org/tools/editor/

4) http://www.dartlang.org/docs/cookbook/

5) http://www.dartlang.org/docs/dart-up-and-running/contents/ch03.html

6) http://www.dartlang.org/docs/

Computer System Automatically Generates TCP Congestion-Control Algorithms

TCP, the transmission control protocol, is one of the core protocols governing the Internet: If counted as a computer program, it’s the most widely used program in the world.

tcp

One of TCP’s main functions is to prevent network congestion by regulating the rate at which computers send data. In the last 25 years, engineers have made steady improvements to TCP’s congestion-control algorithms, resulting in several competing versions of the protocol: Many Windows computers, for instance, run a version called Compound TCP, while Linux machines run a version called TCP Cubic.

At the annual conference of the Association for Computing Machinery’s Special Interest Group on Data Communication this summer, researchers from MIT’s Computer Science and Artificial Intelligence Laboratory and Center for Wireless Networks and Mobile Computing will present a computer system, dubbed Remy, that automatically generates TCP congestion-control algorithms. In the researchers’ simulations, algorithms produced by Remy significantly outperformed algorithms devised by human engineers.

tcp_ip

“I think people can think about what happens to one or two connections in a network and design around that,” says Hari Balakrishnan, the Fujitsu Professor in Electrical Engineering and Computer Science, who co-authored the new paper with graduate student Keith Winstein. “When you have even a handful of connections, or more, and a slightly more complicated network, where the workload is not a constant — a single file being sent, or 10 files being sent — that’s very hard for human beings to reason about. And computers seem to be a lot better about navigating that search space.”

Lay of the land

Remy is a machine-learning system, meaning that it arrives at its output by trying lots of different possibilities, and exploring further variations on those that seem to work best. Users specify certain characteristics of the network, such as whether the bandwidth across links fluctuates or the number of users changes, and by how much. They also provide a “traffic profile” that might describe, say, the percentage of users who are browsing static webpages or using high-bandwidth applications like videoconferencing.

Finally, the user also specifies the metrics to be used to evaluate network performance. Standard metrics include throughput, which indicates the total amount of data that can be moved through the network in a fixed amount of time, and delay, which indicates the average amount of time it takes one packet of information to travel from sender to receiver. The user can also assign metrics different weights — say, reducing delay is important, but only one-third as important as increasing throughput.

Remy needs to test each candidate algorithm’s performance under a wide range of network conditions, which could have been a prohibitively time-consuming task. But Winstein and Balakrishnan developed a clever algorithm that can concentrate Remy’s analyses on cases in which small variations in network conditions produce large variations in performance, while spending much less time on cases where network behavior is more predictable.

They also designed Remy to evaluate possible indicators of network congestion that human engineers have not considered. Typically, TCP congestion-control algorithms look at two main factors: whether individual data packets arrive at their intended destination and, if they do, how long it takes for acknowledgments to arrive. But as it turns out, the ratio between the rates at which packets are sent and received is a rich signal that can dictate a wide range of different behaviors on the sending computer’s end.

Down to cases

Indeed, where a typical TCP congestion-control algorithm might consist of a handful of rules — if the percentage of dropped packets crosses some threshold, cut the transmission rate in half — the algorithms that Remy produces can have more than 150 distinct rules.

“It doesn’t resemble anything in the 30-year history of TCP,” Winstein says. “Traditionally, TCP has relatively simple endpoint rules but complex behavior when you actually use it. With Remy, the opposite is true. We think that’s better, because computers are good at dealing with complexity. It’s the behavior you want to be simple.” Why the algorithms Remy produces work as well as they do is one of the topics the researchers hope to explore going forward.

In the meantime, however, there’s little arguing with the results. Balakrishnan and Winstein tested Remy’s algorithms on a simulation system called the ns-2, which is standard in the field.

In tests that simulated a high-speed, wired network with consistent transmission rates across physical links, Remy’s algorithms roughly doubled network throughput when compared to Compound TCP and TCP Cubic, while reducing delay by two-thirds. In another set of tests, which simulated Verizon’s cellular data network, the gains were smaller but still significant: a 20 to 30 percent improvement in throughput, and a 25 to 40 percent reduction in delay.

courtesy @sciencedaily

Data Mining

A class of database applications that look for hidden patterns in a group ofdata that can be used to predict future behavior. For example, data mining software can help retail companies find customers with common interests. The term is commonly misused to describe software that presents data in new ways. True data mining software doesn’t just change the presentation, but actually discovers previously unknown relationships among the data.

Data mining is popular in the science and mathematical fields but also is utilized increasingly by marketers trying to distill useful consumer data from Web sites. [ Definition from webopedia ]

Overview

Generally, data mining (sometimes called data or knowledge discovery) is the process of analyzing data from different perspectives and summarizing it into useful information – information that can be used to increase revenue, cuts costs, or both. Data mining software is one of a number of analytical tools for analyzing data. It allows users to analyze data from many different dimensions or angles, categorize it, and summarize the relationships identified. Technically, data mining is the process of finding correlations or patterns among dozens of fields in large relational databases.

Continuous Innovation

Although data mining is a relatively new term, the technology is not. Companies have used powerful computers to sift through volumes of supermarket scanner data and analyze market research reports for years. However, continuous innovations in computer processing power, disk storage, and statistical software are dramatically increasing the accuracy of analysis while driving down the cost.

Example

For example, one Midwest grocery chain used the data mining capacity of Oracle software to analyze local buying patterns. They discovered that when men bought diapers on Thursdays and Saturdays, they also tended to buy beer. Further analysis showed that these shoppers typically did their weekly grocery shopping on Saturdays. On Thursdays, however, they only bought a few items. The retailer concluded that they purchased the beer to have it available for the upcoming weekend. The grocery chain could use this newly discovered information in various ways to increase revenue. For example, they could move the beer display closer to the diaper display. And, they could make sure beer and diapers were sold at full price on Thursdays.

Data, Information, and Knowledge

Data

Data are any facts, numbers, or text that can be processed by a computer. Today, organizations are accumulating vast and growing amounts of data in different formats and different databases. This includes:

  • operational or transactional data such as, sales, cost, inventory, payroll, and accounting
  • nonoperational data, such as industry sales, forecast data, and macro economic data
  • meta data – data about the data itself, such as logical database design or data dictionary definitions

Information

The patterns, associations, or relationships among all this data can provide information. For example, analysis of retail point of sale transaction data can yield information on which products are selling and when.

Knowledge

Information can be converted into knowledge about historical patterns and future trends. For example, summary information on retail supermarket sales can be analyzed in light of promotional efforts to provide knowledge of consumer buying behavior. Thus, a manufacturer or retailer could determine which items are most susceptible to promotional efforts.

Data Warehouses

Dramatic advances in data capture, processing power, data transmission, and storage capabilities are enabling organizations to integrate their various databases into data warehouses. Data warehousing is defined as a process of centralized data management and retrieval. Data warehousing, like data mining, is a relatively new term although the concept itself has been around for years. Data warehousing represents an ideal vision of maintaining a central repository of all organizational data. Centralization of data is needed to maximize user access and analysis. Dramatic technological advances are making this vision a reality for many companies. And, equally dramatic advances in data analysis software are allowing users to access this data freely. The data analysis software is what supports data mining.

What can data mining do?

Data mining is primarily used today by companies with a strong consumer focus – retail, financial, communication, and marketing organizations. It enables these companies to determine relationships among “internal” factors such as price, product positioning, or staff skills, and “external” factors such as economic indicators, competition, and customer demographics. And, it enables them to determine the impact on sales, customer satisfaction, and corporate profits. Finally, it enables them to “drill down” into summary information to view detail transactional data.

With data mining, a retailer could use point-of-sale records of customer purchases to send targeted promotions based on an individual’s purchase history. By mining demographic data from comment or warranty cards, the retailer could develop products and promotions to appeal to specific customer segments.

For example, Blockbuster Entertainment mines its video rental history database to recommend rentals to individual customers. American Express can suggest products to its cardholders based on analysis of their monthly expenditures.

WalMart is pioneering massive data mining to transform its supplier relationships. WalMart captures point-of-sale transactions from over 2,900 stores in 6 countries and continuously transmits this data to its massive 7.5 terabyte Teradata data warehouse. WalMart allows more than 3,500 suppliers, to access data on their products and perform data analyses. These suppliers use this data to identify customer buying patterns at the store display level. They use this information to manage local store inventory and identify new merchandising opportunities. In 1995, WalMart computers processed over 1 million complex data queries.

The National Basketball Association (NBA) is exploring a data mining application that can be used in conjunction with image recordings of basketball games. The Advanced Scout software analyzes the movements of players to help coaches orchestrate plays and strategies. For example, an analysis of the play-by-play sheet of the game played between the New York Knicks and the Cleveland Cavaliers on January 6, 1995 reveals that when Mark Price played the Guard position, John Williams attempted four jump shots and made each one! Advanced Scout not only finds this pattern, but explains that it is interesting because it differs considerably from the average shooting percentage of 49.30% for the Cavaliers during that game.

By using the NBA universal clock, a coach can automatically bring up the video clips showing each of the jump shots attempted by Williams with Price on the floor, without needing to comb through hours of video footage. Those clips show a very successful pick-and-roll play in which Price draws the Knick’s defense and then finds Williams for an open jump shot.

How does data mining work?

While large-scale information technology has been evolving separate transaction and analytical systems, data mining provides the link between the two. Data mining software analyzes relationships and patterns in stored transaction data based on open-ended user queries. Several types of analytical software are available: statistical, machine learning, and neural networks. Generally, any of four types of relationships are sought:

  • Classes: Stored data is used to locate data in predetermined groups. For example, a restaurant chain could mine customer purchase data to determine when customers visit and what they typically order. This information could be used to increase traffic by having daily specials.
  • Clusters: Data items are grouped according to logical relationships or consumer preferences. For example, data can be mined to identify market segments or consumer affinities.
  • Associations: Data can be mined to identify associations. The beer-diaper example is an example of associative mining.
  • Sequential patterns: Data is mined to anticipate behavior patterns and trends. For example, an outdoor equipment retailer could predict the likelihood of a backpack being purchased based on a consumer’s purchase of sleeping bags and hiking shoes.

Data mining consists of five major elements:

  • Extract, transform, and load transaction data onto the data warehouse system.
  • Store and manage the data in a multidimensional database system.
  • Provide data access to business analysts and information technology professionals.
  • Analyze the data by application software.
  • Present the data in a useful format, such as a graph or table.

Different levels of analysis are available:

  • Artificial neural networks: Non-linear predictive models that learn through training and resemble biological neural networks in structure.
  • Genetic algorithms: Optimization techniques that use processes such as genetic combination, mutation, and natural selection in a design based on the concepts of natural evolution.
  • Decision trees: Tree-shaped structures that represent sets of decisions. These decisions generate rules for the classification of a dataset. Specific decision tree methods include Classification and Regression Trees (CART) and Chi Square Automatic Interaction Detection (CHAID) . CART and CHAID are decision tree techniques used for classification of a dataset. They provide a set of rules that you can apply to a new (unclassified) dataset to predict which records will have a given outcome. CART segments a dataset by creating 2-way splits while CHAID segments using chi square tests to create multi-way splits. CART typically requires less data preparation than CHAID.
  • Nearest neighbor method: A technique that classifies each record in a dataset based on a combination of the classes of the k record(s) most similar to it in a historical dataset (where k 1). Sometimes called the k-nearest neighbor technique.
  • Rule induction: The extraction of useful if-then rules from data based on statistical significance.
  • Data visualization: The visual interpretation of complex relationships in multidimensional data. Graphics tools are used to illustrate data relationships.

 

What technological infrastructure is required?

Today, data mining applications are available on all size systems for mainframe, client/server, and PC platforms. System prices range from several thousand dollars for the smallest applications up to $1 million a terabyte for the largest. Enterprise-wide applications generally range in size from 10 gigabytes to over 11 terabytes. NCR has the capacity to deliver applications exceeding 100 terabytes. There are two critical technological drivers:

  • Size of the database: the more data being processed and maintained, the more powerful the system required.
  • Query complexity: the more complex the queries and the greater the number of queries being processed, the more powerful the system required.

Relational database storage and management technology is adequate for many data mining applications less than 50 gigabytes. However, this infrastructure needs to be significantly enhanced to support larger applications. Some vendors have added extensive indexing capabilities to improve query performance. Others use new hardware architectures such as Massively Parallel Processors (MPP) to achieve order-of-magnitude improvements in query time. For example, MPP systems from NCR link hundreds of high-speed Pentium processors to achieve performance levels exceeding those of the largest supercomputers.

Reference Links:

 

Introduction to Data Mining

http://www-pcc.qub.ac.uk/tec/courses/datamining/stu_notes/dm_book_1.html

Information about data mining research, applications, and tools:

http://info.gte.com/kdd/

http://www.kdnuggets.com

http://www.ultragem.com/

http://www.cs.bham.ac.uk/~anp/TheDataMine.html

http://www.think.com/html/data_min/data_min.htm

http://direct.boulder.ibm.com/bi/

http://www.software.ibm.com/data/

http://coral.postech.ac.kr/~swkim/software.html

http://www.cs.uah.edu/~infotech/mineproj.html

http://info.gte.com/~kdd/index.html

http://info.gte.com/~kdd/siftware.html

http://iris.cs.uml.edu:8080/

http://www.datamining.com/datamine/welcome.htm

 

Data Sets to test data mining algorithms:

http://www.scs.unr.edu/~cbmr/research/data.html

 

Data mining journal (Read Usama M. Fayyad’s editorial.):

http://www.research.microsoft.com/research/datamine/

 

Interesting application of data mining:

http://www.nba.com/allstar97/asgame/beyond.html

 

Data mining papers:

http://www.satafe.edu/~kurt/index.shtml

http://www.cs.bham.ac.uk/~anp/papers.html

http://coral.postech.ac.kr/~swkim/old_papers.html

 

Data mining conferences:

http://www-aig.jpl.nasa.gov/kdd97

http://www.cs.bahm.ac.uk/~anp/conferences/html

 

Conference on very large databases:

http://www.vldb.com/homepage.htm

 

Sites for datamining vendors and products:

American Heuristics (Profiler)

http://www.heuristics.com

Angoss software (Knowledge Seeker)

http://www.angoss.com

Attar Software (XpertRule Profiler)

http://www.attar.com

Business Objects (BusinessMiner)

http://www.businessobjects.com

DataMind (DataMind Professional)

http://www.datamind.com

HNC Software (DataMarksman, Falcon)

http://www.hncs.com

HyperParallel (Discovery)

http://www.hyperparallel.com

Information Discovery Inc. (Information Discovery System)

http://www.datamining.com

Integral Solutions (Clementine)

http://www.isl.co.uk/index.html

IBM (Intelligent Data Miner)

http://www.ibm.com/Stories/1997/04/data1.html

Lucent Technologies (Interactive Data Visualization)

http://www.lucent.com

NCR (Knowledge Discovery Benchmark)

http://www.ncr.com

NeoVista Sloutions (Decision Series)

http://www.neovista.com

Nestor (Prism)

http://www.nestor.com

Pilot Software (Pilot Discovery Server)

http://www.pilotsw.com

Seagate Software Systems (Holos 5.0)

http://www.holossys.com

SPSS (SPSS)

http://www.spss.com

Thinking Machines (Darwin)

http://www.think.com

 

Math Behind Growth of ‘Coffee Rings’

Last year, a team of University of Pennsylvania physicists showed how to undo the “coffee-ring effect,” a commonplace occurrence when drops of liquid with suspended particles dry, leaving a ring-shaped stain at the drop’s edges. Now the team is exploring how those particles stack up as they reach the drop’s edge, and they discovered that different particles make smoother or rougher deposition profiles at the drop edge depending on their shape.

cofee rings

Slightly stretched particles exhibited a rare Kardar-Parisi-Zhang growth process. (Credit: Art: Felice Macera)

These resultant growth profiles offer tests of deep mathematical ideas about growing interfaces and are potentially relevant for many commercial and industrial coating applications.

The new research was conducted by the members of the original team: professor Arjun Yodh, director of the Laboratory for Research on the Structure of Matter; doctoral candidates Peter Yunker and Matthew Lohr; and postdoctoral fellow Tim Still, all of the Department of Physics and Astronomy in Penn’s School of Arts and Sciences. New to the collaboration were professor D.J. Durian of the Department of Physics and Astronomy and Alexei Borodin, professor of mathematics at the Massachusetts Institute of Technology.

Their study was published in the journal Physical Review Letters.

In the “coffee-ring effect,” drop edges are “pinned” to a surface, meaning that when the liquid evaporates, the drop can’t shrink in circumference and particles are convectively pushed to its edges. The Penn team’s earlier research showed that this phenomenon was highly dependent on particle shape. Spherical particles could flow under or over each other to aggregate on the edges, but ellipsoidal particles formed loosely packed logjams as they interacted with one another on the surface of the drop.

MIT’s Borodin saw the Penn team’s earlier experimental videos online, and they reminded him of analytical and simulation work he and others in the math community had performed on interfacial growth processes. These problems had some similarity to the random-walker problem, a classic example in probability theory that involves tracing the path of an object that randomly picks a direction each time it takes a step. In the present case, however, the random motion involved the shape of a surface: the edge of the drop where new particles are added to the system. Borodin was curious about these growth processes in drying drops, especially whether particle shape had any effect.

“Interfacial growth processes are ubiquitous in nature and industry, ranging from vapor deposition coatings to growing bacterial colonies, but not all growth processes are the same,” Yunker said. “Theorists have identified several qualitatively distinct classes of these processes, but these predictions have proven difficult to test experimentally.”

The two classes of particular interest are “Poisson” and “Kardar-Parisi-Zhang” processes. Poisson processes arise when growth is random in space and time; in the context of an interfacial growth process, the growth of one individual region is independent of neighboring regions. Kardar-Parisi-Zhang, or KPZ, processes are more complicated, arising when growth of an individual region depends on neighboring regions.

A purely mathematical simulation of an interfacial growth process might look like a game of Tetris but with single square blocks. These blocks fall at random into a series of adjacent columns, forming stacks.

In a Poisson process, since individual regions are independent, a tall stack is just as likely to be next to a short stack as another tall stack. Taking the top layers of the stacks as the “surface” of the system, Poisson processes produce a very rough surface, with large changes in surface height from one column to the next.

In contrast, KPZ processes arise when the blocks are “sticky.” When these blocks fall into a column, they don’t always fall all the way to the bottom but can stick to adjacent columns at their highest point. This means that short columns quickly catch up to their tall neighbors, and the resulting growth surfaces are smoother. There will be fewer abrupt changes in height from one column to the next.

“Many theoretical simulations have demonstrated KPZ processes, a fact which might lead one to think this process should be ubiquitous in nature,” Yunker said. “However, few experiments have identified signatures of KPZ processes.”

“The relative paucity of identified KPZ processes in experiments is likely due to two main factors,” Yodh said. “First, a clean experiment is required; the presence of impurities or particle aggregation can destroy signatures of growth processes. Second, a substantial amount of data must be collected to make comparisons to theoretical predictions.

“Thus, experiments must be very precise and must characterize a wide range of size scales from the particle diameter to the growth fronts. Moreover, they must be repeated many times under exactly the same conditions to accumulate statistically meaningful amounts of homogeneous data.”

As in the previous research, the Penn team’s experiment involved drying drops of water with differently shaped plastic particles under a microscope. The team measured the growth fronts of particles at the drying edge, especially their height fluctuations — the edge’s roughness — over time. When using spherical particles, they found their deposition at the edges of the drop exhibited a classic Poisson growth process. As they tried with increasingly elongated particles, however, the deposition pattern changed.

Slightly elliptical particles — spheres stretched by 20 percent — produced the elusive KPZ class of growth. Stretching the spheres further, 250 percent out of round, produced a third growth process known as KPZQ, or Kardar-Parisi-Zhang with Quenched Disorder. It is also called the “colloidal Matthew effect” as the surface’s growth is proportional to the local particle density so that particle-rich regions get richer, while particle poor regions stay poor.

In practical terms, the experiment showed that when spheres and highly stretched particles are deposited, surface roughness grows at a high rate. However, when slightly stretched particles are deposited, surface roughness grows at a relatively slow rate.

The ability to control surface roughness can be important for industrial and commercial applications, as non-uniformity in films and coatings can lead to structural weakness or poor aesthetics. Surface roughness is controlled passively in the team’s experiments, making this process potentially attractive alternative for more costly or complicated smoothing processes currently in use.

“Experimental successes are highly valued in the math community,” Borodin said. “Not only do they demonstrate real-life applicability of very advanced yet originally purely theoretical research, but they also suggest further directions and even predict yet undiscovered mathematical phenomena.”

Courtesy: sciencedaily