DEV Community: Writech

DbVisualizer 24.2: A Complete Review

Antonello Zanini — Mon, 23 Sep 2024 14:01:52 +0000

Discover what DbVisualizer 24.2 has to offer in this in-depth review and learn why it represents the biggest DbVisualizer release to date

DbVisualizer 24.2 marks a major step for the database client with the highest user satisfaction rate on the market, taking it to the next level thanks to a refined user interface and many other improvements.

In this review, you’ll discover why DbVisualizer underwent a UI redesign, what new features and improvements version 24.2 has introduced, and how to try this latest release.

Let’s find out what an experienced developer and database administrator thinks of DbVisualizer 24.2 in my review!

The Need for a Restyling of DbVisualizer

As you may already know, DbVisualizer has been the database client of choice for years according to top companies, government agencies, and individual developers.

According to the official site, over the years, more than 6 million users have downloaded the software, and more than 28,000 companies spanning 145 countries are currently using the commercial Pro version.

The company proudly states that Tesla, NASA, Apple, Netflix, and many other leading companies have chosen DbVisualizer for their database operations.

No surprise, over 216 users on G2 and more than 96 users on Capterra have given it top-notch positive reviews. With a rating of 4.6/5 on G2 and 4.8/5 on Capterra, DbVisualizer has the highest user satisfaction rate in the market. Try DbVisualizer, and you’ll agree with them!

The secret of its success? Well, it must be the support for more than 50 databases and a Java core, which makes the tool multi-platform and extremely reliable.

However, in my opinion as an experienced developer, what sets DbVisualizer apart from other database clients is its extensive range of capabilities. The software offers a stunning number of utilities, options, and functionalities, appealing to both beginners and professional database administrators with years of experience. That’s impressive!

Actually, you can easily tell that the development team behind DbVisualizer has focused their efforts on providing robust, powerful, easy-to-use, and time-saving features.

With DbVisualizer 24.2, the team appears to have put the same dedication into improving the UI and UX, aiming to elevate the database client we all love to the next level.

Time to find out more about this new version of DbVisualizer!

DbVisualizer 24.2: The Biggest Update So Far

Released in June 2024, DbVisualizer 24.2 has been presented as the most significant update in the history of DbVisualizer (as of this writing, at least).

This new version introduces numerous changes, with the most noticeable being the revamped user interface:

As you can see, that’s definitely a remarkable improvement!

The new UI now appears more intuitive, modern, and user-friendly. In addition to the impressive new interface and updated themes, the 24.2 release introduces:

7 new features
17 improvements
11 bug fixes

These additions include support for persistent connections via the dbviscmd CLI tool, dedicated actions to select the previous/next statement in the SQL editor, support for Azure Synapse Analytics, enhanced autocomplete capabilities, full support for roles in PostgreSQL, automatic theme switching, support for Databricks, and many others. Those are a lot of new features!

Discover all the changes provided by DbVisualizer 24.2 in the release notes.

What’s New in DbVisualizer 24.2?

Easy question! Just have a look at the summary table below. You’ll discover the most important changes introduced in this major release of DbVisualizer:

Type	Title	Description
New Feature	UX/UI	Full window support on macOS. Automatic theme switching, new dark and light themes, new scalable icons
New Feature	Command Line Support (`dbviscmd`)	Add support for creating persistent database connections using `dbviscmd`
New Feature	DB Support: Azure Synapse	Add support for Azure Synapse Analytics
New Feature	DB Support: Databricks	Add basic support for Databricks
New Feature	DB Support: MariaDB/Oracle	Navigate between procedures and functions in the package body editor
New Feature	Export	Add support for generating `MERGE` statements when exporting data as SQL and for trimming text values when exporting data
New Feature	SQL Editor	Add actions to select the previous/next statement in the editor (`Ctrl+Alt+Up/Down`)
Improvement	Auto-Completion	Automatically qualify columns when the column name alone is ambiguous
Improvement	Cell Viewer/Editor/Grid Component	Add support for SVG images in the cell viewer and the data grid
Improvement	Create/Alter Table/DB Support: PostgreSQL	Add support for sequence names in auto-generated columns in PostgreSQL
Improvement	DB Support: PostgreSQL	Add support for roles in PostgreSQL (replacing users and groups)
Improvement	DB Support: Redshift	Add support for materialized views in Redshift
Improvement	General	Improved support for arrays
Improvement	Security	Add the option to reset the master password also when a master password is required
Bug Fix	Create/Alter Table/DB Support: PostgreSQL	`NOT NULL` can be omitted in the DDL for auto-generated columns in PostgreSQL
Bug Fix	DB Support: ClickHouse	Can't list databases in older versions of ClickHouse
Bug Fix	Export/Import User Settings	Passwords are not included when exporting/importing SSH configurations
Bug Fix	Query Builder	When loading a query containing an unsupported operator into the query builder, it’s replaced with "="

Let me now review each of the most interesting changes introduced by DbVisualizer 24.2!

A Fresh New UI

In release 24.2, DbVisualizer’s UI has been significantly refined. As the GIF below suggests, that’s not just a color adjustment but a complete UI overhaul.

According to the release notes, the goal of the development was to create a balanced work environment for both light and dark theme users:

Well, I think they achieved their goal brilliantly! The new UI just looks fresh and intuitive.

The dark theme has become darker, and the light theme has become lighter, with DbVisualizer that can now automatically match the dark or light setting of your OS.

You can tell that the team worked hard to balance the look and colors, as well as introduce small improvements to margins around elements and line heights in lists.

Another improvement made by the team in DbVisualizer 24.2 is a new set of icons. They replaced the old icons with modern and scalable SVG icons, ensuring they look good on any screen and resolution settings:

To avoid disappointing or disorienting DbVisualizer veterans, the organization of UI elements remains largely unchanged. Only the placement of some buttons has been improved to enhance usability and make daily use more intuitive. (Thank you for considering us, DbVisualizer team!)

Check out the docs to see how to get the most out of the new UI.

Improved Database Support

Below are the database support improvements added in version 24.2:

Azure Synapse Analytics: DbVisualizer now has extended support for dedicated and serverless SQL pools in Azure Synapse Analytics. That includes support for database-scoped credentials, external file formats and data sources, and external tables. For more information, see the Azure Synapse Dedicated and Azure Synapse Serverless pages on the official site.
Cassandra: Added support for the JDBC wrapper of the Java driver for Cassandra, which is more powerful and future-proof than previous alternatives. Moreover, other Cassandra-related improvements have been implemented, such as support for overloaded functions and error marking in the Procedure Editor.
Databricks: Introduced basic database support for Databricks, with a pre-defined entry for Databricks in the driver manager for simplified setup.
Greenplum: Database integration extended to Greenplum 7, including adjustments for partitioned tables, generated columns, constraints, procedures, functions, aggregates, and sequences.
MariaDB: New navigation panel added to the Package Body Editor, making it easier to navigate between procedures and functions in a package.
MySQL: Added the possibility to create and update generated columns in the Create Table and Alter Table dialogs.
Oracle: The same improvement added for MariaDB has also been introduced for Oracle.
PostgreSQL: Support for PostgreSQL has been extended to include role management. Also, users can now specify the sequence name when defining auto-generated columns.
Redshift: Added support for materialized views in Redshift.
Snowflake: Introduced support for additional table types in Snowflake, including dynamic tables, event tables, hybrid tables, and iceberg tables.

Enhanced Data Export Options

Among the tons of features supported by DbVisualizer is the ability to export databases/schemas and tables.

The first option is ideal for exporting DDL for objects such as tables, views, procedures, functions, triggers, packages, and package bodies in a database/schema. The second option is instead dedicated to exporting table data in various formats, including as an SQL file or to the system clipboard.

With DbVisualizer 24.2, when exporting data in SQL format, users can now select between INSERT statements and MERGE statements:

Compared to INSERT statements, MERGE statements allow for the merging of data from the source table to the target table.

That ensures that existing rows in the target table are updated, while new rows are inserted, offering an efficient and robust way to synchronize data between tables.

Support for text functions has also been added to the data export dialog. When selected, the text function will be applied to all text columns that are exported. Currently, the available options are:

Keep the text as is
Trim both ends
Trim the right end
Trim the left end

Another tweak introduced in the new version of DbVisualizer I found amazing is that, when exporting data to a file,** the correct filename extension is now appended automatically depending on the selected output format**.

When the user selects a format, the export file name is updated accordingly with the appropriate extension. That saves you a lot of unwanted errors, trust me!

As an additional improvement, when previewing the export in SQL format, syntax highlighting is also applied to the generated code to make it easier to read.

Refined SQL Editor

As all DbVisualier users know, one of its most beloved features is its fully-featured SQL editor.

In release 24.2, tthe editor has been further improved with several enhancements:

Advanced substitution in Find and Replace: The Find and Replace panel now includes buttons to add newlines and supports literals \n and \t. Also, it accepts \L and \U for lowercase and uppercase manipulation, respectively.
Smarter auto-completion: When auto-completing column names, these will now be automatically qualified if the column name alone is ambiguous. See the details in the documentation.
Select next/previous statement: Added support for the CTRL+ALT+UP and CTRL+ALT+DOWN shortcuts to select the next and previous statements in the current SQL script, respectively.
Support for a list of choices in custom variables: Introduced the possibility of defining variables with a list of available values for advanced scripting.

Other Changes Worth Mentioning

While I would love to dig into each of the updates and improvements added by DbVisualizer 24.2, they’re just too many. Thus, here are some other noteworthy changes:

Improved support for arrays: DbVisualizer now supports a JSON-based syntax for presenting and editing arrays. Additionally, it has extended support for understanding the content and structure of array objects. This enables you to validate the input before sending data to the database.
Uncommitted SQL statements: When warning about auto-commit being turned off, DbVisualizer now displays which statements will be committed as a result of the commit.
Special characters in text fields: Newlines and tabs in text fields are now rendered as symbols in the Data grid.
Images in the Data grid: Binary columns containing SVG images are now displayed in the Data grid. The team has also implemented multi-threading rendering for faster image loading.
Persistent database connections via CLI: The DbVisualizer CLI now supports the creation of persistent database connections via the command line.

To learn how to make the most of all new features, check out DbVisualizer 24.2 User Guide.

Is 24.2 the Best Version of DbVisualizer?

Yes, I have no doubt that version 24.2 is the best release of DbVisualizer ever!

That’s clear when you consider the pros and cons of this new version:

👍 Pros:

A fresh, modern UI
New SVG icons
Over 10 bug fixes for a more reliable experience
Support for Azure Synapse Analytics
Improved SQL editor
Enhanced autocomplete capabilities
Improved support for arrays
New data export options
Persistent connections via dbviscmd in the command line
Basic support for Databricks
Support for SVG images in the Data view
Improved Find and Replace feature
New shortcuts

👎 Cons:

Adapting to the new UI might take some time

The list of advantages outweighs the drawbacks. The only notable disadvantage is the adaptation to the new UI, which might throw into confusion some veteran users (like me). Still, that’s the inevitable price to pay for a revamped and more modern user interface.

At the end of the day, our habits as users change as technology evolves, and software UIs must evolve accordingly.

The good news is that the team has introduced other tweaks and UX optimizations to greatly reduce the feeling of disorientation. Surprisingly, the new UI just feels familiar. Give it a try, and you'll see what I mean!

How To Try DbVisualizer 24.2

If you’re already a DbVisualizer user, simply upgrade the software to the latest version. If you need assistance with this process, refer to the guide in the official documentation.

If you want to test DbVisualizer 24.2 as a new user, you can download it for free. That’ll give you access to essential features, documented in a helpful User Guide and an active Community forum.

To access all DbVisualizer features, consider that you need to upgrade to the Pro plan. Upon purchase, you’ll also receive additional guidance from the development team for the first 60 days.

For enterprises, businesses, and individuals needing priority assistance throughout the subscription period, there’s a special Pro plan available.

For more details, visit the pricing page on the official website or explore the comparison between the Free and Pro plans.

To test all the features of the Pro version, you can also evaluate DbVisualizer tool for 21 days via a free trial.

Final Verdict

In this review, I had the chance to try out DbVisualizer 24.2 and see why it’s a huge leap forward for one of the most loved database clients out there.

The development team didn’t just build on its already great features—they’ve also polished the user interface to meet modern standards of usability and style. This perfect mix of functionality and design keeps DbVisualizer at the top for both seasoned pros and newcomers in the database world.

If you’re excited to explore DbVisualizer 24.2 further, check out the links below:

I can confidently say that version 24.2 is the best DbVisualizer has ever been. Whether you’re upgrading from an older version or checking it out for the first time, now is a great time to experience its new features.

Review score: 9.5/10

How to Define a Counter in MySQL

Antonello Zanini — Fri, 09 Aug 2024 13:40:45 +0000

The simplest way to identify an object in a database is to assign it a unique integer, as it happens with order numbers. Not surprisingly, most databases support the definition of auto-incremental values. Essentially, an incremental value is just a counter used to uniquely identify an entry in a table. Well, there are several ways to define a counter in MySQL!

In this article, you will understand what a counter is, where it is useful in a database, and how to implement it in MySQL.

Let's dive in!

What Is Counter?

In programming, a counter is a variable used to keep track of the number of occurrences of certain events or actions. In most cases, it is used in a loop to increment a numerical value automatically and keep track of the number of iterations. This is why counters are generally associated with the concept of auto-incremental numbers.

In databases, a counter is commonly used to generate unique identifiers for records, such as sequential numbers for primary keys or tracking numbers for events.

MySQL provides the AUTO_INCREMENT attribute to automatically increase a column value by one with each new record. However, this attribute only increments values by one unit at a time. For more customized behavior, you might need to manually define a MySQL counter.

Reasons to Use a Counter in MySQL

These are the top 5 reasons why using a counter in MySQL:

Create unique identifiers: Sequential values are ideal for primary keys to ensure data integrity and consistency.
Enhanced data management: Automatically incremented counters help to sort and identify records.
Simplified data entry: Automatic unique ID generation reduces manual entry errors and simplifies the data insertion process.
Efficient record tracking: Counters make it easier to track and manage records. That is particularly true in applications where sequential or unique numbering is critical, such as order processing or inventory management.
Customizable formats: By using counters with custom formats, you can create meaningful identifiers that provide context and organization to your data.

Defining a Counter in MySQL

Explore the two most common approaches to defining counters in MySQL.

Note: The MySQL sample queries below will be executed in DbVisualizer, the database client with the highest user satisfaction in the market. Keep in mind that you can run them in any other SQL client.

Using AUTO_INCREMENT

By marking a column with the AUTO_INCREMENT attribute, MySQL will automatically give it an incremental value when inserting new records. This ensures that each entry has a unique, sequential identifier.

Consider the following example:

CREATE TABLE employees (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50),
    surname VARCHAR(50),
    email VARCHAR(100),
    role VARCHAR(50)
);

The above query creates an employees table with an AUTO_INCREMENT primary key id.

Now, suppose the employees table already contains these 5 records:

To add three more records, use the following INSERT query:

INSERT INTO employees (name, surname, email, role) VALUES
('Frank', 'Miller', 'frank.miller@example.com', 'Developer'),
('Grace', 'Davis', 'grace.davis@example.com', 'Manager'),
('Hank', 'Wilson', 'hank.wilson@example.com', 'Designer');

employees will now contain:

Note that the id column of the new records has been populated with an incremental value by default. In particular, you can omit the AUTO_INCREMENT column in the INSERT statement (or set it to NULL), as MySQL will populate it for you.

Note that the AUTO_INCREMENT attribute only works on integer PRIMARY KEYs. Additionally, AUTO_INCREMENT values are always incremented by one unit at a time. Check out this guide to find out more about numeric data types in MySQL.

To customize the behavior of AUTO_INCREMENT, you can use the following variables:

auto_increment_increment: Defines the increment step for the AUTO_INCREMENT values. The default value is 1.
auto_increment_offset: Sets the starting point for the AUTO_INCREMENT values. For example, setting it to 5 will make the first AUTO_INCREMENT value start from 5.

At the same time, these variables apply to all AUTO_INCREMENT columns in the database and have either global or session scope. In other words, they cannot be applied to individual tables.

The following approaches will give you more flexibility when defining counters in MySQL.

Using a Variable

A simple approach to creating a custom counter in MySQL is to use a user-defined variable.

Now, suppose you want each employee to have an internal auto-incremental ID in the following format:

Roogler#<incremental_number>

Add an internal_id column to employees:

ALTER TABLE employees
ADD COLUMN internal_id VARCHAR(50);

Then, you can achieve the desired result with the following query:

-- initialize the counter
SET @counter = 0;

-- update the internal_id column with the formatted incremental values
UPDATE employees
SET internal_id = CONCAT('Roogler#', @counter := @counter + 1);

This uses a variable to implement the counter and the CONCAT function to produce the internal ID in the desired format.

Note that the starting value and the way you increment the counter are totally customizable. This time, there are no restrictions.

Execute the query in your MySQL database client:

Note that DbVisualizer comes with full support from MySQL variables.

If you inspect the data in the employees table, you will now see:

Wonderful! Mission complete.

The main drawback of this solution is that user-defined variables in MySQL are session-specific. This means that their values are only retained for the duration of the current session. So, they are not persistent across different sessions or connections.

For a more persistent solution, you could use a stored procedure along with an SQL trigger to automatically update the internal_id every time a new employee is inserted. For detailed instructions, see this article on how to use stored procedures in SQL.

Conclusion

In this guide, you saw what a counter is, why it is useful, and how to implement it in MySQL. You now know that MySQL provides the AUTO_INCREMENT keyword to define incremental integer primary keys and also supports custom counter definition.

As learned here, dealing with auto-incremental values becomes easier with a powerful client tool like DbVisualizer. This comprehensive database client supports several DBMS technologies, has advanced query optimization capabilities, and can generate ERD-type schemas with a single click. Try DbVisualizer for free!

FAQ

How to count records in MySQL?

To count records in MySQL, use the COUNT aggregate function as in the sample query below:

SELECT COUNT(*) FROM table_name;

This returns the total number of rows in the specified table. When applied to a column, COUNT(column_name) counts all non-NULL values in the specified column.

What is the difference between COUNT and a counter in MySQL?

In MySQL, COUNT is an aggregate function to calculate the number of rows in a result set. Instead, a counter is a mechanism used to generate sequential numbers. COUNT is used for aggregation and reporting, whereas a counter is employed to assign a unique identifier or track the order of records as they are inserted into a table.

Should I use AUTO_INCREMENT or define a custom counter in MySQL?

Use AUTO_INCREMENT when you need an automatic way to generate sequential IDs for a primary key. On the other hand, if you require custom behavior—like specific formatting, starting values, or incrementing patterns—a custom counter implemented using a variable might be more appropriate.

How to define a variable in MySQL?

To define a variable in MySQL in a session, you must use the SET statement as follows:

SET @variable_name = value;

In this case, @variable_name is the variable and value is its initial value. This variable can be used within the session for calculations, conditions, or as part of queries. For local variables within stored procedures or functions, you need instead the DECLARE statement followed by SET:

DECLARE variable_name datatype;
SET variable_name = value;

Does DbVisualizer support database variables?

Yes, DbVisualizer natively supports more than 50 database technologies, with full support for over 30 of them. The full support includes database variables and many other features. Check out the list of supported databases.

The post "How to Define a Counter in MySQL" appeared first on Writech.

Best PostgreSQL GUI Tools

Antonello Zanini — Sat, 15 Jun 2024 14:26:11 +0000

TL;DR: There are many database GUI tools available, but only a few of them have been designed specifically for PostgreSQL. If you want to manage your PostgreSQL databases effortlessly, you must adopt an advanced PostgreSQL GUI tool. Here, you can find a list of the four best PostgreSQL applications for you.

When the first version of PostgreSQL was released, the only way to access data was to run queries from the command line. As you can imagine, interacting with a database via the command line is something that only skilled users can do. This is because you need to know the PostgreSQL language in depth.

Over time, the needs of end users have evolved for developers, data scientists, and data analysts alike. As a result, several PostgreSQL GUI tools have entered the market, and you can now choose between many PostgreSQL clients.

If you've ever felt limited by your PostgreSQL GUI tool or never used one, this article might shed some light on which one to choose. This article will dig into the four best PostgreSQL GUI tools for developers. But first, let's take a look at why you should be using one and which criteria were considered while making the list.

Why You Need a PostgreSQL GUI Tool

Adopting a PostgreSQL GUI tool can bring many advantages to your data management process:

Visual feedback: Managing data visually in the tool makes everything easier and opens the databases to non-technical members of your team.
Better data management: A GUI tool specifically designed to handle PostgreSQL databases makes data management easier.
Scalability: You can use the same tools to connect to several PostgreSQL databases and manage them all.

Elements of a Good PostgreSQL GUI Tool

There are several aspects to consider when selecting and evaluating PostgreSQL GUI tools:

Most commonly used: The more people who adopt the tool, the more documentation there will be online. After all, it's easier to get support if a tool is backed by a large community. This is more likely to happen if the tool is available on all major operating systems.
Easy to use and learn: PostgreSQL is a complex technology, and this is why a GUI tool should make everything easier. A good PostgreSQL GUI tool should be easy to learn and should not require several hours of training.
Plugin support: The ability to extend the PostgreSQL GUI tool with plugins developed by the community makes it future-ready, as new features can be introduced into the tool at any time.
Customizable user interface: You should be able to customize the tool to fit your particular needs. The more customizable the user interface of a PostgreSQL GUI tool is, the better the resulting user experience will be.
Fast and reliable: The tool should be free of major bugs and ensure good performance without using too many resources. Non-technical team members may not be able to run a PostgreSQL GUI tool that requires several GB of RAM because they typically don't have hardware as powerful as technical team members.

Conclusion

A PostgreSQL client is an essential tool when it comes to data management. PostgreSQL clients are particularly important because they make databases simpler for non-engineer members of your team. Data is easier to use and understand, allowing your engineers to save time while supporting the team.

This article explained why you need a PostgreSQL GUI tool and how to identify a good one. You learned about four of the best PostgreSQL GUI tools on the market. TablePlus, OmniDB, and DbVisualizer support other database technologies and have excellent features to support PostgreSQL-based data management processes, while pgAdmin is the only tool officially supported by PostgreSQL developers. Keep in mind that the tool that suits you the best depends on your use cases. So, there is no real winner.

The post "Best PostgreSQL GUI Tools" appeared first on Writech.

Tech Blog on Your Site or on Medium / Dev.to?

Antonello Zanini — Sat, 02 Mar 2024 13:11:35 +0000

One of the most important aspects to consider before creating a tech blog is where to actually host it. Should you build a custom site on a brand-new domain, or should you opt for platforms like Medium, Dev.to, or Hashnode?

Also, if you are not a native English speaker, should you write in English or in your native language? Moreover, should your content be freely available to all users or under a paywall?

These are all good questions you must ask yourself before embarking on the journey of starting a tech blog. To help you sort out the doubts you might have, we asked Serena Sensini, an Italian tech popularizer and technical writer, author of several blog posts and even some books, to answer all those questions.

Let's dive into this interview and learn some great insights on opening a tech blog from a successful and experienced technical writer!

How to Build a Tech Blog According to Serena Sensini

Describe yourself in a few words

Enterprise Architect at Dedalus, and tech popularizer by night. I'm extremely curious, I like to deepen every topic I deal with and I get bored quite easily. I've worn lots of hats during my tech journey, working as a web developer, data scientist, tech lead, and being a trainer. In 2019, I also published my first book with an Italian publishing house about NLP with Python, and in the last 3 years, I've published 4 more books.

In the meanwhile, I've launched a blog called TheRedCode.it, where I post about daily bugs, use cases, and guides working in the tech sector, and where I interview amazing experts to make the digital world more human-friendly.

Why did you decide to start blogging about technical topics?

I'm not a huge fan of religion, but I strongly believe in karma: one good action can come back in a moment of your life that you'll really need, and that's what I hope for my blog.

During my career, I've received a lot from the local tech communities I've been participating in, in terms of knowledge and invested time. I met some amazing people who helped me gain confidence and increase my skills with their collaboration, and that made me the person I am now. Lots of the hard skills I've learnt during these years have been possible by having access to different blogs, forums (oh, the dear old times), and through communities that made available different kinds of resources to train on topics such as developing and architecting software.

Giving back to the future generation has been my number one reason to start my blog and publish content every week: I wanted to thank those who helped me become who I am and help the future "me's" to grow as much as possible having access to free resources that can be used to solve that problem at work which made them crazy, or just to get in touch with a topic that has been really tough for a long time.

How much has having a technical blog impacted your career?

I'd say a lot: in terms of communication, it has been challenging to make myself able to explain topics that could be easy to understand, but really painful to explain for those who haven't been actively working on them. I've used this opportunity to stimulate my curiosity and delve into some topics I've been really keen on, but not having time to study.

Carving out some time to study architecture patterns, rather than to learn a new language or read some publications, has been the perfect chance to grow my skills and be always on the ball with the latest technologies available in our market.

Most developers start their blogs on platforms like Medium, Dev.to, or Hashnode. Why did you opt for a tech blog on a brand-new domain instead? And why did you choose to write technical content in your native language?

That's a good question…

To be honest, I wanted something unique, and I wanted to experiment a little bit with having a brand-new platform to work with. When I started, I just wanted to share my work and my experience with different kinds of use cases, mainly because I'm used to taking lots of notes when I work and I'm into troubleshooting. I try to describe through schemas and words the reasoning I make to solve the problem, and then I use those to do some reverse engineering and build a post.

Medium, Dev.to, and so on are very well-known international platforms for those who work with technology, but one of the biggest issues in Italy is due to the language barrier: to be able to fully understand some topics, your English level must be at least a B2/C1, in terms of certification, and that's not always possible. Especially for those who've been working for more than 10 years, English has not always been a priority, and it can be more difficult for those who are starting now on this amazing journey.

Writing in Italian, on my own website, and having the chance to grow little by little my audience has given me the chance to meet all those incredible people who read my posts and share their doubts, suggestions, and knowledge. I wanted to build something little starting from scratch and have the opportunity to see it grow step by step.

You must have learned a lot during these years of technical blogging in your native language. Any regrets, mistakes, or lessons learned you would like to share?

"Basic" content is underestimated: sometimes people reach me to ask for help on topics I may have considered trivial, forgetting that I've been in their shoes some time ago. For this reason, I've been posting on different topics dealing with different kinds of difficulties, taking into consideration those who can be a challenge for those who are starting to work with them.

Another important lesson: I'd have liked to be more prepared on social media marketing, for sure, and I'd have liked to give more credit to those people who work with them. I've always underestimated how time-consuming it is to be updated on how social media works and how you can take advantage to make your work successful.

What advice would you give to someone who would like to follow your path and start a technical blog?

Being consistent is the key, and being curious is the door to amazing opportunities.

Should technical content be monetized (e.g., behind a paywall), or should it be free?

It depends: I'm really into open source and I believe in open source initiative as a driver to make our world a better place; let's say that my blog, aside from the reasons I've explained before, is a volunteer work. I use my free time to invest in studying or reviewing my work in order to share it: if only one person can solve their problem or learn a new skill, I'm grateful, and that couldn't be paid.

That's certain that content of such level, along with the hosting and the hardware costs, must be paid: since I'd like to keep this project as free as possible, I'm always looking for donations and support from communities and companies that can be hosted on the blog (following different conditions) to make it self-substantial.

Anything in particular you would like to bring attention to in the IT community?

Never underestimate the work that's behind the scenes of technical topics: it requires a lot of time to write, represent, and test what you've been reading, especially if it's dealing with some latest technologies. It can be hard, it can be challenging, but it's totally worth it.

Serena, thanks for your time. It was a pleasure to have your insights on building a technical blog. Where can readers find you?

Conclusion

Should you start a technology blog on your site or on Medium, Dev.to, Hashnode, or a similar platform? Well, it depends...

As explained by Serena Sensini, a corporate architect and passionate tech writer, if you are looking to build something unique and want to experiment with managing a new site or target a local community, then you should opt for a new domain. On the other hand, if you aspire to engage with an international community of developers, then Medium, Dev.to, and Hashnode are all good options.

Thank you for reading! We hope this interview will help you make an informed decision when it comes to starting your tech blog.

The post "Tech Blog on Your Site or on Medium / Dev.to?" appeared first on Writech.

How to Store Spring Boot Application Metrics in InfluxDB

Antonello Zanini — Sat, 02 Mar 2024 13:11:31 +0000

Spring Boot is rapidly becoming one of the most popular frameworks for building web applications and microservices because it supports declarative programming, can be configured extensively, and has a large community of users ready to help.

In particular, Spring Boot is generally used in enterprises because it's considered one of the most reliable technologies on the market. Specifically, it offers several ways to track events and metrics and monitor what's happening through the Spring Boot Actuator.

In this tutorial, you'll learn how to build a Java web application with Spring Boot that collects metrics via the Micrometer library and automatically sends them to an instance of InfluxDB, the ideal database for storing this type of data.

Creating a Spring Boot App to Collect Application Metrics

As previously stated, in this article, you'll learn how to create a Java Spring Boot web application to collect metrics and send them to InfluxDB. Before you begin this tutorial, you'll need the following:

A valid InfluxDB instance or access to InfluxDB Cloud. (If you don't have this, you can learn how to set it up in the next section.)
The Java JDK version 8 or newer installed on your system.
An integrated development environment (IDE) of your choosing.

These are prerequisites for building a Spring Boot web application to manage a publication. This application will expose APIs that allow publication editors to retrieve, create, update, and delete draft posts received from their authors. In addition to providing access to these features, the demo application will use Micrometer to store some useful log metrics in InfluxDB.

If you want to test the demo application you're going to learn how to build, clone the GitHub repository supporting this tutorial with the following command:

git clone https://github.com/Tonel/influxdb-spring-boot-demo

Then run the DemoApplication main class by following this guide in the Spring Boot official documentation.

Now it's time to build the demo application.

Set Up InfluxDB

If you don't have access to an InfluxDB database instance, you can set up an InfluxDB account in order to enter InfluxDB Cloud. This gives you access to an InfluxDB database on the cloud for free:

Fill out the sign-up form and continue following the prompts. Select your cloud provider and region, enter your company name, accept the service agreements, and select Continue:

At this point, you can choose from three different plans. The free plan is sufficient to build the demo application:

Once completed, you'll have access to the InfluxDB platform:

In the left bar, hover over the Load Data event and select API Tokens:

Once selected, you should see the following:

Click + GENERATE API TOKEN > All Access API Token and click Save. An alert containing your API Token should appear:

Select COPY TO CLIPBOARD and store your API Token in a safe place, as you'll need it later on.

Set Up an InfluxDB Bucket

Now it's time to set up your first InfluxDB bucket. In the bar on the left, hover over the Load Data element again, but this time, select Buckets:

Now you should see the bucket management panel:

Click on + CREATE BUCKET in the upper-right-hand corner and name your new bucket "posts":

Select CREATE, and now you're ready to start using InfluxDB!

Initialize a Spring Boot Application

After setting up an InfluxDB bucket, it's time to set up a blank Spring Boot application. Visit spring initializr and fill out the following form:

Select GENERATE, and your browser should automatically download a demo.zip file. Extract it, and you'll find your Spring Boot blank Maven project. Open the project with your favorite IDE, and you can get started adding some libraries.

Add the Required Dependencies

To make your Java Spring Boot demo application collect metrics and send them to InfluxDB, you need to download some additional libraries:

org.springframework.boot:spring-boot-starter-web: provides you with everything you need to build microservices in Spring Boot.
org.springframework.boot:spring-boot-starter-actuator: gives you access to production-ready features to monitor your app, gather metrics, and understand traffic. More information about Spring Boot Actuator is available in Spring Boot's official docs.
org.springframework.boot:spring-boot-starter-data-jpa: allows you to store and retrieve data in a relational database.
com.h2database:h2: gives you access to an in-memory H2 database instance.

Once you've downloaded these libraries, you need to add them to the project's dependencies.

To install these libraries, add the following dependencies to your pom.xml file:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Please note: The H2 database was chosen for simplicity. You can replace it with any other database technology and use the Spring Boot JPA to connect. The demo application will still work.

Keep in mind that the goal of your demo application is to collect metrics and export them to InfluxDB. To achieve this, you need to use the Micrometer tool.

Install Micrometer

Micrometer is a dimensional-first metrics-collection tool that helps you time, count, and gauge your code. The Spring Boot Actuator supports Micrometer and provides dependency management and auto-configuration.

To install Micrometer, add the following dependencies to your pom.xml file:

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
    <version>1.9.3</version>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-influx</artifactId>
    <version>1.9.3</version>
</dependency>

io.micrometer:micrometer-core is the core Micrometer dependency, and io.micrometer:micrometer-registry-influx enables Micrometer to automatically export data to InfluxDB.

Once Micrometer is installed, you can start building your Spring Boot application to store metrics in InfluxDB.

Build the Demo Application

Before building your Spring Book application, you need to initialize the project structure. This will contain the following packages:

controllers: contains all Spring Boot REST controllers.
entities: contains all the JPA entity mappings.
dtos: contains all the data transfer object (DTO) data classes.
repositories: contains all JPA repositories.

To begin building the demo application, configure your H2 database instance. Add the following lines to the application.properties Spring Boot file:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=create-drop

spring.jpa.hibernate.ddl-auto=create-drop causes the database to be recreated each time the Spring Boot application is launched. Considering that H2 is an in-memory database, this is exactly what you want.

Now, enter the entities folder and initialize the Post.java file with the following code:

package com.influxdata.demo.entities;

import javax.persistence.*;
import java.util.Objects;

@Entity
@Table(name = "posts")
public class Post {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String url;

  private String authorEmail;

  // getters, setters, equals, and hashCode omitted for brevity
}

This @Entity class contains the post requests information and maps the posts H2 table that will be created automatically on startup. Keep in mind that you need to implement the omitted getters, setters, equals, and hashCode functions to make the class work. You can take a look at the full code on this GitHub site.

Now, define a JPA repository for Post. Under the repositories folder, initialize the PostRepository.java JPA repository class as follows:

package com.influxdata.demo.repositories;

import com.influxdata.demo.entities.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface PostRepository extends JpaRepository<Post, Long> {
}

If you're not familiar with JPA repositories, you can learn more in the official Spring reference documentation. Specifically, you need the PostRepository class to perform CRUD operations on Post.

Now it's time to configure Micrometer to automatically write data to your InfluxDB instance. You can achieve this by adding the following lines to your application.properties file:

management.metrics.export.influx.bucket=${INFLUXDB_BUCKET}
management.metrics.export.influx.org=${INFLUXDB_ORG}
management.metrics.export.influx.token=${INFLUXDB_TOKEN}
management.metrics.export.influx.uri=${INFLUXDB_URI}

If you don't know how to define these four env files, take a look at the following description:

INFLUXDB_BUCKET: is the name of the InfluxDB bucket (in this example, its "posts").
INFLUXDB_ORG: is your InfluxDB org value. On InfluxDB Cloud, you can retrieve it at /load-data/client-libraries/java.
INFLUXDB_TOKEN: is the API token you created earlier.
INFLUXDB_URI: is the URI to the InfluxDB instance (here, it's https://us-east-1-1.aws.cloud2.influxdata.com).

Next, you need to use a Micrometer to log data. Following is an example of how you can use Micrometer:

Counter counter = Metrics.counter(
  // metric name
  "request.posts",
  // tags
  "postId", // key
  1, // value
  "status", // key
  "draft-received" // value
);

// updating the metric in memory
// and automatically writing it to InfluxDB
counter.increment();

In detail, the snippet earlier will record the metric couples <"postId", "1"> and <"status", "draft-received"> in Micrometer.

As you can see, a Micrometer element consists of a name and a list of tags. You can initialize a Micrometer element with Metrics.counter(). To do so, separate each word of the metric's name with a period. This will help ensure the portability of metric names across different monitoring systems.

Please note that Metrics.counter() tags variables follow a key, value approach. When counter.increment() is executed, the metrics data will be automatically transferred to InfluxDB behind the scenes.

You can configure Spring Boot to expose Micrometer metrics via the Actuator web endpoints with the following application.properties configurations:

management.endpoint.metrics.enabled=true
management.endpoints.web.exposure.include=*
management.endpoint.beans.enabled=true

If you're not familiar with the Spring Boot Actuator web endpoints, you can learn more in this official documentation.

Then you can access the request.posts Actuator endpoint with the following URL:

http://localhost:8080/actuator/metrics/request.posts

This will return the following:

{
  "name": "request.posts",
  "description": null,
  "baseUnit": null,
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 0
    }
  ],
  "availableTags": [
    {
      "tag": "postId",
      "values": [
        "1"
      ]
    },
    {
      "tag": "status",
      "values": [
        "draft-received"
      ]
    }
  ]
}

Now, you need to initialize a PostRequest DTO class. Enter the dtos package and create a PostRequest.java file like this:

package com.influxdata.demo.dtos;

import com.fasterxml.jackson.annotation.JsonProperty;

public class PostRequest {
  @JsonProperty("url")
  private String url;

  @JsonProperty("authorEmail")
  private String authorEmail;

  public PostRequest() {}

  public String getUrl() {
    return url;
  }

  public void setUrl(String url) {
    this.url = url;
  }

  public String getAuthorEmail() {
    return authorEmail;
  }

  public void setAuthorEmail(String authorEmail) {
    this.authorEmail = authorEmail;
  }
}

This class will be used by the following PostController to map the data received from the users in the POST and PUT requests.

Now, you're ready to define a simple PostController class exposing basic CRUD API logging data to InfluxDB with Micrometer. Enter the controllers folder and create a PostController.java file as follows:

package com.influxdata.demo.controllers;

import com.influxdata.demo.dtos.PostRequest;
import com.influxdata.demo.entities.Post;
import com.influxdata.demo.repositories.PostRepository;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.Metrics;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("api/v1/posts")
public class PostController {

  private final PostRepository postRepository;

  PostController(@Autowired PostRepository postRepository) {
    this.postRepository = postRepository;
  }

  @GetMapping()
  public ResponseEntity <List<Post>> getAll() {
    return new ResponseEntity<> (
      postRepository.findAll(),
      HttpStatus.CREATED
    );
  }

  @PostMapping()
  public ResponseEntity <Void> create(
    @RequestBody PostRequest postRequest
  ) {
    // creation logic
    Post postToCreate = new Post();
    postToCreate.setUrl(postRequest.getUrl());
    postToCreate.setAuthorEmail(postRequest.getAuthorEmail());
    Post post = postRepository.save(postToCreate);

    // logging the initial post request status with Micrometer
    Counter counter = Metrics.counter(
      "request.posts",
      "postId",
      post.getId().toString(),
      "status",
      "draft-received"
    );

    counter.increment();

    return new ResponseEntity<>(HttpStatus.CREATED);
  }

  @PutMapping("{id}")
  public ResponseEntity < Void > update(
    @PathVariable(value = "id") Long id,
    @RequestBody PostRequest postRequest
  ) {
    // update logic
    Post postToUpdate = postRepository.findById(id).get();
    postToUpdate.setUrl(postRequest.getUrl());
    postToUpdate.setAuthorEmail(postRequest.getAuthorEmail());
    postRepository.save(postToUpdate);

    // logging the new post request status with Micrometer
    Counter counter = Metrics.counter(
      "request.posts",
      "postId",
      id.toString(),
      "status",
      "updated"
    );

    counter.increment();

    return new ResponseEntity<>(HttpStatus.OK);
  }

  @DeleteMapping("{id}")
  public ResponseEntity<Void> delete(
    @PathVariable(value = "id") Long id
  ) {
    // delete logic
    postRepository.deleteById(id);

    // logging the new post request status with Micrometer
    Counter counter = Metrics.counter(
      "request.posts",
      "postId",
      id.toString(),
      "status",
      "deleted"
    );

    counter.increment();

    return new ResponseEntity <> (HttpStatus.NO_CONTENT);
  }
}

Launch your Spring Boot application and start creating, updating, and deleting posts. Then visit your InfluxDB Data Explorer page, select the posts bucket, and review your metrics:

Please note that the Spring Boot Actuator library automatically defines a list of useful application metrics in Micrometer, which sends them accordingly to InfluxDB. You can learn how to enable or disable these metrics in Spring Boot's official docs.

To view your custom log metrics, activate the Simple Table view, select request_posts at the bottom of the screen, and turn on the View Raw Data option through the slider. And you should be able to see your custom log metrics:

Now, you've officially collected application metrics with Micrometer and stored them on InfluxDB in Spring Boot.

Conclusion

In this article, you learned how to build a Spring Boot Java application that can collect metrics and store them automatically in InfluxDB. With a dimensional metrics collection tool like Micrometer, you can configure your Spring Boot application to collect different metrics and send them to your preferred database technology.

The post "How to Store Spring Boot Application Metrics in InfluxDB" appeared first on Writech.

How to Use a Proxy in PHP with cURL

Antonello Zanini — Fri, 19 Jan 2024 21:41:57 +0000

In this article, you will learn how to perform HTTP requests in PHP behind a proxy. A proxy server acts as a gateway between your PHP application and the Internet, protecting your IP as a result. Proxies provide security, anonymity, and allow you to access services not available in your country. Proxy services are a great ally when it comes to web scraping because they help you avoid your IP from being banned. This is just one of many use cases where proxy servers are useful.

Follow this tutorial and learn how to use web proxies in PHP with cURL!

Why Do You Need a Proxy in PHP?

A proxy server is a service that acts as an intermediary between a client and a server. When a client sends a request to a server, the proxy server intercepts the request and forwards it to the server. So, the server will see the proxy server's IP address, not yours. This ensures anonymity.

