InRhythm

Your partners in accelerated digital transformation

best practices

A Comprehensive Guide To Java’s New HTTP Client

Overview 

The Hypertext Transfer Protocol (HTTP) is the foundation of the World Wide Web, and is used to load web pages using hypertext links. HTTP is an application layer protocol designed to transfer information between networked devices and runs on top of other layers of the network protocol stack. A typical flow over HTTP involves a client machine making a message request to a server, which then sends a response message.

Java is a general-purpose, class-based, object-oriented programming language designed for having lesser implementation dependencies. It is a computing platform for application development. Java is fast, secure, and reliable, therefore, it  is widely used by everyone from the newest to most advanced web developers. 

In Daniel Fuentes’ Lightning Talk session, we will breaking down the following topics:

  • What Is HTTP?
  • Improvements In HTTP 2.0
  • How HTTP 2.0 Impacts Java
  • Live Demonstrations
  • Closing Thoughts

The new HTTP 2.0 Client was released in Java 11. This new client is used to request HTTP resources over the network. It supports HTTP/1.1 and HTTP/2.0, both synchronous and asynchronous programming models, handles request and response bodies as well as reactive-streams, and follows the familiar builder pattern.

What Is HTTP?

HTTP is an application layer protocol designed to transfer information between networked devices. HTTP runs on top of other layers of the network protocol stack. 

HTTP is a protocol for fetching resources such as HTML documents. It is the foundation of any data exchange on the Web and it is a client-server protocol, which means requests are initiated by the recipient, usually the Web browser. A complete document is reconstructed from the different sub-documents fetched, for instance, text, layout description, images, videos, scripts, and more.

Clients and servers communicate by exchanging individual messages (as opposed to a stream of data). The messages sent by the client, usually a Web browser, are called requests and the messages sent by the server as an answer are called responses.

The typical flow over HTTP involves a client machine making a request to a server, which then sends a response message. 

HTTP was invented alongside HTML to load web pages using links (hypertext). It was a part of the first interactive, text-based web browser: the original World Wide Web. Today, the protocol remains one of the primary means of using the Internet.

Improvements In HTTP 2.0

HTTP 2.0 is based on streams and binary frames, in comparison to the text-only request models of its previous iteration. Unlike text-only interfaces, streams can be multiplexed asynchronously over one TCP (Transmission Control Protocol) connection. Comparatively, HTTP 2.0 reduces latency, therefore enhancing its performance. 

How HTTP 2.0 Impacts Java

Java was commonly built upon the HttpURLConnection class – which had an original launch in 1999 when HTTP 1.0 was still a fresh protocol. With a backbone built from outdated technology, it was never able to update properly in response to the rapidly changing nature of web protocols. 

Its steady incompatibility and lack of ease in use, led developers to opt out of Java’s direct class and instead employ third party solutions (ie. Apache, Netty, Eclipse, Google, etc.).

With the new updated Java 11 developer toolkit, came a number of operational changes – but namely, the adoption of HTTP 2.0. In order to meet the demand of an environment consistently in motion, Java made these longevity changes:

  • Eliminating the need for 3rd party client dependencies
  • Building in a backwards compatibility with HTTP 1.0 for remaining servers that may have not yet made the switch to HTTP 2.0
  • Instating an asynchronous support network for multiple HTTP requests
  • Vastly improving performance with the addition of Header compression and Single Connections for multiple requests

Live Demonstrations

Daniel Fuentes has crafted an intuitive demonstration to help guide you through this new Java HTTP in practicum: 

Be sure to follow Daniel’s entire Lightning Talk to view this impressive demonstration in real time.

Closing Thoughts

All programs should always be designed with performance and the user experience in mind. The properties explored above are the primary stepping stones to exploring the basic components needed to test HTTP 2.0 in order to improve your application. Be sure to explore, have fun, and match up the components that work best for your project!

Happy coding!

To learn more about Java’s Updated HTTP Server as well as its influence in web development and to experience Daniel Fuentes’ full Lightning Talk session, watch here. 

