DEV Community: Ashutosh Sharma

Can SciChart 📊 and React revolutionize your data visualization? 🚀

Ashutosh Sharma — Mon, 06 Nov 2023 13:51:41 +0000

During my recent venture into a charts project, I came across SciChart, and it instantly piqued my interest due to its exceptional chart quality, extremely swift real-time data processing, and capability to efficiently manage a considerable number of data points within a single chart.

Since I was highly impressed with its potential, I researched further to get a better sense and understanding of the origin of SciChart. As I delved deeper into the subject, I learned that it was originally designed for Windows Graphics Library (WGL) but eventually expanded to support JavaScript libraries. Despite the documentation being quite comprehensive, I decided to create a succinct yet elaborative demonstration of how one can easily build a simple application with SciChart, using React application.

Introduction

The role of visualizing data cannot be overemphasized, whether it is about examining stock market trends, monitoring vital medical statistics, or simply analyzing progress, visually presented data enables us to make more informed decisions. SciChart offers a versatile solution for particularly these types of tasks.

Discovery of SciChart

My recent endeavor involved developing a financial data analysis tool capable of rendering thousands of data points in a single chart, and it was during this course that I realized that SciChart is an ideal library for the job. As I understood the nuances and the potential applications of this project better, I discovered that while the documentation provided may be extensive, it's still important to follow specific steps to integrate SciChart seamlessly into a React project. This article is tailored for developers seeking a step-by-step guide to implementing SciChart within their React projects.

Building a Simple React Application with SciChart

In this section, I'll guide you through the process of setting up a basic React application with SciChart for data visualization. I'll break down the steps involved and provide the necessary code snippets for a seamless integration.

Create a React App:

To begin, let's set up a new React application. In this example, we are using Vite and npm. You can create your app with the following command:

npm create vite@latest

This command will prompt you to provide details for your project, including the project name, package name, framework (choose React), and variant (choose TypeScript).

PS D:\workspace> npm create vite@latest
√ Project name: ... SciChart-React-Demo
√ Package name: ... scichart-react-demo
√ Select a framework: » React
√ Select a variant: » TypeScript

Scaffolding project in D:\workspace\SciChart-React-Demo...

Done. Now run:

  cd SciChart-React-Demo
  npm install
  npm run dev

npm notice
npm notice New major version of npm available! 9.6.6 -> 10.2.2
npm notice Changelog: https://github.com/npm/cli/releases/tag/v10.2.2
npm notice Run npm install -g npm@10.2.2 to update!
npm notice

After the setup is complete, navigate to your project directory and install the required packages:

cd SciChart-React-Demo
npm install
npm run dev

If everything is fine the application will be up and running on the url http://localhost:5173/

Integrate SciChart:

Now, it's time to include SciChart in your project. To do this, you can use the npm package for SciChart:

npm i scichart

Configure Static File Copy:

To ensure that SciChart's required files are available on your application, you'll need a static file copy plugin. You can install it using the following command:

npm i vite-plugin-static-copy

After installation, make sure to update your vite.config.js file with the provided configuration code. This code configures the ViteStaticCopy plugin to copy specific files from the 'node_modules' directory to the root directory of your project. This step is crucial for making the necessary static files accessible to your web application.

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import { viteStaticCopy } from 'vite-plugin-static-copy'


// https://vitejs.dev/config/
export default defineConfig({
  plugins: [
    react(),
    viteStaticCopy({
      targets: [
        {
          src: 'node_modules/scichart/_wasm/scichart2d.data',
          dest: '/'
        },
        {
          src: 'node_modules/scichart/_wasm/scichart2d.wasm',
          dest: '/'
        },
      ]
    })],
})

Create a SciChart component:

Now that your project is set up and SciChart is integrated, it's time to create a SciChart component that will render your charts. The provided code demonstrates how to define this component. It includes the necessary imports from React and SciChart, and it accepts properties for initialization and styling.

import { CSSProperties, useEffect, useState } from "react";
import { ISciChartSurfaceBase, generateGuid } from "scichart";

interface IChartComponentProps {
    initChart: (rootElementId: string) => Promise<{ sciChartSurface: ISciChartSurfaceBase }>;
    className?: string;
    style?: CSSProperties;
}
export function SciChart(props: IChartComponentProps) {
    const [rootElementId] = useState(`chart-root-${generateGuid()}`);
    useEffect(() => {
        props.initChart(rootElementId);
    }, []);
    return <div id={rootElementId} className={props.className} style={props.style} />;
}

This SciChart component is designed to create and display a chart on a web page. It accepts initialization functions and styling properties as props.

Create Your First Line Chart:

Finally, you can use the SciChart component to render your first chart. The provided code demonstrates how to create a line chart using the createChart function. This function initializes a SciChart surface, sets up X and Y axes, generates sample data, and associates it with a line series. The chart is then added to the SciChart surface.


const createChart = async (divElementId: string) => {
    const { sciChartSurface, wasmContext } = await SciChartSurface.create(divElementId);

    // Create an X,Y Axis and add to the chart
    const xAxis = new NumericAxis(wasmContext);
    const yAxis = new NumericAxis(wasmContext);

    sciChartSurface.xAxes.add(xAxis);
    sciChartSurface.yAxes.add(yAxis);


    const xValues = [];
    const yValues = [];
    for (let i = 0; i < 100; i++) {
        xValues.push(i);
        yValues.push(0.2 * Math.sin(i * 0.1) - Math.cos(i * 0.01));
    }

    const xyDataSeries = new XyDataSeries(wasmContext, {
        xValues,
        yValues,
    });

    const lineSeries = new FastLineRenderableSeries(wasmContext, {
        stroke: "#FF6600",
        strokeThickness: 5,
        dataSeries: xyDataSeries
    });
    sciChartSurface.renderableSeries.add(lineSeries);


    return { sciChartSurface };
};