If your PHP scripts perform HTTP requests, you should execute them behind a proxy server to protect your IP from being banned. So, proxies come in handy when building a web scraper or bot in PHP.

Also, proxy servers in PHP can be used for:

Improving performance: By caching frequently web pages and resources requested by the clients, a proxy server can reduce the load on the original server and improve the overall performance of the network.
Filtering content: A proxy server can be configured to block access to certain websites for censorship reasons.
Bypassing restrictions: A proxy server can be used to bypass geographical or similar restrictions, allowing users to access content that would otherwise be unavailable.

Proxy servers support different protocols, such as HTTP, HTTPS, and SOCKS, and PHP allows you to use all these types of proxies. Let's now learn how to deal with proxy servers in plain PHP with cURL.

How to Use Proxy Servers with cURL in PHP

In this step-by-step section, you will learn everything you need to know to use proxy servers in PHP, from basic to more advanced approaches.

Prerequisites

Before getting started with proxies in PHP, you need to meet the following list of requirements:

PHP >= 8 (with cURL included)
Composer >= 2

If you do not meet one of those requirements, click on the links above and follow the official guides to download and configure what you need. Note that cURL is part of the curl-ext PHP extension and is generally included in most PHP packages. If the PHP package you downloaded did not include that extension, install curl-ext by following the official installation guide.

As you can easily guess from the name of the extension, curl-ext uses cURL behind the scenes. For this reason, you might find it useful to learn more about how to use a proxy server with cURL.

Also, keep in mind that web proxies are typically used when it comes to web scraping. So, follow a guide on web scraping with PHP to learn how to build a web scraper in PHP. Here, you are about to see how you can extend your PHP scraping script to make it use server proxies in cURL.

Let's now learn how to achieve this!

Get started with proxies in cURL

First, let's call how to perform an HTTP request in cURL:

<?php

// initializing a cURL session
$ch = curl_init();

// setting the HTTP method
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");

// specifying the target URL 
curl_setopt($ch, CURLOPT_URL, "https://www.example.com");

// return the result of the request as a string 
// instead of printing it directly
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

// sending the HTTP GET request
// and assigning its response to a variable
$response = curl_exec($ch);

// using the response of the HTTP request...
// close the cURL channel to free up 
// some system resources
curl_close($ch);

As you can see, performing a request in cURL only takes a few lines of code. After initializing a cURL session with curl_init(), you can set all the options required by your request via curl_setopt(). Then, you can execute the HTTP request with the curl_exec(). Finally, when you no longer need the current cURL session, you can close it with curl_close().

Note that the object returned by curl_init() is typically assigned to a PHP variable called ch. That stands for "cURL handle", or simply "channel."

Now, let's extend this cURL example to use a server proxy. First, keep in mind that to connect to a proxy, you need to specify the following info:

Proxy server address
Port
Protocol
Username (if authentication is required)
Password (if authentication is required)

Let's assume the complete URL of your HTTP proxy looks like as follows:

`206.189.156.117:8080`

Then:

206.189.156.117 is the proxy server address
8080 is the port
HTTP is the (implicit) protocol

You can set these parameters in cURL with

curl_setopt($curl, CURLOPT_PROXY, "206.189.156.117");
curl_setopt($curl, CURLOPT_PROXYPORT, "8080");
curl_setopt($curl, CURLOPT_PROXYTYPE, "CURLPROXY_HTTP");

Note that CURLOPT_PROXYTYPE accepts the following values:

CURLPROXY_HTTP
CURLPROXY_SOCKS4
CURLPROXY_SOCKS5
CURLPROXY_SOCKS4A
CURLPROXY_SOCKS5_HOSTNAME

Since CURLPROXY_HTTP is the default value and most proxies are HTTP proxies, you can generally omit the last line. Also, you can directly specify the proxy port by providing the CURLOPT_PROXY option with the complete proxy URL.

In other terms, you can use a proxy in PHP with cURL with the single line of code below:

curl_setopt($curl, CURLOPT_PROXY, "206.189.156.117:8080");

Connect to Authenticated Proxies

Some proxies are protected by authentication. If you want to use them, you need to specify a username and password. To connect to an authenticated proxy server in PHP with cURL, use:

curl_setopt($curl, CURLOPT_PROXYUSERPWD, "<username>:<password>");

Note that the value accepted by the CURLOPT_PROXYUSERPWD cURL option must be in the : format.

So, assuming your username is dabpu462n and password is dh9281048nasy37, a complete example of connecting to a proxy server with cURL in PHP is:

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_URL, "https://www.example.com");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

// setting the proxy server URL
curl_setopt($curl, CURLOPT_PROXY, "206.189.156.117:8080");

// dealing with proxy authentication
curl_setopt($curl, CURLOPT_PROXYUSERPWD, "dabpu462n:dh9281048nasy37");

$response = curl_exec($ch);

// using the response of the HTTP request...
curl_close($ch);

Rotating Proxies with cURL

A proxy server protects your IP address. The target site of your web scraper will see the IP of the proxy, not yours. This means that if you make too many requests, your target site may block the IP of the proxy server.

In other words, relying on a single proxy may not be an ineffective solution. So, if you do not want your web scraping process to be blocked, you can adopt a rotating proxy system. A rotating proxy assigns a different IP address to each new request. In detail, a rotating proxy system has a pool of proxies from which to draw randomly for each request.

This way, your IPs become less likely to be banned, and your web scraping can keep running smoothly as a result. To implement a rotating proxy, you need a list of proxies.

Let's now learn how to implement a rotating proxy system in PHP. First, you need to store your proxy pool in a variable:

$proxies = array(
     array(
         "url" => "myproxy.com:8081",
         "username" => null,
         "password" => null
     ),

     array(
         "url" => "myproxy.com:8082",
         "username" => "asdlwdcm18j",
         "password" => "da913ma01dkannah803n"
     ),

     // ...

     array(
         "url" => "myproxy.com:5001",
         "username" => null,
         "password" => null
     ),
);

Now, let's build a function to handle the rotating proxy logic:

function proxy_request($proxies, $ch, $max_attemps = 5, $wait = 2) {
        $attemps = 0;

        while ($attemps < $max_attemps) {
                // getting a random proxy from 
                // the pool of proxies
                $random_proxy = $proxies[array_rand($proxies)];

                // if the proxy requires authentication
                if (!is_null($random_proxy["username"]) && !is_null($random_proxy["password"])) {
                        curl_setopt($ch, CURLOPT_PROXYUSERPWD, $random_proxy["username"] . ":" . $random_proxy["password"]);
                }

                // configuring the proxy to use
                curl_setopt($ch, CURLOPT_PROXY, $random_proxy["url"]);

                echo "Performing the request with the proxy: " . $random_proxy["url"] . "\n";

                // performing the request
                $result = curl_exec($ch);

                // if the request failed
                if (curl_errno($ch)){
                        echo "Request failed";
                        echo "Waiting " . $wait . "seconds...";

                        // waiting a number $wait of seconds
                        // before performing a new attempt again
                        sleep($wait);

                        // incrementing the attempt counter
                        $attemps++;

                        echo "Trying again...";
                } else {
                        curl_close($ch);

                        return $result;
                }
        }

        // in case of error
        return false;
}

This function simply tries to perform a request already defined in a cURL handle for a number $max_attemps of times, using a random proxy randomly selected from the proxy pool. Note that implementing a retry logic as above is recommended. This is because free proxies are prone to failure.

You can then use proxy_request() as follows:

// $proxies = ...

$ch = curl_init();

curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_URL, "https://www.example.com");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

// performing the HTTP request through a
// rotating proxy
$response = proxy_request($proxies, $ch);

Note that free proxy servers are slow and not reliable. For this reason, you should consider a commercial solution like Bright Data.

Conclusion

As you learned in this article, proxies are an indispensable tool for web scraping. In detail, you saw everything you need to use web proxies in PHP. Performing HTTP requests under a web proxy in cURL is easy and only takes a bunch of lines of code.

Also, you learned how to implement a rotating proxy in PHP and what benefits it can bring to the web scraping process. At the same time, implementing a rotating proxy with free proxies may not be the best approach. For this reason, you should consider a commercial solution such as Bright Data.

The post "How to Use a Proxy in PHP with cURL" appeared first on Writech.

Enabling TypeScript Programming in Visual Studio Code

Antonello Zanini — Fri, 19 Jan 2024 21:41:40 +0000

Visual Studio Code is one of the most popular open-source code editors available. Thanks to the wide range of features it provides, VSC makes coding easier, faster, and less frustrating. This is especially true when it comes to TypeScript, one of the several languages supported by VS Code natively.

Some of the features that make TypeScript developers more productive in VS Code include code completion, parameter hints, and syntax highlighting, which makes it easy to identify and distinguish different parts of the code. Also, VS Code comes with a built-in Node.js debugger that allows you to debug your TypeScript code directly in the editor. At the same time, most of these features need to be configured to get the most out of them.

Follow this step-by-step tutorial and learn how to set up Visual Studio Code for TypeScript development. First, you will see how to initialize a Node.js project in TypeScript. Next, you will use VSC to write some TypeScript code. Finally, it will be time to understand how to compile, run, and debug TypeScript code in VS Code.

How To Set Up VS Code for TypeScript Development

Let's jump into TypeScript development with VSC!

Prerequisites

Before getting started, make sure you have:

Node.js installed and configured locally.
Visual Studio Code (VS Code) downloaded and installed.

You can verify that Node.js is installed on your machine with the command below:

`node -v`

This should return the version of Node.js locally available, as below:

`v18.14.0`

You will need Node.js to set up an npm project in TypeScript and run its compiled files.

Now that you met all prerequisites, it is time to get started with TypeScript in VSC!

Install the TypeScript Compiler

Visual Studio Code supports TypeScript development but does not include the TypeScript compiler. This is a requirement to test your TypeScript code. In detail, the TypeScript compiler tsc can transpile TypeScript code to JavaScript. In other words, tsc takes TypeScript code as input and produces JavaScript code as output. Then, you can execute the JS code with Node.js.

Launch the command below in your terminal to install the TypeScript compiler tsc globally on your computer:

`npm install -g typescript`

Verify the version of tsc installed with:

`tsc --version`

If this command does not return an error, it means that tsc works as expected. You now have everything you need to build a TypeScript project!

Create a TypeScript Project

Let's create a sample Node.js TypeScript project called "hello-world." Open your terminal, create a project for your folder, and enter it with:

mkdir hello-world
cd hello-world

Inside hello-world, initialize an npm project with the npm init command below:

`npm init -y`

This will create a package.json config file for your Node.js project. Time to see what the project consists of in VCS!