The Reactive Streams Difference

Overview

As the world continues to shift towards online-first data, for everything from their remote workplace to streaming their favorite shows on Netflix, it’s become more imperative to recognize that “live” data needs to be handled with extra special care in an asynchronous system. 

Asynchrony is needed in order to enable the parallel use of computing resources, on collaborating network hosts with a single streamline data engine. 

The primary goal of Reactive Streams is to govern the exchange of stream data across an asynchronous boundary – similar to passing elements on to another thread or thread-pool in traditional transfer – while ensuring that the receiving side isn’t forced to buffer arbitrary data. 

Meaning… Reactive Streams allow for MULTIFOLD data processing, as opposed to traditional models, leaving more room for faster response times and a smoother UX experience.

In Hirav Oza’s Lightning Talk session, we will breaking down the following topics:

  • Functional Style Programming
  • Reactive Streams And Back Pressure
  • Popular Reactive Libraries
  • Closing Thoughts

Functional Style Programming

Functional Programming languages are specially designed to handle symbolic computation and list processing applications. It is a declarative type of programming style with a main focus on “what to solve” in contrast to “how to solve” (an imperative style). 

Reactive Programming by nature embraces a functional programming style. It functions similarly to common programmer staples such as Steams API and Lambdas, making it a smooth integration curve. 

Reactive Streams And Backpressure

Backpressure happens when data can’t render as fast as it needs to. This can cause a “buildup” of data at the I/O Switch when buffers are full and cannot receive additional data. At this point, no additional data packets can be transferred until the bottleneck of data has been eliminated or the buffer has been emptied.

Reactive Streams disrupt buildup by supporting the back-pressure so they can signal the database to “hold off” on producing more output, or in other words– “buffer” until the remaining data is processed… Making for a smoother UX  experience for the interface user and a more cohesive data transfer for the programming system. 

Popular Reactive Libraries 

  1. RxJava

RxJava is a specific implementation of reactive programming for Java and Android that is influenced by functional programming. It favors function composition, avoidance of global state and side effects, and thinking in streams to compose asynchronous and event-based programs.

  1. Project Reactor

Reactor Core is a Java 8 library that implements the reactive programming model. It’s built on top of the Reactive Streams specification, a standard for building reactive applications. 

  1. Flow API

Flow API is the official support for reactive streams specification since Java 9. It is a combination of both Iterator and Observer patterns. 

Flow API consists of four basic interfaces:

  • Subscriber: The Subscriber subscribes to Publisher for callbacks.
  • Publisher: The Publisher publishes the stream of data items to the registered subscribers.
  • Subscription: The link between publisher and subscriber.
  • Processor: The processor sits between Publisher and Subscriber, and transforms one stream to another.

Test Your Skills 

You’ve unpacked quite a few introductory principles – think you’re up to exploring a live demonstration of these concepts in play? 

Hirav Oza has crafted an intuitive demonstration to help guide you through these principles in practicum: 

Be sure to follow Oza’s entire Lightning Talk to view this impressive demonstration in real time.

Closing Thoughts

All programs should always be designed with performance and the user experience in mind. The properties explored above are the primary stepping stones to exploring the basic components needed to test how Reactive Streams can improve your personal data application. Be sure to explore, have fun, and match up the components that work best for your project!

Happy coding!

To learn more about Reactive Streams in web development and to experience Hirav Oza’s full Lightning Talk session, watch here. 

The Accelerating Future Of Server-Side Swift In Vapor

Overview

Server-Side Swift is an amazing new opportunity for coders to build fast, safe, and scalable back-end applications. This new open-source framework has enabled developers to use the Swift language on major servers, so nothing can stand between you and effectively creating your backend. 

In Austin-Michael Komatz’s Lightning Talk session, we will be uncovering the following topics:

  • What Is Swift?
  • Introducing Vapor
  • Test Your Skills
  • Closing Thoughts

What is Swift? 

In the simplest of terms, Swift functions as a general-purpose programming language – meaning, it can be used in any environment for a variety of applications.

