Christopher Guest

From June in July 1994, after three days of stir up-meninx with John Guarantees, James Gosling, Joy, Naughton, Wayne Rosing and Eric Schmidt, the team centred the platform on the Web. They thought that with the advent of the Mosaic navigator, Internet was the place where was going to develop the same kind of interactive tool as that which they had considered for the industry of the cable. Naughton developed like prototype a small Web navigator, WebRunner which will become HotJava thereafter.

The same year the language was famous Java after it had been discovered that the name Oak was already used by a video board manufacturer. The name Java was invented in a small bar attended by some members of the team. It is not clear to know or not the name so yes is an acronym, although some claim that it means J Gosling hearts, has rthur V year Hoff and has ndy Bechtolsheim or quite simply J ust has nother V ague has cronym literally (" just a vague acronym of plus"). The belief according to which Java owes its name with the market products in the bar is the fact that the code on 4 bytes (also called magic number) of the files of class is into hexadecimal 0xCAFEBABE. Certain people also claim that the name of Java comes owing to the fact that the program was intended to be able to run on embarked systems, as from the coffee machines (Java means coffee in American slang). In October 1994, HotJava and the Java platform were presented for Sun Executives. Java 1.0a was available in remote loading in 1994 but the first public version of the HotJava navigator arrived on May 23rd, 1995 at the conference SunWorld . The advertisement was carried out by John Gage, the scientific director of Sun Microsystems. Its advertisement was accompanied by the surprised advertisement of Marc Andressen, defect chair executive of Netscape that Netscape was going to include the support of Java in its navigators. January 9th, 1996, the Javasoft group was consisted Sun Microsystems to develop this technology. Two weeks later the first version of Java was available.

Recent history

Web use

Dimensioned customer

The advantages of Java compared to Javascript are primarily the portability. The heavier the interface is, the more it is exhausting even impossible to adapt the interface to all the navigators of the market. The advantages of Java compared to Flash are also valid compared to Javascript : Java proposes a style of more elegant language, and documented extremely well and proposes especially a very effective Environnement of development integrated.

The applet on the Client station can communicate with servlets on the Waiter, just like Javascript can communicate with the Waiter by means of AJAX. Flash uses technology Flex (Macromedia).

The power of Java is often used for more consistent applications like the video Yahoo plays and more recently readers multiplates-forms (for example).

Side waiter

Use on the work station

Microsoft and other systems

• Microsoft provided an work environment of the Java type, named J++, with its operating systems before the exit of Windows XP in 2001. Following legal decision, and within sight of the non-observance of the specifications of this language, Microsoft had to give up this one (cf chapter " Independence with respect to punt-forme" low)
• Beaucoup of computer makers continues to include an environment JRE on their Windows systems.
• Java also seems a standard on the level of Mac OS X of Apple as well as for the Linux distributions. Nowadays, the majority of the users can launch Java applications without any problem.

Passage under free license

The November 13rd 2006, Sun announces the passage of Java, i.e. the JDK (JRE and development tools) and the environments Java EE (already under license CDDL) and Java ME under license LPG. Java thus becomes a Free software.

History of the versions

The Java language knew several evolutions since the JDK (Java Development Kit) 1.0 with the addition of many classes and packages with the standard library. Since the J2SE1.4, the evolution of Java is directed by the JCP (Java Community Process) which uses the JSR (Java Specifications Requests) to propose additions and changes on the Java platform. The language is specified by the JLS (Java Language Specification). The modifications of the JLS are managed under code JSR 901

• JDK 1.0 (January 23rd, 1996 - 211 classes and interfaces) - initial Version. press release

• JDK 1.1 (February 19th, 1997 - 477 classes and interfaces) - many additions (press release) with notamment :

• a complete recasting of the event-driven model AWT.
• the internal classes are added to the language.
• JavaBeans
• JDBC
• Java Remote Invocation (RMI)

• J2SE 1.2 (December 9th, 1998 - 1524 classes and interfaces) - Code name Playground . This version and the following ones until J2SE 5.0 are renamed Java 2 and named version J2SE (Java 2 Platform, Standard Edition) replaces JDK to distinguish the basic platform from version J2EE (Java 2 Platform, Enterprise Edition) and from version J2ME (Java 2 Platform, Micro Edition). Several additions (press release) with notamment :

• the key word strictfp
• the reflection
• the API Swing graph is integrated.
• For the first time, the virtual machine Java of Sun includes a compiler " Just with temps" (Just in Time).
• Java Plug-in
• Java IDL, an implementation of IDL for interworking with CORBA.
• the framework Collections.

