Forem: Wejdi

The Difference Between Continuous Integration, Deployment and Delivery

Wejdi — Thu, 17 Dec 2020 11:25:42 +0000

Frequently used in modern development practices and DevOps, continuous integration (CI), continuous deployment (CD), and continuous delivery (CD) are like vectors that have the same direction, but different magnitude.

Their goal is the same: make our software development and release process faster and more robust by speed delivery and accuracy, giving developers the tools they need to deliver better products, with fewer bugs, and implement improvements. continuously.

So, what’s the difference between continuous integration vs continuous delivery vs continuous deployment ? How they are linked with each other and what are the benefits to opt them ….

1) Continuous Integration (CI)

Is about automating build and test processes to make sure the resulting software is in a good state, ideally every time a developer changes code.

So CI is the process of enforcing developers to merge their code to mainstream branch or working code base as often as possible.

CI Involves triggering a build when a change gets committed to the source code repository by any developer. which includes, fetching the code from source code repository, compiling code, running automated tests and creating build out of it.

CI benefits developers most because it allows for code produced to be automatically tested and continuously “integrated” with other developers’ code, and with the existing codebase.

The developer benefits from receiving continuous and immediate feedback regarding code and integration errors. Fixing these errors, automated testing tools in this stage will report if the errors were successfully fixed and when the code is accepted. This continuous feedback loop dramatically increases a developer’s productivity.

2) Continuous Delivery (CD)

Continuous delivery is an extension of continuous integration since it automatically deploys all code changes to a testing and/or production environment after the build stage. So No Continuous Integration, No Deal.

This means that on top of automated testing, you have an automated release process and you can deploy your application any time by clicking a button.

The goal of Continuous Delivery is to make sure the software is always ready to be released but isn’t pushed to production unless you make the decision to do so. It is a manual step.

3) Continuous Deployment (CD)

Continuous deployment goes one step further than continuous delivery.It's a process that automatically deploys the results of Continuous Delivery into the final production environment, usually every time a developer changes code (assuming all automated tests pass).

There's no human intervention, and only a failed test will prevent a new change to be deployed to production.

Continuous deployment is an excellent way to accelerate the feedback loop with your customers and take pressure off the team as there isn't a Release Day anymore. Developers can focus on building software, and they see their work go live minutes after they've finished working on it.

4) Continuous integration VS Continuous Delivery VS Continuous Deployment

Continuous integration is the beginning of the cycle where builds are created and tested.

Continuous delivery encompasses the cycle from the beginning of CI and ends with the “release” of the verified artifacts packages, VM or container images published onto a download server.

Continuous deployment ensures that qualified releases are automatically deployed to production taken from the download servers and made the currently running version in one or more environments/locations, typically also using rolling upgrades in order to ensure that applications remain available to users during the process.

Continuous Delivery is when your code is always ready to be released but isn’t pushed to production unless you make the
decision to do so. It is a manual step. With Continuous Deployment, any updated working version of the app is automatically pushed to production.

5) Continuous Process Benefits :

Continually integrate and test to reduce risk.
Build Stuff Faster and never ship Broken Code Into Production.
Easy detection of integration Bugs.
Consistency of Build Process.
Always have a deployable build.
Generate metrics to guide project management.
Increases Confidence in the Software.
Accelerated Time to Market.
Improved Productivity and Efficiency.
Improved Customer Satisfaction.

6) Continuous Process Tools

Development teams can take advantage of Continuous Integration by deploying a solution such as Jenkins, the most popular open source tool in the space, and configuring it to build and test their code. Also we can use Bamboo, TeamCity, Buddy...

Continuous Delivery usually involves other DevOps-related tools like Puppet, Chef, Ansible, or SaltStack to install and configure environments for testing. Docker and container orchestration components like Kubernetes make it easier for teams to automatically set up and tear down these environments as part of the CI/CD process. The open source project Spinnaker, created by Netflix, provides a robust Continuous Delivery and Continuous Deployment solution.

There exist several tools, depending on the requirement the tools can be selected.

Conclusion

Like many technological concepts, continuous integration, continuous delivery, and continuous deployment are terms that DevOps teams use without defining them precisely. So, it’s worth taking a closer look at what each of these terms actually means.

I hope you now get the difference between Continuous Integration, Continuous Delivery and Continuous Deployment.

Altogether the practices create an efficient system free of bugs and ready for use.

Web Development. From Design to Code

Wejdi — Tue, 15 Dec 2020 12:38:21 +0000

Web prototyping, design, development… just where do a designer’s skills end and a developer’s begin?

If you don’t know what’s the difference between UX design, UI design, Front-end developement, or Back-end developement and what they can do for your project, this article is for you.

A-Web Designer vs Web Developer