Launch Visual Studio Code and select the "File > Open Folder…" option as shown below:

This will open a file-explorer popup window. Select your project folder and click "Open." This is what your project will look like:

As you can see, it only consists of the package.json file initialized by npm init.

Next, click on "View > Terminal" to get access to the VSC integrated Terminal. Here, launch the command below:

`npx tsc --init`

This will initialize a TypeScript configuration file named tsconfig.json in the project directory.

The tsconfig.json file allows you to customize the behavior of the TypeScript compiler on your project basis. In detail, tsconfig.json provides the TypeScript compiler with instructions on how to transpile the TypeScript code. Without it, tsc will not be able to compile your TypScript project as desired.

Open tsconfig.json in Visual Studio Code and you will notice that it contains a comment for each config option available. Comment out what you do not need and make sure tsconfig.json looks like as follows:

{
  "compilerOptions": {
    "target": "es2016",
    "module": "commonjs",
    "sourceMap": true,
    "outDir": "./build",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true
  }
}

The only difference with the original file created by npx tsc --init are the two lines below:

"sourceMap": true,
"outDir": "./build",

sourceMap creates source map files for emitted JavaScript files As you will learn in the next steps, these map files are required by the VSC compiler. Instead, the outDir configuration defines where the transpiled files will be emitted by the compiler. By default, this corresponds to the root folder of the project. To avoid filling your project folder with build files at every compilation, you should set it to another folder, such as "./build".

Your TypeScript project is now ready to be compiled, but first, you need a TypeScript file.

Right-click on the "Explorer" section, select "New File…", type "index.ts," and press Enter. Your project will now contain a TypeScript file called index.ts:

Initialize it with the TypeScript code below:

const message: string = "Hello, World!";
console.log(message);

This code will simply print the "Hello, World!" message.

Try IntelliSense for Code Completion

When writing the lines of code above in VS Code, you might have noticed some code suggestions made by the editor. This happens because of IntelliSense, one of the greatest features offered by Visual Studio Code. IntelliSense refers to a set of code editing tools offered by VSC that include features like code completion, docs information, and parameter info on functions.

Take a look at IntelliSense in action in the GIF below:

As you can see, IntelliSense automatically suggests how to complete the code as you type it. This can significantly improve your productivity by reducing the time and effort required to write accurate code.

Keep in mind that VSC comes with IntelliSense support for TypeScript projects out of the box. So, you do not have to configure it manually.

You know how to write TypeScript code like a pro in Visual Studio Code. Let's learn how to compile it and see if it works!

Compile the Code in VS Code

Before setting up VS Code to compile your TypeScript code for you, you need to verify that your project works. Open the integrated terminal in VSC and run the command below:

`tsc -p .`

This will transpile the TypeScript project located in the current directory according to the tsconfig.json configuration file. Specifically, the -p . part indicates to the compiler to use the tsconfig.json file located in the current directory.

The resulting JavaScript files will be placed in the ./build directory, as you can verify in VS Code:

Verify that the transpiled JavaScript code works with:

`node ./build/index.js`

This command will run the Node.js JavaScript file produced by index.js and should print:

`Hello, World!`

Great! The code produced by the compiler works as expected. This means that you set up your TypeScript project correctly.

If you want to avoid repeating the procedure described above again and again, click on "Terminal > Run Build Task…" and select the "tsc: build - tsconfig.json" option as below:

This operation will run tsc -p . behind the scenes and build your code directly in the editor. You now know how to compile your TypeScript project in VS Code. All that remains is to figure out how to launch and debug the code.

Run and Debug the Code

Visual Studio Code supports TypeScript debugging thanks to its built-in Node.js debugger. To use the debugger, you must first set it up. Click on the "Run and Debug" icon on the left menu, click "create a launch.json file," and select "Node.js."

This will create a default Node.js launch.json file for you. launch.json is the configuration file used by the Visual Studio Code debugger to launch and debug an application. This config file contains specifies how to launch the application, the command-line arguments to use, and the environment variables to set.

As you can notice in the "Explorer" section, launch.json is located in the .vscode folder of a project:

Open it, and edit it as below:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Launch Program",
            "skipFiles": [
                "node_modules/**"
            ],
            "program": "${workspaceFolder}/index.ts",
            "preLaunchTask": "tsc: build - tsconfig.json",
            "outFiles": ["${workspaceFolder}/build/**/*.js"]
        }
    ]
}

Specifically, you need to change the program, preLaunchTask, and outFiles options considering that:

program: Specifies the path to the entry point of the application to debug. In Typescript, it should contain the main file to execute when launching the application.
preLaunchTask: Defines the name of the VSC build task to run before launching the application. In a TypeScript project, it should be the build task.
outFiles: Contains the path to the transpiled JavaScript files generated by the build process. The source map files generated by tsc thanks to the "sourceMap": true config are used by the debugger to map the TypeScript source code to the generated JavaScript code. This allows you to debug TypeScript code directly.

Save the launch.json file and open index.ts. Click on the blank space before the console.log() line to set a breakpoint. A red point will appear as below:

When running the code with the compiler, the execution will stop there. Thanks to this breakpoint, you can verify that the Node.js debugger in VS Code is working as expected.

Visit the "Run and Debug" section again and click on the "▷" green button to run the debugger. First, you will have to wait for preLaunchTask to be executed. After the code has been compiled, the program will be launched and execution will stop at the breakpoint set before:

On the left, you can see the values of the variables at the time of the stop. Also, you can pause, step over, step in/out, restart, and stop as described on the official doc page. Press F5 to resume the execution and you should see the message below in the DEBUG CONSOLE tab:

`Hello, World!`

This is what you expect the application to produce and means that the program has been executed correctly.

Fantastic! You just learned how to set up Visual Studio Code for TypeScript programming. The tutorial may end here, but there is one more important thing to learn. Let's see how to configure an extension in VS Code to make coding in TypeScript on VSC easier.

Set up ESLint

The core of Visual Studio Code is pretty basic but it can easily be extended by the many extensions available. These provide additional features and functionality to the code editor.

One of the most popular VSC extensions for TypeScript development is the ESLint extension. This allows you to run ESLint directly within the editor. Specifically, ESLint is a popular static code analysis tool for JavaScript and TypeScript that helps developers identify and fix common coding errors and enforce coding standards. Let's integrate ESLint into VS Code in your TypeScript project.

First, initialize ESLint in your project with:

`npm init @eslint/config`

During the configuration process, the command will ask some questions to understand how to generate the ESLint configuration file. You can answer as follows:

√ How would you like to use ESLint? · style

√ What type of modules does your project use? · commonjs

√ Which framework does your project use? · none

√ Does your project use TypeScript? · No / Yes

√ Where does your code run? · browser

√ How would you like to define a style for your project? · guide

√ Which style guide do you want to follow? · standard-with-typescript

√ What format do you want your config file to be in? · JSON

Checking peerDependencies of eslint-config-standard-with-typescript@latest

Local ESLint installation not found.

The config that you've selected requires the following dependencies:

eslint-config-standard-with-typescript@latest @typescript-eslint/eslint-plugin@^5.0.0 eslint@^8.0.1 eslint-plugin-import@^2.25.2 eslint-plugin-n@^15.0.0 eslint-plugin-promise@^6.0.0 typescript@*

√ Would you like to install them now? · No / Yes

√ Which package manager do you want to use? · npm

At the end of the process, you will notice a new .eslintrc.json file containing the following code:

{
    "env": {
        "browser": true,
        "commonjs": true,
        "es2021": true
    },
    "extends": "standard-with-typescript",
    "overrides": [
    ],
    "parserOptions": {
        "ecmaVersion": "latest"
    },
    "rules": {
    }
}

.eslintrc.json is a configuration file used by ESLint to enforce specific code, style, and quality standards. This is what a basic .eslintrc.json for a Node.js TypeScript project looks like:

{
    "env": {
        "browser": true,
        "commonjs": true,
        "es2021": true,
        "node": true
    },
    "extends": "standard-with-typescript",
    "overrides": [
    ],
    "parserOptions": {
        "ecmaVersion": "latest",
        "project": "tsconfig.json"
    },
    "rules": {
        "indent": ["error", 2],
        "no-multi-spaces": ["error"]
    }
}

Now, it is time to install the ESLint extension in VSC. Click on the "Extensions" icon on the left menu and type "ESLint." Find the ESLint extension and click "Install."

To enable the ESLint extension to automatically inspect your TypeScript files and run ESLint on save, define a settings.json file inside .vscode with:

{
    "editor.codeActionsOnSave": {
        "source.fixAll.eslint": true
      },
      "eslint.validate": [
        "typescript"
      ],
      "eslint.codeActionsOnSave.rules": null
}

Note that settings.json is a configuration file used by Visual Studio Code to customize the behavior of the editor and its extensions. To make VS Code loads the new extension and configurations, you need to restart it.

If you open index.ts and start playing with the code, you will see new errors reported by the IDE. When it comes to code style errors, save the file and ESLint will automatically reformat the code as defined in .eslintrc.json.

Wow! Nothing can stop you from writing quality code anymore!

Conclusion

In this tutorial, you learned what you need to do to configure Visual Studio Code for development in TypeScript. In detail, you saw how to create a Node.js project in TypeScript, load it into VS Code, and use it to write code assisted by IntelliSense. You also looked at how to configure the TypeScript compiler, set up the Node.js compiler to debug TypeScript code, and integrate ESLint into the project.

The post "Enabling TypeScript Programming in Visual Studio Code" appeared first on Writech.

How AI Can Support You During Calls

Antonello Zanini — Fri, 19 Jan 2024 21:41:19 +0000

Local and internal meetings with clients and colleagues are now run via Zoom, Google Meet, and Microsoft Teams. As a result of this, all your business calls now go through these applications.

This inevitably led to new opportunities. In particular, since we are all now using such applications to communicate, many advanced AI-based tools have been developed to support you during voice or video calls. These tools allow you to focus on who you are talking to, freeing you from all the encumbrances that come with calls, like taking notes.

Let's now delve into this phenomenon and understand what benefits such AI-based tools can bring to your business.

What Is AI?

Defining what AI (Artificial Intelligence) really is can be a challenging task, especially considering how complex this notion is.

You can think of artificial intelligence as a broad concept involving different technologies and tools. These techniques can be used to build smart machines that can learn, improve, and perform tasks that are generally associated with human intelligence. Traditional software evolves if developers improve it, but AI-based applications can learn and improve on their own.

AI undoubtedly represents the future. Consequently, it has been adopted more and more, and it is now being used by numerous businesses with efficiency in mind, especially when it comes to voice and video calls, both internally and with clients.