• J2SE 1.3 (May 8th, 2000 - 1840 classes and interfaces) - Code name Kestrel . The most important change (press release complete listing of the changes) with notamment :

• HotSpot JVM included (the virtual machine HotSpot left in April 1999 for the virtual machine the J2SE 1.2)
• Changement for the RMI to be based on CORBA.
• JavaSound
• JNDI (Java Naming and Directory Interfaces) included basic (available before like extension)
• JPDA (Java Platform Debugger Architecture)

• J2SE 1.4 (February 6th, 2002 - 2723 classes and interfaces) - Code name Merlin . It was the first revision of the platform under JCP (Java Community Processe) JSR 59. Principal changes (press release - complete listing of the changes sont :

• the key word assert (Specified in JSR 41.)
• rational expressions modelled while taking as a starting point the language Perl.
• the chaining of exception makes it possible an exception to encapsulate the basic exception level of origin. (Specified in JSR 51.)
API
• of journalizing (Specified in JSR 47.)
• API Image I/O for reading and writing images in formats like JPEG and png.
• integration of a parser XML and engine XSLT named JAXP (Specified in JSR 5 and JSR 63.)
• integration of the extensions of safety JCE, JSSE and JAAS.
• Java Web Start (introduced for the first time in March 2001 for J2SE 1.3 - Specified into JSR 56.)

• J2SE 5.0 (September 30th, 2004 - 3270 classes and interfaces) - Code name Tiger . (initially numbered 1.5, which is always used as internal number of version). Developed by JSR 176, Tiger adds a significant number of innovations (press release) to the langage :

• generic Programming - (Specified by JSR 14.)
• Metadata - also called annotations, makes it possible the language to build classes and methods labelled with additional data which can be used as meta-data (Specified in JSR 175.)
• Autoboxing/unboxing - automatic conversion enters of the primitive types (like the int type) and corresponding Wrapper of class (as the Integer class) (Specified in JSR 201).
• Enumerations - the key word enum makes it possible to create an ordered list of values without type. Previously, this could only be carried out by constant entireties (Specified in JSR 201).
• Varargs - syntax Object… used in a declaration of method makes it possible to specify a variable number of arguments for this method. It is an operation equivalent to the function " printf" out of C.
• Imports statics - This functionality makes it possible to use the constants of a class without specifying the name of this class and without passing by " anti-pattern Constant Interface" (it is the expression used on the site of Sun).
• Extension of the for for the loops - the syntax of the for is extended with a special syntax to reiterate them on any Itérable like a table, or a collection by using the syntaxe :

• Java SE 6 (December 11th, 2006 -??? classes and interfaces) - Code name '' Mustang ''. (see JSR 270). A beta release left on February 15th, 2006, another beta in June 2006, a version " release candidate" in November 2006, and the final version on December 12th, 2006. With this version, Sun replaces name J2SE by Java SE and removes the .0 with the number of version (see).

• Java SE 7 - Code name Dolphin . In 2006, this version is still at an early developmental stage. It is the last version with being planned. The development should start at the summer 2006 with an exit estimated in 2008 (see). It will be about the first version under the license LPG.

In addition to the changes on the level of the language, more important changes took place with the passing of years which led few hundreds of classes in the JDK 1.0 to more than 3000 in J2SE 5.0. The API whole ones, like Swing or Java2D were added and much of methods of original JDK 1.0 were declared deprecated (i.e. obsolete and being able to be removed constantly).

Philosophy

During the creation of the Java language, it had been decided that this language was to answer 5 objectifs :

1. to use a directed method objet  ;
2. to allow the same program to be carried out on several operating systems différents  ;
3. to be able to use in a native way the networks informatiques  ;
4. to be able to carry out distant code in manner sûre  ;
5. to be easy to use and have the strong points of the directed computer programming languages object like C++.

A language directed object

Another major goal of the directed programming object is to develop generic objects so that the code can be reusable between various projects. An object “customer” generic for example must have overall the same behavior in the various projects, in particular if these various projects are recut as it is often the case in the large organizations. In this direction, an object can be seen like a plug-in software component, allowing the software industry to build projects of scale starting from reusable basic elements and the stability tested while decreasing in a drastic way time of development.

The re-use of code, when it is subjected the practice proof, encounters two majeures  difficulties;: the creation of really reusable generic objects is a concept very badly included/understood and a methodology to disseminate necessary information with the re-use of code misses cruelly. Certain communities of the world “Open Source” want to contribute to solve this problem by providing to the programmers the possibility of widely disseminating information on the reusable objects and the libraries object.

Independence with respect to the platform

The second characteristic, independence with respect to the platform, means that the programs written in Java function in a perfectly similar way on various material architectures. One can carry out the development on a given architecture and make turn the application on all the others.

This result is obtained by the Java compilers which compile the source code " with moitié" in order to obtain a bytecode (more precisely the bytecode Java , a machine language specific to the platform Java). The code is then interpreted on a virtual machine Java (English JVM), a program writes specifically for the target machine which interprets and carries out the bytecode Java. Moreover, standard libraries are provided to be able to reach certain elements of the machine host (graphics, the multithreading, the programming network…) exactly in the same manner on all architectures. Let us note that even if there is explicitly a first early phase compilation, the bytecode Java is interpreted or then converted with flown into native code by a compiler Juste-with-time ( just in time , JIT).

There exist also Java compilers which compile the Java directly of native object code for the target machine, such as for example GCJ, removing the intermediate phase of the bytecode but the final code produced by these compilers can then be carried out only on only one architecture.

The license of Sun for Java insists on the fact that all the implementations must be compatible. This has leads to the complaint in Justice against Microsoft after Sun noted that the implementation of Microsoft did not support interfaces RMI and JNI and comprised elements specific to certain platforms compared to the initial platform of Sun. Sun obtained damages (20  million dollars) and the act of justice still reinforced the terms of the license of Sun. In answer, Microsoft adopted the support of Java on its platforms and, on the recent versions of Windows, Internet Explorer does not support the Java applet without adding plug-in. However, Sun places at the disposal free of the environments of execution of Java for the various Microsoft platforms.

The first implementations of the language used a virtual machine interpreted to obtain the portability. These implementations produced programs which were carried out more slowly than those written out of C or C++, so that the language suffered from a reputation of weak performances. More recent implementations of the virtual machine Java (JVM) produce programs much faster than before, by using various techniques.

The first technique is to compile directly in native code like a traditional compiler, removing the phase of bytecode completely. Good performances thus are obtained but with depend on the portability. Another technique called compilation Juste-with-time ( just in time , JIT). translated the byte codes in native code during the phase of launching of the program. Certain more sophisticated virtual machines use a dynamic recompiling during which the virtual machine analyzes the behavior of the program and in recompile selectively certain parts. The dynamic recompiling makes it possible to obtain better results that static compilation because the dynamic compilers can optimize according to their knowledge of the target environment and the classes which are used. Compilation JIT and the dynamic recompiling make it possible Java to benefit from the speed of the native code without losing the portability.

The portability is technically an objective difficult to reach and the success of Java in this field is mitigated. Though it is indeed possible to write programs for the Java platform which function correctly on many target machines, the big number of platforms with small errors and inconsistencies led to a diversion of the slogan of Sun " Write ounce, run anywhere" (" To write once, carry out partout") in " Write ounce, debug everywhere" (" To write once, déboguer partout") !

The independence of Java with respect to the platform is however a success with the applications side waiter like the Web services, the servlets and the Beans Java as well as the systems embarked on OSGi, using the environment Embedded Java .

Mechanism of the table tidy ( Garbage Collector )

In java, this problem is avoided thanks to the Ramasse-miettes (Garbage collector). The objects which are created are placed in a heap. The program and the other objects can reach the object thanks to its reference in the heap. When there does not remain any more any reference towards the object, the table tidy automatically destroys the object become inaccessible, releasing the memory and thus preventing a lack of memory. The lacks of memory can nevertheless occur when a program keeps a reference towards an object of which it does not have any more besoin  ; they continue to exist, but only on one level concept much higher. But as a whole, the table tidy returns the creation and the destruction of objects to simpler Java, potentially surer and often faster than in C++.

The table tidy is transparent for the developer and is called regularly and automatically. However, the programmer can with the need to force his launching using the method System.gc () .

Basic concepts

Four primary education goals governed the creation of the Java language. It devait :

• To be Directed object   ;
• To be independent of the Platform client  ;
• To contain Assistance S and Library S for the Data-processing network   ;
• To have the capacity to carry out code of source external in a protected way.

Java is usually compiled towards a standardized virtual machine, in the form of bytecode . This machine can function with an interpreter, a compiler just-in-time (with stolen), or, most usually, with a mixture of both.

There exist alternatives of this schéma :

• allowing to compile the language Java nativement, i.e. to produce achievable able to function out of the environment Java, and to even produce achievable able to function in the environment CLR of Microsoft .NET, thanks to the alternative J# of Java, created by Microsoft  ;
• allowing to produce an achievable Java starting from other languages, like Python using the compiler Jython, or Groovy.

A language directed object

This paradigm of programming aims at making the great projects software easier to manage, improve quality of the software and to reduce the number of failures of project.

In version 1.5 of the language were added the credits, mechanism of polymorphism similar (but different) with the templates of the language C++ or with the functors of Objective Caml. The credits make it possible to express in a simpler and surer way the properties of objects like containers (lists, trees…) : the list type is then considered génériquement compared to the type of object contained in the list.

Independence with respect to the platform

This is allowed in compiling the Source code of a Java program in a intermediate Pseudo-code called Bytecode Java -- instructions machine standardized and intended for a virtual processor . The code is thereafter carried out by an implementation of this virtual machine (JVM), a program written in native Code on the target material which translates the Java pseudo code into code usable for the material concerned. Moreover, libraries are offered to provide the access to functionalities specific to the target machine -- like graphics or the network -- in a unified way. The Java language offers also the support of the programs with several light processes (threads).

The first implementation of the language used a virtual machine to offer the portability, and several implementations still do it. These last produce programs which function more slowly than the programs compiled nativement, like those written in C. This situation conferred a reputation of slowness on the Java programs. However, of the more recent implementations of the virtual machine Java produce programs which are carried out much more quickly thanks to the use of various techniques, but especially the power of the machines starting from 1,5GHz makes the interfaces traditional very comfortable. It is now Javascript which carries the burden of slowness.

The first technique consists in compiling directly in native code, like the traditional compilers, without passing by the pseudo code. This method allows a better performance, but at the price of the portability (cf GCJ). Another technique, compilation with stolen ( just-in-time or JIT), compiles the Java pseudo code in native code with the execution of the program. More sophisticated virtual machines also use the dynamic recompiling , which makes it possible the machine to analyze the behavior of the program and recompiler and to optimize the critical parts. These two techniques make it possible the application to take advantage the speed of execution of the native code while preserving the portability.

The portability is a goal technically difficult to reach, and the success of Java to this goal is prone to controversy. Even if it is indeed possible to write programs for the virtual machines Java which behave in a coherent way on various platforms, the great number of platforms with small errors or inconsistencies led to a parody of the slogan of Sun Write ounce, run anywhere (to write once, carry out anywhere) in Write ounce, debug everywhere (to write once, déboguer everywhere).
The virtual machines developed under license by Microsoft are not foreign with this reputation. Indeed, the editor of Redmond “had singularly adapted” its virtual machines to its own needs. It was condemned to cease the exploitation of the license and to withdraw the virtual machines nonin conformity of its products.

Protected execution of distant code

The manager of safety (the class SecurityManager) allows to define a certain number of authorizations of use of the resources of the local system (filesystem, network, properties system,…). An authorization defines

1. a code accessor (typically, an applet - possibly signed - sent since a Web server)   ;
2. a local resource concerned (for example a repertory)   ;
3. a whole of rights (for example to read/write).

The editors of applet can ask for a Certificat to allow them to numerically sign an applet like sure, giving them thus potentially (with the help of the adequate authorization) the permission to leave restrictive space and to reach the resources of the local system.

The language

The source file must be called HelloWorld.java. You can test it with the following orders (under Linux)  : javac HelloWorld.java CLASSPATH=. HelloWorld java

Line “CLASSPATH=. ” is necessary to indicate to Java which it must also seek the programs class in the current directory. This way can also be specified with the launching of the program by the option - classpath (or - CP in summary)  : javac HelloWorld.java java - CP. HelloWorld

Reserved, primitive and literal words

Structures of control

Collections of objects

• tableaux : To initialize a table of entireties of 10 boxes one écrit : int = new int; the boxes of the table are numbered from 0 to 9. More generally, a table of size N, its boxes are numbered of 0 with n-1. One of the greatest advantages of the tables is the access in time constant O (1), with each box of the table. To reach or modify the iéme element of the table, for 0<= I tab=2; to allot value 2 to the first box of the table. To know the size of the table tab.length is written; . If one tries to modify a box which does not exist, for example = 4; one will obtain the error message suivant : IndexOutOfBoundsException because our table contains only 10 boxes.

• ArrayList : to initialize ArrayList it is necessary to be important the class java.util.ArrayList   ; and to write list = new ArrayList (); since JDK 1.5 one with the possibility of indicating the type of the elements contained in ArrayList : entireties, string, etc

from java.applet importation Applet
 
 
class HelloWorld (Applet):
    def Paint (coil, G):
        g.drawString (" Hello from Jython! " 20,30)

      Java (target = “classes”, source = “src”)
      Gravel bank (target = “test.jar”, source = “classes”)