Primary goals of disgners and developers are to raise user satisfaction, decrease user churn, and ensure user-based company goals are reached. Such goals might include increasing newsletter sign-ups, improving sales conversions, or identifying and removing pain points within an app.

1) Developers

Convert the concept design to a rea-time website.
They Build the core structure of website using coding languages. - They are further divided into 3 categories :

-Front-end: developer is a person who creates the interface and the layout of the website for the interaction between the back end of the website and the users.
-Back-end: developers are those who are responsible for the server-side web application and they are usually write the web services and APIs used by front-end developers.
-Full-Stack: developer works on different layers or stacks which includes both the front and backend.

2) Designers

Focus on the user experience with the aesthetic and visual aspects of the website.
Mainly responsible for the layout of the website.
They are like the architects of the website who take care of the website's feel and look.
Their role is to transfer the client's ideas into an appealing design.
They use tools like Adobe Photoshop, Illustrator or Sketch to design the layout of the website.

Now you must be having a clearer idea about the roles of a website designer and a website developer.Both have a significant role in the creation of a website and both complement each other work.And to ensure the smooth working of a website they should be in regular touch with each other.

B-Design

About 94% of people abandon a poorly designed page. Great web design will let you make a great first impression and transform users into evangelists of your brand.

User Interface (UI) and User Experience (UX) are some of the most frequently mixed-up terms in the world of business technology.

1) What is UX Design in Web Development?

User experience design is a human-first way of designing products.

“User experience encompasses all aspects of the end-user’s interaction with the company, its services, and its products.”
– Don Norman, Cognitive Scientist & User Experience Architect.

The “user experience” part refers to the interaction between the user and a product or service.

The responsibility for UX design enforces the need for a deep and complete understanding of end-users, their motives and the value they get with the product or service.

UX primarily takes place in two distinct phases:
-research: During the research phase, the UX designers use a variety of tools and methods to better understand their intended users. Competitive analysis, user interviews, persona creation, wireframing, heuristic analysis and journey flows may all be involved.
-Validation: After the product has launched, UX designers perform usability/pain point analysis to determine if the product is producing the desired result. If not, refinements and revisions are made based on user data to make the end result better and more efficient.

*Differences Between Good and Bad UX Design

One of the main objectives of a UX design is to create an inviting, usable website that helps users get what they need and stay on your site.

The 5 Key UX Design Principles You Need To Know:
-Hierarchy: Hierarchy is one of designers’ best tools to help users move through a product easily.
-Consistency: Users expect products to be consistent with similar products they’ve used in the past. The more familiar your product is, the more easily users will learn it and the better their experience will be.
-Confirmation: Preventing errors is one of our key goals as designers. When users accidentally delete an item or make an unintended payment, their experience falls apart. Requiring confirmation for any important or irreversible action is one of the best ways to prevent these errors.
-User Control: User control comes into play in a few ways in UX, but generally users have a better experience if you give them control over where they are in the product and what they’re doing.
-Accessibility: In digital product design, accessibility typically means designing products so they’re easy for users with disabilities to use. Since we design products for people, it’s crucial that our products can be used by as many people as possible.

Exemple:

Demonstrate current state

This means that applications that don’t provide timely feedback as to what the system is doing may create a more negative or confusing experience.

WhatsApp’s delete message feature

Here’s what instead happens when you delete your message:

Why it’s bad UX: Informing the recipient that the sender has deleted a message somewhat defeats the purpose of deleting it in the first place. In fact, this looks way more suspicious and is likely to prompt an awkward “why did you delete the message?” type of response.

2) What is UI Design in Web Development?

Unlike UX, user interface design is a strictly digital term. A user interface is the point of interaction between the user and a digital device or product.

Users often judge a system by its interface rather than its functionality and a poorly designed interface is reason why so many software systems are never used.

In relation to websites and apps, UI design considers the look, feel, and interactivity of the product. This is often referred to as the “skin” of an application. It’s all about making sure that the user interface of a product is as intuitive as possible, and that means carefully considering each and every visual, interactive element the user might encounter.

A UI designer will think about icons and buttons, typography and color schemes, spacing, imagery, and responsive design.They also tend to be the ones creating high-fidelity mock-ups and interactive prototypes.

*Differences Between Good and Bad Interface Design

There are not a few UI design principles on the web, but the top golden rules for UI design will be the 4E’ in the following. Also, this can be the standard to judge whether it’s a good UI design:

Error-free.
Easy to use.
Easy to understand.
Effective for the end goal or product.

Exemple:
Distinction between primary and secondary buttons

When working with apps, you will have many actions that the user is able to complete. It is important to give visual importance to the primary actions.

Obviously, good design can make us feel at home and everything out there is just in the right place, while bad design will make you feel like having a bad taste in your mouth and all you want to do is to leave quickly.

C-Development

