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

This article mainly talks about "what are the differences between the basic grammar of Ruby and Java". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "what are the differences between the basic grammar of Ruby and Java"?

Preface

There are many sample code in this article. Java programmers can see some Ruby-related syntax and usage. Ruby programmers can look at the basic syntax and usage of Java. This article is relatively long, about 10,000 words, and is expected to take more than ten minutes. If you have the patience to finish reading the article, you will get and understand:

The basic grammar and usage of Ruby language

The basic grammar and usage of Java language

Analyze and explain the characteristics and differences of language grammar between Ruby and Java from the point of view of veteran drivers

Their respective application scenarios that are suitable and good at

There should be many articles about Ruby and Java on the Internet, but there should be few articles comparing the basic syntax of the two programming languages. The main purpose of writing this article is to summarize and review my recent study of Ruby. The programming language I am most familiar with before is Java. I personally think that qualified programmers should master multiple languages, and there is no harm in learning more than one language. They can have more ideas when solving problems. After the horizontal comparison and use experience in recent months, I first throw my personal conclusion. In individual projects or small teams, teams with strong technical skills, I recommend Ruby. When the team needs rapid expansion and large-scale project planning, I recommend Java, because thanks to the rigor and security of Java syntax, to a large extent, it can ensure the lower limit of team level, Java strong engineering specification and code type checking. You can ensure that beginners will not write destructive code. If you take the two languages as a simple example, the most intuitive feeling is to compare Ruby and Java to the two weapons in Jin Yong's novels:

Ruby is exquisitely designed, small, flexible and fast as the wind, as sharp as crape myrtle soft sword, and users can do whatever they want without being restricted by too many grammar and rules

Java is sophisticated and prudent. Although its grammar and age are more stodgy, it has occupied the first place in the list of TIOBE programming languages for many years. It can be said that it has no edge and no skill.

In the impression of many people, Ruby is mainly popular in start-ups. For example, early Airbnb,GitLab used Ruby as the development language. Ruby is a very flexible and elegant dynamic language. Students interested in understanding can click on links to check Wikipedia entries. Ruby syntax is refined, and the number of lines of code to do the same thing is usually much shorter than Java. The process of writing a program using Ruby is very comfortable, because it does not have to adhere to those rigid and mandatory syntax specifications, which allows developers to express their ideas at will, without forcing semicolon ending, not forcing square brackets, not forcing the length of method parameters and other grammatical norms. This flexible expression design is reflected in all aspects of language use. And if you are using Mac OS, the system naturally supports the Ruby development environment. Enter the following command in the Mac terminal to see the Ruby version number:

Ruby-v # ruby 2.6.5p114 (2019-10-01 revision 67812) [x86_64-darwin19]

Then you can enter the mode mode as long as you type irb in the terminal. Unlike to run the Java program, first install JDK and then configure the environment variables JAVA_HOME and CLASS_PATH, after tedious configuration, you can barely execute the java command to execute the class program. In irb mode, for simple logic programs, you can first write the code in the mode mode to verify the feasibility of the idea and then add it to the code base, which is very convenient to use. Examples are as follows:

> irb > 2.6.5: 001 > p "hello world" # = > "hello world"

The following is simply to write a HelloWorld program to compare, the two programming languages in the print HelloWorld program, the example code is as follows:

/ / java print public class Main {public static void main (String [] args) {System.out.println ("hello world!"); / / Note the end of the semicolon}} # ruby print p "hello world!"

You can see the obvious difference between the two through a simple Hello World program:

The execution of Ruby is executed sequentially from top to bottom, and the main method is the only entrance to the Java program.

Ruby doesn't have to use the; sign Terminator, you don't have to use {} to declare code blocks, and functional methods don't even have to use () to pass parameters (interesting).

After the above explanation, you may have some interest in the beginning, but this is just the beginning. Later, we will briefly introduce the commonly used objects, conditions, loops, methods, operators, numeric values, arrays, strings, hashes, etc., of Ruby. This article is not a strict article, because the sample code accounts for 50% of the article, and the feature of this article is to compare Ruby and Java in syntax. However, I will still explain the basic syntax of Ruby. This article is partial to the entry level, and the content is usually used more than the scene. For the time being, it will not involve more in-depth knowledge points such as Ruby's metaprogramming and Java reflection. There may be separate articles for analysis. After reading the article, you should be able to write some simple programs to run some simple scripts. In fact, script handlers are exactly what Ruby is good at.