Swift has a number of unique features that make it a versatile language to have in your personal “programmer’s tool box”:

  • As open source software (OSS), Swift is a coding language that can be seen, modified, and distributed by anyone
  • At its core, Swift is written in C++. C++ is an object-oriented programming (OOP) language that is one of the best sources for creating large-scale applications

The primary win associated with Swift, is that it’s not a language for only making iOS apps – but instead it can be applied seamlessly to a number of applications – making it an immeasurable advantage to implement into your industry practice.

Introducing Vapor 

Vapor is more than just a web framework. The project includes over a hundred official and community maintained server-first Swift packages. Vapor is a framework for writing HTTP server applications, front end websites, backends, and APIs in Swift.

Vapor has a unique set of properties that set it apart from other frameworks:

  • It is 100% written in Swift
  • It is a non-blocking, event-driven architecture built on top of Apple’s SwiftNIO
  • With a protocol orientation, it allows Vapor to be scalable, modular, and a type-safe network

Vapor allows you to create complex, full-featured applications that can power mobile applications or stand on their own.

Example: The below Vapor code base represents the unique “package manager” the platform utilizes in order to easily implement code cross-functionally. 

Vapor offers many features, some of the most important and widely used ones include:

  1. Databases

Databases allow data to be persisted and stored for later. This data can then be read back at any time. Vapor provides an ORM for working easily with a variety of databases. This allows developers to easily access their database without having to write custom queries.


Vapor allows you to easily create and manage RDS and Aurora Serverless databases directly from the Vapor UI or while using the Vapor CLI. Database backups are automatically performed and you may restore a database to any point in time (down to the second) within the backup retention window.

Vapor supports a number of commonly used databases, including (but not limited to):

  • PostgreSQL
  • redis 
  • SQLite
  • MySQL
  • mongoDB
  1. HTTP

Vapor’s client API allows you to make HTTP calls to external resources. It is built on async-http-client and integrates with the content API.

Vapor supports HTTP/1, HTTP/2, and protocol upgrades like WebSockets. The server also supports Transport Layer Security (TLS).

  1. Authentication

Authentication is the process of transforming a unique token (identifier) to actual user data. This can be a cookie with a session identifier stored in a browser, or in this case a JWT (JSON Web Token), but based on this ID the backend can retrieve the associated user object.

The end user signs in using a login form on a website (or an API endpoint), and sends the usual credentials (email, password) to the backend. If those credentials were valid, then the server will return a (randomly generated) identifier to the client. 

  1. Websockets

WebSockets allow for two-way communication between a client and server. Unlike HTTP, which has a request and response pattern, WebSocket peers can send an arbitrary number of messages in either direction. Vapor’s WebSocket API allows you to create both clients and servers that handle messages asynchronously.

Testing Your Skills

You’ve unpacked quite a few primary principles of the Server-Side Swift backend approach… But the best way to learn is through practical and tangible demonstration.

Austin-Michael Komatz has crafted an intuitive demonstration to help guide you through these principles in practicum: 

Using a coded chat application, Vapor is able to connect the two threads via a websocket to allow for real-time communications. 

Closing Thoughts

Why do you want to use Vapor as a backend engineer? The simple answer is– it uses Swift! It’s an ultra-modern language that is leading architecture use cases in the industry right now.

The longer answer… the abundance of functional benefits put it ahead of the industry curve in terms of speed, stability, and passionate community interactions.

Vapor is an optimistic look to the future for backend engineers, ensuring and maintaining a bigger and better future!

Happy coding!

To learn more about the introduction of Server-Side Swift in Vapor and to experience Austin-Michael Komatz’s full Lightning Talk session, watch here. 

An Introduction To Web Animation

Overview

Web design has undergone a number of innovations over the years, with each new implementation bringing a unique “flavor” to their coding.

Web animation has been dominating our screens in recent years, raising the bar for more intuitive and exciting user experiences online. Website design animation turns an ordinary user experience into an unforgettable journey that amazes with its bold colors, movements, adventures, and exciting interactions. 

