Day: September 26, 2023

In this blog, you will take a closer look at Podman Desktop, a graphical tool when you are working with containers. Enjoy!

Introduction

Podman is a container engine, just as Docker is. Podman commands are to be executed by means of a CLI (Command Line Interface), but it would come in handy when a GUI would be available. That is exactly the purpose of Podman Desktop! As stated on the Podman Desktop website: “Podman Desktop is an open source graphical tool enabling you to seamlessly work with containers and Kubernetes from your local environment.”

In the rapidly advancing world of technology, staying updated with the latest trends and innovations is crucial for career growth and development. The year 2023 still holds a treasure trove of opportunities for developers and IT professionals to do just that. In the article, 'Conferences Developers Can Still Attend in 2023,' we explore a curated list of premier conferences, including AWS re:Invent, KubeCon, SingleStoreNow, QCon, SQL Server Live!, Microsoft Ignite, DevLearn, and TechBash.

Let's go over each conference one by one to understand them properly. 

Debugging is an integral part of software development. While we often discuss general strategies to tackle issues, it's essential to delve deeper into specific techniques that can enhance our debugging productivity. Here's a comprehensive guide to some core debugging tips and tricks.

As a side note, if you like the content of this and the other posts in this series, check out my Debugging book that covers this subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book.

The digital landscape is evolving rapidly, and with it, the way we search for information on the internet. Traditional text-based searches on search engines like Google are being supplemented and, in some cases, replaced by innovative technologies such as ChatGPT, Voice Search, and Image Search. These emerging technologies are transforming the way we interact with the digital world, making searches more efficient, user-friendly, and inclusive. In this article, we will delve into the workings of these cutting-edge search methods and explore how they are shaping the future of online information retrieval.

ChatGPT: Conversational AI Redefining Search

ChatGPT, or Chat Generative Pre-trained Transformer, is a breakthrough in artificial intelligence that enables machines to engage in natural language conversations with users. Developed by OpenAI, GPT-3 and its successors have revolutionized search by allowing users to interact with search engines in a more human-like manner. Here's how ChatGPT works:

If your environment is like many others, it can often seem like your systems produce logs filled with a bunch of excess data. Since you need to access multiple components (servers, databases, network infrastructure, applications, etc.) to read your logs — and they don’t typically have any specific purpose or focus holding them together — you may dread sifting through them. If you don’t have the right tools, it can feel like you’re stuck with a bunch of disparate, hard-to-parse data. In these situations, I picture myself as a cosmic collector, gathering space debris as it floats by my ship and sorting the occasional good material from the heaps of galactic material.

Though it can feel like more trouble than it’s worth, sorting through logs is crucial. Logs hold many valuable insights into what’s happening in your applications and can indicate performance problems, security issues, and user behavior. In this article, we’re going to take a look at how logging can help you make sense of your log data without much effort. We'll talk about best practices and habits and use some of the Log Analytics tools from Sumo Logic as examples. Let’s blast off and turn that cosmic trash into treasure!

There is no doubt that the cloud has changed the way we run our software. Startups, for instance, can get started without buying expensive hardware and scale flexibly. Also, the cloud has enabled novel solutions such as serverless, managed Kubernetes and Docker, or edge functions. For a time, cloud-native applications seemed to be the way forward for most teams, big or small.

But in exchange for all this power, we pay a cost. And it can be a steep one. 37signals — the company behind HEY.com and Basecamp.com — has calculated that by buying a few servers and moving from the cloud to on-premise, they can save 7 million dollars over 5 years.

Lost in Communication and Collaboration addresses two categories from the Scrum anti-patterns taxonomy that are closely aligned: ineffective collaboration at the stakeholder level, often resulting in an unsuited reporting system based on misaligned metrics.

Learn how these Scrum anti-patterns categories manifest themselves and how they affect value creation for customers and the organization’s long-term sustainability.

In this tutorial, we will explore how to automate database operations using Ansible and DbVisualizer. Ansible is a powerful automation tool that allows you to define and manage infrastructure as code, while DbVisualizer is a feature-rich database management tool that enables you to interact with various databases. By combining these two tools, Ansible automates repetitive database tasks and streamlines your workflows, while DbVisualizer helps you visualize your database during the process. We will cover the installation and configuration of Ansible and DbVisualizer and demonstrate how to automate common database operations using Ansible playbooks.

Prerequisites

1. Basic knowledge of databases and SQL.
2. Familiarity with Ansible concepts and syntax.
3. Access to a target database server.
4. Python 3.7 or later
5. PyMySQL installed using pip install PyMySQL
6. [DbVisualizer]

We’ll start by telling you a couple of things about Ansible and then tell you how to automate your database operations. Follow along!

The Modbus protocol is a communication protocol that allows devices to communicate over various types of media, such as serial lines and ethernet. It was developed in 1979 by Modicon, a company that produced Programmable Logic Controllers (PLCs), to enable these devices to communicate with each other.