To use the SciChart component and display your line chart, simply include the following line in your code:

 <SciChart initChart={createChart} style={{ width: 800, height: 600 }} />

With these steps, you're all set to create and visualize data with SciChart in your React application.

The expected result should resemble the following:

Conclusion

In the light of the aforesaid, it is safe to conclude that SciChart emerges as a powerful ally in the world of data visualization. Its capabilities in handling real-time data, seamless integration with popular JavaScript libraries, and detailed documentation make it a preferred option for the developers.

By following our guide, you can speedily integrate SciChart into your React projects, creating dynamic charts that will transform data into extraordinary insights. With SciChart, you will be able to unlock a realm of multiple possibilities, enhancing decision-making and user experiences in various applications. Explore, experiment, and let SciChart infuse life into your data.

If you want to explore and access all the codes used in this article, it's available on GitHub repository.

https://github.com/ashusharmatech/scichart-react-demo

Resources:

Oracle Upgrade Decoded: Insights from an App Developer's Perspective

Ashutosh Sharma — Fri, 07 Jul 2023 06:45:22 +0000

Drawing inspiration from the wisdom of Vincent Van Gogh, who wisely remarked that "Great things are not accomplished by impulsive actions, but rather by the culmination of small steps," I recently completed Oracle migration for a critical application.

This article explores the thorough planning required for an Oracle upgrade, highlighting key factors. Moreover, it provides an insightful account of a firsthand experience upgrading a colossal database from Oracle 11g to 19c.

There are a few points which you consider before upgrading Oracle upgrade:

Types of Upgrades

Before proceeding with the upgrade, it's crucial to determine the appropriate upgrade path. Oracle documentation specifies that not all versions can be directly upgraded to Oracle 19c. For instance, while 11.2.0.4 can be upgraded directly to 19c, 11.2.0.3 must first be moved to 11.2.0.4 before upgrading further. Fortunately, in our case, a direct upgrade path was available.

Reference: Oracle Database 19c Upgrade Guide

Out-of-place Upgrade vs. In-Place Upgrade

There are two main types of upgrades: out-of-place and in-place upgrades. An out-of-place upgrade involves installing a newer version in a separate Oracle Clusterware home, allowing you to have both versions available while copying data from the old database to the new Oracle 19c. This approach enables easy rollback to the previous version in case of issues. On the other hand, an in-place upgrade overwrites the software in the current Oracle Grid Infrastructure home without the need for additional hardware. However, it doesn't provide the option of easily reverting to the previous version in case of problems. Considering the time constraints and hardware procurement challenges, we opted for an in-place upgrade. In this article, I will also share how we mitigated the potential downsides of an in-place upgrade.

Compatibility of the Application:

Assessing the compatibility of the application with the new Oracle version is crucial. In our case, we encountered two compatibility challenges:

Code Compatibility

Oracle Database 19c does not support connecting using SID (System Identifier). Starting from Oracle Database 12c, Oracle introduced a new connection method using service names instead of SIDs. Service names provide a more flexible and scalable approach to database connections.

When connecting to Oracle Database 19c, it is recommended to use the service name instead of the SID for proper connectivity. This adjustment ensures compatibility and aligns with Oracle's recommended connection method. The SID serves as a unique name assigned to each Oracle instance, facilitating identification and connection to specific databases. When connecting using the SID, the syntax typically follows the format jdbc:oracle:thin:@host:port:SID.

On the other hand, a service name represents a logical name associated with a database service, offering a more abstract and adaptable approach to establishing connections. When connecting using the service name, the syntax generally adheres to the format jdbc:oracle:thin:@host:port/service_name.

Driver Compatibility

During an Oracle upgrade, it is recommended to review the documentation provided by Oracle to identify the supported driver versions for the target database release. If the existing driver version is not compatible with the new Oracle version, an updated driver version may need to be installed or integrated into the application. This ensures that the application can establish a successful connection and effectively utilize the functionalities provided by the upgraded Oracle database.

We were upgrading to Oracle 19c so we preferred to use the ojdbc8.jar.

A quick reference from the Oracle Documentation for compatible libraries.


+----------------------+--------------------------------------+
| ojdbc Driver Version | Compatible Oracle Database Versions  |
+----------------------+--------------------------------------+
| ojdbc6.jar           | Oracle Database 11g                  |
| ojdbc7.jar           | Oracle Database 12c                  |
| ojdbc8.jar           | Oracle Database 12c, 18c, 19c        |
| ojdbc10.jar          | Oracle Database 19c                  |
+----------------------+--------------------------------------+

Compatibility of Other Software Components

In addition to considering the compatibility of your Oracle database upgrade, it is crucial to assess the compatibility of other components you may be utilizing. For instance, if you are employing Informatica, it is essential to note that based on Informatica 10.1 documentation, it is not compatible with Oracle 19c. This information highlights the need to plan the upgrade carefully and make necessary adjustments to ensure seamless compatibility between all components.

Downtime Considerations

Downtime consideration is a crucial aspect when planning an Oracle upgrade. The duration of downtime can vary depending on the size of the database, complexity of the upgrade, and any specific requirements or constraints. It is essential to carefully evaluate the impact of downtime on business operations and user accessibility.