Now that you have a well-designed User Experience and an outstanding User Interface designed accordingly, you still need to create your app or website and its interface. What you have now is the visual part that actually doesn't do anything. Now it's time to let developers do their job.

Main parts of every website are: the client, the database, the server , the user:
-The Server:this part of website is responsible for holding data, running the website’s back-end architecture, processing requests, and sending response to the browser.
-The Client: requests pages from the Server, and displays them to the The User. In most cases, the client is a web browser.
-The DataBase: is a data structure that stores organized information that can easily be accessed, managed and updated.
-The User: uses the Client in order to surf the web, fill in forms, watch videos online, in other words and interact with webpage.

1) What is Front-end in Web Development?

All websites consist of structure, data, design, content, and functionality. Creating user-facing functionality is the task of a front-end developer. Using a combination of markup languages, design, client-side scripts, and frameworks, they create everything that users see and interact with: content, layout, and functional elements.

So, as you can see, for the front-end of the application to work, you need more than just User Interface. This visual part needs to be programmed. This is where front-end developers enter to do their job.

It's good when a front-end developer knows the essentials of UX and UI design principles. However, most often it is a typically technical role that needs mainly programming skills. On the other hand, you might meet front-end developers, who are UI designers at the same time.

2) What is Back-end in Web Development?

Back end development refers to the server side of an application and everything that communicates between the database and the browser.

Back-end developers create services that process business logic and access other resources such as databases, file servers, cloud services and more. These services are the backbone of any application and can be accessed and used not only by server-side rendering apps but also from client-side rendering apps.

3) Some of the technologies on which the developer works

-HTML or hypertext markup language: it is the standard computer language used to achieve graphical and functional effects on web pages.
-CSS Cascading style sheets (CSS): describes how HTML elements are to be displayed on screen, paper, or in other media.
-JavaScript: With its frameworks and libraries, JavaScript is the programming language which is used to make web pages interactive.It is called the first client-side language and is still the most common client-side script on the web.
-PHP, ASP, Java or C++: open source Back-end programming languages which are created explicitly to create dynamic sites which are different from static sites in that these types of websites store database information.
-MySQL: it is the flexible open-source database management system and it is the most popular choice for managing online content in the database.

Conclusion

This article focused on the key aspects of design and development as the way from design to real digital product.

User experience (UX) design is centered around the satisfaction the user experiences with your software. Front-end development is the technical implementation of the software’s user interface (UI). UI design is the graphical bridge that connects the two. Having these three areas working together seamlessly is the key to happy users and happy upper management alike.

How Java Has Advanced In The Past 6 Years (From Java 8 to Java 15)

Wejdi — Fri, 11 Dec 2020 13:00:11 +0000

Java Release Cycle

Until version 8 , Java version release was one every 3 years ,so there were few versions with many features.

It was therefore complicated to deliver a new version of Java and complicated for developers to upgrade their applications due to the number of changes included.

This pace no longer keeps up with the reality of the IT world where everything is going faster and faster! So Java architects decided to publish a version every 6 months (therefore a fixed schedule)

In each version, all the ready features are incorporated, those that are not ready will be delivered in the next one (no more late version).

Java 8 most important Features with Examples

1) New Features in Java language
● forEach() method
Java 8 has introduced forEach method in java.lang.Iterable interface so that while writing code we focus on business logic only.

● Lambda Expression
The biggest new feature of Java 8 is language level support for lambda expressions (Project Lambda).
Lambda Expressions syntax is (argument) -> (body).

● Interface’s default and Static Methods
Prior to java 8, interface in java can only have abstract methods. All the methods of interfaces are public & abstract by default. Java 8 allows the interfaces to have default and static methods.

-Default methods : The reason we have default methods in interfaces is to allow the developers to add new methods to the interfaces without affecting the classes that implements these interfaces.

-Static methods : in interfaces are similar to the default methods except that we cannot override these methods in the classes that implements these interfaces.
For example, there are many static methods on the new Stream interface. This makes “helper” methods easier to find since they can be located directly on the interface, instead of a different
class such as StreamUtil or Streams.

● Functional Interface
In Java 8 a functional interface is defined as an interface with exactly one abstract method. This even applies to interfaces that were created with previous versions of Java.
Java 8 comes with several new functional interfaces in the package, java.util.function.
-Function - takes an object of type T and returns R.
-Supplier - just returns an object of type T.
-Predicate - returns a boolean value based on input of type T.
-Consumer - performs an action with given object of type T.

● Method References
Method references are a special type of lambda expressions. They're often used to create simple lambda expressions by referencing existing methods.
There are four kinds of method references:
-Static methods
-Instance methods of particular objects
-Instance methods of an arbitrary object of a particular type
-Constructor
Exemple :

2) New Features in Java libraries
● Stream API
The Stream interface is such a fundamental part of Java 8 .