In Alec McGovern’s Lightning Talk session, we will be uncovering the following animation topics:

  • What Is Animation?
  • Timing Functions
  • Test Your Skills
  • Closing Thoughts

What Is Animation?

Animation is all about breathing life into your web page. It can be anything from a simple button hover to a more complex customized menu slide – an animation serves a primary purpose in making your application readable, user friendly, and overall… FUN! Animations work to engage your users in a tangible way, meanwhile drawing attention and focus.

The two most commonly used CSS (Cascading Style Sheets) for animation are:

  1. Transitions

Transitions are the simplest way to animate a DOM (Document Object Model) element – or in other words, the determined page contents and its associated elements. They allow you to make a smooth consistent change to page elements over a specific duration of time. 

The primary components to a successful transition animation rule are:

  • transition-property

A transition-property will specifically denote what CSS element you’ll be specifically changing (examples include: color, opacity, etc.)

  • transition-duration

A transition-duration will specifically denote the allotted time the animation should take to complete before looping.

  • transition-delay

A transition-delay will specifically denote how long the animation should wait (in-between period) before looping the animation over again. 

  • transition-timing-function

A transition-timing-function will specifically denote how “fast” the visual animation should move on the web browser when a user engages with it. 

Example: The below transition code utilizes the property and duration formulas used to show that changes in opacity (transparency) should span a duration of two seconds before disappearing completely.

  1. @keyframes

For more complex animated changes over time, @keyframes, a specialized CSS rule, needs to be utilized. @keyframes allow a larger string of properties to be changed within a singular animated sequence. 

Example: The below @keyframes codes utilize the more complex from→to animation types (fadeout), as well as a percentage formula of exact color transitions throughout each animation duration point.

Once you’ve defined your @keyframes elements, you’ll be able to directly code them into your DOM, as shown below:

With both these animation formulas in mind, you’ll not only have a basic understanding of the coding associated but will also be able to implement either CSS code to execute the following tenets of animated web elements. 

What Are Time Functions? 

A time function controls the speed that your animation occurs at. The most commonly used value is, ease: which starts slow, accelerates in the middle, and slows again as the animation loop comes to an end. 

Some other examples include:

  • linear
  • ease-in, ease-out
  • step (int, start│end)
  • cubic-bezier (n,n,n,n)

Test Your Skills

You’ve unpacked quite a few animation principles – think you’re up to trying your hand at some practical animation exercises?

Alec McGovern has created an individual testing space just for you!

To rise to the challenge and apply what you’ve learned to the following animation exercise, click here. 

Closing Thoughts

All animations should always be designed with performance and the user experience in mind. The properties explored above are the primary stepping stones to experimenting with the basic components needed to test how animation can improve your personal web application. Be sure to explore, have fun, and match up the components that work best for your project!

Happy coding!

To learn more about the introduction of animation coding in web development and to experience Alec McGovern’s full Lightning Talk session, watch here. 

Why you should migrate away from Angular JS

Hello readers! A big fan of the Angular Javascript framework here. Today I wanted to go through a few of the reasons why you should look to migrate your existing AngularJS projects (any Angular release version under 2) to a more modern and actively supported framework (or library).

You might be thinking “well, this guy is internally conflicted”, but give me the opportunity to explain myself. Even though AngularJS is a fantastic piece of technology that surely was top of its class when it came out (October 2010) and despite the fact that I enjoy working with its successor Angular.io (also known as Angular 2+), AngularJS has become outdated (EOL December 2021), and a risk to your company in many different ways.

Dilbert strip - Larry tries to tell PHB what the legacy systems did. PHB says no, he doesn't care about legacy systems. Dilbert asks, "I though we replaced all of our legacy systems." Larry says, "Keep your thoughts to yourself."
@2017, Scott Adams, Inc.

The framework has reached end of support (Version Support Status). This means that it has become read-only mode, it will not be updated further. The framework has not been developed for over a year now (Release 1.8.2 happened in October 2020), and even though extended support was supposed to end mid-2021, it was extended to December 2021 due to the global pandemic. Here’s a blog post by the Angular team regarding discontinued long term support.