So, it is time to dig into how AI can support you during your business calls.

How AI Call Assistant Software Works

Many AI-based applications have been developed to support you during your calls. Such tools integrate directly with the conference call application you are using to produce reports, highlights, and notes that you can then access from a web or desktop platform.

In other words, they mainly consist of a plugin or extension for your browser or call application that actively supports you during your calls. These tools register meaningful data throughout your conversation and use AI-based processes to get the transcript. Thus, they automatically extract significant text notes and produce video highlights for you, analyzing the words or facial expressions used by your interlocutors to give you advice and help you engage them. Then, you can access all this data from an external platform, such as a web application.

These AI-based assistant applications are configurable to fit your needs and automatically extract what matters based on the keywords you defined or input feedback you provided during the call. Also, they usually come with features to share the result of their analysis with your team seamlessly and effortlessly.

Behind the scenes, all the data collected during your calls is analyzed according to your preferences and needs by AI services and algorithms. Notably, the most popular programming languages used for AI are Python, Java, and C++. Typically, Python is adopted for data science, while C++ is used when performance is a top priority.

These programming languages come with libraries that implement the most effective AI algorithms, but these applications also rely on services like AWS AI, Azure A, or IBM Watson. In detail, they call their APIs (Application Programming Interface) directly or through their proprietary SDKs (Software Development Kit) and use their features to analyze the data collected during the call.

Benefits of Using AI During Calls

Adopting AI call assistant applications brings 3 main pros. See them all in detail.

Avoid distractions

These applications allow you to avoid wasting physical and mental energy taking notes or worrying about losing important information during the call. This allows you to focus completely on the people you are talking to, which is critical, especially during sales calls.

More engaged clients

AI is also about sentiment analysis. So, through the analysis of the words, and expressions used by your clients, as well as their behavior and reactions to your statements, your AI assistant will provide you with useful feedback to make your sales call a success.

Easier coaching and training

These tools collect a lot of data and analyze it to understand what behaviors and strategies are best to achieve the desired result. So, you can use this to coach and train your teams and help them become more effective and efficient.

Conclusion

Artificial intelligence is here to stay and support us during our daily tasks. In recent years, calls and meetings have gone digital, and AI tools have been developed to support you and become the best assistant you have ever had. Here, we looked at how these AI-based call assistant applications work and what benefits they can bring to your business.

Thanks for reading! We hope that you found this article helpful.

The post "How AI Can Support You During Calls" appeared first on Writech.

5 Steps to Create a Digital Marketplace

Antonello Zanini — Fri, 19 Jan 2024 21:41:11 +0000

Regardless of how old or large your business is, having a digital presence is now essential. In particular, being able to sell products and services online is an opportunity to grow your business and reach new customers. Thus, this is why having an ecommerce platform is so important, especially if your business is small or operates in a niche market.

Now, let's take a look at what is required to build an ecommerce website from scratch and start generating money from your online sales.

Online Selling in 5 Easy Steps

Selling products online is not a complex task and can be accomplished in just 5 steps. On the other hand, building an e-commerce can be a challenging task if the digital world is new to you.

Let's now learn more about these 5 steps.

1. Find an Appealing Domain Name

Even though you already have a website, you want your e-commerce platform to be easy to find. Also, remember that a domain typically costs between $10 to $30 per year. So, having more than one website should not be a problem.

If you do not know what a domain name is, think of it as your digital address. The easier to remember, the better. Specifically, finding the right domain name is crucial to your brand, and consequently to your success. Your domain name should be short, easy to write and remember, and contain words related to your business and what you expect to sell. These requirements are essential for any business's SEO (Search Engine Optimization) strategy.

Take also into account that some of the ecommerce platforms you are about to learn about allow you to pick a domain name for free, if you decide to adopt them to build your ecommerce website.

2. Select the Best E-Commerce Platform for Your Needs

An ecommerce platform allows you to build your ecommerce website according to your needs straightforwardly and with no or little code involved. There are several options available online to choose from, but they can be boiled down to 4 types. Let's take a look at the top ones for each of them.

Dedicated e-commerce platforms

Dedicated e-commerce platforms are non-free solutions that allow you to launch an e-commerce website effortlessly. They come with features aimed at building a complete e-commerce website easily, allowing you to enable powerful built-in features with a bunch of clicks. To use them, you usually have to pay a monthly fee of about $30, but they typically offer a free trial period where you can test them out.

The top dedicated e-commerce platforms include:

Free e-commerce platforms

These e-commerce platforms allow you to build your digital marketplace for free. On the other hand, they generally come with some limitations, which can be removed only after paying a fee.

The top dedicated e-commerce platforms include:

E-commerce plugins

You might already have a working website, such as a WordPress website. In this case, you can easily integrate e-commerce features by adopting one of the following e-commerce plugins:

General website builders with ecommerce features

The most popular website builders for non-developers largely come with e-commerce features. Again, if your website was built with one of these platforms, you can buy the e-commerce plan and start taking advantage of all the e-commerce features you will have access to.

The top general website builders offering e-commerce features include:

3. Build Your E-Commerce Website

Now, all you need to do is build your e-commerce website. This step changes based on which e-commerce platform or solution you choose. E-commerce plugins might require you to write some lines of code to be integrated into your existing website. On the contrary, the other solutions should allow you to build your e-commerce without any code involved. At the same time, being in contact with web developers will make everything faster and more effective.

4. Populate Your Digital Marketplace

Think of the products displayed in your digital marketplace as your store window. Simply placing your products there with no effort would not be effective. Your product information must be detailed and engaging. Particularly, take time to produce high-quality photos and videos for each of the products you are selling. Your products must be eye-catching!

Also, text descriptions should be exhaustive, accurate, and not too long. Similarly, giving your users the possibility to customize your products will be a great plus. Then, do not forget to highlight the average delivery time, price, discount, and how many products are available. This information is crucial and should be outstanding and easy to find.

5. Advertise Your New Business

You now have an e-commerce website, and you are ready to sell online your products. The only remaining step is to let everyone know about your new digital business. Paid ads, email marketing, and a blog where to advertise your products will be useful tools for this step. If this scares you, hire one or more digital marketing experts. Finally, while promoting your website remember to be convincing, but not too spammy.

Also, let users know about your story and why you decided to embark on this adventure. After all, selling is also about selling a story, and you want your new online customers to buy products from you to support you.

Conclusion

Your business might be a small or brick-and-mortar business. Either way, you should consider starting to take advantage of the digital world. Specifically, here we looked at how easy it is to start selling online. In detail, we learned how to build your e-commerce website from scratch with a 5-step approach, and understood the most valuable lessons for generating money through it.

Thanks for reading! We hope that you found this article helpful.

The post "5 Steps to Create a Digital Marketplace" appeared first on Writech.

When to Use JSON Data in a Relational Database

Antonello Zanini — Fri, 19 Jan 2024 21:41:03 +0000

Most relational database technologies can now store JSON data and perform queries on it. The introduction of the JSON data type to relational databases represented a turning point and opened up many new possibilities. Considering the innovative nature of this feature, you might have several doubts about whether adopting JSON data is the right choice. In particular, the risk of abusing of JSON and losing the benefits of the relational model is high. That is why having a clear understanding of the advantages and disadvantages that JSON data can bring to a relational database is so important.

Here, you will see everything you need to know about JSON columns and what are the best scenarios in which to rely on them.

What Is JSON?

JSON stands for JavaScript Object Notation and represents a lightweight, easy-to-understand, human-readable data format. In a relational database, the JSON data type is a special binary or text column that allows you to store data in JSON format.

{
  "user": {
    "id": "1",
    "name": "Maria",
    "surname": "Williams",
    "hobbies": [
      {
        "name": "Tennis",
        "since": 1985
      },
      {
        "name": "Reading",
        "since": 1974
      }
    ]
  }
}

The relational databases that support JSON generally come with JSON-specific functions and operators to query and perform operations on this data type.

Why Does Relational Databases Support JSON Data?

Over time, the features offered to users have become increasingly complex. As a result, it is unlikely that the right data structure to support an application can be purely relational. The importance of data is increasing, and the way to represent it is evolving accordingly. Those who develop relational database technologies know this and have introduced the JSON data type to support the new way of thinking about data.

MySQL introduced JSON support starting from version 5.7, in 2015. PostgreSQL supports JSON data type since version 9.2, released in 2012. SQL Server has supported JSON since SQL Server 2016. As you can see, the most popular RDBMSes enable storing JSON data. This does not mean that the relational model is dying or is no longer useful. On the contrary, it is simply evolving and adapting to new needs.

After all, relational database technologies support JSON only as a data type. This means that you can add one or more JSON columns to your relational tables. This does not radically disrupt the relational approach and represents just a possibility, a useful and powerful feature to have.

When To Store JSON Data in a Relational Database

Embracing the JSON data type and adding JSON columns to your tables can bring several advantages to your relational schema. This is especially true in the following scenarios.

For logging

You should be able to easily read and understand your log data, and the JSON format is a great way to store it. Therefore, you should consider turning your log data into JSON format and storing it in JSON columns. In addition, having a JSON column containing log data is an effective approach to keeping track of what happened just by looking at a row. With this approach, you do not have to define new tables, perform JOINs, or spend time retrieving the log data.

JSON columns are also useful for logging where the data came from, especially when importing data via API. Considering that API responses are generally in JSON format, storing them in a JSON column is an effortless solution to not lose this data and exploit it when needed.

To store permissions and configurations

Not all users may have access to the same features and sections of your application. Similarly, each user might configure your application based on their preferences. These are two common scenarios and involve data that changes a lot over time. This is because your application is likely to evolve, involving new configurations, views, features, and sections. As a result, you have to continuously update your relational schema to match the new data structure. This takes time and energy.

Instead, you can store permissions and configurations in a JSON column directly connected to your user table. Also, JSON is a good data format for your permissions and configuration. In fact, your application is likely to treat this data in JSON format.

To avoid slow performance on highly nested data

If performance is a key requirement and your application involves data that is highly nested, you should consider JSON columns. This is particularly true when you have to use it as one piece. In a relational approach, you would have to structure your data in several tables. To retrieve it, you would have to nest various JOINs, which would make queries very slow.

On the contrary, by storing this nested data in a JSON column, you can retrieve it with a simple SELECT query. This would make your data retrieval process faster while keeping your data structure easy.

When To Avoid JSON Data in a Relational Database

Some consider using the JSON data type as an antipattern and something to adopt sparingly. The reason is that using a format without constraints such as JSON can undermine your relational schema. In detail, you should avoid JSON in the following cases.

