Java - J2ee Solutions
Java (software platform)
Java is a set of several computer software products and specifications from Sun Microsystems (which has since merged with Oracle Corporation), that together provide a system for developing application software and deploying it in a cross-platform computing environment. Java is used in a wide variety of computing platforms from embedded devices and mobile phones on the low end, to enterprise servers and supercomputers on the high end. While less common, Java applets are sometimes used to provide improved and secure functions while browsing the World Wide Web on desktop computers.
On November 13, 2006, Sun Microsystems made the bulk of its implementation of Java available under the GNU General Public License (GPL).
An edition of the Java platform is the name for a bundle of related programs from Sun that allow for developing and running programs written in the Java programming language. The platform is not specific to any one processor or operating system, but rather an execution engine (called a virtual machine) and a compiler with a set of libraries that are implemented for various hardware and operating systems so that Java programs can run identically on all of them.
Java Card: A technology that allows small Java-based applications (applets) to be run securely on smart cards and similar small-memory devices.
Java ME (Micro Edition):Specifies several different sets of libraries (known as profiles) for devices with limited storage, display, and power capacities. Often used to develop applications for mobile devices, PDAs, TV set-top boxes, and printers.
Java SE (Standard Edition): For general-purpose use on desktop PCs, servers and similar devices.
Java EE (Enterprise Edition): Java SE plus various APIs useful for multi-tier client-server enterprise applications.
The Java platform consists of several programs, each of which provides a portion of its overall capabilities. For example, the Java compiler, which converts Java source code into Java bytecode (an intermediate language for the JVM), is provided as part of the Java Development Kit (JDK). The Java Runtime Environment (JRE), complementing the JVM with a just-in-time (JIT) compiler, converts intermediate bytecode into native machine code on the fly. An extensive set of libraries are also part of the Java platform.
The essential components in the platform are the Java language compiler, the libraries, and the runtime environment in which Java intermediate bytecode "executes" according to the rules laid out in the virtual machine specification.
Java Virtual Machine
The heart of the Java platform is the concept of a "virtual machine" that executes Java bytecode programs. This bytecode is the same no matter what hardware or operating system the program is running under. There is a JIT(Just In Time) compiler within the Java Virtual Machine, or JVM. The JIT compiler translates the Java bytecode into native processor instructions at run-time and caches the native code in memory during execution.
The use of bytecode as an intermediate language permits Java programs to run on any platform that has a virtual machine available. The use of a JIT compiler means that Java applications, after a short delay during loading and once they have "warmed up" by being all or mostly JIT-compiled, tend to run about as fast as native programs. Since JRE version 1.2, Sun's JVM implementation has included a just-in-time compiler instead of an interpreter.
Although Java programs are cross-platform or platform independent, the code of the Java Virtual Machines (JVM) that execute these programs is not. Every supported operating platform has its own JVM.
- Java (software platform) :
In most modern operating systems (OSs), a large body of reusable code is provided to simplify the programmer's job. This code is typically provided as a set of dynamically loadable libraries that applications can call at runtime. Because the Java platform is not dependent on any specific operating system, applications cannot rely on any of the pre-existing OS libraries. Instead, the Java platform provides a comprehensive set of its own standard class libraries containing much of the same reusable functions commonly found in modern operating systems. Most of the system library is also written in Java. For instance, Swing library paints the user interface and handles the events itself, eliminating many subtle differences between how different platforms handle even similar components.
The Java class libraries serve three purposes within the Java platform. First, like other standard code libraries, the Java libraries provide the programmer a well-known set of functions to perform common tasks, such as maintaining lists of items or performing complex string parsing. Second, the class libraries provide an abstract interface to tasks that would normally depend heavily on the hardware and operating system. Tasks such as network access and file access are often heavily intertwined with the distinctive implementations of each platform. The java.net and java.io libraries implement an abstraction layer in native OS code, then provide a standard interface for the Java applications to perform those tasks. Finally, when some underlying platform does not support all of the features a Java application expects, the class libraries work to gracefully handle the absent components, either by emulation to provide a substitute, or at least by providing a consistent way to check for the presence of a specific feature.
The word Java..., alone, usually refers to the Java programming language that was designed for use with the Java platform. Programming languages are typically outside of the scope of the phrase "platform", although the Java programming language is listed as a core part of the Java platform. The language and runtime are therefore commonly considered a single unit.
Nevertheless, third parties have produced many compilers or interpreters that target the JVM. Some of these are for existing languages, while others are for extensions to the Java language. These include:
- BeanShell a lightweight scripting language for Java
- Clojure, a dialect of the Lisp programming language.
- Groovy, a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk.
- JRuby, a Ruby interpreter
- Jython, a Python interpreter
- Scala, a multi-paradigm programming language designed as a "better Java"
- Gosu, a general-purpose Java Virtual Machine-based programming language released under the Apache License 2.0.
The success of Java and its write once, run anywhere concept has led to other similar efforts, notably the .NET Framework, appearing since 2002, which incorporates many of the successful aspects of Java. .NET in its complete form (Microsoft's implementation) is currently only fully available on Windows platforms, whereas Java is fully available on many platforms. .NET was built from the ground-up to support multiple programming languages, while the Java platform was initially built to support only the Java language, although many other languages have been made for JVM since.
.NET includes a Java-like language called Visual J# (formerly named J++) that is incompatible with the Java specification, and the associated class library mostly dates to the old JDK 1.1 version of the language. For these reasons, it is more a transitional language to switch from Java to the .NET platform, than a first class .NET language. Visual J# was discontinued with the release of Microsoft Visual Studio 2008. The existing version shipping with Visual Studio 2005 will be supported until 2015 as per the product life-cycle strategy.
Java Development Kit
The Java Development Kit (JDK) is a Sun product aimed at Java developers. Since the introduction of Java, it has been by far the most widely used Java software development kit (SDK). It contains a Java compiler, a full copy of the Java Runtime Environment (JRE), and many other important development tools.
The Java platform and language began as an internal project at Sun Microsystems in December 1990, providing an alternative to the C++/C programming languages. Engineer Patrick Naughton had become increasingly frustrated with the state of Sun's C++ and C application programming interfaces (APIs) and tools. While considering moving to NeXT, Naughton was offered a chance to work on new technology and thus the Stealth Project was started.
The Stealth Project was soon renamed to the Green Project with James Gosling and Mike Sheridan joining Naughton. Together with other engineers, they began work in a small office on Sand Hill Road in Menlo Park, California. They were attempting to develop a new technology for programming next generation smart appliances, which Sun expected to be a major new opportunity.
The team originally considered using C++, but it was rejected for several reasons. Because they were developing an embedded system with limited resources, they decided that C++ needed too much memory and that its complexity led to developer errors. The language's lack of garbage collection meant that programmers had to manually manage system memory, a challenging and error-prone task. The team was also troubled by the language's lack of portable facilities for security, distributed programming, and threading. Finally, they wanted a platform that could be easily ported to all types of devices.
Bill Joy had envisioned a new language combining Mesa and C. In a paper called Further, he proposed to Sun that its engineers should produce an object-oriented environment based on C++. Initially, Gosling attempted to modify and extend C++ (that he referred to as "C++ ++ --") but soon abandoned that in favor of creating a new language, which he called Oak, after the tree that stood just outside his office.
By the summer of 1992, they were able to demonstrate portions of the new platform including the Green OS, the Oak language, the libraries, and the hardware. Their first attempt, demonstrated on September 3, 1992, focused on building a personal digital assistant (PDA) device named Star7 that had a graphical interface and a smart agent called "Duke" to assist the user. In November of that year, the Green Project was spun off to become firstperson, a wholly owned subsidiary of Sun Microsystems, and the team relocated to Palo Alto, California.The firstperson team was interested in building highly interactive devices, and when Time Warner issued a request for proposal (RFP) for a set-top box, firstperson changed their target and responded with a proposal for a set-top box platform. However, the cable industry felt that their platform gave too much control to the user and firstperson lost their bid to SGI. An additional deal with The 3DO Company for a set-top box also failed to materialize. Unable to generate interest within the TV industry, the company was rolled back into Sun.
Java meets the Internet
Java Web Start allows provisioning applications over the Web In June and July 1994, after three days of brainstorming with John Gage, the Director of Science for Sun, Gosling, Joy, Naughton, Wayne Rosing, and Eric Schmidt, the team re-targeted the platform for the World Wide Web. They felt that with the advent of graphical web browsers like Mosaic, the Internet was on its way to evolving into the same highly interactive medium that they had envisioned for cable TV. As a prototype, Naughton wrote a small browser, WebRunner (named after the movie Blade Runner), later renamed HotJava.
That year, the language was renamed Java after a trademark search revealed that Oak was used by Oak Technology. Although Java 1.0a was available for download in 1994, the first public release of Java was 1.0a2 with the HotJava browser on May 23, 1995, announced by Gage at the SunWorld conference. His announcement was accompanied by a surprise announcement by Marc Andreessen, Executive Vice President of Netscape Communications Corporation, that Netscape browsers would be including Java support. On January 9, 1996, the JavaSoft group was formed by Sun Microsystems to develop the technology.
According to Oracle, the Java Runtime Environment is found on over 850 million PCs. Microsoft has not bundled a Java Runtime Environment (JRE) with its operating systems since Sun Microsystems sued Microsoft for adding Windows-specific classes to the bundled Java runtime environment, and for making the new classes available through Visual J++. A Java runtime environment is bundled with Apple's Mac OS X (although as of the Java for Mac OS X 10.6 Update 3 release, the Apple-supplied runtime is deprecated and may be removed from future OS releases), and many Linux distributions include the partially compatible free software package GNU Classpath and increasingly mostly compatible IcedTea.
Some Java applications are in fairly widespread desktop use, including the NetBeans and Eclipse integrated development environments, and file sharing clients such as LimeWire and Vuze. Java is also used in the MATLAB mathematics programming environment, both for rendering the user interface and as part of the core system. Java provides cross platform user interface for some high end collaborative applications like Lotus Notes.
Java ME has become popular in mobile devices, where it competes with Symbian, BREW, and the .NET Compact Framework. The diversity of mobile phone manufacturers has led to a need for new unified standards so programs can run on phones from different suppliers - MIDP. The first standard was MIDP 1, which assumed a small screen size, no access to audio, and a 32kB program limit. The more recent MIDP 2 allows access to audio, and up to 64kB for the program size. With handset designs improving more rapidly than the standards, some manufacturers relax some limitations in the standards, for example, maximum program size.
Google's Android operating system uses the Java language, but not its class libraries, therefore the Android platform cannot be called Java. Android executes the code on the Dalvik VM instead of the Java VM.
When generics were added to Java 5.0, there was already a large framework of classes (many of which were already deprecated), so generics were chosen to be implemented using erasure to allow for migration compatibility and re-use of these existing classes. This limited the features that could be provided by this addition as compared to some other languages.
Unsigned integer types
Java lacks native unsigned integer types. Unsigned data are often generated from programs written in C and the lack of these types prevents direct data interchange between C and Java. Unsigned large numbers are also used in many numeric processing fields, including cryptography, which can make Java less convenient to use for these tasks. Although it is possible to partially circumvent this problem with conversion code and using larger data types, it makes using Java cumbersome for handling the unsigned data. While a 32-bit signed integer may be used to hold a 16-bit unsigned value with relative ease, a 32-bit unsigned value would require a 64-bit signed integer. Additionally, a 64-bit unsigned value cannot be stored using any integer type in Java because no type larger than 64 bits exists in the Java language. If abstracted using functions, function calls become necessary for many operations which are native to some other languages. Alternatively, it is possible to use Java's signed integers to emulate unsigned integers of the same size, but this requires detailed knowledge of complex bitwise operations.
Floating point arithmetic
While Java's floating point arithmetic is largely based on IEEE 754 (Standard for Binary Floating-Point Arithmetic), certain features are not supported even when using the strictfp modifier, such as Exception Flags and Directed Roundings - capabilities mandated by IEEE Standard 754. Additionally, the extended precision floating-point types permitted in 754 and present in many processors are not permitted in Java.
In the early days of Java (before the HotSpot VM was implemented in Java 1.3 in 2000) there were some criticisms of performance. Java has been demonstrated to run at a decent speed compared with native code, and modern JVM implementations are regularly benchmarked and is typically at least two times slower than C and C++ is 33% slower than C.
Java's performance has improved substantially since the early versions. Performance of JIT compilers relative to native compilers has in some optimized tests been shown to be quite similar.
Java bytecode can either be interpreted at run time by a virtual machine, or it can be compiled at load time or runtime into native code which runs directly on the computer's hardware. Interpretation is slower than native execution, and compilation at load time or runtime has an initial performance penalty for the compilation. Modern performance JVM implementations all use the compilation approach, so after the initial startup time the performance is equivalent to native code.
The Java platform provides a security architecture which is designed to allow the user to run untrusted bytecode in a "sandboxed" manner to protect against malicious or poorly-written software. This "sandboxing" feature is intended to protect the user by restricting access to certain platform features and APIs which could be exploited by malware, such as accessing the local filesystem, running arbitrary commands, or accessing communication networks.
In recent years, researchers have discovered multiple security flaws in some widely-used Java implementations, including Oracle's, which allow untrusted code to bypass the sandboxing mechanism, exposing users to malicious attacks. (These flaws affect only Java applications which execute arbitrary untrusted bytecode, such as web browser plugins that run Java applets downloaded from public websites. Applications where the user trusts, and has full control over, all Java code being executed are unaffected.)
On August 31, 2012, Java 6 and 7 on the platforms Microsoft-Windows, Mac OS X, and Linux were found to have a serious security flaw that allowed a remote exploit to take place by simply loading a malicious web page. Additionally, Java 5 has been found to be flawed as well.
On January 10, 2013, three computer specialists spoke out against Java, telling Reuters that it was not secure and that people should disable Java. Jaime Blasco, Labs Manager with AlienVault Labs stated that "Java is a mess. It’s not secure", and added a cautious note that "You have to disable it." This vulnerability affects Java 7 and it is unclear if it affects Java 6, so it is suggested that consumers disable it. Security alerts from Oracle announce schedules of critical security-related patches to Java.
On January 14, 2013, security experts said that the update still failed to protect PCs from attack. This exploit hole prompted a response from the United States Department of Homeland Security encouraging users to disable or uninstall Java. Apple blacklisted Java completely for any Mac OS X (Mac operating systems) computer to protect its systems.
- Java (programming language) :
Java (programming language)
Java is a general-purpose, concurrent, class-based, object-oriented computer programming language that is specifically designed to have as few implementation dependencies as possible. It is intended to let application developers "write once, run anywhere" (WORA), meaning that code that runs on one platform does not need to be recompiled to run on another. Java applications are typically compiled to bytecode (class file) that can run on any Java virtual machine (JVM) regardless of computer architecture. Java is, as of 2012, one of the most popular programming languages in use, particularly for client-server web applications, with a reported 10 million users. Java was originally developed by James Gosling at Sun Microsystems (which has since merged into Oracle Corporation) and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++, but it has fewer low-level facilities than either of them.
The original and reference implementation Java compilers, virtual machines, and class libraries were developed by Sun from 1991 and first released in 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun relicensed most of its Java technologies under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.
James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June 1991. Java was originally designed for interactive television, but it was too advanced for the digital cable television industry at the time. The language was initially called Oak after an oak tree that stood outside Gosling's office; it went by the name Green later, and was later renamed Java, from Java coffee, said to be consumed in large quantities by the language's creators. Gosling aimed to implement a virtual machine and a language that had a familiar C/C++ style of notation.
Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run Anywhere" (WORA), providing no-cost run-times on popular platforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as J2SE 1.2 in December 1998 - 1999), new versions had multiple configurations built for different types of platforms. For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively.
In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process. Java remains a de facto standard, controlled through the Java Community Process. At one time, Sun made most of its Java implementations available without charge, despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the compiler, utility programs, and header files.
On November 13, 2006, Sun released much of Java as free and open source software, (FOSS), under the terms of the GNU General Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free software/open-source distribution terms, aside from a small portion of code to which Sun did not hold the copyright.
Sun's vice-president Rich Green said that Sun's ideal role with regards to Java was as an "evangelist." Following Oracle Corporation's acquisition of Sun Microsystems in 2009-2010, Oracle has described itself as the "steward of Java technology with a relentless commitment to fostering a community of participation and transparency". This did not hold Oracle, however, from filing a lawsuit against Google shortly after that for using Java inside the Android SDK (see Google section below). Java software runs on laptops to data centers, game consoles to scientific supercomputers. There are 930 million Java Runtime Environment downloads each year and 3 billion mobile phones run Java. On April 2, 2010, James Gosling resigned from Oracle.
James Gosling, the creator of Java There were five primary goals in the creation of the Java language :
- It should be "simple, object-oriented and familiar"
- It should be "robust and secure"
- It should be "architecture-neutral and portable"
- It should execute with "high performance"
- It should be "interpreted, threaded, and dynamic"
Major release versions of Java, along with their release dates:
- JDK 1.0 (January 21, 1996)
- JDK 1.1 (February 19, 1997)
- J2SE 1.2 (December 8, 1998)
- J2SE 1.3 (May 8, 2000)
- J2SE 1.4 (February 6, 2002)
- J2SE 5.0 (September 30, 2004)
- Java SE 6 (December 11, 2006)
- Java SE 7 (July 28, 2011)
One characteristic of Java is portability, which means that computer programs written in the Java language must run similarly on any hardware/operating-system platform. This is achieved by compiling the Java language code to an intermediate representation called Java bytecode, instead of directly to platform-specific machine code. Java bytecode instructions are analogous to machine code, but they are intended to be interpreted by a virtual machine (VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE) installed on their own machine for standalone Java applications, or in a Web browser for Java applets.
Standardized libraries provide a generic way to access host-specific features such as graphics, threading, and networking. A major benefit of using bytecode is porting. However, the overhead of interpretation means that interpreted programs almost always run more slowly than programs compiled to native executables would. Just-in-Time (JIT) compilers were introduced from an early stage that compile bytecodes to machine code during runtime.
Oracle Corporation is the current owner of the official implementation of the Java SE platform, following their acquisition of Sun Microsystems on January 27, 2010. This implementation is based on the original implementation of Java by Sun. The Oracle implementation is available for Mac OS X, Windows and Solaris. Because Java lacks any formal standardization recognized by Ecma International, ISO/IEC, ANSI, or other third-party standards organization, the Oracle implementation is the de facto standard.
The Oracle implementation is packaged into two different distributions: The Java Runtime Environment (JRE) which contains the parts of the Java SE platform required to run Java programs and is intended for end-users, and the Java Development Kit (JDK), which is intended for software developers and includes development tools such as the Java compiler, Javadoc, Jar, and a debugger.
OpenJDK is another notable Java SE implementation that is licensed under the GPL. The implementation started when Sun began releasing the Java source code under the GPL. As of Java SE 7, OpenJDK is the official Java reference implementation.
The goal of Java is to make all implementations of Java compatible. Historically, Sun's trademark license for usage of the Java brand insists that all implementations be "compatible". This resulted in a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support RMI or JNI and had added platform-specific features of their own. Sun sued in 1997, and in 2001 won a settlement of US$20 million, as well as a court order enforcing the terms of the license from Sun. As a result, Microsoft no longer ships Windows with Java.
Platform-independent Java is essential to Java EE, and an even more rigorous validation is required to certify an implementation. This environment enables portable server-side applications.
Programs written in Java have a reputation for being slower and requiring more memory than those written in C++. However, Java programs' execution speed improved significantly with the introduction of Just-in-time compilation in 1997/1998 for Java 1.1,the addition of language features supporting better code analysis (such as inner classes, the StringBuffer class, optional assertions, etc.), and optimizations in the Java virtual machine itself, such as HotSpot becoming the default for Sun's JVM in 2000. As of December 2012, microbenchmarks show Java 7 is approximately 44% slower than C++.
Some platforms offer direct hardware support for Java; there are microcontrollers that can run Java in hardware instead of a software Java virtual machine, and ARM based processors can have hardware support for executing Java bytecode through their Jazelle option.
Automatic memory management
Java uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer in use. Once no references to an object remain, the unreachable memory becomes eligible to be freed automatically by the garbage collector. Something similar to a memory leak may still occur if a programmer's code holds a reference to an object that is no longer needed, typically when objects that are no longer needed are stored in containers that are still in use. If methods for a nonexistent object are called, a "null pointer exception" is thrown.
One of the ideas behind Java's automatic memory management model is that programmers can be spared the burden of having to perform manual memory management. In some languages, memory for the creation of objects is implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. In the latter case the responsibility of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak occurs. If the program attempts to access or deallocate memory that has already been deallocated, the result is undefined and difficult to predict, and the program is likely to become unstable and/or crash. This can be partially remedied by the use of smart pointers, but these add overhead and complexity. Note that garbage collection does not prevent "logical" memory leaks, i.e. those where the memory is still referenced but never used.
Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is guaranteed to be triggered if there is insufficient free memory on the heap to allocate a new object; this can cause a program to stall momentarily. Explicit memory management is not possible in Java.
Java does not support C/C++ style pointer arithmetic, where object addresses and unsigned integers (usually long integers) can be used interchangeably. This allows the garbage collector to relocate referenced objects and ensures type safety and security.
As in C++ and some other object-oriented languages, variables of Java's primitive data types are not objects. Values of primitive types are either stored directly in fields (for objects) or on the stack (for methods) rather than on the heap, as commonly true for objects (but see escape analysis). This was a conscious decision by Java's designers for performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language. However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their wrapper class.
Java contains multiple types of garbage collectors. By default, HotSpot uses the concurrent mark sweep collector, also known as the CMS garbage collector or CMS. However, there are also several other garbage collectors that can be used to manage the heap. For 90% of applications in Java, the CMS garbage collector is sufficient. Oracle aims to replace CMS with the Garbage-first collector (G1).
- List of Java virtual machines :
List of Java virtual machines :
This article's use of external links may not follow Wikipedia's policies or guidelines. Please improve this article by removing excessive or inappropriate external links, and converting useful links where appropriate into footnote references. (April 2012)
This article does not cite any references or sources. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (April 2012)
This article provides non-exhaustive lists of Java SE Java virtual machines (JVMs). It does not include a large number of Java ME vendors. Note that Java EE runs on the standard Java SE JVM but that some vendors specialize in providing a modified JVM optimized for Java EE applications. A large amount of Java development work takes place on Windows, Solaris and Linux, primarily with the Sun JVMs. Note the further complication of different 32-bit/64-bit varieties.
The primary reference Java VM implementation is HotSpot, produced by Oracle Corporation.
Azul Zing JVM a fully compliant Java Virtual Machine based on HotSpot that uses the Azul C4 (Continuously Concurrent Compacting Collector) garbage collector. Supports memory heaps up to 512 GB without GC pauses and is able to grow and shrink the heap based on load.
- CEE-J is a clean room implementation of Sun's Java technology, Skelmir is not a licensee of Oracle.
- Excelsior JET is a licensed Java SE implementation with AOT compiler
- Hewlett-Packard, Java for HP-UX, OpenVMS, Tru64 and Reliant (Tandem) UNIX platforms
- J9 (IBM), for Windows, AIX, Linux (x86 and PPC), MVS, OS/400, Pocket PC, z/OS
- "Classic JVM" for IBM OS/400 (superseded by J9)
- Imsys AB provides their SNAP (Simple Network Application Platform) JVM running on their proprietary IM1000 and IM3000 microprocessors that feature microcode execution of Java byte codes.
- Apogee provides embedded Java using IBM J9 and Apache Harmony Class Library for X86, ARM, MIPS, PowerPC running on Linux, LynxOS, WinCE.
- JBed, (Esmertec) is an embedded Java with multimedia capabilities
- JamaicaVM, (aicas) is a hard real-time Java VM for embedded systems
- JBlend, (Aplix) is a Java ME implementation
- Jinitiator, developed by Oracle before they purchased Sun. Designed to improve support for Oracle Forms in web sites.
- JRockit (originally from Appeal Virtual Machines) acquired by Oracle for Linux, Windows and Solaris
- Mac OS Runtime for Java (MRJ)
- MicroJvm (IS2T - Industrial Smart Software Technology) Wide range of virtual machines dedicated to embedded systems (including hard real-time constrained systems), ARM7, ARM9, AVR, AVR32, PPC, MIPS, ...
- Microsoft Java Virtual Machine (discontinued in 2001)
- OJVM (also known as "JServer") from Oracle Corporation
- PERC (Aonix/Atego) is a real time Java for embedded. Aonix is not a licensee of Oracle.
- SAPJVM (SAP) is a licensed and modified SUN JVM ported to all supported platforms of SAP NetWeaver, started as Java 5, in the meantime Java 6 compatible (Windows i386, x64, IA-64; Linux x86, IA-64, PowerPC; AIX PowerPC; HP-UX SPARC IA-64; Solaris SPARC x86-64; i5/OS PowerPC)
- Waratek Cloud VM for Java A multitenant JVM that allows per-tenant isolation, metering and resource control
Lesser-known proprietary Java virtual machines
Blackdown Java was a licensed port to Linux of the reference SunSoft implementation. It was discontinued in 2007, after OpenJDK became available.
- C virtual machine (CVM, from Sun), supports C
- Gemstone - modified for Java EE features (application DBMS)
- Golden Code Development (EComStation and OS/2 port of Java RTE and SDK for Java SE v1.4.1_07)
- HP ChaiVM and MicrochaiVM
- Intent (Tao Group)
- Novell, India.
- NSIcom CrE-ME
- PreonVM (Virtenio) A VM for embedded systems and small devices.
Free and open source implementations
- AegisVM (inactive since 2004).
- Apache Harmony — supports several architectures and systems. Apache License 2.0.
- Avian — A small, easily embeddable Java VM and classpath using just-in-time compilation.
- CACAO — uses GNU Classpath, supports multiple architectures. GPL. 1.6.0 released September 4, 2012.
- Dalvik used in Google Android
- GCJ the GCC Java compiler, that compiles either to bytecode or to native machine code.
- HaikuVM, for Atmel AVRs (Arduino) and other micros using the leJOS runtime.
- HotSpot, the primary reference Java VM implementation.
- IcedTea — has the only working free software Java Web browser plugin. GPL+linking exception.
- IKVM.NET — Java for Mono and the Microsoft .NET Framework. Uses OpenJDK. Zlib License.
- Jamiga — for the Amiga platform. Depends on GNU Classpath. GPL.
- JamVM — Developed to be an extremely small virtual machine compared to others. Designed to use GNU Classpath. Supports several architectures. GPL.
- Jaos — Java on Active Object System. Uses GNU Classpath as a standard library. Unmaintained.
- Jato VM — uses GNU Classpath. GPL.
- JC — Converts class files from byte-code into C. Uses Soot and GNU Classpath. GNU Library or LGPL licenses.
- Jelatine JVM.
- JESSICA (Java-Enabled Single-System-Image Computing Architecture).
- Jikes RVM (Jikes Research Virtual Machine) — Research project. PPC and IA-32. Supports Apache Harmony and GNU Classpath libraries. Eclipse Public License.
- JNode — operating system. Version 0.2.8 released on January 29, 2009. LGPL.
- JOP — Hardware implementation of the JVM. GPL 3.
- Juice — JavaME experimental JVM developed to run on the NUXI operating system.
- Jupiter — Uses Boehm garbage collector and GNU Classpath. GPL. Unmaintained.
- JwiK™ Open Source Java VM for 8bit micro for wireless applications.
- JX (operating system) — GPL. Version 0.1.1 released on October 10, 2007.
- Kaffe — Uses GNU Classpath. GPL. 1.1.9 released on February 26, 2008.
- leDos real-mode x86 JVM running on MS-DOS. MPL.
- leJOS — Robotics suite, a firmware replacement for Lego Mindstorms programmable bricks, provides a Java programming environment for the Lego Mindstorms RCX and NXT robots.
- MateVM — An experimental JIT implemented in Haskell. GPL.
- Maxine — meta-circular open source research VM from Oracle Labs.
- Mika VM — intended for use in embedded devices. Cross-platform. BSD-style licence.
- miniMV (from UABC-Tij for embedded systems and Wireless Sensor network devices).
- Mysaifu (Windows CE/Windows Mobile) — the only open source Java SE-compatible JVM still in development for PocketPC devices. GPL 2.
- NanoVM — developed to run on the Atmel AVR ATmega8 used in the Asuro Robot, can be ported to other AVR-based systems.
- SableVM — First free software JVM to support JVDMI and JDWP. Makes use of GNU Classpath. LGPL. Version 1.13 released on March 30, 2007.
- Squawk virtual machine — A Java ME VM for embedded systems and small devices. Cross-Platform. GPL.
- SuperWaba — Java-like virtual machine for portable devices. GPL. Discontinued, succeeded by TotalCross.
- TakaTuka — for wireless sensor network devices. GPL.
- VM02 a Java-compatible environment for the Apple II series of computers.
- VMkit of Low Level Virtual Machine.
- Wonka VM — Developed to run on Acunia's ARM-based hardware. Some code drawn from GNU Classpath. BSD-style licence. No longer under active
- development, superseded by Mika VM.
- Java Virtual Machine :
Java virtual machine
Overview of a Java virtual machine (JVM) architecture. Source code is compiled to Java bytecode, which is verified, interpreted or JIT-compiled for the native architecture. The Java APIs and JVM together make up the Java Runtime Environment (JRE).
A Java virtual machine (JVM) is a virtual machine that can execute Java bytecode. It is the code execution component of the Java platform. Sun Microsystems has stated that there are over 5.5 billion JVM-enabled devices.
A Java virtual machine is a program which executes certain other programs, namely those containing Java bytecode instructions. JVM's are most often implemented to run on an existing operating system, but can also be implemented to run directly on hardware. A JVM provides a run-time environment in which Java byte code can be executed, enabling features such as automated exception handling, which provides root-cause debugging information for every software error (exception). A JVM is distributed along with Java Class Library, a set of standard class libraries (in Java bytecode) that implement the Java application programming interface (API). These libraries, bundled together with the JVM, form the Java Runtime Environment (JRE).
JVMs are available for many hardware and software platforms. The use of the same bytecode for all JVMs on all platforms allows Java to be described as a write once, run anywhere programming language, versus write once, compile anywhere, which describes cross-platform compiled languages. Thus, the JVM is a crucial component of the Java platform.
Java bytecode is an intermediate language which is typically compiled from Java, but it can also be compiled from other programming languages. For example, Ada source code can be compiled to Java bytecode and executed on a JVM.
Oracle Corporation, the owner of the Java trademark, produces the most widely used JVM, named HotSpot, that is written in the C++ programming language. JVMs using the Java trademark may also be developed by other companies as long as they adhere to the JVM specification published by Oracle Corporation and to related contractual obligations.
Oracle's Java execution environment is termed the Java Runtime Environment, or JRE.
Programs intended to run on a JVM must be compiled into Java bytecode, a standardized portable binary format which typically comes in the form of .class files (Java class files). A program may consist of many classes in different files. For easier distribution of large programs, multiple class files may be packaged together in a .jar file (short for Java archive).
The Java application launchers, java and javaw offer a standard way of executing Java code, with or without a console window respectivily. The JVM runtime executes .class or .jar files, emulating the JVM instruction set by interpreting it or using a just-in-time compiler (JIT) such as Oracle's HotSpot. JIT compiling, not interpreting, is used in most JVMs today to achieve greater speed. There are also ahead-of-time compilers that enable developers to precompile class files into native code for particular platforms.
Like most virtual machines, the Java virtual machine has a stack-based architecture akin to a microcontroller/microprocessor. However, the JVM also has low-level support for Java-like classes and methods, which amounts to a highly idiosyncratic memory model and capability-based architecture.
A basic philosophy of Java is that it is inherently safe from the standpoint that no user program can crash the host machine or otherwise interfere inappropriately with other operations on the host machine, and that it is possible to protect certain methods and data structures belonging to trusted code from access or corruption by untrusted code executing within the same JVM. Furthermore, common programmer errors that often lead to data corruption or unpredictable behavior such as accessing off the end of an array or using an uninitialized pointer are not allowed to occur. Several features of Java combine to provide this safety, including the class model, the garbage-collected heap, and the verifier.
The JVM verifies all bytecode before it is executed. This verification consists primarily of three types of checks:Branches are always to valid locations Data is always initialized and references are always type-safe Access to private or package private data and methods is rigidly controlled.
The first two of these checks take place primarily during the verification step that occurs when a class is loaded and made eligible for use. The third is primarily performed dynamically, when data items or methods of a class are first accessed by another class.
The verifier permits only some bytecode sequences in valid programs, e.g. a jump (branch) instruction can only target an instruction within the same method. Furthermore, the verifier ensures that any given instruction operates on a fixed stack location, allowing the JIT compiler to transform stack accesses into fixed register accesses. Because of this, that the JVM is a stack architecture does not imply a speed penalty for emulation on register-based architectures when using a JIT compiler. In the face of the code-verified JVM architecture, it makes no difference to a JIT compiler whether it gets named imaginary registers or imaginary stack positions that must be allocated to the target architecture's registers. In fact, code verification makes the JVM different from a classic stack architecture, of which efficient emulation with a JIT compiler is more complicated and typically carried out by a slower interpreter.
Code verification also ensures that arbitrary bit patterns cannot get used as an address. Memory protection is achieved without the need for a memory management unit (MMU). Thus, JVM is an efficient way to get memory protection on simple architectures that lack an MMU. This is analogous to managed code in Microsoft's .NET Common Language Runtime, and conceptually similar to capability architectures such as the Plessey 250, and IBM System/38.
The original specification for the bytecode verifier used natural language that was incomplete or incorrect in some respects. A number of attempts have been made to specify the JVM as a formal system. By doing this, the security of current JVM implementations can more thoroughly be analyzed, and potential security exploits prevented. It will also be possible to optimize the JVM by skipping unnecessary safety checks, if the application being run is proved to be safe.
The JVM has instructions for the following groups of tasks :
- Load and store
- Type conversion
- Object creation and manipulation
- Operand stack management (push / pop)
- Control transfer (branching)
- Method invocation and return
- Throwing exceptions
- Monitor-based concurrency
The aim is binary compatibility. Each particular host operating system needs its own implementation of the JVM and runtime. These JVMs interpret the bytecode semantically the same way, but the actual implementation may be different. More complex than just emulating bytecode is compatibly and efficiently implementing the Java core API that must be mapped to each host operating system.
The Java virtual machine heap is the area of memory used by the JVM, specifically HotSpot, for dynamic memory allocation. The heap is divided into generations:
The young generation stores short-lived objects that are created and immediately garbage collected. Objects that persist longer are moved to the old generation (also called the tenured generation).
The permanent generation (or permgen) is used for class definitions and associated metadata. Permanent generation is not part of the heap.
Originally there was no permanent generation, and objects and classes were stored together in the same area. But as class unloading occurs much more rarely than objects are collected, moving class structures to a specific area allows significant performance improvements.
Secure execution of remote code
A virtual machine architecture allows very fine-grained control over the actions that code within the machine is permitted to take. This is designed to allow safe execution of untrusted code from remote sources, a model used by Java applets. Applets run within a VM incorporated into a user's browser, executing code downloaded from a remote HTTP server. The remote code runs in a restricted sandbox, which is designed to protect the user from misbehaving or malicious code. Publishers can purchase a certificate with which to digitally sign applets as safe, giving them permission to ask the user to break out of the sandbox and access the local file system, clipboard, execute external pieces of software, or network.
C to bytecode compilers
This section relies on references to primary sources. Please add references to secondary or tertiary sources. (November 2011) From the viewpoint of a compiler, the Java virtual machine is just another processor with an instruction set, Java bytecode, for which code can be generated. The JVM was originally designed to execute programs written in the Java language. However, the JVM provides an execution environment in the form of a bytecode instruction set and a runtime system that is general enough that it can be used as the target for compilers of other languages.
Because of its close association with the Java language, the JVM performs the strict runtime checks mandated by the Java specification. That requires C to bytecode compilers to provide their own lax machine abstraction, for instance producing compiled code that uses a Java array to represent main memory (so pointers can be compiled to integers), and linking the C library to a centralized Java class that emulates system calls. Most or all of the compilers listed below use a similar approach.
Several C to bytecode compilers exist:
- NestedVM translates C to MIPS machine language first before converting to Java bytecode.
- Cibyl works similarly to NestedVM but targets J2ME devices.
- LLJVM compiles C to LLVM IR, which is then translated to JVM bytecode.
- C2J is also GCC-based, but it produces intermediary Java source code before generating bytecode. Supports the full ANSI C runtime. Win32 only.
- Axiomatic Multi-Platform C supports full ANSI C 1989, SWT, and J2ME CDC 1.1 for mobile devices.
- Java Backend for GCC, possibly the oldest project of its kind, was developed at The University of Queensland in 1999.
- Javum is an attempt to port the full GNU environment to the JVM, and includes one of the above compilers packaged with additional utilities.
- Compilers targeting Java bytecode have been written for other programming languages, including Ada and COBOL.
A Java processor is the implementation of the Java Virtual Machine (JVM) in hardware. In other words the bytecodes that make up the instruction set of the abstract machine become the instruction set of a concrete machine.
- Up to now the following Java processors are available:
- picoJava was the first attempt by Sun Microsystems to build a Java processor
- aJ102 and aJ200 from aJile Systems, Inc.. Available on boards from Systronix
- Cjip from Imsys Technologies. Available on boards and with wireless radios from AVIDwireless
- Komodo is a multithreaded Java microcontroller for research on real-time scheduling
- FemtoJava is a research project to build an application specific Java processor
- ARM926EJ-S is an ARM processor able to run Java bytecode, this technology being named Jazelle
- Java Optimized Processor for FPGAs. A PhD thesis is available
- SHAP bytecode processor from the TU Dresden
- jHISC provides hardware support for object-oriented functions
- ObjectCore is a multicore Java processor designed by Vivaja Technologies.
- Java Offload Engine (JOE) is a high performance Java co-processor from Temple Computing Labs LLP.
- List of Java APIs :
List of Java APIs
There are 3 types of Java Programming Language Application Programming Interfaces (APIs) :
the official core Java API, contained in the JDK or JRE, of one of the editions of the Java Platform. The three editions of the Java Platform are Java ME (Micro edition), Java SE (Standard edition), and Java EE (Enterprise edition).
optional official APIs that can be downloaded separately. The specification of these APIs are defined according to a Java Specification Request (JSR), and sometimes some of these APIs are later included in the core APIs of the platform (the most notable example of this kind is Swing). unofficial APIs, developed by third parties, but not related to any JSRs.
Third-parties can freely implement any JSR specifications for an official API (even for the core API of the language), providing that they conform to the Technology Compatibility Kit (TCK) for this JSR (the TCK is a suite of tests that checks conformance of implementations for a JSR). The result of this freedom is that many official APIs have more implementations than the Sun's Reference implementation (RI).
The following is a partial list of Application Programming Interfaces (APIs) for the Java Programming Language.
- Java Advanced Imaging JAI : A set of interfaces that support a high-level programming model allowing to manipulate images easily.
- Java Data Objects JDO : A specification of Java object persistence.
- JavaHelp : A full-featured, extensible help system that enables you to incorporate online help in applets, components, applications,
- operating systems, and devices.
- Java Media Framework JMF : An API that enables audio, video and other time-based media to be added to Java applications and applets.
- Java Naming and Directory Interface JNDI : An API for directory services.
- Java Speech API JSAPI : This API allows for speech synthesis and speech recognition.
- Java 3D : J3D A scene graph-based 3D API.
- Java OpenGL : JOGL A wrapper library for OpenGL.
- Java Mail : A framework to build mail and messaging applications
- Java USB for Windows : A USB communication of Java applications
- Rich Client Platforms : Eclipse Rich Client Platform (RCP) , NetBeans Platform
- Office_compliant libraries : Apache POI
- Compression : LZMA SDK, the Java implementation of the SDK used by the popular 7-Zip file archive software (available here)
- Game engines : Slick , jMonkey Engine , JPCT Engine , LWJGL
- Real-time libraries : Javolution
- Windowing libraries : Standard Widget Toolkit (SWT)
- Java Platform, Standard Edition :
Java Platform, Standard Edition
Java Platform, Standard Edition or Java SE is a widely used platform for development and deployment of portable applications for desktop and server environments. Java SE uses object-oriented Java programming language. Strictly speaking, Java SE is a platform specification. It defines a wide range of general purpose APIs - such as Java APIs for the Java Class Library and also includes the Java Language Specification and the Java Virtual Machine Specification. One of the most well known implementations of Java SE is Oracle Corporation's Java Development Kit (JDK).
Java SE was known as Java 2 Platform, Standard Edition or J2SE from version 1.2 until version 1.5. The "SE" is used to distinguish the base platform from the Enterprise Edition (Java EE) and Micro Edition (Java ME) platforms. The "2" was originally intended to emphasize the major changes introduced in version 1.2, but was removed in version 1.6. The naming convention has been changed several times ------------- over the Java version history. Starting with J2SE 1.4 (Merlin), Java SE has been developed under the Java Community Process, which produces descriptions of proposed and final specifications for the Java platform called Java Specification Requests (JSR). JSR 59 was the umbrella specification for J2SE 1.4 and JSR 176 specified J2SE 5.0 (Tiger). Java SE 6 (Mustang) was released under JSR 270.
Java Platform, Enterprise Edition (Java EE) is a related specification that includes all the classes in Java SE, plus a number that are more useful to programs that run on servers as opposed to workstations.
Java Platform, Micro Edition (Java ME) is a related specification intended to provide a certified collection of Java APIs for the development of software for small, resource-constrained devices such as cell phones, PDAs and set-top boxes.
The Java Runtime Environment (JRE) and Java Development Kit (JDK) are the actual files downloaded and installed on a computer to run or develop Java programs, respectively.
General purpose packages
The Java package java.lang contains fundamental classes and interfaces closely tied to the language and runtime system. This includes the root classes that form the class hierarchy, types tied to the language definition, basic exceptions, math functions, threading, security functions, as well as some information on the underlying native system. This package contains 22 of 32 Error classes provided in JDK 6.
The main classes and interfaces in java.lang are :
- Object - the class that is the root of every class hierarchy.
- Enum - the base class for enumeration classes (as of J2SE 5.0).
- Class - the class that is the root of the Java reflection system.
- Throwable - the class that is the base class of the exception class hierarchy.
- Error, Exception, and RuntimeException - the base classes for each exception type.
- Thread - the class that allows operations on threads.
- String - the class for strings and string literals.
- StringBuffer and StringBuilder - classes for performing string manipulation (StringBuilder as of J2SE 5.0).
- Comparable - the interface that allows generic comparison and ordering of objects (as of J2SE 1.2).
- Iterable - the interface that allows generic iteration using the enhanced for loop (as of J2SE 5.0).
- ClassLoader, Process, Runtime,SecurityManager, and System - classes that provide "system operations" that manage the dynamic loading of
- classes, creation of external processes, host environment inquiries such as the time of day, and enforcement of security policies.
- Math and StrictMath - classes that provide basic math functions such as sine, cosine, and square root (StrictMath as of J2SE 1.3).
- The primitive wrapper classes that encapsulate primitive types as objects.
- The basic exception classes thrown for language-level and other common exceptions.
- Classes in java.lang are automatically imported into every source file.
The java.lang.ref package provides more flexible types of references than are otherwise available, permitting limited interaction between the application and the Java Virtual Machine (JVM) garbage collector. It is an important package, central enough to the language for the language designers to give it a name that starts with "java.lang", but it is somewhat special-purpose and not used by a lot of developers. This package was added in J2SE 1.2.
Java has an expressive system of references and allows for special behavior for garbage collection. A normal reference in Java is known as a "strong reference." The java.lang.ref package defines three other types of references — soft, weak, and phantom references. Each type of reference is designed for a specific use.
A SoftReference can be used to implement a cache. An object that is not reachable by a strong reference (that is, not strongly reachable), but is referenced by a soft reference is called "softly reachable." A softly reachable object may be garbage collected at the discretion of the garbage collector. This generally means that softly reachable objects are only garbage collected when free memory is low—but again, this is at the garbage collector's discretion. Semantically, a soft reference means, "Keep this object when nothing else references it, unless the memory is needed."
A WeakReference is used to implement weak maps. An object that is not strongly or softly reachable, but is referenced by a weak reference is called "weakly reachable". A weakly reachable object is garbage collected in the next collection cycle. This behavior is used in the class java.util.WeakHashMap. A weak map allows the programmer to put key/value pairs in the map and not worry about the objects taking up memory when the key is no longer reachable anywhere else. Another possible application of weak references is the string intern pool. Semantically, a weak reference means "get rid of this object when nothing else references it at the next garbage collection."
A PhantomReference is used to reference objects that have been marked for garbage collection and have been finalized, but have not yet been reclaimed. An object that is not strongly, softly or weakly reachable, but is referenced by a phantom reference is called "phantom reachable." This allows for more flexible cleanup than is possible with the finalization mechanism alone. Semantically, a phantom reference means "this object is no longer needed and has been finalized in preparation for being collected."
Each of these reference types extends the Reference class, which provides the get() method to return a strong reference to the referent object (or null if the reference has been cleared or if the reference type is phantom), and the clear() method to clear the reference.
The java.lang.ref also defines the class ReferenceQueue, which can be used in each of the applications discussed above to keep track of objects that have changed reference type. When a Reference is created it is optionally registered with a reference queue. The application polls the reference queue to get references that have changed reachability state.
Reflection is a constituent of the Java API that lets Java code examine and "reflect" on Java components at runtime and use the reflected members. Classes in the java.lang.reflect package, along with java.lang.Class and java.lang.Package accommodate applications such as debuggers, interpreters, object inspectors, class browsers, and services such as object serialization and JavaBeans that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class. This package was added in JDK 1.1.
Reflection is used to instantiate classes and invoke methods using their names, a concept that allows for dynamic programming. Classes, interfaces, methods, fields, and constructors can all be discovered and used at runtime. Reflection is supported by metadata that the JVM has about the program.
There are two basic techniques involved in reflection :
Discovery - this involves taking an object or class and discovering the members, superclasses, implemented interfaces, and then possibly using the discovered elements.
Use by name - involves starting with the symbolic name of an element and using the named element.
Discovery typically starts with an object and calling the Object.getClass() method to get the object's Class. The Class object has several methods for discovering the contents of the class, for example :
- getMethods() - returns an array of Method objects representing all the public methods of the class or interface
- getConstructors() - returns an array of Constructor objects representing all the public constructors of the class
- getFields() - returns an array of Field objects representing all the public fields of the class or interface
- getClasses() - returns an array of Class objects representing all the public classes and interfaces that are members (e.g. inner classes) of the class or interface
- getSuperclass() - return the Class object representing the superclass of the class or interface (null is returned for interfaces)
- getInterfaces() - returns an array of Class objects representing all the interfaces that are implemented by the class or interface
Use by name
The Class object can be obtained either through discovery, by using the class literal (e.g. MyClass.class) or by using the name of the class (e.g. Class.forName("mypackage.MyClass")). With a Class object, member Method, Constructor, or Field objects can be obtained using the symbolic name of the member. For example:
getMethod("methodName", Class...) - returns the Method object representing the public method with the name "methodName" of the class or interface that accepts the parameters specified by the Class... parameters.
getConstructor(Class...) - returns the Constructor object representing the public constructor of the class that accepts the parameters specified by the Class... parameters.
getField("fieldName") - returns the Field object representing the public field with the name "fieldName" of the class or interface.
Method, Constructor, and Field objects can be used to dynamically access the represented member of the class. For example:
Field.get(Object) - returns an Object containing the value of the field from the instance of the object passed to get(). (If the Field object represents a static field then the Object parameter is ignored and may be null.)
Method.invoke(Object, Object...) - returns an Object containing the result of invoking the method for the instance of the first Object parameter passed to invoke(). The remaining Object... parameters are passed to the method. (If the Method object represents a static method then the first Object parameter is ignored and may be null.)
Constructor.newInstance(Object...) - returns the new Object instance from invoking the constructor. The Object... parameters are passed to the constructor. (Note that the parameterless constructor for a class can also be invoked by calling newInstance().)
Arrays and proxies
The java.lang.reflect package also provides an Array class that contains static methods for creating and manipulating array objects, and since J2SE 1.3, a Proxy class that supports dynamic creation of proxy classes that implement specified interfaces.
The implementation of a Proxy class is provided by a supplied object that implements the InvocationHandler interface. The InvocationHandler's ) invoke(Object, Method, Object) method is called for each method invoked on the proxy object - the first parameter is the proxy object, the second parameter is the Method object representing the method from the interface implemented by the proxy, and the third parameter is the array of parameters passed to the interface method. The invoke() method returns an Object result that contains the result returned to the code that called the proxy interface method.
The java.io package contains classes that support input and output. The classes in the package are primarily stream-oriented; however, a class for random access files is also provided. The central classes in the package are InputStream and OutputStream, which are abstract base classes for reading from and writing to byte streams, respectively. The related classes Reader and Writer are abstract base classes for reading from and writing to character streams, respectively. The package also has a few miscellaneous classes to support interactions with the host file system.
The stream classes follow the decorator pattern by extending the base subclass to add features to the stream classes. Subclasses of the base stream classes are typically named for one of the following attributes:the source/destination of the stream data the type of data written to/read from the stream additional processing or filtering performed on the stream data The stream subclasses are named using the naming pattern XxxStreamType where Xxx is the name describing the feature and StreamType is one of InputStream, OutputStream, Reader, or Writer.
The following table shows the sources/destinations supported directly by the java.io package:
- Source/Destination Name Stream types In/Out Classes
- byte array (byte) ByteArray byte in, out ByteArrayInputStream, ByteArrayOutputStream
- char array (char) CharArray char in, out CharArrayReader, CharArrayWriter
- file File byte, char in, out FileInputStream, FileOutputStream, FileReader, FileWriter
- string (StringBuffer) String char in, out StringReader, StringWriter
- thread (Thread) Piped byte, char in, out PipedInputStream, PipedOutputStream, PipedReader, PipedWriter
- Other standard library packages provide stream implementations for other destinations, such as the InputStream returned by the
- java.net.Socket.getInputStream() method or the Java EE javax.servlet.ServletOutputStream class.
Data type handling and processing or filtering of stream data is accomplished through stream filters. The filter classes all accept another compatible stream object as a parameter to the constructor and decorate the enclosed stream with additional features. Filters are created by extending one of the base filter classes FilterInputStream, FilterOutputStream, FilterReader, or FilterWriter.
The Reader and Writer classes are really just byte streams with additional processing performed on the data stream to convert the bytes to characters. They use the default character encoding for the platform, which as of J2SE 5.0 is represented by the Charset returned by the java.nio.charset.Charset.defaultCharset() static method. The InputStreamReader class converts an InputStream to a Reader and the OutputStreamWriter class converts an OutputStream to a Writer. Both these classes have constructors that support specifying the character encoding to use. If no encoding is specified, the program uses the default encoding for the platform.
The RandomAccessFile class supports random access reading and writing of files. The class uses a file pointer that represents a byte-offset within the file for the next read or write operation. The file pointer is moved implicitly by reading or writing and explicitly by calling the seek(long) or skipBytes(int) methods. The current position of the file pointer is returned by the getFilePointer() method.
The File class represents a file or directory path in a file system. File objects support the creation, deletion and renaming of files and directories and the manipulation of file attributes such as read-only and last modified timestamp. File objects that represent directories can be used to get a list of all the contained files and directories.
The FileDescriptor class is a file descriptor that represents a source or sink (destination) of bytes. Typically this is a file, but can also be a console or network socket. FileDescriptor objects are used to create File streams. They are obtained from File streams and java.net sockets and datagram sockets.
In J2SE 1.4, the package java.nio (NIO or New I/O) was added to support memory-mapped I/O, facilitating I/O operations closer to the underlying hardware with sometimes dramatically better performance. The java.nio package provides support for a number of buffer types. The subpackage java.nio.charset provides support for different character encodings for character data. The subpackage java.nio.channels provides support for channels, which represent connections to entities that are capable of performing I/O operations, such as files and sockets. The java.nio.channels package also provides support for fine-grained locking of files.
The java.math package supports multiprecision arithmetic (including modular arithmetic operations) and provides multiprecision prime number generators used for cryptographic key generation. The main classes of the package are:
- BigDecimal - provides arbitrary-precision signed decimal numbers. BigDecimal gives the user control over rounding behavior through RoundingMode.
- BigInteger - provides arbitrary-precision integers. Operations on BigInteger do not overflow or lose precision. In addition to standard arithmetic operations, it provides modular arithmetic, GCD calculation, primality testing, prime number generation, bit manipulation, and other miscellaneous operations.
- MathContext - encapsulate the context settings that describe certain rules for numerical operators.
- RoundingMode - an enumeration that provides eight rounding behaviors.
The java.net package provides special IO routines for networks, allowing HTTP requests, as well as other common transactions.
The java.text package implements parsing routines for strings and supports various human-readable languages and locale-specific parsing.
Data structures that aggregate objects are the focus of the java.util package. Included in the package is the Collections API, an organized data structure hierarchy influenced heavily by the design patterns considerations.
Special purpose packages
Created to support Java applet creation, the java.applet package lets applications be downloaded over a network and run within a guarded sandbox. Security restrictions are easily imposed on the sandbox. A developer, for example, may apply a digital signature to an applet, thereby labeling it as safe. Doing so allows the user to grant the applet permission to perform restricted operations (such as accessing the local hard drive), and removes some or all the sandbox restrictions. Digital certificates are issued by certificate authorities.
Included in the java.beans package are various classes for developing and manipulating beans, reusable components defined by the JavaBeans architecture. The architecture provides mechanisms for manipulating properties of components and firing events when those properties change. The APIs in java.beans are intended for use by a bean editing tool, in which beans can be combined, customized, and manipulated. One type of bean editor is a GUI designer in an integrated development environment.
The java.awt, or Abstract Window Toolkit, provides access to a basic set of GUI widgets based on the underlying native platform's widget set, the core of the GUI event subsystem, and the interface between the native windowing system and the Java application. It also provides several basic layout managers, a datatransfer package for use with the Clipboard and Drag and Drop, the interface to input devices such as mice and keyboards, as well as access to the system tray on supporting systems. This package, along with javax.swing contains the largest number of enums (7 in all) in JDK 6.
The java.rmi package provides Java remote method invocation to support remote procedure calls between two java applications running in different JVMs.
Support for security, including the message digest algorithm, is included in the java.security package.
An implementation of the JDBC API (used to access SQL databases) is grouped into the java.sql package.
The javax.rmi package provides the support for the remote communication between applications, using the RMI over IIOP protocol. This protocol combines RMI and CORBA features.
Java SE Core Technologies - CORBA / RMI-IIOP
Swing is a collection of routines that build on java.awt to provide a platform independent widget toolkit. javax.swing uses the 2D drawing routines to render the user interface components instead of relying on the underlying native operating system GUI support.
This package contains the largest number of classes (133 in all) in JDK 6. This package, along with java.awt also contains the largest number of enums (7 in all) in JDK 6. It supports pluggable looks and feels (PLAFs) so that widgets in the GUI can imitate those from the underlying native system. Design patterns permeate the system, especially a modification of the model-view-controller pattern, which loosens the coupling between function and appearance. One inconsistency is that (as of J2SE 1.3) fonts are drawn by the underlying native system, and not by Java, limiting text portability. Workarounds, such as using bitmap fonts, do exist. In general, "layouts" are used and keep elements within an aesthetically consistent GUI across platforms.
The javax.swing.text.html.parser package provides the error tolerant HTML parser that is used for writing various web browsers and web bots.
The javax.xml.bind.annotation package contains the largest number of Annotation Types (30 in all) in JDK 6. It defines annotations for customizing Java program elements to XML Schema mapping.
The org.omg.CORBA package provides the support for the remote communication between applications using the General Inter-ORB Protocol and supports other features of the common object request broker architecture. Same as RMI and RMI-IIOP, this package is for calling remote methods of objects on other virtual machines
This package contains the largest number of Exception classes (45 in all) in JDK 6. From all communication possibilities CORBA is portable between various languages; however, with this comes more complexity.
The org.omg.PortableInterceptor package contains the largest number of interfaces (39 in all) in JDK 6. It provides a mechanism to register ORB hooks through which ORB services intercept the normal flow of execution of the ORB.
- Java Platform, Enterprise Edition :
Java Platform, Enterprise Edition
Java Platform, Enterprise Edition or Java EE is Oracle's enterprise Java computing platform. The platform provides an API and runtime environment for developing and running enterprise software, including network and web services, and other large-scale, multi-tiered, scalable, reliable, and secure network applications. Java EE extends the Java Platform, Standard Edition (Java SE), providing an API for object-relational mapping, distributed and multi-tier architectures, and web services. The platform incorporates a design based largely on modular components running on an application server. Software for Java EE is primarily developed in the Java programming language. The platform emphasizes Convention over configuration and annotations for configuration. Optionally XML can be used to override annotations or to deviate from the platform defaults.
Standards and specifications
Java EE is defined by its specification. As with other Java Community Process specifications, providers must meet certain conformance requirements in order to declare their products as Java EE compliant.
Java EE includes several API specifications, such as JDBC, RMI, e-mail, JMS, web services, XML, etc., and defines how to coordinate them. Java EE also features some specifications unique to Java EE for components. These include Enterprise JavaBeans, Connectors, servlets, JavaServer Pages and several web service technologies. This allows developers to create enterprise applications that are portable and scalable, and that integrate with legacy technologies. A Java EE application server can handle transactions, security, scalability, concurrency and management of the components that are deployed to it, in order to enable developers to concentrate more on the business logic of the components rather than on infrastructure and integration tasks.
The Java EE APIs includes several technologies that extend the functionality of the base Java SE APIs.
- Java EE 7 Platform Packages
- Java EE 6 Platform Packages
- Java EE 5 Platform Packages
The servlet specification defines a set of APIs to service mainly HTTP requests. It includes the JavaServer Pages specification.
The Java API for WebSocket specification defines a set of APIs to service WebSocket connections.
This package defines the root of the JavaServer Faces (JSF) API. JSF is a technology for constructing user interfaces out of components.
This package defines the component part of the JavaServer Faces (JSF) API. Since JSF is primarily component oriented, this is one of the core packages. The package overview contains a UML diagram of the component hierarchy.
This package defines the classes and interfaces for Java EE's Expression Language. The Expression Language (EL) is a simple language originally designed to satisfy the specific needs of web application developers. It's used specifically in JSF to bind components to (backing) beans and in CDI to name beans, but can be used throughout the entire platform.
These packages define the injection annotations for the contexts and Dependency Injection (CDI) APIs.
These packages define the context annotations and interfaces for the Contexts and Dependency Injection (CDI) API.
The Enterprise JavaBean (EJB) specification defines a set of lightweight APIs that an object container (the EJB container) will support in order to provide transactions (using JTA), remote procedure calls (using RMI or RMI-IIOP), concurrency control, dependency injection and access control for business objects. This package contains the Enterprise JavaBeans classes and interfaces that define the contracts between the enterprise bean and its clients and between the enterprise bean and the ejb container.
This package contains the annotations and interfaces for the declarative validation support offered by the Bean Validation API. Bean Validation provides a unified way to provide constraints on beans (e.g. JPA model classes) that can be enforced cross-layer. In Java EE, JPA honors bean validation constraints in the persistence layer, while JSF does so in the view layer.
This package contains the classes and interfaces that define the contracts between a persistence provider and the managed classes and the clients of the Java Persistence API (JPA).
This package provides the Java Transaction API (JTA) that contains the interfaces and annotations to interact with the transaction support offered by Java EE. Even though this API abstracts from the really low-level details, the interfaces are also considered somewhat low-level and the average application developer in Java EE is either assumed to be relying on transparent handling of transactions by the higher level EJB abstractions, or using the annotations provided by this API in combination with CDI managed beans.
javax.security.auth.message.*This package provides the core of the Java Authentication SPI (JASPIC) that contains the interfaces and classes to build authentication modules for secure Java EE applications. Authentication modules are responsible for the interaction dialog with a user (e.g. redirecting to a Form or to an OpenID provider), verifying the user's input (e.g. by doing an LDAP lookup, database query or contacting the OpenID provider with a token) and retrieving a set of groups/roles that the authenticated user is in or has (e.g. by again doing an LDAP lookup or database query).
This package provides the interfaces for interacting directly with Java EE's platform default managed thread pool. A higher-level executor service working on this same thread pool can be used optionally. The same interfaces can be used for user-defined managed thread pools, but this relies on vendor specific configuration and is not covered by the Java EE specification.
This package defines the Java Message Service (JMS) API(Application programming Interface). The JMS API provides a common way for Java programs to create, send, receive and read an enterprise messaging system's messages.
This package defines the entry AP for Java EE Batch Applications. The Batch Applications API provides the means to run long running background tasks that possibly involve a large volume of data and which may need to be periodically executed.
This package defines the Java EE Connector Architecture (JCA) API. Java EE Connector Architecture (JCA) is a Java-based technology solution for connecting application servers and enterprise information systems (EIS) as part of enterprise application integration (EAI) solutions. This is a low-level API aimed at vendors that the average application developer typically does not come in contact with.
- Java Platform, Micro Edition :
Java Platform, Micro Edition
Java Platform, Micro Edition, or Java ME, is a Java platform designed for embedded systems (mobile devices are one kind of such systems). Target devices range from industrial controls to mobile phones (especially feature phones) and set-top boxes. Java ME was formerly known as Java 2 Platform, Micro Edition (J2ME).
Java ME was designed by Sun Microsystems, acquired by Oracle Corporation in 2010; the platform replaced a similar technology, PersonalJava. Originally developed under the Java Community Process as JSR 68, the different flavors of Java ME have evolved in separate JSRs. Sun provides a reference implementation of the specification, but has tended not to provide free binary implementations of its Java ME runtime environment for mobile devices, rather relying on third parties to provide their own.
As of 22 December 2006, the Java ME source code is licensed under the GNU General Public License, and is released under the project name phoneME.
As of 2008, all Java ME platforms are currently restricted to JRE 1.3 features and use that version of the class file format (internally known as version 47.0). Should Oracle ever declare a new round of Java ME configuration versions that support the later class file formats and language features, such as those corresponding to JRE 1.5 or 1.6 (notably, generics), it will entail extra work on the part of all platform vendors to update their JREs.
Java ME devices implement a profile. The most common of these are the Mobile Information Device Profile aimed at mobile devices, such as cell phones, and the Personal Profile aimed at consumer products and embedded devices like set-top boxes and PDAs. Profiles are subsets of configurations, of which there are currently two: the Connected Limited Device Configuration (CLDC) and the Connected Device Configuration (CDC).
There are more than 2.1 billion Java ME enabled mobile phones and PDAs. Although it's not used on some of today's newest mobile platforms (e.g. iPhone, Windows Phone 7 and newer, BlackBerry 10, Android), it continues to be very popular in sub $200 devices such as Nokia's Series 40. It is also used on new Bada operating system and on Symbian OS along with native software. Also, there are implementations for Windows CE, Windows Mobile, Maemo, MeeGo and Android available for separate download.
Connected Limited Device Configuration :
The Connected Limited Device Configuration (CLDC) contains a strict subset of the Java-class libraries, and is the minimum amount needed for a Java virtual machine to operate. CLDC is basically used for classifying myriad devices into a fixed configuration.
A configuration provides the most basic set of libraries and virtual-machine features that must be present in each implementation of a J2ME environment. When coupled with one or more profiles, the Connected Limited Device Configuration gives developers a solid Java platform for creating applications for consumer and embedded devices. The configuration is designed for devices with 160KB to 512KB total memory, which has a minimum of 160KB of ROM and 32KB of RAM available for the Java platform.
Mobile Information Device Profile :
Designed for mobile phones, the Mobile Information Device Profile includes a GUI, and a data storage API, and MIDP 2.0 includes a basic 2D gaming API. Applications written for this profile are called MIDlets. Almost all new cell phones come with a MIDP implementation, and it is now the de facto standard for downloadable cell phone games. However, many cellphones can run only those MIDlets that have been approved by the carrier, especially in North America.
JSR 271: Mobile Information Device Profile 3 (Final release on 09 Dec, 2009) specified the 3rd generation Mobile Information Device Profile (MIDP3), expanding upon the functionality in all areas as well as improving interoperability across devices. A key design goal of MIDP3 is backward compatibility with MIDP2 content.
Information Module Profile :
The Information Module Profile (IMP) is a profile for embedded, "headless" devices such as vending machines, industrial embedded applications, security systems, and similar devices with either simple or no display and with some limited network connectivity.
Originally introduced by Siemens Mobile and Nokia as JSR-195, IMP 1.0 is a strict subset of MIDP 1.0 except that it doesn't include user interface APIs - in other words, it doesn't include support for the Java package javax.microedition.lcdui. JSR-228, also known as IMP-NG, is IMP's next generation that is based on MIDP 2.0, leveraging MIDP 2.0's new security and networking types and APIs, and other APIs such as PushRegistry and platformRequest(), but again it doesn't include UI APIs, nor the game.
Connected Device Configuration :
The Connected Device Configuration is a subset of Java SE, containing almost all the libraries that are not GUI related. It is richer than CLDC.
Foundation Profile :
The Foundation Profile is a Java ME Connected Device Configuration (CDC) profile. This profile is intended to be used by devices requiring a complete implementation of the Java virtual machine up to and including the entire Java Platform, Standard Edition API. Typical implementations will use some subset of that API set depending on the additional profiles supported. This specification was developed under the Java Community Process.
Personal Basis Profile :
The Personal Basis Profile extends the Foundation Profile to include lightweight GUI support in the form of an AWT subset. This is the platform that BD-J is built upon.
Sun provides a reference implementation of these configurations and profiles for MIDP and CDC. Starting with the JavaME 3.0 SDK, a NetBeans-based IDE will support them in a single IDE.
In contrast to the numerous binary implementations of the Java Platform built by Sun for servers and workstations, Sun does not provide any binaries for the platforms of Java ME targets with the exception of an MIDP 1.0 JRE (JVM) for Palm OS. Sun provides no J2ME JRE for the Microsoft Windows Mobile (Pocket PC) based devices, despite an open-letter campaign to Sun to release a rumored internal implementation of PersonalJava known by the code name "Captain America". Third party implementations like JBlend and JBed are widely used by Windows Mobile vendors like HTC and Samsung.
Operating systems targeting Java ME have been implemented by DoCoMo in the form of DoJa, and by SavaJe as SavaJe OS. The latter company was purchased by Sun in April 2007 and now forms the basis of Sun's JavaFX Mobile. The company IS2T provides a Java ME virtual machine (MicroJvm) for any RTOS and even with no RTOS (then qualified as baremetal). When baremetal, the virtual machine is the OS/RTOS: the device boots in Java.
MicroEmulator provides an open source (LGPL) implementation of an MIDP emulator. This is a Java Applet based emulator and can be embedded in web pages.
The open-source Mika VM aims to implement JavaME CDC/FP, but is not certified as such (certified implementations are required to charge royalties, which is impractical for an open-source project). Consequently devices which use this implementation are not allowed to claim JavaME CDC compatibility.
- Web Container :
Web container (also known as a Servlet container) is the component of a web server that interacts with Java servlets. A web container is responsible for managing the lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the URL requester has the correct access rights. A web container implements the web component contract of the Java EE architecture, specifying a runtime environment for web components that includes security, concurrency, lifecycle management, transaction, deployment, and other services. A web container provides the same services as a JSP container as well as a federated view of the Java EE platform APIs.
List of Servlet containers
The following is a list of applications which implement the Java Servlet specification from Sun Microsystems, divided depending on whether they are directly sold or not.
- Non-commercial Web containers
- Apache Tomcat (formerly Jakarta Tomcat) is an open source web container available under the Apache Software License.
- Apache Geronimo is a full Java EE implementation by Apache.
- GlassFish (open source), from Sun Microsystems
- JBoss Application Server (open source) is a full Java EE implementation by Red Hat inc., division JBoss.
- Jetty is (open source) from the Eclipse Foundation. Also supports SPDY and WebSocket protocols.
- Jaminid contains a higher abstraction than servlets.
- Winstone supports specification v2.5 as of 0.9, has a focus on minimal configuration and the ability to strip the container down to only what you need.
- Tiny Java Web Server (TJWS) 2.5 , small footprint, modular design
- Eclipse Virgo provides modular, OSGi based web containers implemented using embedded Tomcat and Jetty. Virgo is open source and available under the Eclipse Public License.
Commercial Web containers
- Borland Enterprise Server
- Sun GlassFish Server, from Sun Microsystems
- Sun Java System Web Server, from Sun Microsystems
- Sun Java System Application Server (is an Application Server, but includes a web container)
- JBoss Enterprise Application Platform (open source)
- JRun, from Adobe Systems (formerly developed by Allaire Corporation)
- LiteWebServer (open source)
- WebLogic Application Server, from Oracle Corporation (developed by BEA Systems)
- Orion Application Server, from IronFlare
- Caucho's Resin Server (open source)
- ServletExec, from New Atlanta Communications
- WebSphere Application Server, from IBM
- NetWeaver, from SAP
- tc Server (SpringSource)
- Java BluePrints :
Java BluePrints is Sun Microsystems' best practices for Enterprise Java development. This is Sun's official programming model for Java Platform, Enterprise Edition (Java EE) Software Development Kit (SDK). It began with Java Pet Store, the original reference application for the Java EE platform. This became the de facto source code for using Enterprise JavaBeans and all the latest components of the Java EE platform.
Java BluePrints began as J2EE BluePrints and was started by Connie Weiss, Jeff Jackson, Jim Inscore, Nick Kassem, and Rick Saletta. The original engineers included Inderjeet Singh, Greg Murray, Sean Brydon, Vijay Ramachandran, Elisabeth White, and Nick Kassem. Nick Kassem is the author of the original book. The idea of Java Pet Store came from Connie Weiss and Greg Murray who were both animal lovers. After the first year, Nick Kassem left the team and Inderjeet Singh became lead architect.
Throughout its existence, Java BluePrints has offered all of its content for free and has been focused on promoting developer success. Java Pet Store became the symbol for J2EE's ascendency; Microsoft created a competing .NET Pet Shop to showcase its competing technology. Since then, many technologies such as Tapestry, Spring, and others have implemented their own versions of the Pet Store application as a way to demonstrate best practices for their given technology.
With the arrival of J2EE 1.4 technology, web services became a standard part of the Java EE specification. Java BluePrints came out with a second application: the Java Adventure Builder reference application. This application never became as popular as Java Pet Store but then again, it never became as controversial.
There have been three Java BluePrints books, and the Core Java EE design patterns which are hosted on the Java BluePrints site have become the standard lingua for Java EE application development. Java BluePrints was the first source to promote Model View Controller (MVC) and Data Access Object (DAO) for Java EE application development. Before this, the MVC design pattern was widely promoted as part of Smalltalk.
- RIA Applications
- WOA Architecture
- Content Writing
- Php Solutions
- Lamp Solutions
- Dotnet Solutions
- J2ee Solutions
- Spring -Spring Mvc-Hibernate
- Java Server Faces-Hibernate
- Struts 1.3 - Hibernate
- Struts 2.0 - Hibernate
- Liferay Portal - Hibernate
- Portal Solutions
- Joomla - Mvc
- Struts 1.3
- Struts 2.0
- Java Server Faces
- Spring Mvc
- Spring Webflow
- Ruby on Rails
- Moo Tools
- Adobe Flex
- Yahoo! User Interface Library (YUI)
- GWT (Googel Web Toolkit)
- SEO Optimization
- SEO Branding
- SEO Consulting
- PPC (Pay Per Click )
- SMS Service
- Web Hosting
A solid working knowledge of productivity software and other IT tools has become a basic foundation for success in virtually any career. Beyond that, however, I don't think you can overemphasise the importance of having a good background in maths and science.....
"Every software system needs to have a simple yet powerful organizational philosophy (think of it as the software equivalent of a sound bite that describes the system's architecture)... A step in thr development process is to articulate this architectural framework, so that we might have a stable foundation upon which to evolve the system's function points. "
"All architecture is design but not all design is architecture. Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change"
"The ultimate measurement is effectiveness, not efficiency "
"It is argued that software architecture is an effective tool to cut development cost and time and to increase the quality of a system. "Architecture-centric methods and agile approaches." Agile Processes in Software Engineering and Extreme Programming.
"Java is C++ without the guns, knives, and clubs "
"When done well, software is invisible"
"Our words are built on the objects of our experience. They have acquired their effectiveness by adapting themselves to the occurrences of our everyday world."
"I always knew that one day Smalltalk would replace Java. I just didn't know it would be called Ruby. "
"The best way to predict the future is to invent it."
"In 30 years Lisp will likely be ahead of C++/Java (but behind something else)"
"Possibly the only real object-oriented system in working order. (About Internet)"
"Simple things should be simple, complex things should be possible. "
"Software engineering is the establishment and use of sound engineering principles in order to obtain economically software that is reliable and works efficiently on real machines."
"Model Driven Architecture is a style of enterprise application development and integration, based on using automated tools to build system independent models and transform them into efficient implementations. "
"The Internet was done so well that most people think of it as a natural resource like the Pacific Ocean, rather than something that was man-made. When was the last time a technology with a scale like that was so error-free? The Web, in comparison, is a joke. The Web was done by amateurs. "
"Software Engineering Economics is an invaluable guide to determining software costs, applying the fundamental concepts of microeconomics to software engineering, and utilizing economic analysis in software engineering decision making. "
"Ultimately, discovery and invention are both problems of classification, and classification is fundamentally a problem of finding sameness. When we classify, we seek to group things that have a common structure or exhibit a common behavior. "
"Perhaps the greatest strength of an object-oriented approach to development is that it offers a mechanism that captures a model of the real world. "
"The entire history of software engineering is that of the rise in levels of abstraction. "
"The amateur software engineer is always in search of magic, some sensational method or tool whose application promises to render software development trivial. It is the mark of the professional software engineer to know that no such panacea exist "
Core Values ?Agile And Scrum Based Architecture
Agile software development is a group of software development methods based on iterative and incremental development, where requirements and solutions evolve through collaboration.....more
Core Values ?Total quality management
Total Quality Management / TQM is an integrative philosophy of management for continuously improving the quality of products and processes. TQM is based on the premise that the quality of products and .....more
Core Values ?Design that Matters
We are more than code junkies. We're a company that cares how a product works and what it says to its users. There is no reason why your custom software should be difficult to understand.....more
Core Values ?Expertise that is Second to None
With extensive software development experience, our development team is up for any challenge within the Great Plains development environment. our Research works on IEEE international papers are consider....more
Core Values ?Solutions that Deliver Results
We have a proven track record of developing and delivering solutions that have resulted in reduced costs, time savings, and increased efficiency. Our clients are very much ....more
Core Values ?Relentless Software Testing
We simply dont release anything that isnt tested well. Tell us something cant be tested under automation, and we will go prove it can be. We create tests before we write the complementary production software......more
Core Values ?Unparalled Technical Support
If a customer needs technical support for one of our products, no-one can do it better than us. Our offices are open from 9am until 9pm Monday to Friday, and soon to be 24hours. Unlike many companies, you are able to....more
Core Values ?Impressive Results
We have a reputation for process genius, fanatical testing, high quality, and software joy. Whatever your business, our methods will work well in your field. We have done work in Erp Solutions ,e-commerce, Portal Solutions,IEEE Research....more
Why Choose Us ?
The intellectual commitment of our development team is central to the leonsoft ability to achieve its mission: to develop principled, innovative thought leaders in global communities.Read More
Today's most successful enterprise applications were once nothing more than an idea in someone's head. While many of these applications are planned and budgeted from the beginning.Read More
We constantly strive to redefine the standard of excellence in everything we do. We encourage both individuals and teams to constantly strive for developing innovative technologies....Read More
If our customers are the foundation of our business, then integrity is the cornerstone. Everything we do is guided by what is right. We live by the highest ethical standards.....Read More