Jecan - Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications
Here you can read online Jecan - Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications full text of the book (entire story) in english for free. Download pdf and epub, get meaning, cover and reviews about this ebook. City: Berkeley;CA, year: 2017, publisher: Apress, genre: Computer. Description of the work, (preface) as well as reviews are available. Best literature library LitArk.com created for fans of good reading and offers a wide selection of genres:
Romance novel
Science fiction
Adventure
Detective
Science
History
Home and family
Prose
Art
Politics
Computer
Non-fiction
Religion
Business
Children
Humor
Choose a favorite category and find really read worthwhile books. Enjoy immersion in the world of imagination, feel the emotions of the characters or learn something new for yourself, make an fascinating discovery.
Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications: summary, description and annotation
We offer to read an annotation, description, summary or preface (depends on what the author of the book "Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications" wrote himself). If you haven't found the necessary information about the book — write in the comments, we will try to find it.
Develop modular applications using the Java Platform Module System, the single most anticipated feature in Java 9. You will improve maintainability and performance of your Java applications by deploying only modules that are needed and encapsulating their implementation details. Until now Java has been monolithic. Using any one part of Java has meant incorporating the entirety of the runtime environment, an approach ill-suited to the increasing number of IoT devices such as fitness monitors, kitchen appliances, toys and games, and so forth. This book shows a new way, to make Java scale from the smallest of footprints in the smallest of devices through desktop PCs and on up to server platforms. With Java 9 Modularity Revealed you will learn to make your projects more reliable and scalable than ever using the most important feature in Java 9--The Java Platform Module System, known more commonly as Pro ject Jigsaw. You will learn how to avoid one of the major pain points of Java programming, that of conflicting class names from different modules, or packages. You will learn to create custom run-time images that represent a minimal and more compact JRE containing only those modules that you need. You will further learn to migrate existing Java applications to modular ones using different approaches and tools. The end result is a new ability to plug together different modules without fear of namespace and other conflicts, and you can deploy to everything from small devices to large servers. This book provides code examples and explanations. What Youll Learn: Build Java applications using the new modular system introduced in Java 9 Create your own JRE consisting only of the modules that you require Declare your dependencies on other modules Enable modules to export only specific packages Migrate existing Java applications to modular ones Improve maintainability and performance of Java applications.;Introduction -- Chapter 1: Modular Programming Concepts -- Chapter 2: Project Jigsaw -- Chapter 3: Modular JDK and Source Code -- Chapter 4: Defining and Using Modules -- Chapter 5: Modular Run-Time Images -- Chapter 6: Services -- Chapter 7: jLink: The Java Linker -- Chapter 8: Migration -- Chapter 9: The New Module API -- Chapter 10: Advanced topics -- Chapter 11: Testing Modular Applications -- Chapter 12: Integration with Tools.
Jecan: author's other books
Who wrote Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications? Find out the surname, the name of the author of the book and a list of all author's works by series.
Phil Coulthard
Gupta
Benjamin J. Evans
Nicolai Parlog
![Alexandru Jecan [Alexandru Jecan] - Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications](/uploads/posts/book/119405/thumbs/alexandru-jecan-alexandru-jecan-java-9.jpg)
Alexandru Jecan [Alexandru Jecan]
![Fu Cheng [Fu Cheng] - Exploring Java 9: Build Modularized Applications in Java](/uploads/posts/book/119397/thumbs/fu-cheng-fu-cheng-exploring-java-9-build.jpg)
Fu Cheng [Fu Cheng]
David Flanagan
David R. Heffelfinger
Arun Gupta
David R. Heffelfinger
Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications — read online for free the complete book (whole text) full work
Below is the text of the book, divided by pages. System saving the place of the last page read, allows you to conveniently read the book "Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications" online for free, without having to search again every time where you left off. Put a bookmark, and you can go to the page where you finished reading at any time.
Light
Font size:
↓
↑
Reset
Interval:
↓
↑
Bookmark:
Make
Alexandru Jecan 2017
Alexandru Jecan Java 9 Modularity Revealed1. Modular Programming Concepts
Alexandru Jecan 1
(1)
Munich, Germany
Youve almost surely had to deal with complexity in your software projects. The complexity level of a software application is usually low when development begins, but after a while the complexity begins to increase due to the changes performed on the platform. Complexity keeps increasing constantly as new features are added and the existing functionality is customized. The more changes and customizations are performed, the more complex the system becomesit may get so complex that it becomes difficult for a new developer to ramp up the project and be able to understand all its inner workings. And if the documentation of the system software isnt good enough, then understanding the system becomes even harder. A high level of complexity requires more energy, resources, and time to be spent in order to understand the inner structure of the application.
What is it that causes software systems to become so difficult to maintain? The answer is related to the fact that there are a lot of existing dependencies throughout the code. That happens when a piece of code depends on many other pieces of code, and it can generate a lot of issues. Enhancing such a system becomes painful because making a change on one place may affect many other parts of the application. By modifying an application in many different areas, the risk of introducing new errors grows. Besides that, reaching a satisfactory level of reuse becomes very difficult. The software has so many dependencies that simply reusing a component can become costly in terms of time and it could also further increase complexity. This also hinders the desire to enhance the system. By having a system with many dependencies, adding new functionality becomes a nightmare. Furthermore, the testing process also becomes more difficult because testing separate components is almost impossible to achieve. For you as a developer, understanding every part of the system is hard due to its complexity. As new features are added on a regular basis, and the software system evolves, keeping up to date with the changes can be challenging. In order to mitigate and reduce the negative effects of rising complexity, maintaining the system is mandatory, although maintaining itself becomes demanding in terms of time, effort, and cost.
What do we need in order to get rid of these problems? The answer is modularity.
General Aspects of Modularity
Modularity specifies the interrelation and intercommunication between the parts that comprise a software system. Modular programming defines a concept called the module. Modules are software components that contain data and functions. Integrated with other modules, together they form a unitary software system. Modular programming provides a technique to decompose an entire system into independent software modules. Modularity plays a crucial role in modern software architecture . It divides a big software system into separate entities and helps reduce the complexity of software applications while simultaneously decreasing the development effort.
The goal of modularity is to define new entities that are easy to understand and use. Modular programming is a style of developing software applications by splitting the functionality into different modules software units that contain business logic and have the role of implementing a specific piece of functionality. Modularity enables a clear separation of concerns and assures specialization. It also hides the modules implementation details. Modularity is an important part of agile software development because it allows us to change or refactor modules without breaking other modules.
Two of the most important aspects of modularity are maintainability and reusability, both of which bring great benefits.
Maintainability
Maintainability refers to the degree to which a software system is upgraded or modified after delivery. A big, monolithic software application is hard to maintain, especially if it has many dependencies inside the code.
The architecture of the system and the design patterns used help us create maintainable code. Maintainability is often ensured by simplicity. For instance, one of the simplest ways to improve maintainability is to provide a reference only to the interface that is implemented by the class as a substitute of the class itself. Low maintainability is a consequence of technical debt. Duplicating code may sometimes decrease the level of maintainability. For example, if one piece of code is altered, then other pieces of code that are similar to it also require the same sort of modifications. Because the code is in are many locations, its easy to omit some of the code segments that have to be modified, and this introduces new software issues into the system. The level of maintainability is associated with the quality of the software: the higher the degree of maintainability, the higher the quality of software. Maintainability is enhanced as a result of splitting a monolithic application into a set of modules that present well-defined boundaries between them. In a modular software application, changing a module is easier when it has fewer incoming and outgoing dependencies.
Reusability
Object-oriented programming can be used to obtain reusability, especially via inheritance. In order to reuse the functionality encapsulated in an object, a second object must inherit the first object.
How do modules relate to reusability? It should be possible to reuse a module elsewhere in the same application or in other application. Reusability is the degree to which we can reuse or replace a module. Reusability avoids duplicating code and reduces the number of lines of code, which has a positive impact on the number of software defects. It not only improves software quality, it also helps in developing software faster and makes performing updates on it easier. By applying reusability, the functionality is replicated in a coherent form throughout the entire software system.
Reusability makes the developers job easy because it increases their productivity when developing software components. Modules can be reused because they implement a well-defined interface that makes communication with other modules possible. The interface, which is specified as a contract, allows modules to be exchanged. The module interface is expressed in a standard way so that it may be understood and recognized by other modules. In order to achieve a high degree of software reusability, a module should perform a well-defined function. A design once, deploy many times software architecture is realized by taking advantage of source code reusability. As a property of good software design, reusability is increased by reducing the dependencies between the modules.
Reusability plays an important role in the migration of applications and libraries. Migration becomes simpler when you can reuse software components or modules. Reusability is not easy to achieve because it is challenging to design software that must be successfully used to fit somewhere else.
Module Definition
A software module is an independent and deployable software component of a larger system that interacts with other modules and hides its inner implementation. It has an interface that allows inter-modular communication. The interface defines which components it provides for external use and which components it requires for internal use. A module determines a boundary by specifying which part of the source code is inside the module. It also provides flexibility and increases the reusability of the software system.
Light
Font size:
↓
↑
Reset
Interval:
↓
↑
Bookmark:
Make
Similar books «Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications»
Look at similar books to Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications. We have selected literature similar in name and meaning in the hope of providing readers with more options to find new, interesting, not yet read works.
Phil Coulthard
Gupta
Benjamin J. Evans
Nicolai Parlog
Alexandru Jecan [Alexandru Jecan]
Fu Cheng [Fu Cheng]
David Flanagan
David R. Heffelfinger
Arun Gupta
David R. Heffelfinger
Reviews about «Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications»
Discussion, reviews of the book Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications and just readers' own opinions. Leave your comments, write what you think about the work, its meaning or the main characters. Specify what exactly you liked and what you didn't like, and why you think so.