Java is a high-level programming language developed by Sun Microsystems. It was originally created for the development of programs for set-top boxes and handheld devices, but later became a popular and popular language for creating web applications. Oracle acquired Sun Microsystems in January 2010, so Java is now supported and distributed by Oracle.
Java uses an object-oriented programming model and can be used to create applications that can run on a single computer or distributed between servers and clients on a network. It can also be used to create a small application module or applet for use as part of a web page.
Benefits
The Java syntax is similar to C ++, but it is a strictly object-oriented programming language. For example, most Java programs contain classes that are used to define objects and methods. Methods, in turn, are assigned to individual classes. Java is also known as a more formal formal sign system than C ++. This means that variables and functions must be explicitly defined, that the source code can detect errors or "exceptions" easier and faster than other languages. It also limits other types of errors that may be caused by undefined variables or unassigned types.
Unlike Windows executables (.EXE files) or Macintosh applications (.APP files), Java programs do not run directly by the operating system. Instead, the data is interpreted by a Java or JVM virtual machine that runs on multiple platforms. All Java programs are multi-platform and can run on different platforms, including Macintosh, Windows, and Unix computers. JVM must be installed for applications or applets to run. Available as a free download.
Elements and principles
The success and popularity of Java has contributed to the characteristics of the language. We list the main ones:
Programs created in Java have network portability. The source code is compiled so that the programming language calls a bytecode that can be run anywhere on the network on a server or client with a Java Virtual Machine (JVM). The JVM interprets the bytecode in code that will run on computer hardware. In contrast, most programming languages, such as COBOL, C ++, Visual Basic, or Smalltalk, compile code into a binary file. The binaries are platform dependent, so a program written for an Intel-based Windows computer cannot run a Mac, Linux machine, or IBM mainframe. The JVM includes the optional Just-in-time (JIT) compiler, which dynamically compiles the bytecode into executable code as an alternative to interpreting one bytecode instruction at a time. In many cases, dynamic JIT compilation is faster than interpreting a virtual machine.
Code reliability. Unlike programs written in C ++ and some other languages, Java objects do not contain references to external data or other known objects. This ensures that the instruction does not contain the data storage address in another application or in the operating system itself, because of which the program and the operating system itself may terminate or cause a malfunction. The JVM performs a series of checks at each entity to ensure integrity.
Java is an object oriented language. An object can take advantage of the fact that it is part of an object class and inherits code that is common to the class. This method can be considered as one of the possibilities or behavior of the object. The object-oriented method is relatively common in the modern programming landscape, but as early as 1996 only a few languages effectively used object-oriented concepts and design patterns.
Flexibility of applets. Java applet has all the features designed for quick launch.
Java is easy to learn. The language syntax is similar to C ++. If the developer speaks C / C ++ languages, mastering this language is not difficult.
A common misconception is that there is a connection between Java and JavaScript. These languages have similarities in syntax, but from a constructive point of view they are different structures.
Platforms
There are three key platforms on which programmers develop Java applications:
Java SE - Simple, stand-alone applications are developed using the Java Standard Edition. Formerly known as J2SE, Java SE provides all the APIs needed to develop traditional desktop applications.
Java EE - Java Enterprise Edition, formerly known as J2EE, provides the ability to create server components that can respond to a request-response web loop. This arrangement allows you to create Java programs that can interact with Internet clients, including web browsers, CORBA-based clients, and even REST and SOAP-based web services.
Java ME - Java also provides a lightweight mobile development platform known as Java Micro Edition, formerly known as J2ME. Java ME has established itself as a very popular platform for developing embedded devices, but it has struggled to succeed in the arena of smartphone development. In terms of smartphone development, Android has become a mobile development platform.
Examples of using
Using the various components provided by Java EE, it is easy for developers to write programs that use popular software design patterns and universally consistent best practices.
The Struts, Spring, and JavaServer Faces frameworks use the Java servlet to implement the front controller design pattern to centralize requests.
Meanwhile, most of the Java ecosystem is a huge number of open source projects, software platforms, and APIs that the community has created using the language. For example, the Apache Foundation hosts various projects written using Java, including:
Simple Java Logging Framework (SLF4J).
Large data processing platforms.
Integration platforms such as Apache Camel, Apache Axis, and CXF for developing RESTful web services.
Microservices development platforms.
Other enterprises will attempt to migrate Java EE environments to the cloud. As developers create cloud services, the ability to quickly scale these services is a key issue, as is the ability to work together in the cloud.
Criticism
Java syntax is often deprecated for verbosity. Excessive setters and getters, strong typing, make Java programs bloated. In response, several peripheral languages appeared to solve this problem, including Groovy, which quickly began to gain popularity.
Another disadvantage is that Java programs cannot scale linearly in the world of high-performance computing. Because Java refers to objects within, complex and parallel list-based operations can lead the JVM to look for workarounds. Scala solves many of the shortcomings of the Java language that reduce its scalability.
Java threads
Threads is a programming paradigm invented by J. Paul Rodker-Morrison in the late 60s that uses the concept of “data processing” to design and build applications. The Java thread defines applications as networks of processes that exchange data using blocks of data (information packets) moving over predefined connections. These processes can be connected endlessly to form applications without changing their internal content. In this way, the flow is component oriented.
Creating a Java stream is a specific form of programming a data stream. It is based on limited buffers, information packets with specific lifetimes, named ports and a separate definition of connections.
Processes communicate through connections that are accessed through ports. Links are usually implemented through limited buffers. The size of the buffer or the maximum number of packets that a queue can hold is called connection bandwidth. Some implementations allow you to establish connections with a capacity of 0, which means that IP data addresses are immediately transferred between the sending and receiving processes.
Definition
Stream programming considers the application as a set of processes (“black boxes”) that communicate through connections to which processes access via ports. A process is an instance of a component that runs simultaneously with other processes, including other instances of the same component.
A general approach to stream programming is to conceptualize a program as a series of threads and sub-flows that flow through a series of related processes. Concurrency is implemented by restricting the connection between processes using information packet streams at the end of a Java stream.
Visual programming in this context involves connecting text components or graphs in a two-dimensional representation, which uses the ability to recognize human images and visual styles of thinking. Text programming is still available at the component level, and for simple applications at the network level.
Key features include code reuse, testability, and concurrency.
Introduction
Stream programming defines applications using the data factory metaphor. An application is considered not as a single sequential process that begins at a certain point in time, and then does one operation per unit time until complete completion, but as a network of asynchronous processes communicating through flows of structured data blocks called information packets (IP). A network is defined by external processes as a list of connections that are interpreted by a piece of software, commonly called a scheduler.
Processes interact through a fixed capacity connection. The connection is connected to the process using the port, which has a name that is consistent between the process code and the network definition. The same code can execute more than one process. At any given time, a given IP address can belong to only one process or be in a path between two processes. Ports can be either simple or massive.
Since Java thread processes can continue to run for as long as there is input and output data, applications using this method usually work in less time than regular programs and optimally use all processors on the machine.
Network
The definition of a network is usually schematic and converted to a list of connections in a language or lower-level notation. Java I / O streams are often a visual programming language at this level. More complex network definitions have a hierarchical structure that is created from subnets with flexible connectivity. Other Java threading examples are based on more traditional programming languages. In particular, RaftLib uses C ++ and iostream-like operators to execute a Java thread.
Process description
Working with Java threads demonstrates data binding as the weakest connection between components. The concept of free communication, in turn, is associated with the concept of service-oriented architectures. The Java thread pool meets a number of criteria for such an architecture.
The stream method promotes a high-level functional style of specifications that simplify the development of hypothetical prerequisites for system behavior. An example of Java streams is the distributed data movement model for constructively creating and analyzing the semantics of distributed protocols.
Specifications
Stream programming has the following unique properties:
Structurality: diagrams and components have a clear structure (interface, state, and behavior).
The system design is divided into two layers: graphic (usually visual) and component (usually text). In terms of software architecture, various roles are encouraged. As an example: Java flows are controlled by the Role Functions of the Chart Designer and the Component-Implementer.
The principle of parallelism: each process runs in its own thread, companion program, or other environment.
Activation - from the point of view of the designer, the points of the process graph are executed simultaneously, and the function of the scheduling software allows you to distribute processor time and manage other services as necessary to maintain this functionality.
Information packages when creating a Java thread have a life cycle and belong to only one process.
Components can have multiple inputs or outputs.
The application is a graph, not a tree. Cyclic connections are allowed (feedback loops).
Connections can be combined in a graph, implying that packets from different arcs arrive at the input port. Connections must be separated through the component due to the variety of separation strategies and IP ownership rules.
Connections are implemented as limited buffers with volumes from 0 to a number limited by the implementation.
Examples
Java data stream components often form complementary pairs. In ordinary logic, the programmer quickly discovers that neither input nor output structures can be used to control the hierarchy of calls to the control flow. In Java input streams, the very description of the problem offers a solution.
“Words” are clearly indicated in the description of the problem, so the developer needs to consider them as information packets (IP). Java input streams do not have a single hierarchy of calls, so the programmer does not need to configure prioritization.
When creating a Java stream, source information packets (IIP) can be used to indicate parametric information, such as the desired length of the output record or file names. IIPs are data blocks associated with a port in a network definition that become “regular” IP addresses when a “received” parameter is issued for the corresponding port.
Batch update
This type of program involves transferring a file of information (changes, additions and deletions) to the main file and creating an updated main file and one or more reports. The new Java stream is quite difficult to encode using synchronous procedural code, since two (sometimes more) input streams must be synchronized.
In a streaming architecture, the reusable component greatly simplifies the recording of this type of application, since this tool combines two streams and inserts IP data to indicate grouping levels. Suppose that one or two Java threads consist of IP addresses with key values 1, 2, and 3, and the IP addresses of the second thread have key values 11, 12, 21, 31, 32, 33, and 41, where the first digit corresponds to the values master key. Using the parenthesis characters to represent IP addresses, the assembled output stream will look like this: (m1 d11 d12) (m2 d21) (m3 d31 d32d33) (d41).
Multiplexing processes
Stream programming supports process multiplexing. Since components are read-only, any number of instances of this component (“processes”) can run asynchronously with each other.
When computers had one processor, it was useful when many Java thread I / O operations continued. Now that machines have multiple processors, this is becoming a really useful tool. Java Threads are multitasking.
DrawFBP as a tool
Stream programming is a paradigm where programs are created from components that have a set of specific input and output ports. These ports are connected together to create a graph that defines the logic and data flow. DrawFBP is a desktop application that can define thread-based graphics for Java and C #. This is the most functionally complete user interface for streaming programming, but it is somewhat limited by the capabilities of the Java firewall and the inability to introspect information available through the component loading interface.
A key part of the user interface is to simplify the creation and understanding of programs based on the threading method.