We can use Java Stream API to implement internal iteration, that is better because java framework is in control of the iteration.

The Stream interface supports the map/filter/reduce pattern and executes lazily, forming the basis
(along with lambdas) for functional-style programming in Java 8.

There are also corresponding primitive streams (IntStream, DoubleStream, and LongStream) for performance reasons.

With Java 8, Collection interface has two methods to generate a Stream :
-stream():Returns a sequential stream considering collection as its source.

-parallelStream() : Returns a parallel Stream considering collection as its source.

● Optional
Java 8 comes with the Optional class in the java.util package for avoiding null return values (and thus NullPointerException).

If a value is present, isPresent() will return true and get() will return the value. Stream terminal operations return Optional object.
Some of these methods are:
-Optional reduce(BinaryOperator accumulator)
-Optional min(Comparator<? super T> comparator)
-Optional max(Comparator<? super T> comparator)
-Optional findFirst()
-Optional findAny()

● Date/Time API
With Java 8, a new Date-Time API is introduced to cover the following drawbacks of old date-time API:
-Not thread safe
-Poor design
-Difficult time zone handling

Java 8 Date Time API consists of following packages:
1.java.time Package: This is the base package of new Java Date Time API. such as LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration etc. All of these classes are immutable and thread safe.

java.time.chrono Package: This package defines generic APIs for non ISO calendar systems. We can extend AbstractChronology class to create our own calendar system.
java.time.temporal Package: This package contains temporal objects and we can use it for find out specific date or time related to date/time object. For example, we can use these to find out the first or last day of the month. You can identify these methods easily because they always have format “withXXX”.
java.time.zone Package: This package contains classes for supporting different time zones and their rules.

Java 9 most important Features with Examples

Java 9 included better support for multi-gigabyte heaps, better native code integration, a different default garbage collector (G1, for "shorter response times") and a self-tuning JVM.

● Java Platform Module System (Project Jigsaw)
It is a new kind of Java programing component that can be used to collect Java code (classes and packages). The main goal of this project is to easily scale down application to small devices. In Java 9, JDK itself has divided into set of modules to make it more lightweight. It also allows us to develop modular applications.

● JShell: the interactive Java REPL
JShell is a REPL (Read Evaluate Print Loop) tool and run from the command line.
It is an interactive Java Shell tool, it allows us to execute Java code from the shell and shows output immediately.

● Process API Improvements
Java has improved its process API in Java 9 version, they have added couple new classes and methods to ease the controlling and managing.
Two new interfcase in Process API:

java.lang.ProcessHandle
java.lang.ProcessHandle.Info

● Interface Private Methods
In Java 9, we can create private methods inside an interface. Interface allows us to declare private methods that help to share common code between non-abstract methods.

● Java Collection Factory Methods
Factory methods are special type of static methods that are used to create unmodifiable instances of collections. It means we can use these methods to create list, set and map of small number of elements.
It is unmodifiable, so adding new element will throw java.lang.UnsupportedOperationException

● Stream API Improvement
The Streams API is arguably one of the best improvements to the Java standard library in a long time.
In Java 9, Stream API has improved and new 4 methods are added to the Stream interface :iterate(), dropWhile(), takeWhile(), ofNullable().

● Reactive Streams
Java SE 9 Reactive Streams API is a Publish/Subscribe Framework to implement Asynchronous, Scalable and Parallel applications.
Reactive Streams is about asynchronous processing of stream, so there should be a Publisher and a Subscriber. The Publisher publishes the stream of data and the Subscriber consumes the data.

● HTTP 2 Client
A new way of performing HTTP calls arrives with Java 9. This much overdue replacement for the old HttpURLConnection API also supports WebSockets and HTTP/2 protocol.
It supports both Synchronous (Blocking Mode) and Asynchronous Modes.

● G1 Garbage Collector
The “Garbage-first” garbage collector, aka G1, is a concurrent multi-threaded GC. It mostly works alongside the application threads (much like the concurrent mark sweep GC) and is designed to offer shorter, more predictable pause times – while still achieving high throughput.

● Other new Fectures
-Stack-Walking API
-Filter Incoming Serialization Data
-Deprecate the Applet API
-Indify String Concatenation
-Enhanced Method Handles
-Java Platform Logging API and Service
-Compact Strings
-Parser API for Nashorn
-Javadoc Search
-HTML5 Javadoc

Java 10 most important Features with Examples

Java 10 is the fastest release of a java version in its 23-year history. Java has been criticized for its slow growth and evolution, but Java 10 just shattered that concept.

● Local-Variable Type Inference
Local variable type inference is the biggest new feature in Java 10 for developers.
Similar to Javascript, Kotlin, and Scala, now Java will also have a var keyword that allows you to declare a local variable without specifying its type.