Add: comparing the grammatical differences between the two languages of Java,Ruby, the article is not about which programming language is good or bad. My personal point of view is: there is no difference between good and bad programming languages, only appropriate choices can be made in different scenarios, and students who are familiar with Java should also understand that the advantages of Java never lie in language and syntax, but in ecology and concurrent programming. These features of virtual machine and stability are the core competitiveness of Java. Ecologically, the high-quality wheels represented by Spring Framework cover all aspects of Java applications. It can be said that no language can compete with Java in the diversity of wheels, so if a simple grammatical summary of the quality of the language is very general, let's get to the point and list the outline of the article first. The introduction will only briefly talk about some basic grammar:

Multiple assignment

Conditional judgment

Cycle

Method

Classes and modules

Operator

Exception handling

Multiple assignment

Most of the scenarios in which each variable is assigned individually are the same, so there is no introduction. In program development, we often assign multiple variables at the same time, which is much more efficient. Each language supports multiple assignments differently. Let's first compare the different ways of writing multiple assignments in Java,Ruby language through a piece of code:

/ / Java multiple assignment int a, b, c = 1,2,3; / / compile error int a, long b, short c = 1,2L, 3; / / complier error int a = 1, b = 2, c = 3 Multiple assignment in compile pass# Ruby is very easy a, b, c = 1, 2, 3 # = > [1, 2, 3] # compatible with different types a, s, c = 1, "2", 3 # = > [1, "2", 3] # compatible with different lengths a, b, c = 1, 2, nil] a, b, c, = 1, 2, 3, 4 # = > [1,2 3] automatically cut the excess length

Combined with the above cases, it seems that Java is not very friendly to multiple assignments, and many substandard grammars will be intercepted and reported errors during compilation. After a simple comparison, it is concluded:

Java has many restrictions on assignment because of its strong type, for example, it can only assign simple values to variables of the same type.

Multiple assignment in Ruby is relatively easy, regardless of type, length and other problems. Too long and too short will not throw problems at compile time.

Ruby does not need to declare types like Java when declaring types, which is also a feature of dynamic languages, which I personally prefer.

Conditional judgment

There are mainly three kinds of condition judgment of Ruby:

If statement

Unless statement

Case statement

First, look at the example and the comparison code:

A, b = 10, 20 p "a larger than b" if a > b p "a smaller than b" if a

< b # =>

The condition that an is smaller than b # unless is not introduced much, and its usage is just the opposite of the if statement, similar to the! = operator in java. Example code: a, b = 10, 20 p "an and b are not equal" unless a = = b # = > an and b are not equal int a = 10, b = 20; if (a > b) System.out.println ("an is larger than b"); / / brackets {} if (a) are recommended in cooperative projects

< b) System.out.println("a 比 b 小"); //=>

An is smaller than b int a = 10, b = 20; if (a! = b) System.out.println ("an and b are not equal"); / / = > an is smaller than b

In addition, the case statement is mainly used to judge multiple conditions. The sentence is used by case~when~end to judge the combined conditions, which has the same function as switch in Java, and the logical operators = =,! =, |, & & are all general basic knowledge, so we don't have to write detailed instructions and sample code, otherwise it will be very verbose.

Summary: the use of conditional judgment statements is very simple, and the two programming languages are basically similar, but there are still the following differences:

Ruby has a little more keyword selection. For example, unless actually replaces the operator! = and adds some readability.

The if syntax is basically similar, but Java forces expressions to use parentheses (), while Ruby does not

Unlike Ruby, which uses if~then~end syntax to mark code blocks, Java uses square brackets {} to mark code blocks

Ruby condition determines that if/unless is placed at the back of the code, and the program can look more compact and concise.

Cycle

Ruby is rich in loop structure sentences. Compared with Java, there are only two loop methods available in Ruby: time,while,each,for,until,loop, but most of them are the same, so they will not be introduced one by one. This chapter mainly focuses on several requirements commonly used to do a simple explanation, comparing the differences between the use of the two languages, as follows:

How to perform a fixed number of cycles?