During the upgrade process, the database may need to be taken offline, resulting in temporary unavailability of services and applications relying on it. This downtime can disrupt business activities, affect productivity, and potentially lead to financial implications.

In some cases, organizations may explore alternative solutions to reduce downtime, such as utilizing backup systems, implementing high availability configurations, or leveraging data replication techniques. These strategies can provide continuous availability or minimize downtime during the upgrade process.

Given the substantial size of our database, using the replicated server was not feasible during the in-place upgrade. This was primarily because our backup database was intended to serve as a contingency plan in case any issues arose during the release. so we had to plan for 24 hours of downtime of our application.

Testing Scope

The testing scope can vary for different applications, and it's important to define the scope comprehensively. To ensure a smooth upgrade, we conducted a full regression test, covering all interfacing applications and relevant functionalities. Based on the testing timeline, we defined the production go-live date accordingly.

Rollback Plan

As part of our in-place upgrade strategy, we needed a reliable rollback plan in case any issues arose during the upgrade. Our fallback option was to leverage the backup database. Before initiating the upgrade, we ensured that the production database and backup database were in sync. If a rollback became necessary, we would postpone the activity, make the backup server the primary server, and replicate the database to create another backup instance. This plan allowed us to proceed with confidence, knowing that we had a reliable fallback option available.

Outcome

Thanks to the collaborative efforts and meticulous planning, we successfully upgraded the database. The entire process was a valuable learning experience, as it involved coordinating with multiple teams and collaborating with new individuals to ensure a successful outcome.

Socket & Highchart Gauge: Real-Time Data Visualization

Ashutosh Sharma — Wed, 07 Jun 2023 19:02:32 +0000

Real-time data visualization is an effective technique for monitoring, analyzing, and making decisions based on real-time data updates. We can create interactive and dynamic visualizations that provide real-time insights by combining WebSocket for real-time data communication and Highchart's gauge chart for visual representation. In this article, we will look at real-time data visualization use cases and show how to implement them using socket communication and Highchart's gauge chart.

Use Cases of Real-Time Data Visualization
Real-time data visualization with WebSocket and Highchart's gauge chart finds applications in various domains. Let's explore a few notable use cases:

IoT Sensor Monitoring: Sensors collect data from various devices and environments in IoT (Internet of Things) applications. Users can monitor sensor readings such as temperature, humidity, or air quality in real time using real-time data visualization. Users can quickly identify anomalies or trends by visualizing this data on gauge charts, allowing them to make informed decisions and take appropriate actions.
Financial Data Analysis: In financial systems where real-time market data, stock prices, or currency exchange rates are constantly changing, real-time visualization is critical. Traders and investors can quickly assess market conditions, identify patterns, and make informed decisions about investments or trading strategies by visualizing financial data on gauge charts.
Network Monitoring and Performance Analysis: Real-time data visualization can help network administrators and IT teams monitor network performance metrics like bandwidth usage, latency, and packet loss. Gauge charts can provide an intuitive representation of these metrics, allowing administrators to quickly identify anomalies or bottlenecks and take proactive measures to ensure network stability and performance.
Healthcare Monitoring: Real-time data visualization is essential in healthcare applications, particularly in monitoring patients' vital signs. Healthcare professionals can track metrics such as heart rate, blood pressure, and oxygen saturation in real-time by integrating sensors with real-time gauge charts. This allows healthcare providers to respond quickly and provide timely interventions by detecting abnormal readings early.
Environmental Monitoring: In environmental monitoring systems such as weather stations or pollution monitoring, real-time visualization is critical. Temperature, humidity, air quality index, and pollutant levels can all be displayed in real time on gauge charts. This enables researchers, environmentalists, and policymakers to monitor and analyze environmental conditions in real time, allowing them to make informed decisions.

These are just a few examples of how real-time data visualization with WebSocket and Highchart's gauge chart can be applied across different domains. The versatility and flexibility of this approach make it a powerful tool for real-time monitoring, analysis, and decision-making. Now, let's dive into the technical aspects of setting up the server and creating the HTML page to implement real-time gauge chart visualization.

Technical Implementation
We will create a sample application for monitoring temperature using a WebSocket server and a gauge chart to demonstrate real-time data visualization. The server will simulate temperature data, and the gauge chart will display the current temperature.

Setting up the Server
To begin, let's set up a server that establishes a WebSocket connection and sends data to connected clients. We'll be using Node.js and the ws library to create a simple WebSocket server.



const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 1234 });

console.log('WebSocket server started');

wss.on('connection', (ws) => {
  console.log('New WebSocket connection');

  const interval = setInterval(() => {
    const data = String(Math.floor(Math.random() * 100) + 1);
    ws.send(data);
    console.log('Sent data:', data);
  }, 2000);

  ws.on('close', () => {
    console.log('WebSocket connection closed');
    clearInterval(interval);
  });
});

In the code above, we create a WebSocket server that listens on port 1234. When a client connects, a new WebSocket connection event is triggered. We start sending random data to the client every 2 seconds using a setInterval function. If the client disconnects, we clear the interval to stop sending data.

Creating the HTML Page

Next, let's create an HTML page that will host our Highcharts gauge chart and handle the WebSocket connection to receive real-time data updates. We'll be using Highcharts version 9.3.1.



<!DOCTYPE html>
<html>
<head>
  <title>Gauge Chart Example</title>
  <script src="https://code.highcharts.com/highcharts.js"></script>
  <script src="https://code.highcharts.com/modules/solid-gauge.js"></script>