● Time-Based Release Versioning
From JDK 10 release, Java has adopted a new schedule of a new release every six months. There is a lot of debate whether this is a practical approach or not, larger companies also appreciated the stability and the low rate of change of Java so far.

Oracle has responded to these concerns and continues to
offer long-term releases on a regular basis, but also at
longer intervals. And after Java 8, it is Java 11, which will
receive a long term support again.

In fact, Java 9 and Java 10 support has just ended, since
Java 11 is out.

● Application Class-Data Sharing
This feature extends the existing CDS feature for allowing application classesto be placed in the shared archive in order to improve startup and footprint.

The general idea was that when the JVM first launched, anything loaded was serialized and stored in a file on disk that could be reloaded on future launches of the JVM.

This meant that multiple instances of the JVM shared the class metadata so it wouldn’t have to load them all every time.

● Parallel Full GC for G1
G1 garbage collector was made default in JDK 9.However, the full GC for G1 used a single threaded mark sweepcompact algorithm.

This has been changed to the parallel mark-sweep-compact algorithm
in Java 10 effectively reducing the stop-the-world time during full GC.

This change won’t help the best-case performance times of the
garbage collector, but it does significantly reduce the worst-case
latencies.

● Garbage-Collector Interface
This is one more interesting and useful Java 10 feature which improves the code isolation of different garbage collectors by introducing a common Garbage Collector Interface.

It will help in the future for adding new GC without changing existing codebase, also help in removing or housekeeping of the previous GC.

● Root Certificates
With Java 10, Oracle has open-sourced the root certificates in
Oracle’s Java SE Root CA program in order to make OpenJDK
builds more attractive to developers and to reduce the
differences between those builds and Oracle JDK builds.

● Thread-Local Handshakes
This is an internal JVM feature to improve performance.
This feature provides a way to execute a callback on threads without performing a global VM safepoint. Make it both possible and cheap to stop individual threads and not just all threads or none.

● API’s Added
-List, Map & Set Interfaces are added with a static copyOf(Collection) method. Its returns an unmodifiable List, Map or Set containing the entries provided. For a List, if the given List is subsequently modified, the returned List will not reflect such modifications.

-Optional & its primitive variations get a method orElseThrow(). This is exactly same as get(), however the java doc states that it is a preferred alternative then get().

-Collectors class gets various methods for collecting unmodifiable collections (Set, List, Map).

Java 11 most important Features with Examples

Java 11 is the second LTS release after Java 8. Since Java 11, Oracle JDK would no longer be free for commercial use.

● Running Java File
We can avoid the compilation phase. We can compile execute in one command. We use the java command. It will implicitly compile without saving the.class file.

● Java String Methods
1) isBlank(): This method returns true if the string is empty or contains only white spaces code points.

2) lines() : returns a reference for a stream of strings that are substrings we received after splitting by lines.

3) strip(), stripLeading() and the stripTrailing : remove white spaces from the beginning, the ending and the remr of the string. Itis a 'Unicode-Aware' evolution of trim();

4) repeat(): method repeats the string on which it is invoked the number of times it receives.

● Using var in Lambda Expressions
As of Java 11 we can use the var keyword within lambda expressions.

When using var in a lambda expression we must use it on all parameters and we cannot mix it with using specific types.

● Nested Based Access Control
Before Java 11, Java allows classes and interfaces to be nested within each other. These nested types have unrestricted access to each other, including to private fields, methods, and constructors.

As of Java 11, there are new methods in Class class that assist us with getting information about the created nest. These methods include the following:
getNestHost() : This returns the nest host of the nest to which this Class object belongs
getNestMembers() : This returns an array containing Class objects representing all the members of the nest to which this Class object belongs
isNestemateOf() : This determines if the given Class is a nestmate of this Class object

● Epsilon: A No-Op Garbage Collector
As of Java 11, the JVM has an experimental feature that allows us to run the JVM without any actual memory reclamation.

The goal is to provide a completely passive garbage collector implementation with a bounded allocation limit and the lowest latency overhead possible.

● ZGC Scalable Low Latency GC
As of Java 11, we can use the ZGC. This new GC is available as an experimental feature.
ZGC is a scalable low latency garbage collector. It performs the expensive work concurrently without stopping the execution of application threads for more than 10ms.

● HTTP Client
As of Java 11, the HTTP Client API is more standardized. The new API supports both HTTP/1.1 and HTTP/2. The new API also supports HTML5 WebSockets.

● Files Reading and Writing
Java 11 introduces two new methods that significantly assist with reading and writing strings from and to files : readString(), writeString()

● Flight Recorder
Flight Recorder which earlier used to be a commercial add-on in Oracle JDK is now open-sourced since Oracle JDK is itself not free anymore.