Modbus provides a messaging structure designed to establish master-slave communication between intelligent devices. A Modbus message sent from a Device A (master) will initiate a response from Device B (slave). The function of the Modbus protocol is to define the content of the communication, how the information is packaged, and the order in which messages are sent and received.

Containerization is the modern solution to a cross-platform deployment where the entire application lives inside a container that deploys on different machines. Single containers work perfectly for simple applications, but with a micro-services architecture, each service requires a separate container. 

However, managing multiple containers can be cumbersome, which is why you have container orchestration tools that aid container communication, health monitoring, and management, as well as security protocol processes.

Redux is a popular state management library used with React and React Native to manage the application's state efficiently. While Redux provides many benefits, it can also present some challenges, especially when used in the context of React Native mobile app development. In this blog, we'll explore some common problems developers encounter when using Redux with React Native and how to address them.

1. Boilerplate Code

Redux is known for its boilerplate code, which can be extensive. React Native projects tend to benefit from lean and concise codebases, so Redux's verbosity can be overwhelming. To mitigate this issue, consider using libraries like Redux Toolkit, which simplifies the setup and reduces boilerplate code.

This is an article from DZone's 2023 Database Systems Trend Report.

For more:

Read the Report

Hearing the vague statement, "We have a problem with the database," is a nightmare for any database manager or administrator. Sometimes it's true, sometimes it's not, and what exactly is the issue? Is there really a database problem? Or is it a problem with networking, an application, a user, or another possible scenario? If it is a database, what is wrong with it? 

This article is a sponsored by Neon Tech

Branching off to make code changes is a tried and tested approach to software development, but why should database development be any different? Well, branching with Neon allows you to make changes to your database without affecting the production environment. If you’re familiar with Git, you’ll feel right at home.

For demonstration purposes, and to explain how branching works, I’ll use a typical “contact us” form and make a “fictional” change.

The form currently submits the following fields.

• name
• email_address
• company_website
• company_size
• message

The form works by sending the form data using a client-side request to a Vercel Edge Function, which in turn securely connects to a Neon Serverless Postgres database.

Here’s a snippet of the client-side fetch request.

const handleSubmit = async (event) => {
  event.preventDefault();

  const data = Object.fromEntries(
    new FormData(event.currentTarget).entries()
  );

  try {
    await fetch('/api/submit', {
      method: 'POST',
      body: JSON.stringify({ data }),
    });
  } catch (error) {
    console.error(error);
  }
};

And here’s a code snippet of the Edge Function that destructures the form values from the request body and INSERTs them into a table named contact_us.

import { neon } from '@neondatabase/serverless';

export default async function handler(req) {
  const {
    data: { name, email_address, company_website, company_size, message },
  } = await new Response(req.body).json();

  const sql = neon(process.env.DATABASE_URL);

  try {
    await sql`INSERT INTO contact_us 
        (name, email_address, company_website, company_size, message)
            VALUES(
      ${name},
      ${email_address},
      ${company_website},
      ${company_size},
      ${message}
        );`;

    return Response.json({
      message: 'A Ok!',
    });
  } catch (error) {
    return Response.json({
      message: 'Error',
    });
  }
}

export const config = {
  runtime: 'edge',
};

The change I’d like to make will happen “behind the scenes”, and along with information entered by the user, I also want to capture and store the geographical location of where in the world the form was submitted.

To do this I’m going to use Vercel’s geolocation helper function from the @vercel/edge package. The changes I’ll be making will affect both the Edge Function and the database table schema.

I don’t want to change the table schema on the live production database until I’ve tested it all works correctly, and thanks to branching, I don’t have to.

Here’s how I’d go about making a change of this nature.

Neon has a super cool browser console (just look at it! 😍), and all database changes can be made, and tested in the browser, no messing around with a dweeby-looking terminal window!

1. The project is called branching-sample.
2. The primary branch name is main.
3. To create a branch, click this button.

Clicking “Create branch” will take you to the next screen where I’ll configure the new branch.

1. This will be the name of the new branch. Typically I’ll name the branch the same as the Git branch. (I’ll show you that shortly).
2. This is the parent branch that I want to “branch off” from. Normally it’s always going to be main, but in some cases, I might branch off from another branch.

3. These are the branch configuration options. For this demonstration, I’ll be branching using the Head option. There are a number of reasons why branching from a specific point in Time, or LSN are more suitable. E.g, In cases where you might be performing a backup, or debugging an issue and want to see “when things went wrong”.

   1. Head: Creates a branch with data up to the current point in time.
   2. Time: Creates a branch with data up to the specified date and time.
   3. LSN: Creates a branch with data up to the specified Log Sequence Number (LSN)
4. In order to test the changes I’ll be making in the Edge Function (which I’ll explain in a moment), I’ll want to ensure I’m inserting data correctly. By creating a compute endpoint with the branch, I can do this without worrying that I’ll be messing up the production database!
5. A button that will create the new branch