How to traverse an array?

How to traverse a Hash?

Executing a fixed number of loops is a specialty of the time loop method, and the and statement is also very simple. If no subscript value is required, the | I | parameter can also be removed. The example code is as follows

3.time do | I | # I can also omit p "# {I} print" end # = > 0 print # = > first print # = > second print

If you want to execute a fixed-length loop in Java, you can't do it through forEach but through the old for..i. The specific code is as follows:

For (int I = 0; I

< 3; i++) { System.out.println("第" + i + "次打印"); } // 第0次打印 // 第1次打印 // 第2次打印 如何遍历一个数组? 在 Ruby 中通常会推荐使用 **each ** 不仅语法简单，而且可以轻松拿到元素值，示例代码如下： ["abc","efg","hmn"].each do |e| p "#{e}!" end #=>

Abc! Dfg! Hmn!

After Java has been enhanced by Stream and Lambda syntax in JDK 8, traversing the array is not as old-fashioned as expected. Sample code:

Arrays.asList ("abc", "dfg", "hmn") .forEach (e-> System.out.println (e + "!")); / / abc! Dfg! Hmn!

However, when traversing an array, you often encounter a requirement that you not only want to get the elements of the array, but also need to get the index value of the current loop. Ruby provides a special each implementation, that is, the each_with_index method, which will pass [element, index] to the do code block. Specific example code:

["abc", "def", "ghi"] .each_with_index do | e, I | p "current element # {e}, and cycle # {I}" end # = > "current element abc, and cycle 0" # = >.

If Java wants to achieve the same loop effect, it can not be implemented with iterator-based ForEach, but can only be implemented with for..i. The example code is as follows:

List list = Arrays.asList ("abc", "deg", "ghi"); for (int I = 0; I

< list.size(); i++) { String e = list.get(i); System.out.println("当前元素" + e + "，以及第 " + i + "次循环"); } // 当前元素abc，以及第 0次循环 // .. 如何遍历一个 Hash ? Hash 是 Ruby 的常用的对象，因此循环遍历获取 K，V 也是相当方便的，示例代码： hash = {name: "apple", age: 15, phone: "15815801580"} hash.each do |k, v| p "key： #{k}， value： #{v}" end #=>

Key: name, value: apple # = >.

The most commonly used Hash implementation of Kmurv structure in Java is HashMap based on Map interface, which is a non-thread-safe hash table implementation. It is commonly used because it takes into account both efficiency and time balance. Internally, it is implemented through an array, using linked table method to deal with hash conflicts, and then introducing a red-black tree to solve the problem of too long linked list caused by too many hash conflicts. Otherwise, we can talk about this for a long time. The sample code shows how Java traverses Hash:

Map hashMap = new HashMap (); hashMap.put ("name", "apple"); hashMap.put ("age", "15"); hashMap.put ("phone", "15815801580"); for (Map.Entry entry: hashMap.entrySet ()) {System.out.println ("key:" + entry.getKey () + ", value:" + entry.getValue ());} / / key: name, value: apple / /.

There are many ways for Java to iterate through Hash, and we'll show only the most common use here, by ForEach traversing the collection returned by entrySet ().

Finally, let's talk about an interesting loop method, but there should be very few scenarios. A loop loop method without termination must rely on the break keyword to jump out of the loop because there is no termination condition. Java can also easily achieve this loop effect, but the syntax is different. We can take a look at the following example comparison:

/ / java uses while (true) or for (;;) to implement an infinite loop while (true) System.out.println ("i use java"); # ruby infinite loop loop do p "i use ruby" end

If the program enters an infinite loop, it can only terminate the program through CTRL + C. conclusion: there is little difference between the two languages in the loop. Although there are many ways to cycle in Ruby, it is usually used only in each and for. The difference in the loop is mostly just the difference in syntax between the two languages.

Method

classification

The methods in Ruby can be broadly divided into three categories:

Example method

Class method

Functional method

Instance method: the instance method Instance method in Ruby is similar to the common method in Java. As the name implies, the caller must be an instance (object) of a class. If you need to call an instance method, you must construct an instance object through the class before you can call it. For more information, please see the sample code:

Instance method in # ruby [1,2,3] .clear # cleanup array = > [] 100.to_s # int to string = > "100,100" .to _ I # string to int = > 100 ["a", "b", "c"] .index ("b") # Lookup subscript = > result: 1ip / java instance method StringBuilder stringBuilder = new StringBuilder (); stringBuilder.append ("abc") / / instance method append stringBuilder.append ("efg"); List strList = new ArrayList (); strList.add ("abc"); / / instance method add strList.add ("efg")

Class method: the class method class method of Ruby can be understood as the static method of Java, that is, the method that requires the class object as the receiver, which means that its own method can be called directly through the class without building the object of the class. It is most common in tool classes. Please see the sample code:

/ / static method Arrays.asList (T.. a) in java / / Array transfer set Executors.newCachedThreadPool () / / create thread pool # class method in ruby # create hash object Time.new # create time object

A function method is a method without a receiver, but this type of method does not exist in Java. Refer to the sample code, such as the function method p above.

P "hello" puts "print words"

Define instance method

Ruby definition method is very simple, not as many format specifications as Java: modifier: static declaration: return value: method name: (parameter...). It is much simpler in the form of method declaration, mainly through the def keyword. For more information, please see the sample code:

/ / java define method public static int add (int x, int y) {return x * y} add (2,5) / / 1 method ruby define method def add (x, y) x * y end add (2,5) # = > 1 method with default value def add (x, y) x * y end # the parameter is omitted using the default value to call the method add # = > 12 # method add (2,5) # = > 10

In the naming convention of the method, the two languages also have the following differences:

The Ruby method name can consist of letters, numbers, and underscores, but cannot start with a number, such as hello_with_name

The first letter of the Java method name must start with a lowercase. The English format follows the hump principle, and connectors are not allowed, such as addPerson.

Return value return: the above ruby method does not declare the return statement to get the return value, which does not mean that ruby does not have the return keyword. A feature of ruby is that if the return statement is not declared, then the last expression of the method will become the return value of the method following this convention, so the above method can omit the return keyword, so the return keyword will be less used in daily development.

Define class methods

As I mentioned earlier, the class method of Ruby is actually equal to the static method of Java, and the sample code that defines the class method in Ruby:

# ruby definition class method class Hello # class "1.0" # Ruby defines constants class PhoneNumber BeiJing =" 020 "GuangZhou =" 021 "end p PhoneNumber::BeiJing # = >" 020 "p PhoneNumber::GuangZhou # = >" 021 "Phonenumber::BeijING =" 303 "# = > Ruby can modify the constant without reporting an error, but will prompt a warning p PhoneNumber.Beijing # = > ERROR undefined method!

Differences in defining constants:

Naming rules: Ruby requires constant capitalization, hump or full capitalization, Java requires constant capitalization and must be final static modified (final in Java stands for immutable and can declare classes, methods and variables)

Calling method: Ruby must use:: to access constants externally through the class name. Java treats constants as ordinary local variables and uses connectors. Just access it directly.

Modify variables: Java does not allow modification of constants. Any modification will cause the compiler to report an error Connot assign a value to final variable and fail to compile. Unlike Ruby, constants are allowed to be modified, but the interpreter will prompt a warning message: warning: already initialized constant

Access level

Ruby and Java are not very different in method access level, except that Ruby does not have the concept of Package, so naturally, there is no package access permission in Java. There are three ways to define the access level of Ruby. The specific usage can be found directly in the sample code:

# declare the access permission when defining the method private def call_v1 p "call_v1 is private" end # define the method, then set the access permission def call_v2 p "call_v2 is private" end private: call_v2 # set call_v2 to private # set the code block, and the following method is defined as private private def call_v3 p "call_v3 is private" end def call_v3 p "call_v4 is private" end

Java sets the access level of a method in a single way, and can only be declared at definition time:

Private String priv () {return "priv is private";}

To sum up, the differences and summary of the access levels between the two languages:

The default modifier for the Java method is package access.

The default access level of the Ruby method is public (with initialize exception)

The Java method can only use keywords to set the access level at definition time

Commonly used in Ruby, there are three ways to set the access level of the method, which is very flexible.

Inherit

All the classes of Ruby and Java are based on Object subclasses, while Ruby has a more lightweight BasicObject primitive class. Let's not describe it in detail here, and let's not say much about the concept of inheritance. For the basic knowledge of object-oriented, let's first look at the way the two languages implement inheritance.