</head>
<body>
  <div id="chart-container" style="width: 400px; height: 300px;"></div>

  <script>
    var container = document.createElement('div');
    document.body.appendChild(container);

    window.chart = new Highcharts.Chart({
      chart: {
        renderTo: container,
        type: 'gauge'
      },
      title: {
        text: 'Humidity'
      },
      series: [{
        name: 'Humidity',
        data: [0],
        dataLabels: {
          format: '{y} %'
        },
        yAxis: {
          min: 0,
          max: 100
        },
        tooltip: {
          valueSuffix: ' %'
        }
      }]
    });

    var socket = new WebSocket('ws://localhost:1234');

    socket.onopen = function (event) {
      console.log('WebSocket connection established.');
    };

    socket.onmessage = function (event) {
      var value = parseInt(event.data);
      console.log('Received data:', value);
      chart.series[0].points[0].update(value);
    };
  </script>
</body>
</html>

In the HTML code, we include the Highcharts library from the Highcharts CDN. The <div> element with the id chart-container is where the gauge chart will be rendered.

Inside the <script> tag, we create a new Highcharts chart by instantiating the Highcharts.Chart constructor. We configure the chart to display a gauge type chart with a title and a single series representing humidity. We set the initial data value to 0.

We establish a WebSocket connection to ws://localhost:1234, assuming the server is running on the same machine and port. The onopen event listener confirms that the WebSocket connection is established. When a new message is received (onmessage event), we parse the data and update the chart's series with the new value using chart.series[0].points[0].update(value).

Running the Application

To run the application, follow these steps:

Save the server code to a file called server.js.
Install the ws package by running npm install ws in the same directory as server.js.
Start the websocket server by running node server.js.
Save the HTML code to a file called index.html.
Open a web browser and visit index.html.
Open the browser console to view the WebSocket connection status and received data updates.

With the server running and the HTML page loaded, the gauge chart will update in real-time as the server sends random data to the clients. The needle on the gauge chart will reflect the new values received.

Integrating WebSocket with Highcharts allows us to create powerful and dynamic data visualization applications. By establishing a WebSocket connection between the server and the client and utilizing Highcharts' gauge chart, we can visualize real-time data updates in an intuitive and visually appealing manner. This enables us to build interactive dashboards for monitoring various types of real-time data, such as sensor readings, financial data, or performance metrics. Feel free to customize the code and explore different chart configurations to create your own real-time visualization solutions.

Converting PDFs to DOCX Made Easy with Python

Ashutosh Sharma — Sun, 28 May 2023 18:26:32 +0000

Converting PDF files to DOCX format is a common task that many professionals and researchers encounter in their daily workflow. PDF files provide a convenient way to share and preserve document formatting, but sometimes it's necessary to convert them to a more editable format like DOCX. In this article, we will explore a Python code snippet that utilizes the pdf2docx library to seamlessly convert multiple PDF files to DOCX format.

from pdf2docx import Converter
import os

# Directory paths for input and output files
path_input = r'C:\Users\pdf'
path_output = r'C:\Users\docx'

for file in os.listdir(path_input):
    input_file = os.path.join(path_input, file)
    output_file = os.path.join(path_output, os.path.splitext(file)[0] + '.docx')

    cv = Converter(input_file)
    cv.convert(output_file, start=0, end=None)
    cv.close()
    print(file)

The code begins by importing the necessary libraries: pdf2docx and os.
The path_input variable stores the directory path where the PDF files are located. Replace the path with the actual location of your PDF files.
Similarly, the path_output variable holds the directory path where the converted DOCX files will be saved. Adjust this path according to your desired output location.
The os.listdir() function retrieves the list of files in the path_input directory.
The code then iterates over each file in the directory using a for loop.
Inside the loop, the full paths of the input and output files are created using os.path.join() to join the directory path and the file name.
An instance of the Converter class is created with the input_file path.
The convert() method of the Converter class is called, specifying the output file path (output_file). The start and end parameters can be adjusted to convert specific pages or the entire document.
Finally, the cv.close() method is called to close the Converter instance.
The file name is printed to the console, providing a progress update for each conversion.

By utilizing the pdf2docx library and the Python code snippet presented in this article, you can automate the conversion process for multiple PDF files effortlessly. Whether you're a professional, researcher, or simply someone in need of converting PDFs, this code will save you time and effort, enabling you to focus on more critical tasks in your workflow.

Why are Companies stuck with Java 8?

Ashutosh Sharma — Tue, 23 May 2023 18:00:08 +0000

Java 8, which was released in 2014, is considered quite old now, having been around for almost 9 years. However, many projects and companies are still on Java 8/JDK 8.

According to survey data, 46% of projects are still using JDK 8 as of 2022.

https://newrelic.com/resources/report/2022-state-of-java-ecosystem

Is Java 8 the best Java release to date? Why don't the projects upgrade the JDK?
Let me attempt to list the key improvements that Java 8 introduces before we attempt to respond to this. The Streams API, Lambda Expressions, functional interfaces, the new date-time API, and default methods were all presented as essential features.
In this blog, I want to go over the challenges faced in migrating to newer versions and, with that, what benefits a team can get if they keep the latest long-term supported version of JDK.
It is important to understand why teams are reluctant to upgrade the JDK project, I tried to summarize a few points based on my experience:

Stability and Compatibility: JDK 8 has established itself as a reliable and stable Java version. This version, which has undergone thorough testing and debugging, has been the foundation around which many businesses have built their systems and applications. Companies may be cautious about moving since upgrading to newer versions could cause compatibility problems with already-existing codebases, libraries, and frameworks.
Limited Resources and Time Constraints: Java version upgrades can be time-consuming processes that demand a lot of skill and resources. Companies frequently have a backlog of tasks and objectives, which makes it difficult to conduct the extensive testing and compatibility tests required for a seamless transfer. Moreover, limited financial resources and understaffing further impede improvement efforts.
**Dependence on Older Libraries: **Some businesses depend on third-party libraries that haven't been upgraded to work with more recent Java versions. These dependencies present a problem since, before upgrading, businesses must confirm that all system components are compatible. Companies may be discouraged from switching since it can be difficult to upgrade existing libraries or locate substitutes.
Compatibility Concerns with Legacy Systems: Upgrading Java versions presents special difficulties for businesses with extensive legacy systems. These systems might be bound to JDK 8 by extensive dependencies, dated components, or unique configurations. The process of upgrading these systems to more recent versions of Java is hard and risky because it calls for thorough planning, intensive testing, and potential refactoring.
Risk Mitigation: For some companies, the perceived risks of upgrading outweigh the benefits. Newer versions may introduce unidentified bugs or behavioral changes, whereas JDK 8 is an established, mature version with a solid track record. Organizations that are risk-averse can choose to continue with the secure and comfortable environment that JDK 8 offers rather than take a chance on interruption or unforeseen behavior.

But let’s assume you managed to overcome these challenges and decided to upgrade the JDK versions. What benefits can you can expect with JDK Upgrade:

Performance improvements: Each JDK version includes performance upgrades that may lead to decreased memory usage and increased execution speed. Cost savings may result from this, particularly in big setups with several JVMs. Bug fixes and security patches: Upgrading to newer JDK versions ensures access to security updates, bug fixes, and patches that address vulnerabilities and improve overall stability and dependability.
Access to new features: New features and functionalities are added to the JDK with each new release, which can improve development productivity, allow for better code optimization, and provide users access to modern language capabilities. Attractiveness to developers: Using recent JDK versions can be enticing to developers that favor cutting-edge technology. It can support keeping up with competition in the job market and luring top personnel.

Path to upgrade

Recommended upgrade path: It is generally advised to follow a step-by-step upgrade path, such as moving from JDK 8 to 11, then to 16, and finally to 17. This ensures a smoother transition and allows for compatibility testing and adjustments along the way. Encapsulation changes: With JDK 11, stronger encapsulation of JDK internals was introduced. Therefore, migration from JDK 11 to 16 may reveal different issues compared to migration from JDK 11 to 17. Workarounds may be required when a drop-in replacement is not feasible.

Conclusion

Overall, while upgrading JDK brings benefits, such as improved performance, bug fixes, and access to new features, teams may encounter challenges related to library compatibility, ecosystem adoption, and codebase adjustments. Careful planning, testing, and collaboration between development and operations teams can help mitigate these challenges and ensure a successful JDK upgrade.

Java Through the Ages: Unraveling the Top Features of Each Major Version

Ashutosh Sharma — Sun, 21 May 2023 07:38:35 +0000

Since its beginnings, Java, a flexible and popular programming language, has undergone a remarkable growth and change. Java has added new features and improvements with each major version release, changing the way programmers write code and create applications. In this article, we'll trip through the several Java iterations and examine their key characteristics, highlighting key turning points in the development of the language.

Version	Release Date	Top Features
Java 1	Jan 23, 1996	Platform independence, basic object-oriented programming
Java 2	Dec 8, 1998	Improved libraries and APIs, Java Development Kit (JDK)
Java 5	Sep 30, 2004	Generics, enhanced for loop, annotations
Java 6	Dec 11, 2006	Scripting language support, enhanced JDBC
Java 7	Jul 28, 2011	Switch statement enhancements, try-with-resources
Java 8	Mar 18, 2014	Lambda expressions, Stream API, Default methods
Java 9	Sep 21, 2017	Module system, JShell, HTTP/2 support
Java 10	Mar 20, 2018	Local variable type inference
Java 11	Sep 25, 2018	HTTP Client API, Local variable syntax for lambda parameters
Java 12	Mar 19, 2019	Switch expressions, compact number formatting
Java 13	Sep 17, 2019	Text blocks, dynamic CDS, ZGC
Java 14	Mar 17, 2020	Pattern matching for instanceof, records
Java 15	Sep 15, 2020	Sealed classes, hidden classes, text blocks
Java 16	Mar 16, 2021	Records, pattern matching for instanceof
Java 17	Sep 14, 2021	Sealed classes, pattern matching for switch
Java 18	Mar 22, 2022	Vector API incubation, preview of pattern matching for switch expr.
Java 19	Sep 20, 2022	Structured concurrency, record patterns, preview of foreign API
Java 20	Mar 21, 2023	Virtual threads, vector API proposal, structured concurrency, more

Conclusion:
Over time, Java has seen tremendous change as it adapted to the shifting demands of developers and the market. Every significant Java update has added useful features and enhancements that allow programmers to create cleaner, more effective, more contemporary code. Keeping up with the most recent Java release ensures access to these developments, enabling developers to produce creative and reliable apps. We eagerly anticipate further releases of Java and the fascinating features they will bring.

KISS: Keep It Simple, Stupid

Ashutosh Sharma — Sat, 20 May 2023 08:45:39 +0000

