Four technologies that may challenge Java's advantages

Java is an outstanding industrial development language because it brings great unity and attention to important standards that do not actually exist before. But like all languages, Java will fade in the future. Based on my research that surpasses Java, a recurring topic is that more and more people believe that Java is no longer efficient enough. The following groups of technologies can make you more efficient. They are not suitable for all projects, but they are excellent tools when applied to suitable projects.

1. Dynamic Language

Dynamic languages can be more efficient than static languages like C ++ or Java. They allow you to express more meaning in less languages. Here, I will pay attention to the latest popular dynamic language Ruby. Compare ruby's "Hello, world" with Java:

puts "Hello, world."

This is obviously simple and clear. You don't need to write other code to do this. The following is a description in Java:

class HelloWorld{ public static void main(String[] args) { System.out.println("Hello World!") }}

In Java, the type is static. This indicates that the compiler needs to check all types; you must create and compile a complete program. In Ruby, the types are dynamic, so you don't need to declare them. You can write and run them immediately. The following is a sequence of Fibonacci described in two languages:

First, Ruby:x1, x2 = 0, 1 //110.times do puts x2 x1, x2 = x2, x1+x2 //4end

Note that two variables are declared at the same time in the first and fourth rows, so that you can easily express two different declaration forms. In addition, note that 10 is an object and it supports methods, such as times. In addition, there is a code block between do and end. The ruby code block allows you to pass the code block into the method .. This technology leads to incredible efficiency and concise code. Next, let's take a look at the Code implemented in Java:

class Fib { public static void main (String args[]) { int x1 = 0; int x2 = 1; int total = 1; for (int i=0; i<10; i++) { System.out.println(total); total = x1+x2; x1 = x2; x2 = total; } }}

You need to declare all the variables and write in detail the iterations that you implement with the for loop. Each variable is independent, so you must have a temporary variable to store total. Dynamic Language is more concise than dynamic language. According to a common rule, if you can write less code without sacrificing readability, this code will lead to higher efficiency. (But you cannot sacrifice readability to achieve this step. We can end with a Perl example .) More importantly, the dynamic language performs better on important issues that Java developers want to solve, such as metaprogramming. Hibernate uses metaprogramming technology to make objects persistent. Spring uses metaprogramming to add services to Java objects, saving you from building additional support for them. In the rails framework, Ruby, which is popular, uses its own capabilities to build a certain existing and most efficient application development framework. Surprisingly, many Java developers use ruby. Ant and tomcat inventor James Duncan David son are using Ruby on Rails and one of the best-selling authors of Java. David Geary, a member of the JSP Expert Group, is writing a book about rub on Rails y. Many people with smart ideas in the Java Community turn to dynamic languages like Ruby. This is because this new language can better solve the most interesting problems. Dynamic languages will not completely replace Java, but they will be suitable for solving small and lightweight problems. 2. The continuation Service web programming is definitely a disaster. Ten years after the birth of Java, we still cannot build a framework that makes the return button correct. Web applications are borderless, so Web applications will develop better. However, it is difficult to build borderless applications, and our existing framework cannot provide us with enough help. When you use most Java Web frameworks, you have built many unrelated applications that use servlets or JSP technology. Then they are integrated by manually saving objects. These objects are what you need and are used to temporarily store object sessions. Continuation is a language constructor that allows you to quickly store the status of a thread and then execute this thread. In general, the continuation-based Web framework simulates a monitoring application to make web development easier. When your application needs to obtain data from the user, this framework uses continuation to automatically save the state of the application. If you press the return button or return to the previous page through the browser's historical records, the application can read a new continuation. The best continuation-based framework is developed in dynamic languages. So far, the most robust framework is seaside. He is based on a Smalltalk squeak language framework. Seaside supports debugging. You can check, debug, and modify your code in your browser in real time. Borges, Iowa, and wee are both ruby-based and support for the continuation framework. Java does not support continuations, but some Java frameworks constructed under special restrictions support simulating continuations. These frameworks have some characteristics of the continuations framework written in other languages. Popular frameworks use advanced technologies such as bytecode enhancement, reflection, and special class loaders. These technologies partially implement continuations using Java. Cocoon 2 adds continuations to the rhino JavaScript Virtual Machine to simulate monitoring status applications. Spring webflow uses a state machine to provide good support for response buttons and other features of the continuation service. Lakeshore uses a suspended thread to simulate continuations. This method is not as scalable as other methods, and lacks complete support for return buttons, but these are expected to be available in the future. Every month, a new framework will appear. In my opinion, in the next three years, we will all use a web development framework that supports the continuations-a framework written in one language or another. 3. Convention goes beyond Configuration

Java developers often find ways to improve configurations. More and more new frameworks are configured using Java 5 annotations. Other frameworks use a different method. Common Ruby conventions in rails are used to infer the connections that need to be configured in other frameworks.

For example, at the end, a rails controller named blogcontroller with a show method will automatically submit a view named show. rhtml in the blog_controller directory. Rails also uses naming conventions to bind persistent classes in the database table. By default, the perosn class matches the plural people in English with the table.

The new framework will support conventions rather than configurations.

4. metaprogramming

As mentioned above, there are many hypes in Ruby on the rails programming framework. I think this kind of hype is correct. Ruby on Rails allows you to write your program at a more abstract level than Java. With Ruby on Rails, you can create a domain object, which can discover the content of the associated database table. For example, you can write such a simple model object:

class Person < ActiveRecord::Baseend

This type of surface looks quite limited. But once you execute it, rails will show its magic. In this way, the persistent rails activity record framework is associated with related databases, and system tables are scanned for table definitions, and columns in the database are also found. Then, the activity record adds an attribute for each column in the database, and adds a unique identifier for the ID column name in the database in the class. You can use the following classes to write code:

person=Person.newperson.name='BruceTate'person.email='bruce.tate@j2life.nospam.com'person.save

The column names and actions of the database are added to the person class after the runtime. You can easily extend the person class:

class Person < ActiveRecord::Base has_many :carsend

Using a simple belongs_to method in Ruby and the Department identifier, I implemented everything I wanted to do. Activity records implicitly call Ruby's metaprogramming to add all methods and variables. These methods and variables are used to manage one-to-multiple relationships between any department. Rails users use domain languages to manage relationships such as inheritance. In addition, they can use Ruby to work at a more abstract level. Rails seamlessly extends the ruby language.

Will rails be the next generation of great frameworks? Possible. To make a choice, rails should be the first in the trend of metaprogramming frameworks using Ruby or other dynamic programming languages. Alternatively, you may see that rails serves as the hub of some loosely aligned technologies. It is based on metaprogramming. In any situation, you will be more efficient.

Summary

In the book "Beyond Java", I have expressed that Java will not be eliminated, but in the last decade, we have witnessed notable innovations beyond the Java field. These four technologies will play an important role in the near future. Please pay close attention to them.