Ruby passed

< 父类名 实现继承，示例代码： class Car def drive p "car start.." end end class SuperCar < Car def speed_up p "speed to 200km ..." end end s = SuperCar.new s.drive s.speed_up #=>

"car start.." # = > "speed to 200km..."

Java implements inheritance through extends, sample code:

Class Car {void drive () {System.out.println ("Car Start...");}} public class SuperCar extends Car {void speedUp () {System.out.println ("speed to 200km...");} public static void main (String [] args) {SuperCar c = new SuperCar (); c.drive (); c.speedUp () }} / / Car Start... / / speed to 200km...

We can draw the following summary about the inheritance of the class:

Ruby passed

< 实现继承， Java 通过 extends 关键字实现继承 Ruby ，Java 在类没有指定父类的情况下都默认继承 Object类 关于继承还有一些经验分享的就是，继承的特性更多用于重写父类和多态，如果是想要复用公共的功能，但是类之类没有明显的继承关系的话，就应该遵循组合优先大于继承的原则，不过在 Ruby 中很好的通过 Mix-in 扩展解决的继承这个问题 模块和Mix-in 模块使用 module 关键字创建，命名规则和类一样，首字母必须大写，我们先来看看如何创建模块 module Display def open p "open display..." end end Display.open # private method `open' called for Display:Module (NoMethodError) 模块是 Ruby 的特色功能，定位也很明确，有以下几个特点： 不能拥有实例，不能被继承，所以模块定位清晰，仅仅表示事物的通用行为 函数仅仅只能在内部被调用，除非使用 module_function 声明模块函数 模块更多是结合 Mix-in 和 include 使用，为类提供增强和更多的可能性 Ruby 中的模块提供的命名空间 namespace 概念就跟 Java 的包(Package)类似，都是用于区分相同的类，常量，Mix-in 结合 include 也就类似 Java 里面的静态导入，在 Java 中 import static 可以无需声明包路径直接调用导入类的变量和方法，所谓的 Mix-in 就是利用模块的抽象能力把非继承关系的类之间的共性进行抽象和复用，有些类似 AOP 的概念，可以使代码既强大又灵活 当我们用 OOP 思想对现实进行抽象的时候，会发现很多非继承关系又存在共同功能的事物，例如智能手机，手表继承自不同的父类，但是他们又都有看时间 watch_time的能力，我们用代码展现这种继承关系，请看示例代码： class Phone def call p "phone call.." end end class IPhone < Phone # iPhone 继承自 Phone 类，但是不仅可以打电话，还可以看时间 def watch_time p "watch_time 12:00:000" end end class Watch # 手表都可以看时间 def watch_time p "watch_time 12:00:000" end end class AppleWatch < Watch # AppleWatch 不仅看时间，还有运动的功能 def run p "start run" end end 结合上面的代码，我们可以看到 watch_time 代码重复，对于不同继承体系但是相同功能的时候，就可以用 Mix-in 解决这个问题，思路如下： 将例如 watch_time 相同的方法和代码，抽出定义在 module 模块中 使用 include 引入模块，将方法引入到实际的类中 使用 Mix-in 后我们可以看下代码变化，示例代码： module WatchTime # 抽出通用的方法 def watch_time p "watch_time 12:00:000" end end class Phone def call p "phone call.." end end class IPhone < Phone include WatchTime end class Watch include WatchTime end class Apple_watch < Watch # apple_watch 不仅看时间，还可以运动 def run p "start run" end end 使用 Mix-in 这种灵活的语法实现了鱼和熊掌兼得，即没有破坏继承结构关系又实现共性方法的代码复用问题，因为 Java 没有 Mix-in 的概念所以就不展示示例代码了，不过 Java 也有自己的解决方案，而且在 Java 的解决代码复用问题通常都应该遵循 组合大于继承 的原则，因为 Java 的语言设计让继承更多用于多态而非复用 运算符 简单说一下运算符，虽然大多编程语言的运算符非常的简单，赋值运算，逻辑运算，条件运算符所有语言的使用方式都几乎差不多，好像没什么好讲的，但 Ruby 灵活的语法是有不少语法糖，还是可以 Java 程序员羡慕的一下的，假设一张我们在业务代码中经常遇到的情况，根据表达式取值，当表达式为 true 时改变变量的值，这种简单逻辑赋值在 Java 只能这样写，请看示例代码 String value = "abc"; if (condition != null) { value = condition; } // 看上去很啰嗦 这种情况在 Ruby 中一行代码可以实现相同语义： # 当 condition 表达式为 true 执行 value = condition ， 否则执行 value = "abc" value = condition || "abc" 只所以可以实现是因为 Ruby 有一个不同 Java 的特定， Ruby 对象都可以用于进行布尔表达式判断，判断逻辑为**对象本身不为 nil 或者 false 表达式则为 true，否则为 false ** 还有一种逻辑则是取相反的情况，例如我们经常遇到一种情况是，判断数组不为空的时候取数组的某一个下标，在 Java 中只能这样写，示例代码 List list = Arrays.asList("a", "b", "c"); String item = null; if (list != null) { item = list.get(0); } // "a" 这种情况可以用逻辑运算符 &&， 它刚好与上面 || 相反，也是一行代码可以实现相同功能 str_list = ["a", "b", "c"] item = str_list && str_list[0] #=>