When we enter the world of software development, we are surrounded by a plethora of programming languages, frameworks, tools, and technologies. It's easy to lose sight of simplicity in the midst of this immense ocean. To reach actual efficacy, we must, however, take a step back and unburden ourselves of unneeded complications.

Enter the KISS principle, an acronym that stands for "Keep It Simple, Stupid."

The name may appear strange, even comical, yet its substance is quite powerful. Let us begin on a trip to discover the magic of the KISS principle and experience its revolutionary influence on our coding practices in this blog article.

The Essence of the KISS Principle
The KISS principle, at its foundation, encourages us to prefer simplicity over complication. It encourages us to eliminate superfluous complexities, minimise over-engineering, and prioritise clean and succinct solutions. Simplicity does not imply dullness; rather, it promotes attractive and simple designs that are easy to understand, alter, and debug.

Readability: The Pathway to Collaboration

The foundation of maintainable and collaborative software development is readability. When our code is straightforward and easy to understand, it allows for smooth cooperation among team members.

Let us imagine ourselves as part of a team working on an engaging weather application. One of the criteria for this project is to display the current temperature in both Celsius and Fahrenheit. Allow me to present Raj, a skilled engineer on our team who will be in charge of putting this feature into action.

Initially, Raj devises the following code:

def temp(c, f):
    print("Temp:")
    print("C: ", c, "°C")
    print("F: ", f, "°F")

# Usage
c = 25
f = (c * 9/5) + 32
temp(c, f)

Though the code works properly, understanding it requires close examination owing to truncated variable names and a lack of clarity. When dealing with more complicated codebases, such reduced readability might lead to confusion and blunders.

With keen observation and review comments, Raj refines the code as follows:


def display_temp(c, f):
    print("Celsius: ", c, "°C")
    print("Fahrenheit: ", f, "°F")

# Usage
celsius = 25
fahrenheit = (celsius * 9/5) + 32
display_temp(celsius, fahrenheit)

The code becomes more understandable by using meaningful variable names and providing explicit labels in the output. When other team members evaluate the code, they quickly grasp its purpose and application. Furthermore, if Raj has to revisit or edit the code in the future, its readability allows him to comprehend and implement changes without causing problems.

Maintainability: The Key to Longevity
A software system's ultimate test is not just its initial implementation, but also its long-term maintainability. Complex code frequently becomes a maintenance nightmare, fostering errors, impeding debugging efforts, and making upgrades and additions difficult. Simplicity, on the other hand, allows for faster problem repairs, easier upgrades, and the inclusion of new features. The KISS principle protects codebases against the invasion of technical debt, promoting efficient iterations and long-term development.

Testability: Simplifying the Verification Process

Comprehensive testing is essential for producing trustworthy software. However, testing sophisticated code may be a difficult effort. When code grows sophisticated and intricate, it becomes difficult to write effective tests, resulting in incomplete or inadequate test coverage. The KISS principle advocates for testable code that is straightforward to verify. Simpler code architectures sometimes demand fewer test cases since their behaviour is easily deduced. We can build testable codebases that improve the quality of our product by embracing simplicity.

Performance: Efficiency through Simplicity

While optimising performance is critical, we must resist the attraction of complexity. Overly complex code introduces needless complexity, making it difficult to discover and optimise performance bottlenecks. The KISS concept promotes simplicity as a means of achieving efficiency. Developers may optimise crucial code parts, quickly discover performance issues, and efficiently simplify their programmes by concentrating on simple fixes.

Consider the following scenario: you decide to write a programme that computes the sum of numbers from 1 to N, where N is a huge positive integer.


def calculate_sum(n):
    total_sum = 0
    for i in range(1, n+1):
        total_sum += i
    return total_sum

# Usage
N = 1000000
total_sum = calculate_sum(N)
print("Sum:", total_sum)

However, if we take a moment to pause and reconsider, we can simplify the process by employing a formula:


def calculate_sum(n):
    return (n * (n + 1)) // 2

# Usage
N = 1000000
total_sum = calculate_sum(N)
print("Sum:", total_sum)

We eliminate the requirement for a loop and iteration over N integers by using the strength of this formula, resulting in a considerable speed boost.

Practical Tips for Embracing the KISS Principle

Break down difficult problems: Tackle big problems by breaking them down into smaller, more manageable pieces. Solving each component separately promotes simplicity throughout the development process.
Refactoring on a regular basis: Review and refactor your code on a regular basis to eliminate redundancy, improve readability, and increase maintainability. Small, gradual improvements can have a big impact over time.
Avoid over-optimization: Prioritise simplicity in the early phases of development. Premature optimization frequently results in complicated and confusing code that is difficult to alter and maintain.
Seek feedback: Create a culture of peer code reviews and feedback sessions to guarantee your codebase follows the KISS principle. New viewpoints can provide light on areas that can be simplified.

The KISS principle embodies a compelling idea that raises simplicity to the status of a guiding principle in software development. We may create code that is legible, manageable, testable, and performant by following its principles. Pursuing simplicity not only increases individual productivity, but it also fosters teamwork and long-term success within development teams. So, when you begin your coding adventure, make simplicity your ally, and watch as your codebase thrives with elegance and efficiency.

Maximizing Azure Performance: A Deep Dive into Premium and Standard Storage Accounts

Ashutosh Sharma — Tue, 14 Feb 2023 05:51:32 +0000

Azure Storage offers different types of storage accounts to support different workloads and scenarios. Two of the most common types of storage accounts are Premium and Standard. In this tutorial, we'll discuss the differences between these two types of storage accounts in Azure.