Clicking “Create the branch” will take you to the next screen.

This is where things get really, really cool!

1. This is a new connection string for an entirely new database, and it was set up almost instantly and contains “real” data! A key point to communicate is that any data pushed to this branch won’t appear in the production environment, but this “copy” of the database will be identical to the production database, in line with where you branched off from, in my case, Head.
2. The copy button allows you to quickly copy the connection string.

Using the handy little “copy” button, I can copy the new connection string and add it to my .env file.

1. This is just my preferred approach of course but, in my .env file, I comment out the production database connection string, and add a new variable using the same name of DATABASE_URL. I then add a comment above it with the name of the branch I used in the Neon console. And for what it’s worth, my Git branch is also named the same way.

I’ve found this to be super helpful when I have multiple branches on the go at the same time. That one little comment above the connection string helps me identify which branch it relates to in the Neon console.

Before going too much further I like to double check I’m viewing the correct branch in the Neon console. If you’ve followed the steps above you should be able to see your new branch when selecting “Branches” from the navigation.

1. Yep, this is the new branch I created.

Clicking the branch name will take you to the next screen.

1. From the SQL Editor, you can also switch between branches which makes it easy to run queries against different branches.

Before making any changes to the code I prepare the database and test it all works by running SQL commands directly in Neon’s SQL Editor.

Show the current table schema

To work out what the current schema for the contact_us table looks like, I can navigate to “Tables” in the navigation and see the schema for the table.

1. Showing the branch you’re currently on.
2. The schema for the contact_us table.

I know the change I want to make will require that I add two new columns which will store geolocation data. The two new column names will be as follows.

1. country_code
2. city

ALTER the table

To add the new columns I use the following SQL command.

ALTER TABLE contact_us 
ADD COLUMN country_code VARCHAR,
ADD COLUMN city VARCHAR;

1. Using the ALTER TABLE command I’m adding both the above-named columns and giving them a data type of VARCHAR.

To double-check check the changes were made correctly I can head back over to “Tables” and take a look at the table schema again.

1. Showing the branch you’re currently on.
2. The city and country_code columns have been added to the schema for the contact_us table.

Now that I know the table is configured correctly, I’ll head back to the “SQL Editor” and run a quick INSERT to check there are no errors.

1. INSERT statement to add a row which includes values for the new country_code and city column.
2. Confirmation the request was successful.

If I SELECT * FROM contact_us, I’ll see the row I added will contain the country_code and city columns.

1. A new row has been added with the correct values for country_code and city.

This test data will only be added to the branch, not the production environment, so you can safely run as many tests as you like without polluting the “real” data.

With the change confirmed to be working, I can now switch back to the main branch, and run the ALTER command from earlier.

This will apply the changes to the production database!

ALTER TABLE contact_us 
ADD COLUMN country_code VARCHAR,
ADD COLUMN city VARCHAR;

I can double, double check this worked by going to “Tables” again in the console. If all is ok, I can safely delete the development branch: feat/geolocation-data and move on to making the required changes to my Edge Function 🎉

The values I’ll be adding to the INSERT statement can be extracted from incoming requests to an Edge Function. To access these values I'll use the geolocation helper function from the @vercel/edge package.

To use this package, I’ll first need to install it.

npm install @vercel/edge

I can then use it in my Edge Function. Here’s a diff of the change. You can see the full diff for the PR on my GitHub here.

import { neon } from '@neondatabase/serverless';
+ import { geolocation } from '@vercel/edge';

export default async function handler(req) {
  const {
    data: { name, email_address, company_website, company_size, message },
  } = await new Response(req.body).json();

+  const { country, city } = geolocation(req);

  const sql = neon(process.env.DATABASE_URL);

  try {
    await sql`INSERT INTO contact_us (
        name,
        email_address,
        company_website,
        company_size,
        message,
+       country_code,
+       city
       )
     VALUES(
       ${name},
       ${email_address},
       ${company_website},
       ${company_size},
       ${message},
+      ${country},
+      ${city}
      );
     `;

    return Response.json({
      message: 'A Ok!',
    });
  } catch (error) {
    return Response.json({
      message: 'Error',
    });
  }
}

export const config = {
  runtime: 'edge',
};

One snag with this package when testing locally is, both the country and city will be null. The geolocation function will only return actual values when the Edge Function has been deployed. ☝️

And that’s it, brrrrranches!

Branches are a really nice (and safe) way to configure or reconfigure your database without fear of screwing up the production database, and in my experience, branches can really help speed up development time, and it doesn’t matter how many test INSERTs I run, test data will always remain on the branch and will never affect the production environment.

If you’d like to try Neon today, pop over here and sign up: neon.tech, you might also want to sneak a peak at our getting started guides:

• Sign up
• Create your first project
• Query with Neon’s SQL editor