"a"

Personally, I like this concise way of writing very much, but I suggest not to use too much syntax sugar in multi-person projects, otherwise it may cause confusion in the readability of the project code.

Exception handling

Many programmers spend most of their time on error checking, so it is critical to locate exceptions quickly. First, take a look at the exception format file name of Ruby: line number: in method name: error message (exception class name) simple usage does not write sample code, otherwise it takes up too much space. The two languages handle exceptions in more or less the same way, and the specific handling methods are as follows:

Ruby handles exceptions using begin ~ rescue ~ ensure ~ end. If it's too simple, I won't write the sample code.

After Java 7 uses try ~ catch ~ finally to Java 8, there is a more efficient try ~ with ~ resources that can automatically close resources.

However, Ruby's Retry is a feature that Java does not have. It is suitable for quick retry of some error-prone programs (such as calling external API). For more information, please see the sample code.

Class HandleException def zero x, y = 100,0 begin x = x / y rescue p 'execute exception logic' y = 2 retry end x end end h = HandleException.new p h.zero # = > "execute exception logic" # = > 50

The above program is very simple. The logic is that the first execution will throw an exception, then it will be captured by rescue and copied again. The second operation is successful. If Java wants to achieve the same semantics, the code is not so concise. The logic operator & &, | similar to resuce also has the operation of conditional expression and has strong expressive ability. We try to simplify the above code. Example code:

X, y = 100,0 x = x / y rescue 50 # = > x = 50

When there is no exception in the operation x / y, the operation x = x / y, and when the exception is caught by resuce, the operation x = 50, but the same logic will be a bit verbose in Java. Please see the sample code:

Int x = 100, y = 0; try {x = x / y;} catch (ArithmeticException ae) {x = 50;} / x = 50

However, tips like this can only be used in simple scenarios. If the business process is complex, it is recommended to use the standard begin ~ rescue ~ ensure ~ end exception handling statement to ensure that the code is clear and easy to understand. This concludes the exception chapter. At the end of the article, we summarize the difference between Java and Ruby in exception handling:

Ruby standard exception libraries inherit Exception classes, and programs usually can only handle StandarError exceptions or their subclasses.

Java exceptions inherit Throwable, and exceptions are divided into Error exceptions and Exception. Programs usually only deal with RuntimeException, a subclass of Exception, and its subclasses.

Ruby allows retry to quickly retry from exceptions, rescue expressions simplify exception code handling, and Java does not have this feature

Java actively throws exceptions using throw new Exception, while Ruby uses the raise method

This is the end of the basic grammatical comparison between the two languages, not analysis and summary for the time being, because I will continue to explore the differences between Ruby and Java in other usage levels, such as strings, data types, collections, and hashes. Finally, I would like to leave a question: what do you think is the most obvious difference between static languages and dynamic languages? What's wrong with each of them? In what scenarios do you prefer dynamic languages and what scenarios do you prefer static languages?

At this point, I believe you have a deeper understanding of "what are the differences between the basic syntax of Ruby and Java". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.