Performance:
Premium storage is designed for high-performance workloads that require low latency and high IOPS (Input/Output Operations per Second). It uses solid-state drives (SSDs) for storage, which provides faster read and write speeds compared to standard storage. Premium storage also supports larger disk sizes, up to 64TB per disk, which is useful for large-scale enterprise workloads. Standard storage, on the other hand, uses hard disk drives (HDDs) and is suitable for most workloads that do not require high-performance storage.

Availability:
Premium storage provides a higher level of availability and durability than standard storage. Premium storage offers an availability SLA (Service Level Agreement) of 99.9%, while standard storage offers an availability SLA of 99.99%. This means that premium storage may be more suitable for mission-critical workloads that require high availability.

Cost:
Premium storage is more expensive than standard storage, as it provides higher performance and availability. The cost of premium storage is based on the amount of data stored and the number of transactions performed. Standard storage is less expensive than premium storage and is suitable for most workloads that do not require high-performance storage.

Use cases:
Premium storage is suitable for workloads such as databases, big data analytics, and high-performance computing. It is also suitable for applications that require low latency and high IOPS, such as online gaming, financial trading, and real-time data processing. Standard storage, on the other hand, is suitable for most workloads that do not require high-performance storage, such as backup, file sharing, and archiving.

Performance Characteristics	Premium Storage	Standard Storage
Storage Media	Solid-State Drives (SSDs)	Hard Disk Drives (HDDs)
IOPS	Up to 200,000	Up to 20,000
Throughput	Up to 2,000 MB/s	Up to 60 MB/s per disk
Disk Size	Up to 64 TB	Up to 32 TB
Availability SLA	99.9%	99.99%
Redundancy	Locally Redundant Storage (LRS) and Zone Redundant Storage (ZRS)	LRS, ZRS, and Geo-Redundant Storage (GRS)
Cost	More expensive	Less expensive
Use Cases	Databases, big data analytics, high-performance computing, online gaming, financial trading, real-time data processing	Backup, file sharing, archiving, and other common workloads

In conclusion, the choice of storage account type in Azure depends on the specific needs of your workload. If you require high-performance storage with low latency and high IOPS, then premium storage is the best option. However, if you require basic storage for common workloads, then standard storage is the most suitable option.

Reference:
https://learn.microsoft.com/en-us/azure/storage/common/storage-account-overview

Python: Publishing Packages

Ashutosh Sharma — Mon, 02 Jan 2023 15:35:04 +0000

You've created a Python project and you're eager to share it with others. But first, you'll have to package it! This tutorial walks you through how to package a simple Python project. It will show you how to add the necessary files and structure to create the package, how to build the package, and how to upload it to PyPI.

Environment Setup:

pip Upgrade: Update the pip version to the latest:

python3 -m pip install --upgrade pip

Twine : Install the twine (https://pypi.org/project/twine/), this is a utility for publishing Python packages on PyPI.

pip install twine

Wheel: Let's install wheel (https://pypi.org/project/wheel/), which is the reference implementation of the Python wheel packaging standard, as defined in PEP 427.

pip install wheel

Python Project and Structure:

Let's create a small project to upload to PyPI.

I was looking for an idea what to create to explain the packaging, and I was watching Friends so thought to create something around it.

So let's name the project FriendsPy ( it's not Friend SPY :D ).

Create a new folder name it FriendsPy. Under the folder we need below structure:

FriendsPy/
├── friendspy/
│   ├── qoutes/
│      ├── __init__.py
├── setup.py
├── README.md

The setup.py will hold all the required properties to upload the package to PyPI.

Sample file will have below content:

from setuptools import setup

VERSION = '0.0.1'
DESCRIPTION = 'Friends Show Related API'
LONG_DESCRIPTION = 'A package that allows to get details about friends show'

# Setting up
setup(
    name="friendspy",
    version=VERSION,
    author="Ashutosh Sharma",
    author_email="email2ashusharma@gmail.com",
    description=DESCRIPTION,
    long_description_content_type="text/markdown",
    long_description=LONG_DESCRIPTION,
    packages = ['friendspy.qoutes'], # this should have the list of packages we want to expose
    install_requires=[],
    keywords=['python', 'friends', 'entertainment', 'fun'],
    classifiers=[
        "Development Status :: 1 - Planning",
        "Intended Audience :: Developers",
        "Programming Language :: Python :: 3",
        "Operating System :: Unix",
        "Operating System :: MacOS :: MacOS X",
        "Operating System :: Microsoft :: Windows",
    ]
)

Let's create a method under __init__.py file which can be used by other:

def random():
    return "How you doin'?"

Build the package:

Now we have to package the complete project using:

python setup.py sdist bdist_wheel

It will create a dist folder which will have the packages compatible for PyPI.

Upload to PyPI:
To upload this package we have to run below command:

twine upload dist/*

It will ask you for the username and password for PyPI website. Once authenticated it will uploaded to PyPI.

GitHub Repository: https://github.com/ashusharmatech/friendspy
PyPI: https://pypi.org/project/friendspy/

Use this library:
Install the latest version of package:

pip install friendspy==0.0.2

Import the project in your py file, and call the method:

import friendspy.qoutes as qoutes
print(qoutes.random())

It will print:

How you doin'?

Suggest cool applications publishing contents to Instagram ?

Ashutosh Sharma — Wed, 01 Jun 2022 15:16:55 +0000

I am trying to build an application, which publishes pictures to Instagram.. I am looking for ideas.

Why you should use virtualenv in Python Projects

Ashutosh Sharma — Sun, 29 May 2022 18:00:24 +0000

Python virtual environment is a tool that allows projects to run in an isolated environment to avoid any conflict of dependencies.

This is really helpful when you are working on multiple project on same system, these project can have dependency with different version. Virtual environment will allow to maintain the isolation and you will not run into unnecessary issues.

To use this, first we need to install virtualenv module to the project using command

pip install virtualenv

In case you get similar warning

  WARNING: The script virtualenv.exe is installed in 'C:\Users\username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\Scripts' which is not on PATH.
  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.

Add this to your PATH variable after that check the version of virtualenv to verify the installation.

C:\Users\username\virtualenv-demo>virtualenv --version
virtualenv 20.14.1 from C:\Users\username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\site-packages\virtualenv\__init__.py

Create a virtual environment using command:
virtualenv <name of the environment>


C:\Users\username\virtualenv-demo>virtualenv my_virtual_env
created virtual environment CPython3.9.13.final.0-64 in 3256ms
  creator Venv(dest=C:\Users\username\virtualenv-demo\my_virtual_env, clear=False, no_vcs_ignore=False, global=False, describe=CPython3Windows)
  seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=C:\Users\username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\Local\pypa\virtualenv)
    added seed packages: pip==22.0.4, setuptools==62.1.0, wheel==0.37.1
  activators BashActivator,BatchActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator

It will create a new directory in the project:

This directory has all the required libraries and executables which are required by python project.

To use the virtual environment we need to activate it first. To activate this we need to run a script <name of the environment>/bin/activate

On Windows System:

C:\Users\username\virtualenv-demo\> .\my_virtual_env\Scripts\activate

On Unix systems:

source \my_virtual_env\Scripts\activate

Once it is activated the name of the environment will appear at the front of the command prompt.

(my_virtual_env) PS C:\Users\username\virtualenv-demo>

Now you can install all the required dependencies. for example

pip install fastapi=0.78.0

Once you have all the required packages installed you can also create a list of packages using command

pip freeze > requirements.txt

It will create a new file requirement.txt with all the packages and versions. Which can be used to install all the libraries easily wherever you want.

Having a updated requirements.txt file always helps when you have to install the project on different environment.

Just use below command and your environment will be ready to run the application

pip install -r requirements.txt

Comment below how you find virtulenv

Happy Learning !

1B+ Downloaded Docker Images on Dockerhub

Ashutosh Sharma — Sat, 28 May 2022 07:01:31 +0000

postgres

The PostgreSQL object-relational database system provides reliability and data integrity.

https://hub.docker.com/_/postgres
```
docker pull postgres
```
alpine

A minimal Docker image based on Alpine Linux with a complete package index and only 5 MB in size!

https://hub.docker.com/_/alpine
```
docker pull alpine
```
redis

Redis is an open source key-value store that functions as a data structure server.

https://hub.docker.com/_/redis
```
docker pull redis
```
nginx
NGINX is open source software for web serving, reverse proxying, caching, load balancing, media streaming, and more.

https://hub.docker.com/_/nginx
```
docker pull nginx
```
ubuntu
Ubuntu is a Debian-based Linux operating system based on free software.

https://hub.docker.com/_/ubuntu
```
docker pull ubuntu
```
node
Node.js is a JavaScript-based platform for server-side and networking applications.

https://hub.docker.com/_/node
```
docker pull node
```
mysql
MySQL is a widely used, open-source relational database management system (RDBMS).

https://hub.docker.com/_/mysql
```
docker pull mysql
```
postgres

The PostgreSQL object-relational database system provides reliability and data integrity.

https://hub.docker.com/_/postgres
```
docker pull postgres
```
busybox
Busybox base image.

https://hub.docker.com/_/busybox
```
docker pull busybox
```
python
Python is an interpreted, interactive, object-oriented, open-source programming language.

https://hub.docker.com/_/python
```
docker pull python
```
httpd
The Apache HTTP Server Project

https://hub.docker.com/_/httpd
```
docker pull httpd
```
mongo
MongoDB document databases provide high availability and easy scalability.

https://hub.docker.com/_/mongo
```
docker pull mongo
```
memcached
Free & open source, high-performance, distributed memory object caching system.

https://hub.docker.com/_/memcached
```
docker pull memcached
```
traefik
Traefik, The Cloud Native Edge Router

https://hub.docker.com/_/traefik
```
docker pull traefik
```
mariadb
MariaDB Server is a high performing open source relational database, forked from MySQL.

https://hub.docker.com/_/mariadb
```
docker pull mariadb
```
hello-world
Hello World! (an example of minimal Dockerization)
https://hub.docker.com/_/hello-world
```
docker pull hello-world
```
docker
Docker is a set of platform as a service (PaaS) products that use OS-level virtualization to deliver software in packages called containers.

https://hub.docker.com/_/docker
```
docker pull docker
```
registry

The Docker Registry 2.0 implementation for storing and distributing Docker images

https://hub.docker.com/_/registry
```
docker pull registry
```
rabbitmq
RabbitMQ is an open source multi-protocol messaging broker.

https://hub.docker.com/_/rabbitmq
```
docker pull rabbitmq
```
openjdk
"Vanilla" builds of OpenJDK (an open-source implementation of the Java Platform, Standard Edition

https://hub.docker.com/_/openjdk
```
docker pull openjdk
```
golang
Go (golang) is a general purpose, higher-level, imperative programming language.

https://hub.docker.com/_/golang
```
docker pull golang
```

Comment below how many have you used from these ?