JFR is a profiling tool used to gather diagnostics and profiling data from a running Java application.

Its performance overhead is negligible and that’s usually below 1%. Hence it can be used in production applications.

Java 12 most important Features with Examples

Java 12 was launched on March 19 2019 , which is a part of the six-month release cycle.
It is a Non-LTS version. Hence it won’t have long term support.

● JVM Changes
– Shenandoah A Low-Pause-Time Garbage Collector: Java 12 adds Shenandoah, an experimental garbage-collection algorithm, to reduce garbage-collection pause times by performing evacuation work concurrently with running of Java threads.

-Prompt return of unused committed memory: G1 to automatically return Java heap memory to the operating system when idle. This memory is released in a reasonable period of time when there is very low application activity.

-Abortable Mixed Collections for G1: Improvements in G1 efficiency include making G1 mixed collections abortable if they might exceed the defined pause target. This is done by splitting the mixed collection set into mandatory and optional.

-Default CDS Archives: The end goal is to improve the JDK build process by generating a class data-sharing (CDS) archive. Among the goals for this feature are:
1) Improve out-of-the-box startup time.
2) Get rid of the need to run -Xshare: dump to benefit from the CDS.

● Switch Expressions
There are two main changes to switch in Java with this JEP:
1) Introduction of case L -> syntax that removes the need for break statements, because only the statements next to -> is executed.
2) switch can be an expression, so it can have a value, or it can return a value.

● File.mismatch method
Java 12 added the following method to compare two files:

This method returns the position of the first mismatch or -1L if there is no mismatch.

● Compact Number Formatting
Java 12 extends existing number formatting APIs to provide support for locale-sensitive compact number formatting.
Now numbers like 1000 (for example) can be formatted as "1K" (short style) or "1 thousand" (long style).

● Teeing Collectors
Teeing Collector is the new collector utility introduced in the Streams API.
This collector has three arguments – Two collectors and a Bi-function.
All input values are passed to each collector and the result is available in the Bi-function.

● Java Strings New Methods

1) java.lang.String :

-indent(int n): Adjusts the indentation of each line of this string based on the value of n, and normalizes line termination characters.

-If n > 0, then n spaces (U+0020) are inserted at the beginning of each line.
-If n < 0, then up to n white space characters are removed from the beginning of each line. If a given line does not contain sufficient white space then all leading white space characters are removed. The tab character is also treated as a single character.
-If n = 0, then the line remains unchanged. However, line terminators are still normalized

- R transform(Function<? super String,? extends R> f): This method allows the application of a function to this string.

2) JVM Constants API :

The Constants API methods don’t have much usage for normal development related tasks.

-Optional describeConstable(): Returns an Optional containing the nominal descriptor for this instance, which is the instance itself.

-String resolveConstantDesc(MethodHandles.Lookup lookup): Resolves this instance as a ConstantDesc, the result of which is the instance itself.

#Java 13 most important Features with Examples#

Java 13 was released for production use on 17th September 2019. There are not a lot of developer-specific features in Java 13 because of the 6-month release cycle.

● Switch Expressions
We initially saw switch expressions in JDK 12. Java 13's switch expressions build on the previous version by adding a new yield statement.

● Text Blocks
Text blocks for multi-line Strings such as embedded JSON, XML, HTML, etc.It allows us to create multiline strings easily. The multiline string has to be written inside a pair of triple-double quotes.

Earlier, to embed JSON in our code, we would declare it as a String literal:

Now, it’s useful in easily creating HTML and JSON strings in our Java program :

Also, java.lang.String now has three new methods to manipulate text blocks:
1) formatted(Object… args): it’s similar to the String format() method. It’s added to support formatting with the text blocks.

2) stripIndent(): used to remove the incidental white space characters from the beginning and end of every line in the text block. This method is used by the text blocks and it preserves the relative indentation of the content.

3) translateEscapes(): returns a string whose value is this string, with escape sequences translated as if in a string literal.

● Dynamic CDS Archive
Class data sharing (CDS) has been a prominent feature of Java HotSpot VM for a while now. It allows class metadata to be shared across different JVMs to reduce startup time and memory footprint.
Now, the creation of CDS archive and using it is much easier.

● ZGC: Uncommit Unused Memory
The Z Garbage Collector was introduced in Java 11 as a low-latency garbage collection mechanism.It adds a short pause time before the heap memory cleanup. But, the unused memory was not being returned to the operating system.

Starting with Java 13, the ZGC now returns uncommitted memory to the operating system by default.

● FileSystems.newFileSystem() Method
Three new methods have been added to the FileSystems class to make it easier to use file system providers, which treats the contents of a file as a file system :
-newFileSystem(Path)
-newFileSystem(Path, Map)
-newFileSystem(Path, Map, ClassLoader)