To add some support to the point I’m trying to make, I’ll share that Angular was created and mainly maintained by Google. Google recognized the shortcomings of AngularJS, and completely rewrote it to release Angular.io. AngularJS only made it to version 1.8.3, however Angular.io has already made it to major version 13 (current at time of writing), with many more versions to come.

What could be making you hold onto your existing AngularJS apps

Trust me, I’ve been there. You have a perfectly functioning application which needs little maintenance, and you have engineers who know it in and out already. Why invest a part of your budget in fixing something that’s not broken? Why bring in new people that don’t know the product? Why push your engineers to do something new/different to what they’ve been doing?

Dilbert strip - PHB announces to Dilbert that the legacy system maintainer quit. Tells Dilbert to fix it. Dilbert standing in front of odd large mechanical device with a screen, pipes, and pipes with the thought bubble, "Frack."
@2016, Scott Adams, Inc.

The reasons

Technology: As I stated earlier, AngularJS is outdated. This means that in its feature-set, performance, and just keeping up with latest developments in Javascript and the web browsers, AngularJS has clearly lagged behind, mainly due to the fact that it has been in maintenance mode and not actively developed on for years. If you stay on this framework, you won’t take advantage of the rapidly evolving web world, and the evolving smart devices and their new features.

Support: As the framework is no longer maintained, any new issues or limitations you encounter will not only lack an answer/help from the AngularJS team (again, not supported anymore), you most probably also won’t have a huge community online to help you with it, like you would have with any modern framework. This could mean a longer time to fix issues that come up in your application, and a rough experience for your engineers and users.

Security: Perhaps the biggest reason why you should move away from AngularJS. Like any unsupported package out there, you won’t be protected when any new security exploits are identified, be it within the framework itself, or any of its thousands of dependencies and indirect dependencies (yes, your app can be exploited by vulnerabilities in the dependencies of the dependencies of AngularJS which is your app’s dependency… you get the point). Usually when something like this happens in an actively supported package, a fix will be published quite swiftly in response to it, or any dependency that includes the vulnerability will be updated with a newer version.

Talent: Not only do you want to provide the best possible experience for your users, but also for your app engineers. When you are trying to retain or expand your software team, AngularJS will weigh on any engineer’s decision. Engineers will want to work with quality, cutting edge technology. It is hard for engineers to get or even stay excited about working on a framework that has reached end of life. It will be much easier for you to retain and hire engineers if your apps run on modern technologies and following best practices and industry trends. I cannot stress how much easier will it be to fill open positions when your tech stack is attractive for the engineers. You can also think about what will happen once you actually find someone willing to do the job on your legacy system, they will play hard to get and you’ll end up paying more for an engineer that is probably not up to date on industry standards.

Business: For current technologies, the help you will get from the online community is massive, which speeds up the time it takes to fix and implement new features, and to resolve critical situations that may arise. Not only your engineers will be happier and more engaged in what they are doing, it also impacts your branding. Are you a company that invests in and works with the latest and greatest? Or a company that settles with whatever is there?

Dilbert strip - Patty asks Larry how long it will take to add a feature to the legacy system. Larry asks when the new system will replace the old system. Patty responds, six months. Larry then says the new feature will take seven months.
@2017, Scott Adams, Inc.

I know that was a lot of talking, but I can tell you with confidence that we have seen the impact that migrating legacy applications has for many of our customers, and it is massive. Not only do applications come alive and look and feel more modern, but engineers come to work in a better mood and eager to get things done, and a true engineering culture is fostered. Even though keeping legacy systems might seem like the easy or cost-efficient way, there are several hidden (or not obvious) costs that come with it.

If you need any help assessing or migrating your systems, do not hesitate to reach out to us at any of the following:

get@inrhythm.com

InRhythm Website – Contact Us

+1 (800) 683-7813

Written by Juan Porley, Director of Engineering, Web Practice @ InRhythm