You are not sure what data to store in the JSON column

The JSON format is flexible, but this does mean that you can use it to store whatever you want. Before adding JSON columns to your database, you must clearly define their purpose. Otherwise, they are likely to become junk drawers. If this happens, the consequences can be deadly for the future of your application. The only way you have to avoid it is by designing a data format for your JSON columns.

Avoid using JSON columns if you do not know how to use them. Having JSON columns storing data in different formats means having no data validation on the database level, which can lead to no consistency or integrity at the application level.

You do not want to deal with complex queries

Storing data in JSON format is cool, but do not forget that it comes with additional costs and complications. One of these is that querying data in JSON columns leads to more complicated-looking queries.

Here is what a query involving JSON columns looks like in PostgreSQL:

And this is the equivalent query in a traditional scenario:

The second one is much easier to read and understand. Avoid using JSON if the benefit brought by JSON is not enough to justify the complexity of the new queries.

You have a strongly typed ORM

When mapping your database with a strongly typed ORM technology, you may encounter problems with types. This is because types at the database level are different from types at the application level. When you want to deal with the data stored in JSON columns at the application level, you have two approaches.

The first one is to define JSON columns in your ORM mapping as a string and then transform them into an object. Otherwise, if your ORM supports this option, you can map the column with a custom structured type. In either case, the application or the ORM must perform the data conversion behind the scenes. This comes at a cost and can compromise backend performance.

Conclusion

Data has evolved, and the relational model might no longer be enough to represent data efficiently. This is why relational database technologies introduced ways to deal with unstructured data. Specifically, the most popular RDBMSes available now support the JSON data type. Thanks to this, you can the benefits of NoSQL into your relational database. Here, we looked at what JSON data type is, why it was introduced, and when to use or avoid it.

The post "When to Use JSON Data in a Relational Database" appeared first on Writech.

How To Design a Multi-Language Database

Antonello Zanini — Fri, 19 Jan 2024 21:40:53 +0000

Reaching millions of users with an application is every developer's dream. Achieving this goal becomes easier if users from all over the world can use your application. Since not all users know English or your target language, you need to design your application to be multilingual. This would not be possible without a multi-language database.

Designing a multi-language database that can easily scale to new languages is not easy. This is why you should rely on best practices. Here, you will see why you need a multi-language database, three great multi-language database designs, and how to choose the best one for you.

Let's now learn everything you need to know about multi-language database design.

Why You Need a Multi-Language Database

You never know how much your project will grow, and your small app for your friends could become an international service used by millions of people. If you want your product to be able to scale internationally, you need to design it so that you can easily adapt it to different cultures and markets. That is what internationalization is about.

Building a database ready for internationalization means designing a database that can store multilingual data. In other words, the backend should be able to provide data in multiple languages. To do this, the backend should connect and retrieve this data from a multi-language database.

Notice that giving users the possibility to switch between several languages is a nice feature to have. This is especially useful for polyglots or non-native speakers. So, even if your project is small and targets a local market, you should consider a multi-language database. After all, you cannot know in advance how successful your project will be and which users will use it.

Let's now learn why choosing the right multi-language database design for your needs is crucial.

Why You Should Design Your Multi-Language Database Carefully

Changing a database is a very costly operation in terms of time and energy because it triggers a ripple effect. Modifying the structure of the database involves changing the backends connected to it. This may also require you to adapt the frontends that rely on those backends accordingly. As you can see, changing a database structure is not an operation without consequences. For this reason, you should design a database that can scale easily, and you do not have to change frequently.

As you can imagine, there are several ways to design a multi-language database, and each solution has its pros and cons. Considering the importance of the database structure for an application, you have to design your multi-language database wisely. This is why you should not start from scratch but rely on best practices.

Let's now take a look at some multi-language designs based on best practices.

3 Multi-Language Database Designs

Let's delve deeper into the pros and cons of three different multi-language designs.

1. Column Approach

In this approach, each field in a multilingual table has numerous columns equal to the number of languages supported by the database.

Specifically, this is what the column name template looks like:

`columnName_languageCode`

Pros

Simple: It is easy to implement.
Fast: It does not involve JOIN or slow queries.
Easy to deal with non-translated fields: If the translation for a field is missing, you can just use COALESCE. E.g. COALESCE(name_it, name_en) returns name_it if it is not NULL, otherwise the name_en default value.

Cons

Hard to maintain: Adding a new language requires updating all multi-language tables in the database. This also means that you need to change your ORM mappings accordingly.
Not scalable: The number of columns in tables grows with the number of languages supported by the application.
Complex SELECT conditions: Forget about SELECT *. You need to specify each column in your SELECT clause.

2. Row Approach

In this approach, there is one row for each language. The key to identifying a multi-language entity is the following composite primary key:

`<id, languageCode>`

Pros

Simple: It is easy to implement.
Fast: Retrieving the translated content only requires a WHERE condition on languageCode.

Cons

Complex keys: Using a composite primary key makes identifying an element and JOIN queries more complex.
Duplicated content: To simplify things, non-translated columns generally store the same content saved in the columns of the default language row. This means that you will have a lot of duplicate content in multi-language tables.

3. Translation Table Approach

In this approach, each column of a multi-language table is an external key to a translation table. In other words, there is a translation table for each table that involves multi-language fields.

Pros

Scalable: Adding a new language does not involve changes to the database structure.
Supports historical data: You can use the translation table to keep track of the translation history for each field in an entity.
Centralized: All translations for an entity are stored in one place.

Cons

Complex queries: Queries become more complex because the information associated with a multi-language entity is spread over two tables.
Slow queries: Retrieving all the info associated with an entity requires as many JOINs as the number of columns. Considering the burden that JOINs have on performance, this can easily become a problem.
Duplicated tables: It increases the size of your database in terms of tables. Plus, you need two tables to define each multi-language entity.

What Is the Best Multi-Language Database Design for You?

As you can see, every multi-language database design has the same amount of pros and cons. This means that there is no preferred approach in absolute terms. You have to choose carefully based on your requirements, needs, and goals. I have personally used all three approaches in different projects and learned the following lessons.

The column approach is particularly useful when dealing with Big Data. If you have a database with tables with several millions of rows, you cannot afford JOIN queries or duplicated content. Although it is not the most scalable solution, the column approach is the only viable design with large data.

On the other hand, the row-by-row approach is useful when your company's branches operating in the local market have freedom of action. In this case, duplication of content can even be an advantage.

Finally, the tabular approach is the right design if you are looking for an elegant and scalable solution and do not mind the performance drawback. The table approach is best for projects where you know that the data will not grow too large.

Conclusion

Designing a database that can store multilingual data is essential to help your business scale internationally. Also, it enables non-native speakers to use your application. Changing a database is a complex and time-consuming operation with non-negligible consequences on the application architecture. This is why you should design your database as multi-language right from the start. Here, we have looked at three different approaches to designing a multilingual database, studying their pros and cons, and going into detail about which one is best for you.

The post "How To Design a Multi-Language Database" appeared first on Writech.

	`var`	`let`	`const`
Scope	Global scoped or function scoped	Block scoped	Block scoped
Declaration	You can declare it without initialization	You can declare it without initialization	You can declare it without initialization
Assignment and update	You can update it and re-declare it into the scope	You can update it into the scope, but you cannot re-declare i	You cannot update it or re-declare it into the scope
Access	You can access it even without initializing. Its default value is `undefined`.	You cannot access it without initialization	You can access it only after initializing it, since it requires you to define it

DEV Community: Writech

DbVisualizer 24.2: A Complete Review

The Need for a Restyling of DbVisualizer

DbVisualizer 24.2: The Biggest Update So Far

What’s New in DbVisualizer 24.2?

A Fresh New UI

Improved Database Support

Enhanced Data Export Options

Refined SQL Editor

Other Changes Worth Mentioning

Is 24.2 the Best Version of DbVisualizer?

How To Try DbVisualizer 24.2

Final Verdict

How to Define a Counter in MySQL

What Is Counter?

Reasons to Use a Counter in MySQL

Defining a Counter in MySQL

Using AUTO_INCREMENT

Using a Variable

Conclusion

FAQ

How to count records in MySQL?

What is the difference between COUNT and a counter in MySQL?

Should I use AUTO_INCREMENT or define a custom counter in MySQL?

How to define a variable in MySQL?

Does DbVisualizer support database variables?

Best PostgreSQL GUI Tools

Why You Need a PostgreSQL GUI Tool

Elements of a Good PostgreSQL GUI Tool

Top Four PostgreSQL GUI Tools

DbVisualizer

OmniDB

pgAdmin

TablePlus

Conclusion

Tech Blog on Your Site or on Medium / Dev.to?

How to Build a Tech Blog According to Serena Sensini

Conclusion

How to Store Spring Boot Application Metrics in InfluxDB

Creating a Spring Boot App to Collect Application Metrics

Set Up InfluxDB

Set Up an InfluxDB Bucket

Initialize a Spring Boot Application

Add the Required Dependencies

Install Micrometer

Build the Demo Application

Conclusion

Top 20 Frontend Interview Questions With Answers

1. What's the Difference Between var, let, and const in JavaScript?

2. How Should You Log Errors?

3. What Is the <meta> Tag in HTML? What Is It Used For?

4. What Is a CSS Rule?

5. How Can You Implement Internationalization?

6. What Is the Bootstrap Grid System?

7. What Is Semantic HTML? What Is It Based On?

8. What Is a Promise in JavaScript?

9. What Are Higher-Order Functions? Does JavaScript Support Them?

10. How Can You Make a Frontend Application or Website Load Faster?

11. What Is Cross-Site Scripting (XSS)?

12. What Is the BEM Approach to CSS?

13. How Can You Deal With Full Screen Programmatically?

14. What is the Difference Between <span> and <div>?

15. What Is a Mixin?

16. What Is the Document Object Model (DOM)?

17. What Is Webpack?

18. What Is npm?

19. What is the difference between CSS and SCSS?

20. How Can You Improve Technical SEO Performance?

How to Use a Proxy in PHP with cURL

Why Do You Need a Proxy in PHP?

How to Use Proxy Servers with cURL in PHP

Prerequisites

Connect to Authenticated Proxies

Rotating Proxies with cURL

Conclusion

Enabling TypeScript Programming in Visual Studio Code

How To Set Up VS Code for TypeScript Development

Prerequisites

Install the TypeScript Compiler

Create a TypeScript Project

1. What's the Difference Between `var`, `let`, and `const` in JavaScript?

3. What Is the `<meta>` Tag in HTML? What Is It Used For?

14. What is the Difference Between `<span>` and `<div>`?