● DOM and SAX Factories with Namespace Support
There are new methods to instantiate DOM and SAX factories with Namespace support:
-newDefaultNSInstance()
-newNSInstance()
-newNSInstance(String factoryClassName, ClassLoader classLoader)

● Miscellaneous Changes
Java 13 has given us a few more notable changes:
-java.time – new official Japanese era name added
-javax.crypto – support for MS Cryptography Next Generation (CNG)
-javax.security – property jdk.sasl.disabledMechanisms added to disable SASL mechanisms
-javax.xml.crypto – new String constants introduced to represent Canonical XML 1.1 URIs
-javax.xml.parsers – new methods added to instantiate DOM and SAX factories with namespaces support
-Unicode support upgraded to version 12.1
-Support added for Kerberos principal name canonicalization and cross-realm referrals

Java 14 most important Features with Examples

Keeping up with the six-month cycle tradition, Java 14, another non-LTS version is scheduled to release on March 17, 2020.

● Switch Expressions
Switch Expressions after staying a preview feature in the last two releases –Java 12 and Java 13 have finally attained permanent status in Java 14.

● Pattern Matching for instanceof
The old way to typecast a type to another type is:

The new way is :

In the above code, the instance jd would be only assigned if obj is of type Journaldev. The scope of the variable is limited to the conditional block only.

● Helpful NullPointerExceptions
Improvement in NullPointerExceptions exception message generated by JVM.

Before Java 14:

Java 14 introduced a new JVM feature which gives better insights with a more descriptive stack as shown below:

● Records
We need to write a lot of low-value, repetitive code to write a simple data carrier class responsibly: constructors, accessors, equals(), hashCode(), toString(), etc. To avoid this repetitive code, Java is planned to use record.

Before Java 14 :

After Java 14 :

Furthermore, we can add additional fields, methods, and constructor to the record in the following way:

Few important things to note about Records:
-A record can neither extend a class nor it can be extended by another class. It’s a final class.
-Records Can Implement Interfaces.
-Records support multiple constructors.
-Records Allow Modifying Accessor Methods.
-Records cannot be abstract.
-Records cannot extend any other class and cannot define instance fields inside the body. Instance fields must be defined in the state description only.
-Declared fields are private and final.
-The body of a record allows static fields and methods.

● Text Blocks
Text Blocks were introduced as a preview feature in Java 13 with the goal to allow easy creation of multiline string literals. It’s useful in easily creating HTML and JSON or SQL query strings.

In Java 14, Text Blocks are still in preview with some new additions:
-Backslash for displaying nice-looking multiline string blocks.
-\s is used to consider trailing spaces which are by default ignored by the compiler. It preserves all the spaces present before it.

● Foreign-Memory Access API
An effective Java API is to be introduced in the Java 14 JDK, which enables Java applications to safely and efficiently access foreign memory stored outside the Java heap. The foreign-memory access API introduces three main abstractions: MemorySegment, MemoryAddress and MemoryLayout.

Java 15 most important Features with Examples

Java 15 (Java SE 15) and its Java Development Kit 15 (JDK 15) open-source has been released on 15 September 2020.

● Sealed Classes
Sealed classes have been there in Kotlin since a while and Java 15 finally introduces this feature for better control over inheritance.
A class can be sealed by using the sealed modifier.

So, the above code means, only the classes defined after the keyword permits are allowed to extend the Vehicle sealed class.

Every permitted class must be set with an explicit modifier. It can either be final or sealed or non-sealed :
-A permitted subclass that’s declared final cannot be extended further.
-A permitted subclass that’s declared sealed can be extended further but only by classes that are permitted by the subclass.
-A permitted subclass may be declared non-sealed can be extended further by any class. The superclass cannot restrict the subclasses further down this class hierarchy.

● Hidden Classes
While most developers won't find a direct benefit from them, anyone who works with dynamic bytecode or JVM languages will likely find them useful.

The goal of hidden classes is to allow the runtime creation of classes that are not discoverable.

Classes such as these typically have a short lifecycle, and thus, hidden classes are designed to be efficient with both loading and unloading.

● Foreign Memory API
Foreign memory access is already an incubating feature of Java 14. In Java 15, the goal is to continue its incubation status while adding several new features:
-A new VarHandle API, to customize memory access var handles
-Support for parallel processing of a memory segment using the Spliterator interface
-Enhanced support for mapped memory segments
-Ability to manipulate and dereference addresses coming from things like native calls

● Garbage Collectors
In Java 15, both ZGC and Shenandoah will be no longer be experimental. Both will be supported configurations that teams can opt to use, while the G1 collector will remain the default.

● The Nashorn JavaScript engine
Of note, The Nashorn JavaScript engine, originally introduced in Java 8, is now removed. With the introduction of GraalVM and other VM technologies recently, it's clear Nashorn no longer has a place in the JDK ecosystem.

