Shulou(Shulou.com)06/03 Report--

Overview of MapReduce

MapReduce is derived from Google's MapReduce paper, which was published in December 2004. Hadoop MapReduce can be said to be an open source implementation of Google MapReduce. The advantage of MapReduce is that large amounts of data can be processed offline, and MapReduce is easy to develop, because the MapReduce framework helps us package the development of distributed computing. And the requirement of hardware facilities is not high, it can be run on cheap machines. MapReduce also has its shortcomings, its main disadvantage is that it can not complete real-time streaming computing, so it can only be processed offline.

MapReduce is a programming model that is used for parallel operations on large datasets (larger than 1TB). The concepts "Map" and "Reduce" are their main ideas, both borrowed from functional programming languages and features borrowed from vector programming languages. It greatly facilitates programmers to run their programs on distributed systems without distributed parallel programming. The current software implementation is to specify a Map (mapping) function, which is used to map a set of key-value pairs into a new set of key-value pairs, and to specify concurrent Reduce (reduction) functions, which are used to ensure that each of the mapped key-value pairs shares the same key group.

The address of the official MapReduce document is as follows:

Https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html

Before learning MapReduce, we need to prepare the environment of Hadoop, that is, we need to install HDFS and YARN. The way to build the environment can refer to my previous two articles: building HDFS pseudo-distributed environment and distributed resource scheduling-- YARN framework

Talking about the MapReduce programming Model from the WordCount case

When installing Hadoop, it comes with a case of WordCount, which is the number of times each word appears in the statistics file, that is, word frequency statistics. When we learn the development of big data, we usually use WordCount as an introduction.

For example, I now have a test.txt with the following contents:

Hello worldhello hadoophello MapReduce

The requirement now is to count the number of times each word appears in this file. Suppose I have now written some code to implement the word frequency statistics of this file, and the results are as follows:

Hello 3world 1hadoop 1MapReduce 1

The above is an example of word frequency statistics.

Word frequency statistics seems to be very simple, generally does not need much code to complete, and if you are familiar with shell scripts, even a sentence of code can complete this word frequency statistics function. It is true that word frequency statistics is not difficult, but why use big data technology to complete this word frequency statistics function? This is because the implementation of word frequency statistics for small files may be done with simple code, but can it be done with simple code for hundreds of GB, TB or even PB-level large files? This is obviously impossible, and even if it can, it will cost a lot of time.

Big data technology is to solve this problem of dealing with massive data, in which MapReduce acts as a distributed parallel computing role, distributed parallel computing can greatly improve the processing speed of massive data, after all, multiple people must work faster than one person. Going back to the example of word frequency statistics mentioned above, in practical work, many scenarios are developed on the basis of WordCount. For example, to count the most visited url and the most visited IP from the access logs of all servers, this is a typical WordCount application scenario, knowing that even small companies' server access logs are usually GB-level.

A schematic diagram of the process of performing WordCount using MapReduce:

From the figure above, you can see that the input data set is split into multiple blocks, and then these blocks are placed on different nodes for parallel computing. In the Splitting part, the words will be split according to the separator or segmentation rules, and after the split is completed, it will be transferred to the Mapping. In the Mapping part, the same words will be mapped or transferred to the same node through the network. Then these same words will be reshuffled in the Shuffling link, that is, merge, and after the merger will be completed, it will enter the Reducing link, which is to merge all the merged words again, that is, they will be output to a file in the HDFS file system. Generally speaking, it is a process of splitting and merging, so MapReduce is divided into map and Reduce. Most importantly, it is important to understand that this process is distributed and parallel, and that each node is not dependent on each other and is independent of each other.

MapReduce execution process

As mentioned above, MapReduce is divided into Map and Reduce, which means that a MapReduce job is split into Map and Reduce phases. The Map phase corresponds to a bunch of Map Tasks, and the same Reduce phase corresponds to a bunch of Reduce Tasks.

In fact, to put it simply, this is also an input / output process. It is important to note that the data sets entered in the MapReduce framework are serialized into key / value pairs. These key-value pairs are sorted after the map phase is completed, and finally merged and output in the reduce phase. The output is also key / value pairs. The process of writing official website documents is as follows:

(input)-> map->-> combine->-> reduce-> (output)

Schematic diagram:

We can see that there are several main points:

InputFormat: split our input data (split) Split: hand over the data block to the MapReduce job for processing. The data block is the smallest computing unit in MapReduce. In HDFS, the data block is the smallest storage unit. By default, HDFS and MapReduce correspond one to one by default. Of course, we can also manually set the relationship between them (but not recommended) OutputFormat: output the final processing result.

We can look at another figure. Suppose we manually set the correspondence between block and split. One block corresponds to two split:

In the figure above, one block corresponds to two split (default is one-to-one), and one split corresponds to one Map Task. After grouping the data into groups, Map Task will output the data to Shuffle,Shuffle and output to Reduce, and each Reduce Tasks will be output to a file. There are three Reduce Tasks in the image above, so it will be output to three files.

MapReduce1.x architecture

The MapReduce1.x architecture diagram is as follows:

Briefly describe several of these components:

JobTracker: the manager of the job, which breaks down the job into a pile of tasks, that is, the Task,Task contains MapTask and ReduceTask. It assigns the decomposed tasks to TaskTracker to run, and it also needs to complete job monitoring and fault-tolerant processing (if the task job dies, task will be restarted). If the JobTracker does not receive a heartbeat message from a TaskTracker within a certain period of time, it determines that the TaskTracker is dead, and then assigns the task running on that TaskTracker to another TaskTracker. TaskTracker: the executor of the task, our Task (MapTask and ReduceTask) runs on TaskTracker, and TaskTracker can interact with JobTracker, such as executing, starting or stopping jobs, and sending heartbeats to JobTracker. MapTask: the Map task we developed will be handed over to the Task, which parses the data of each record, then gives it to the Map method written by ourselves to process it, and writes the output of Map to the local disk when the processing is complete. However, some jobs may have only map and no reduce, so the results are usually output to the HDFS file system. ReduceTask: the data output from MapTask is read, grouped according to the rules of the data, and then passed to the reduce method written by ourselves for processing. When the processing is complete, the output is written to HDFS by default. MapReduce2.x architecture

As shown in the MapReduce2.x architecture diagram, you can see that JobTracker and TaskTracker no longer exist and have been replaced by ResourceManager and NodeManager. Not only the architecture has changed, but the function has also changed. After 2.x, YARN was introduced. On top of YARN, we can run different computing frameworks. Instead of 1.x, we can only run MapReduce:

The architecture of MapReduce2.x has been explained previously in the distributed resource scheduling-YARN framework, so I won't repeat it here.

Implementation of wordcount function in Java version

1. Create a Maven project. The configuration depends on the following:

Cloudera https://repository.cloudera.com/artifactory/cloudera-repos/ true false UTF-8 2.6.0-cdh6.7.0 org.apache.hadoop hadoop-client ${hadoop.version} junit junit 4.10 test

two。 Create a class and start writing our wordcount implementation code:

Package org.zero01.hadoop.mapreduce;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.Path;import org.apache.hadoop.io.LongWritable;import org.apache.hadoop.io.Text;import org.apache.hadoop.mapreduce.Job;import org.apache.hadoop.mapreduce.Mapper;import org.apache.hadoop.mapreduce.Reducer;import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;import java.io.IOException / * * @ program: hadoop-train * @ description: develop WordCount applications using MapReduce * @ author: 01 * @ create: 2018-03-31 14:03 * * / public class WordCountApp {/ * Map: read the contents of the input file * / public static class MyMapper extends Mapper {LongWritable one = new LongWritable (1) Protected void map (LongWritable key, Text value, Context context) throws IOException, InterruptedException {/ / each line of data received String line = value.toString (); / / split String [] words = line.split ("") according to the specified delimiter For (String word: words) {/ / output the processing result of map to context.write (new Text ((word)), one) through the context } / * Reduce: merge operation * / public static class MyReducer extends Reducer {protected void reduce (Text key, Iterable values, Context context) throws IOException, InterruptedException {long sum = 0; for (LongWritable value: values) {/ / find the total number of key occurrences sum + = value.get () } / / output the final statistical result to context.write (key, new LongWritable (sum));}} / * define Driver: encapsulates all the information of the MapReduce job * / public static void main (String [] args) throws IOException, ClassNotFoundException, InterruptedException {Configuration configuration = new Configuration () / / create Job, set the name of Job by parameter Job job = Job.getInstance (configuration, "wordcount"); / / set the processing class job.setJarByClass (WordCountApp.class) of Job; / / set the input path for job processing FileInputFormat.setInputPaths (job, new Path (args [0])); / / set map related parameter job.setMapperClass (MyMapper.class) Job.setMapOutputKeyClass (Text.class); job.setMapOutputValueClass (LongWritable.class); / / set reduce related parameters job.setReducerClass (MyReducer.class); job.setOutputKeyClass (Text.class); job.setOutputValueClass (LongWritable.class); / / set the output path FileOutputFormat.setOutputPath (job, new Path (args [1])) after job processing is completed System.exit (job.waitForCompletion (true)? 0: 1);}}

3. After the writing is complete, compile and package it through Maven in IDEA:

4. Upload the packaged jar package to the server:

The test file is as follows:

[root@localhost ~] # hdfs dfs-text / test.txthello worldhadoop welcomehadoop hdfs mapreducehadoop hdfshello hadoop [root@localhost ~] #

5. Then execute the following command to execute Job:

[root@localhost ~] # hadoop jar. / hadoop-train-1.0.jar org.zero01.hadoop.mapreduce.WordCountApp / test.txt / output/wc

Briefly explain this command:

Hadoop jar is the command for Hadoop to execute the jar package. / hadoop-train-1.0.jar is the path of the jar package org.zero01.hadoop.mapreduce.WordCountApp is the main class of the jar package, that is, the main class / test.txt is the test file, that is, the path where the input file is located (the path on HDFS) / output/wc is the existence path of the output file.

6. Go to YARN to view the information about task execution:

Apply for resources:

Run:

Complete:

7. You can see that the execution has been successful, and the log output of the command line terminal is as follows:

18-03-31 22:55:51 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... Using builtin-java classes where applicable18/03/31 22:55:52 INFO client.RMProxy: Connecting to ResourceManager at / 0.0.0.0:803218/03/31 22:55:52 WARN mapreduce.JobResourceUploader: Hadoop command-line option parsing not performed. Implement the Tool interface and execute your application with ToolRunner to remedy this.18/03/31 22:55:53 INFO input.FileInputFormat: Total input paths to process: 118-03-31 22:55:53 INFO mapreduce.JobSubmitter: number of splits:118/03/31 22:55:53 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_1522505784761_000118/03/31 22:55:54 INFO impl.YarnClientImpl: Submitted application application_1522505784761_000118/03/31 22:55:54 INFO mapreduce.Job: The url to track the job : http://localhost:8088/proxy/application_1522505784761_0001/18/03/31 22:55:54 INFO mapreduce.Job: Running job: job_1522505784761_000118/03/31 22:56:06 INFO mapreduce.Job: Job job_1522505784761_0001 running in uber mode: false18/03/31 22:56:06 INFO mapreduce.Job: map 0 reduce 0 reduce 03 Greg 31 22:56:11 INFO mapreduce.Job: map 100% reduce 0 Legend 03 INFO mapreduce.Job: 31 22:56:16 INFO mapreduce.Job: Map reduce 100-03-31 22:56:16 INFO mapreduce.Job: Job job_1522505784761_0001 completed successfully18/03/31 22:56:16 INFO mapreduce.Job: Counters: 49 File System Counters FILE: Number of bytes read=190 FILE: Number of bytes written=223169 FILE: Number of read operations=0 FILE: Number of large read operations=0 FILE: Number of write operations=0 HDFS: Number of bytes read=174 HDFS: Number of bytes written=54 HDFS: Number of Read operations=6 HDFS: Number of large read operations=0 HDFS: Number of write operations=2 Job Counters Launched map tasks=1 Launched reduce tasks=1 Data-local map tasks=1 Total time spent by all maps in occupied slots (ms) = 3151 Total time spent by all reduces in occupied slots (ms) = 2359 Total time spent by all map tasks (ms) = 3151 Total time spent by all reduce tasks (ms) = 2359 Total vcore-seconds taken by all map tasks=3151 Total vcore-seconds taken by all reduce tasks=2359 Total megabyte-seconds taken by all map tasks=3226624 Total megabyte-seconds taken by all reduce tasks=2415616 Map-Reduce Framework Map input records=5 Map output records=11 Map output bytes=162 Map output materialized bytes=190 Input split bytes=100 Combine input records=0 Combine output records=0 Reduce input groups=6 Reduce shuffle bytes=190 Reduce input records=11 Reduce output records=6 Spilled Records=22 Shuffled Maps = 1 Failed Shuffles=0 Merged Map outputs=1 GC time elapsed (ms) = 233CPU time spent (ms) = 1860 Physical memory (bytes) snapshot=514777088 Virtual memory (bytes) snapshot=5571788800 Total committed heap usage (bytes) = 471859200 Shuffle Errors BAD_ID=0 CONNECTION=0 IO_ERROR=0 WRONG_LENGTH=0 WRONG_MAP=0 WRONG_REDUCE=0 File Input Format Counters Bytes Read=74 File Output Format Counters Bytes Written=54

8. View the contents of the output file:

[root@localhost ~] # hdfs dfs-ls / output/wc/Found 2 items-rw-r--r-- 1 root supergroup 0 2018-03-31 22:56 / output/wc/_SUCCESS-rw-r--r-- 1 root supergroup 54 2018-03-31 22:56 / output/wc/part-r-00000 # output file of execution result [root@localhost ~] # hdfs dfs-text / output/wc/part-r- 00000 # View file content hadoop 4hdfs 2hello 2mapreduce 1welcome 1world 1 [root@localhost ~] # wordcount function reconfiguration of Java version

Although we have successfully implemented the wordcount function by writing java code, there is a problem. If we execute the previous command again, we will report the following error:

[root@localhost ~] # hadoop jar. / hadoop-train-1.0.jar org.zero01.hadoop.mapreduce.WordCountApp / test.txt / output/wc18/04/01 00:30:12 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... Using builtin-java classes where applicable18/04/01 00:30:12 INFO client.RMProxy: Connecting to ResourceManager at / 0.0.0.0 WARN security.UserGroupInformation: PriviledgedActionException as:root (auth:SIMPLE) cause:org.apache.hadoop.mapred.FileAlreadyExistsException: Output directory hdfs://192.168.77.130:8020/output/wc already existsException in thread "main" org.apache.hadoop.mapred.FileAlreadyExistsException: Output directory hdfs://192.168.77.130: 8020/output/wc already exists at org.apache.hadoop.mapreduce.lib.output.FileOutputFormat.checkOutputSpecs (FileOutputFormat.java:146) at org.apache.hadoop.mapreduce.JobSubmitter.checkSpecs (JobSubmitter.java:270) at org.apache.hadoop.mapreduce.JobSubmitter.submitJobInternal (JobSubmitter.java:143) at org.apache.hadoop.mapreduce.Job$10.run (Job.java:1307) at org.apache.hadoop.mapreduce.Job$10.run (Job.java:1304) at java. Security.AccessController.doPrivileged (NativeMethod) at javax.security.auth.Subject.doAs (Subject.java:422) at org.apache.hadoop.security.UserGroupInformation.doAs (UserGroupInformation.java:1693) at org.apache.hadoop.mapreduce.Job.submit (Job.java:1304) at org.apache.hadoop.mapreduce.Job.waitForCompletion (Job.java:1325) at org.zero01.hadoop.mapreduce.WordCountApp.main (WordCountApp.java:86) at sun.reflect.NativeMethodAccessorImpl .invoke0 (NativeMethod) at sun.reflect.NativeMethodAccessorImpl.invoke (NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke (DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke (Method.java:498) at org.apache.hadoop.util.RunJar.run (RunJar.java:221) at org.apache.hadoop.util.RunJar.main (RunJar.java:136) [root@localhost ~] #

In normal MapReduce program development, this exception is very common because the directory where the output file is stored already exists: Output directory hdfs://192.168.77.130:8020/output/wc already exists

There are two ways to solve this problem:

When executing a MapReduce job, delete or change the directory where the output file is stored (not recommended) to complete the automatic deletion function in the code (recommended)

Let's implement the automatic deletion function in the code, adding the following to the code just now:

/ * define Driver: encapsulates all the information of the MapReduce job * / public static void main (String [] args) throws IOException, ClassNotFoundException, InterruptedException {Configuration configuration = new Configuration (); / / prepare to clean the existing output directory Path outputPath = new Path (args [1]); FileSystem fileSystem = FileSystem.get (configuration); if (fileSystem.exists (outputPath)) {fileSystem.delete (outputPath,true) System.out.println ("output file exists, but is has deleted");}.

After writing, upload the edited jar package again, and then execute the command hadoop jar. / hadoop-train-1.0.jar org.zero01.hadoop.mapreduce.WordCountApp / test.txt / output/wc, and there will be no more errors.

Combiner application development

Combiner is similar to the local Reduce, which is equivalent to doing a Reduce operation in the Map phase, which can reduce the amount of data output by Map Task and the amount of network transmission.

As shown below:

In the figure above, you can see that there is a layer of Combiner between Mapper and Reducer. Mapper first makes a Combiner of the data locally, that is, it first does a merge of local data, which is similar to the process that Reduce is local, that is, the local node. When the Combiner merge is complete, the data is transferred to the Reducer for the final merge again. In this way, the amount of data output by Map Task will be greatly reduced, and the performance will be improved accordingly, as can be seen in the figure above.

Let's try to add a layer of Combiner to the wordcount program we just developed. Adding Combiner is easy, as long as you add a line of code between the code that sets the map and reduce parameters, as follows:

/ / set the Combiner processing class through the Job object, which is logically the same job.setCombinerClass (MyReducer.class) as reduce.

After the modification is completed and the jar package is re-uploaded, then execute the wordcount program. In the log output information of the terminal, you will find that all the fields related to Combiner have values, which means that our Combiner has been successfully added:

Applicable scenarios for Combiner:

Summing, counting, and accumulating scenarios are suitable for use

Scenarios where Combiner is not applicable:

Operations such as averages and common divisors are not suitable. If Combiner is used in this scenario, the result is wrong Partitioner application development.

Partitioner determines which Reduce Task handles the data output from Map Task, which is similar to making a distribution rule. The implementation of the distribution rule by default: the hash value of the distributed key is modeled on the number of Reduce Task.

As shown below:

In the figure above, the circular data is put on the same Reduce Task, the hexagonal data on the same Reduce Task, and the rest of the graphic data on the rest of the Reduce Task. Such a distribution process is Partitioner.

For example, I now have a set of data as follows, which is the sales volume of various mobile phone brands today:

[root@localhost] # hdfs dfs-text / partitioner.txt xiaomi 200huawei 300xiaomi 100iphone7 300iphone7 500nokia 100 [root@localhost ~] #

Now I have a need to distribute the same brand of mobile phone name to the same Reduce for processing. This requires the use of Partitioner, adding the following to our previous code:

Public class WordCountApp {/ * Map: read the contents of the input file * / public static class MyMapper extends Mapper {protected void map (LongWritable key, Text value, Context context) throws IOException, InterruptedException {/ / each line of data received String line = value.toString () / / split String [] words = line.split ("") according to the specified delimiter; / / output the processing result of map through context to context.write (new Text ((words [0])), new LongWritable (Long.parseLong (word [1]) }}. / * Partitioner: set the distribution rules for Map Task output data * / public static class MyPartitioner extends Partitioner {public int getPartition (Text key, LongWritable value, int numPartitions) {if (key.toString (). Equals ("xiaomi")) {return 0 } if (key.toString (). Equals ("huawei")) {return 1;} if (key.toString (). Equals ("iphone7")) {return 2;} return 3 }} / * define Driver: encapsulate all the information of MapReduce job * / public static void main (String [] args) throws IOException, ClassNotFoundException, InterruptedException {. / / set partition job.setPartitionerClass (MyPartitioner.class) of Job; / / set 4 reducer, one job.setNumReduceTasks (4) for each partition;.}}

Similarly, after changing the code, you need to recompile and package to upload the new jar to the server. Then execute the command:

[root@localhost ~] # hadoop jar. / hadoop-train-1.0.jar org.zero01.hadoop.mapreduce.WordCountApp / partitioner.txt / output/wc

When the execution is successful, you can see that there are four result files in the / output/wc/ directory, because we have set four reducer on the code, and we can see that the contents are all correct:

[root@localhost] # hdfs dfs-ls / output/wc/Found 5 items-rw-r--r-- 1 root supergroup 0 2018-04-01 04:37 / output/wc/_SUCCESS-rw-r--r-- 1 root supergroup 11 2018-04-01 04:37 / output/wc/part-r-00000-rw-r--r-- 1 root supergroup 11 2018-04-01 04:37 / output/wc/part -output/wc/part-r-00003 [root@localhost] # for i in `seq 0 3` / root supergroup 13 2018-04-01 04:37 / output/wc/part-r-00002-rw-r--r-- 1 root supergroup 10 2018-04-01 04:37 / output/wc/part-r-00003 Do hdfs dfs-text / output/wc/part-r-0000$ I; configuration of donexiaomi 300huawei 300iphone7 800nokia 100 [root@localhost ~] # JobHistory

JobHistory is a history server that comes with Hadoop, which is used to record MapReduce information that has been run to the specified HDFS directory. We all know that after executing a MapReduce task, you can find information about the task on the management page of YARN, but since JobHistory is not enabled by default, we cannot view the historical information by clicking History:

So we need to open this service and edit the contents of the configuration file:

[root@localhost ~] # cd / usr/local/hadoop-2.6.0-cdh6.7.0/etc/hadoop [root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/etc/hadoop] # vim mapred-site.xml # add the following content: mapreduce.jobhistory.address 192.168.77.130 usr/local/hadoop-2.6.0-cdh6.7.0/etc/hadoop 10020 MapReduce JobHistory Server IPC host:port mapreduce.jobhistory.webapp.address 192.168.77.130 usr/local/hadoop-2.6.0-cdh6.7.0/etc/hadoop 19888 MapReduce JobHistory Server IPC host:port mapreduce.jobhistory.done-dir / history/done mapreduce.jobhistory.intermediate-done-dir / history/done_ update [root @ localhost / usr/local/hadoop-2.6.0-cdh6.7.0/etc/hadoop] # vim yarn-site.xml # add the following content: yarn.log-aggregation-enable true [root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/etc/hadoop] #

After editing the configuration file, restart the YARN service:

[root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/sbin] #. / stop-yarn.sh [root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/sbin] #. / start-yarn.sh

Start the JobHistory service:

[root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/sbin] #. / mr-jobhistory-daemon.sh start historyserverstarting historyserver, logging to / usr/local/hadoop-2.6.0-cdh6.7.0/logs/mapred-root-historyserver-localhost.out [root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/sbin] #

Check the process:

[root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/sbin] # jps2945 DataNode12946 JobHistoryServer3124 SecondaryNameNode12569 NodeManager13001 Jps2812 NameNode12463 ResourceManager [root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/sbin] #

Then perform a case test:

[root@localhost / usr/local/hadoop-2.6.0-cdh6.7.0/share/hadoop/mapreduce] # hadoop jar. / hadoop-mapreduce-examples-2.6.0-cdh6.7.0.jar pi 3 4

After the task is executed successfully, visiting http://192.168.77.130:19888 will take you to the web page of JobHistory:

Normal access means that the configuration has been successful, and now the execution logs of all tasks can be viewed here, which is conducive to troubleshooting in our daily development, and the ui interface is more convenient to operate.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.