Conclusion

This article presented the evolution of Java from Java 8 to Java 15 .

Java has evolved enormously as a language and as an ecosystem since Java 8 was released over six years ago by adding many new features help to make Java a competitive option compared to other JVM-based rivals.

Why Should I Learn ReactJS?

Wejdi — Mon, 07 Dec 2020 15:06:18 +0000

What is ReactJS?

ReactJS is an open source JavaScript library designed by Facebook for creating rich and engaging web apps fast and efficiently with minimal coding.
The core objective of ReactJS is providing the best possible rendering performance using The Virtual DOM.
Its strength comes from the focus on individual components , so Instead of working on the entire web app, ReactJS allows a developer to break down the complex UI into simpler components.

ReactJS Popularity

There's a high probability that there's no web framework that took as little time as React JS to be a leading one in the front-end web development.
Google Trends confirms that React is currently at the top. Why do we believe in its potential ? When it comes to developing interactive, dynamic user interfaces, nothing can beat it. An estimated number of 8064 industry leaders currently use React.js.

It's really no accident that React JS is used so much.
It has been only seven years since the first release back in 2013, and it was open-sourced from the beginning. And in this short period of time, React JS has been one of the most used JavaScript frameworks.It's been growing rapidly in its path.
React JS is the most loved amongst the frameworks, libraries, and technologies being used today.
React has continued to rise in popularity over the years and has been consistently ranked as the most used and favorite JavaScript library for building frontend applications according to State of JavaScript survey of 2019.
The rise of React,is impressive and as an early adopter of React, I am and excited for its growth.

Who uses ReactJS ?

Part of this huge popularity comes from the fact that top corporations use it to solve user interface related issues. This credibility has drawn a lot of people to the framework.
Both developers and entrepreneurs agree that React JS is the future of oriented framework, and it's very worth investing money and time to it.
Here are some of the biggest sites built with React:
Facebook, Instagram, What's up, Twitter, Microsoft, Yahoo, Netflix, PayPal, Imdb , Uber, Wix, Atlassian, CloudFalare, Slack, Dropbox, Salesforce, Airbnb, Reddit, BBC And the list goes on!

Top reasons why you should learn React right now

1-React has an awesome community
One of the most preferred reasons to learn React JS is its popularity. And with popularity comes a wide community to help new developers.

2-React is SEO-friendly
React is widely recognised as the friendliest JavaScript library for SEO purposes. While React in itself isn’t SEO-friendly (like all JS frameworks), React embraces SEO and its components are easier for Google to crawl.

3-React is very scalable
The very first and main evidence of the React JS scalability is Facebook itself.
It's made entirely on React JS and has over 50,000 different components. And it's still growing without any performance problems!

4-React is all about Reusable Components
React saves you time and money on development because it’s component-based. You can break down an interface into reusable components that allow you to build dynamic user interfaces.

5-React’s Performance is Amazing
High performance is critical for web applications. 47% of people expect a webpage to load in 2 seconds or less. Additionally, 33% of your userbase will abandon your website if it takes more than 10 seconds to load.
Businesses that use ReactJS are assured of better performance compared to those that use other frameworks.
React is using a virtual DOM, which means it doesn’t have to generate all the HTML files from the bottom to the top, whenever the change appears.
Instead, he looks for the differences between the current and the old HTML and updating it accordingly, making all the loading experience feels like a blink of an eye.

6-Development Speed
React been also built with developers in mind.
The coding itself allows you to create web and mobile apps way much faster than any other framework.
The great advantage of React is that you can just code it once, and use it on the different platforms. You can hire one good React developer and he will be able to build web apps, mobile apps, and even apps for a tablet.

7-Backward Compatibility
Still, none of the other frameworks is able to be so easily compatible.
If you use Angular, there is a big chance that instead of upgrading it to the new version you will have to write your app from scratch with the new public API.
Whenever a new version of React is coming out, the public API remains almost totally the same. This helps Facebook refresh it’s code and still be able to work on his old pieces at the same time.
In other words, you don’t have to learn React again and again after each and every launch, and you can be sure your older version remains compatible with all the new components.

The Future of ReactJS

The future is 100% great due to the support of substantial big Community Facebook. The developers and businesses strongly believe that the ReactJS applications give them high performance and good quality for market reach.
You can think and imagine the future of ReactJS by yourself after knowing the large and most popular companies names that use React.

Conclusion

Each and every technology seems to have the same goal – doing things easier, faster, and ultimately better.

Learning ReactJS is the need of the hour and makes sense as it is providing much-needed ease to developers in building highly engaging web applications and user interfaces in very lesser time, where they create large scale apps with frequently changing data.

So I guess there’s only one question left to ask: what are you waiting for?