: U2192 # RIGHTWARDS ARROW
+EOT
+```
+
+Then you can test by starting a new X11 application, forcing libraries to use XIM as input method:
+
+```
+GTK_IM_MODULE="xim" QT_IM_MODULE="xim" xterm
+```
+
+The new compose sequence should be available in the application you launched. I encourage you to learn more about the compose file format by typing `man 5 compose`.
+
+To make XIM the default input method for all your applications, just add to your `~/.profile` file the following two lines. that change will be effective the next time you’ll open a session on your computer:
+
+```
+export GTK_IM_MODULE="xim"
+export QT_IM_MODULE="xim"
+```
+
+It’s pretty cool, isn’t it? That way you can add all the compose sequences you might want. And there are already a couple of funny ones in the default XIM settings. Try for example to press composeLLAP.
+
+Well, I must mention two drawbacks though. XIM is relatively old and is probably only suitable for those of us who don’t regularly need multi-bytes input methods. Second, when using XIM as your input method, you no longer can enter Unicode characters by their code point using the Ctrl+Shift+u sequence. What? Wait a minute? I didn’t talk about that yet? So let’s do it now:
+
+### What if there is no compose key sequence for the character I need?
+
+The compose key is a nice tool to type some characters not available on the keyboard. But the default set of combinations is limited, and switching to XIM and defining a new compose sequence for a character you will need only once in a lifetime can be cumbersome.
+
+Does that prevent you to mix Japanese, Latin and Cyrillic characters in the same text? Certainly not, thanks to Unicode. For example, the name あゆみ is made of:
+
+- the [HIRAGANA LETTER A (U+3042)][25]
+- the [HIRAGANA LETTER YU (U+3086)][26]
+- and the [HIRAGANA LETTER MI (U+307F)][27]
+
+I mentioned above the official Unicode character names, following the convention to write them in all upper cases. After their name, you will find their Unicode code point, written between parenthesis, as a 16-bit hexadecimal number. Does that remind you something?
+
+Anyway, once you know the code point of a character, you can enter it using the following combination:
+
+- Ctrl+Shift+u, then XXXX (the _hexadecimal_ code point of the character you want) and finally Enter.
+
+As a shorthand, if you don’t release Ctrl+Shift while entering the code point, you won’t have to press Enter.
+
+Unfortunately, that feature is implemented at software library level rather than at X11 level. So the support may be variable among different applications. In LibreOffice, for example, you have to type the code point using the main keyboard. Whereas Gtk-based application will accept entry from the numeric keypad as well.
+
+Finally, when working at the console on my Debian system, there is a similar feature, but requiring instead to press Alt+XXXXX where XXXXX is the code point of the character you want, but written in _decimal_ this time. I wonder if this is Debian-specific or related to the fact I’m using the en_US.UTF-8 locale. If you have more information about that, I would be curious to read you in the comment section!
+
+| GUI | Console | Character |
+| :- | :- | :- |
+| Ctrl+Shift+u3042Enter | Alt+12354 | あ |
+| Ctrl+Shift+u3086Enter | Alt+12422 | ゆ |
+| Ctrl+Shift+u307FEnter | Alt+12415 | み |
+
+### Dead keys
+
+Last but not least, there is a simpler method to enter key combinations that do not rely (necessarily) on the compose key.
+
+Some keys on your keyboard were specifically designed to create a combination of characters. Those are called [dead keys][28]. Because when you press them once, nothing seems to happen. But they will silently modify the character produced by the next key you will press. This is a behavior inspired from mechanical typewriter: with them, pressing a dead key imprinted a character, but will not move the carriage. So the next keystroke will imprint another character at the same position. Visually resulting in a combination of the two pressed keys.
+
+We use that a lot in French. For example, to enter the letter “ë” I have to press the ¨ dead key followed by the e key. Similarly, Spanish people have the ~ dead key on their keyboard. And on the keyboard layout for Nordic languages, you can find the ° key. And I could continue that list for a very long time.
+
+![hungary dead keys][29]
+
+Obviously, not all dead keys are available on all keyboard. I fact, most dead keys are NOT available on your keyboard. For example, I assume very few of you— if any— have a dead key ¯ to enter the macron (“flat accent”) used to write Tōkyō.
+
+For those dead keys that are not directly available on your keyboard, you need to resort to other solutions. The good news is we’ve already used those techniques. But this time we will use them to emulate dead keys. Not “ordinary” keys.
+
+So, a first option could be to generate the macron dead key by using Compose- (the hyphen-minus key available on your keyboard). Nothing appears. But if after that you press the o key it will finally produce “ō”.
+
+The list of dead keys that Gtk can produce using the compose mode can be found [here][30].
+
+A different solution would use the Unicode COMBINING MACRON (U+0304) character. Followed by the letter o. I will leave the details up to you. But if you’re curious, you may discover this leads to a very subtlely different result, rather than really producing a LATIN SMALL LETTER O WITH MACRON. And if I wrote the end of the previous sentence in all uppercase, this is a hint guiding you toward a method to enter ō with fewer keystrokes than by using a Unicode combining character… But I let that to your sagacity.
+
+### Your turn to practice!
+
+So, did you get it all? Does that work on your computer? It’s your turn to try that: using the clues given above, and a little bit of practice, now you can enter the text of the challenge given in the beginning of this article. Do it, then copy-paste your text in the comment section below as proof of your success.
+
+There is nothing to win, except maybe the satisfaction of impressing your peers!
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/unicode-linux/
+
+作者：[Sylvain Leroux][a]
+选题：[lkxed][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.yesik.it/
+[b]: https://github.com/lkxed
+[1]: https://itsfoss.com/wp-content/uploads/2017/10//text-challenge.png
+[2]: https://en.wikipedia.org/wiki/ISO/IEC_8859-15
+[3]: https://itsfoss.com/wp-content/uploads/2017/10//ISO_8859-15.png
+[4]: https://en.wikipedia.org/wiki/KOI8-R
+[5]: https://en.wikipedia.org/wiki/Windows-1251
+[6]: https://itsfoss.com/wp-content/uploads/2017/10//Windows-1251.png
+[7]: https://en.wikipedia.org/wiki/ASCII
+[8]: https://itsfoss.com/wp-content/uploads/2017/10//windows-1251-to-iso8859-15-encoding-decoding-error-example.png
+[9]: https://en.wikipedia.org/wiki/Email_client
+[10]: https://en.wikipedia.org/wiki/Mojibake
+[11]: https://itsfoss.com/wp-content/uploads/2017/10/Mojibake-french-example.png
+[12]: https://en.wikipedia.org/wiki/Unicode
+[13]: https://en.wikipedia.org/wiki/Code_point
+[14]: https://itsfoss.com/wp-content/uploads/2017/10//unicode-utf-32-encoding-example.png
+[15]: https://en.wikipedia.org/wiki/UTF-32
+[16]: https://en.wikipedia.org/wiki/UTF-16
+[17]: https://en.wikipedia.org/wiki/UTF-8
+[18]: https://itsfoss.com/wp-content/uploads/2017/10//unicode-utf-16-encoding-example.png
+[19]: https://itsfoss.com/wp-content/uploads/2017/10//unicode-utf-8-encoding-example.png
+[20]: https://en.wikipedia.org/wiki/Compose_key
+[21]: https://itsfoss.com/wp-content/uploads/2022/12/compose_key_on_lk201_keyboard.jpg
+[22]: https://en.wikipedia.org/wiki/Hyphen-minus
+[23]: https://help.ubuntu.com/community/GtkComposeTable
+[24]: https://en.wikipedia.org/wiki/X_Input_Method
+[25]: http://www.fileformat.info/info/unicode/char/3042/index.htm
+[26]: http://www.fileformat.info/info/unicode/char/3086/index.htm
+[27]: http://www.fileformat.info/info/unicode/char/307F/index.htm
+[28]: https://en.wikipedia.org/wiki/Dead_key
+[29]: https://itsfoss.com/wp-content/uploads/2022/12/hungary_dead_keys.png
+[30]: https://help.ubuntu.com/community/GtkDeadKeyTable
diff --git a/sources/tech/20221213.3 ⭐️ Linux Mint Upgrade Tool Usage Guide.md b/sources/tech/20221213.3 ⭐️ Linux Mint Upgrade Tool Usage Guide.md
new file mode 100644
index 0000000000..fe68240171
--- /dev/null
+++ b/sources/tech/20221213.3 ⭐️ Linux Mint Upgrade Tool Usage Guide.md
@@ -0,0 +1,104 @@
+[#]: subject: "Linux Mint Upgrade Tool: Usage Guide"
+[#]: via: "https://www.debugpoint.com/mint-upgrade-tool/"
+[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
+[#]: collector: "lkxed"
+[#]: translator: "geekpi"
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+Linux Mint Upgrade Tool: Usage Guide
+======
+
+**Here’s how you can upgrade to new Linux Mint versions using the Mint upgrade tool, i.e. mintupgrade GUI with actual upgrade process screenshots.**
+
+If you are looking for **detailed upgrade** steps to the recently released **Linux Mint 21 Vanessa**, read this guide 👉 [upgrade-linux-mint-21-from-20-3][1]
+
+### Linux Mint Upgrade Tool
+
+The Linux Mint team [announced][2] a few months back, that they built a new utility to upgrade the Linux Mint’s significant versions. It’s called the “mintupgrade2”. Development is complete, and It is currently under the support and planning for upgrading to the major versions—for example, Linux Mint 20 to 21 and not the minor version upgrades.
+
+Although you can upgrade the versions using the standard apt commands, the Mint team believes significant version upgrades are tricky. It would be difficult for the new users to perform a seamless upgrade because it involves the terminal and a set of complex steps with commands.
+
+Moreover, the GUI is a wrapper with additional features to the mintupgrade program, which brings a set of pre-system checks and upgrade processes with a one-click Fix.
+
+In addition, the mintupgrade checks basic checks, whether you are connected to power, the system is up to date, disk space availability and many more features.
+
+To show you how it looks and works, we set up a testbed with LMDE 4 and give it a go.
+
+But before that, here’s a quick set of features:
+
+- Entirely GUI-driven upgrade process
+- Multi-language support
+- Pre-upgrade checks: system backup, power, disk space, list of removed packages
+- Configurable
+- Alert you about the orphaned packages from the prior version
+- It gives you the option to fix issues
+
+### How it works
+
+When we ran the mint upgrade utility via the command `mintupgrade`, the GUI, the friendly welcome screen gives you an excellent starting point and starts the upgrade process. And then, it begins with a series of checks on its own.
+
+![Starting the upgrade process][3]
+
+In addition to that, when it finds some problem in your system, it stops and gives you sufficient details about it. Once you click on Fix, it can resume the process again.
+
+That’s not all; it can resume the upgrade process if interrupted due to network or internet or any other problem.
+
+The utility found the following errors in our test system during our test and fixed them with just one click.
+
+![Apt Cache check][4]
+
+![Mint Upgrade detects that system snapshots not present][5]
+
+![Check for Orphan Packages][6]
+
+![Status before upgrade][7]
+
+![Mint Upgrade can detect the packages require downgrade][8]
+
+Lastly, we successfully upgraded a test system from LMDE 4 to LMDE 5.
+
+![Upgrade Complete][9]
+
+#### How to get this upgrade utility
+
+The installation of the utility is easy using the commands below. However, if you are running the latest version of Linux Mint 21, it should already be installed and try by running mintupgrade from the terminal.
+
+```
+sudo apt update
+```
+
+```
+sudo apt install mintupgrade
+```
+
+### Closing Notes
+
+Finally, I think it’s one of the best utilities by the Linux Mint team. As you can see above, it handled many errors on its own. All I did was click the “Fix” button. And the utility is smart enough to understand all the failure points and take care of the remediations.
+
+[GitHub and source code of mintupgrade][10]
+
+--------------------------------------------------------------------------------
+
+via: https://www.debugpoint.com/mint-upgrade-tool/
+
+作者：[Arindam][a]
+选题：[lkxed][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.debugpoint.com/author/admin1/
+[b]: https://github.com/lkxed
+[1]: https://www.debugpoint.com/upgrade-linux-mint-21-from-20-3/
+[2]: https://www.debugpoint.com/2022/04/linux-mint-21-announcement/
+[3]: https://www.debugpoint.com/wp-content/uploads/2022/04/Starting-the-upgrade-process.jpg
+[4]: https://www.debugpoint.com/wp-content/uploads/2022/04/Apt-Cache-check.jpg
+[5]: https://www.debugpoint.com/wp-content/uploads/2022/04/Mint-Upgrade-detects-that-system-snapshots-not-present.jpg
+[6]: https://www.debugpoint.com/wp-content/uploads/2022/04/Check-for-Orphan-Packages.jpg
+[7]: https://www.debugpoint.com/wp-content/uploads/2022/04/Status-before-upgrade.jpg
+[8]: https://www.debugpoint.com/wp-content/uploads/2022/04/Mint-Upgrade-can-detect-the-packages-require-downgrade.jpg
+[9]: https://www.debugpoint.com/wp-content/uploads/2022/04/Upgrade-Complete.jpg
+[10]: https://github.com/linuxmint/mintupgrade
diff --git a/sources/tech/20221213.4 ⭐️⭐️ Use Django to send emails with SMTP.md b/sources/tech/20221213.4 ⭐️⭐️ Use Django to send emails with SMTP.md
new file mode 100644
index 0000000000..7e6ab1dc0a
--- /dev/null
+++ b/sources/tech/20221213.4 ⭐️⭐️ Use Django to send emails with SMTP.md
@@ -0,0 +1,300 @@
+[#]: subject: "Use Django to send emails with SMTP"
+[#]: via: "https://opensource.com/article/22/12/django-send-emails-smtp"
+[#]: author: "Sofiia Tarhonska https://opensource.com/users/sofiiatarhonska"
+[#]: collector: "lkxed"
+[#]: translator: " "
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+Use Django to send emails with SMTP
+======
+
+Numerous professions utilize simple mail transfer protocol (SMTP) to deliver emails to their end users. SMTP also retrieves messages, though that has not been its primary use case. Open source frameworks like Django, a Python-based web framework, allows more control for sending emails using functions and expressions.
+
+This article shows how to configure an SMTP server and send emails in Django using SMTP.
+
+### Project setup and overview
+
+Before proceeding, this tutorial requires a code editor (such as [VS Code or Codium][1]) on your preferred device.
+
+Start by creating a new directory using the command in the terminal:
+
+```
+mkdir exampledirectory
+```
+
+Then change into the directory using the command:
+
+```
+cd exampledirectory
+```
+
+Within the newly created directory, create a [virtual environment][2] using the built-in venv module in the command terminal:
+
+```
+python -m venv
+```
+
+This command creates a virtual environment within the folder created earlier. To activate it, use the following command in the terminal:
+
+On Linux and Mac:
+
+```
+source .virtenv/bin/activate
+```
+
+On Windows:
+
+```
+\Scripts\activate
+```
+
+### Creating a Django project
+
+After activating the virtual environment, proceed to install the Django package from [pip][3]:
+
+```
+pip install django
+```
+
+Create a new Django project:
+
+```
+python -m django startproject NewEmailProject
+```
+
+This command creates a project with the name `NewEmailProject`. To run the project, head to the project directory (`NewEmailProject`) and run the server:
+
+```
+python manage.py runserver
+```
+
+Open the link for the developmental server in a browser. You see the Django homepage with release notes.
+
+### Configuration for sending emails
+
+Next, open the `settings.py` file (in the `NewEmailProject` folder) to customize configurations for sending emails using Django.
+
+Scroll to the end of the code and update the file with the following code:
+
+```
+EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+EMAIL_HOST = 'smtp.yourserver.com'
+EMAIL_USE_TLS = False
+EMAIL_PORT = 465
+EMAIL_USE_SSL = True
+EMAIL_HOST_USER = 'your@djangoapp.com'
+EMAIL_HOST_PASSWORD = 'your password'
+```
+
+Change the value of the `EMAIL_HOST` depending on your email client. Here are the acceptable values for common email clients:
+
+- **Gmail:**`smtp.gmail.com`
+- **Outlook:**`smtp-mail.outlook.com`
+- **Yahoo:**`smtp.mail.yahoo.com`
+
+You can change the `EMAIL_PORT` or leave 465 as the default.
+
+You can use the secure socket layer (SSL) and transport socket layer (TSL) interchangeably as they specify connection security.
+
+To figure out other custom configurations for your email server, check out the full [Django Project documentation][4].
+
+### SMTP email backend
+
+The `EMAIL_BACKEND` expression helps determine the most suitable backend when sending emails through the Django SMTP server. This variable points to `smtp.EmailBackend`, which receives all the parameters needed for sending emails. It tells Django to send the email to the recipient email using SMTP and not to the console.
+
+### Sending emails with SMTP
+
+When the environment is set up and `settings.py` is updated, you can send emails in Django. You can use an HTML form that sends a post request of the necessary information needed for sending an email.
+
+Create a Django application for sending emails:
+
+```
+python manage.py startapp mail
+```
+
+Next, open the `settings.py` file and add the Django application (mail) to the `INSTALLED_APPS` list:
+
+```
+INSTALLED_APPS = [
+"django.contrib.admin",
+"django.contrib.auth",
+"django.contrib.contenttypes",
+"django.contrib.sessions",
+"django.contrib.messages",
+"django.contrib.staticfiles",
+"mail"]
+```
+
+### Send mail function
+
+In the mail application's `views.py` file, start by importing the `EmailMessage` and `get_connection` from `django.core.mail`:
+
+```
+from django.core.mail import EmailMessage, get_connection
+```
+
+The `EmailMessage` class is responsible for creating the email message itself. The `get_connection()` function returns an instance of the email backend specified in `EMAIL_BACKEND`.
+
+Now create a function that accepts a `POST` request, which contains form data submitted from the client side. Followed by the `get_connection()` functions parameters containing the email configurations created in the project `settings.py` file.
+
+Next, import the settings:
+
+```
+from django.conf import settings
+```
+
+This import allows access to the email configurations created in the `settings.py`. Next, create the variables:
+
+```
+subject, recipient_list,
+```
+
+Then you can `message`, and store the corresponding attributes used in the HTML form. The `email_from` variable contains the sender email, which is obtained from `EMAIL_HOST_USER` in the `settings.py` file.
+
+After the variables are processed, the `EmailMessage` class sends an email using the `sends()` method, and then closes the connection. The `send_email()` function renders the `home.html` file containing the email form.
+
+You can create a templates folder within your mail application and store the HTML files within that folder:
+
+```
+from django.core.mail import EmailMessage, get_connectionfrom django.conf import settingsdef send_email(request):
+ if request.method == "POST":
+ with get_connection(
+ host=settings.EMAIL_HOST,
+ port=settings.EMAIL_PORT,
+ username=settings.EMAIL_HOST_USER,
+ password=settings.EMAIL_HOST_PASSWORD,
+ use_tls=settings.EMAIL_USE_TLS
+ ) as connection:
+ subject = request.POST.get("subject")
+ email_from = settings.EMAIL_HOST_USER
+ recipient_list = [request.POST.get("email"), ]
+ message = request.POST.get("message")
+ EmailMessage(subject, message, email_from, recipient_list, connection=connection).send()
+
+ return render(request, 'home.html')
+```
+
+This is a bootstrap form for generating a message:
+
+```
+
+```
+
+This form sends a post request to the `send_email()` function. This processes the form data and sends the email to the recipients.
+
+Now open the `urls.py` file in the `NewEmailProject` folder to create the homepage URL. Update the `urlpattern` list by adding the code `path("", send_email)` .
+
+### Sending email to multiple recipients
+
+To specify multiple recipients when sending the same email, create a new function called `send_emails` within the `views.py` file and modify the send function code:
+
+```
+def send_emails(request):
+ if request.method == "POST":
+ with get_connection(
+ host=settings.EMAIL_HOST,
+ port=settings.EMAIL_PORT,
+ username=settings.EMAIL_HOST_USER,
+ password=settings.EMAIL_HOST_PASSWORD,
+ use_tls=settings.EMAIL_USE_TLS
+ ) as connection:
+ recipient_list = request.POST.get("email").split()
+ subject = request.POST.get("subject")
+ email_from = settings.EMAIL_HOST_USER
+ message = request.POST.get("message")
+ print(type(recipient_list))
+ EmailMessage(subject, message, email_from, recipient_list, connection=connection).send()
+
+ return render(request, 'send_emails.html')
+```
+
+For the `recipient_list` variable, I'm using the Python `split()` method to convert the recipients email string to list so that I can email all of them.
+
+Next, create another HTML file called `send_emails.html` in the templates folder and use the same form code for the `home.html` file within it.
+
+To specify multiple email recipients, use a space between each email address:
+
+```
+first@gmail.com second@gmail.com third@gmail.com
+```
+
+You should also update the `urlpattern` list by adding the code:
+
+```
+path("send-emails/", send_email)
+```
+
+### Sending HTML emails
+
+You can also send HTML emails with Django using a slightly modified version of the `send_email` function:
+
+```
+html_message = '''this is an automated message
'''
+msg = EmailMessage(subject, html_message, email_from,recipient_list, connection=connection)
+msg.content_subtype = "html"
+msg.send()
+```
+
+### Sending emails with attachment
+
+To include attachment to mails, create a variable and put it in the file path in a string like this:
+
+```
+attachment = "mail/templates/example.png"
+```
+
+Then, move the `EmailMessage` function to a variable and call the `attach_file` method followed by the `send` method:
+
+```
+msg = EmailMessage(subject, message, email_from, recipient_list, connection=connection)
+msg.attach_file(attachment)
+msg.send()
+```
+
+### Django email libraries
+
+This guide on sending emails in Django would not be complete if I didn't mention the email libraries that are available to users. Here are some noteworthy email libraries.
+
+- **Django mailer** is a Django app for queuing as it saves emails in a database and sends the mail out at a designated time.
+- **Django templated email** aims to send templated emails. It offers features like configurable template naming and location, template inheritance, and adding recipients to the CC and BCC lists.
+- **Anymail** allows the use of an email service provider (ESP). By using `django.core.mail`, it provides a sustained API that avoids tying your code to a single ESP.
+
+### Emailing with Django
+
+Sending emails in Django can sound daunting, but it's as simple as creating a virtual environment. You can add Django to the environment and create an email backend. Finally, you can set up an HTML template. Give it a try.
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/22/12/django-send-emails-smtp
+
+作者：[Sofiia Tarhonska][a]
+选题：[lkxed][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/sofiiatarhonska
+[b]: https://github.com/lkxed
+[1]: https://opensource.com/article/20/6/open-source-alternatives-vs-code#vscodium
+[2]: https://opensource.com/article/21/2/python-virtualenvwrapper
+[3]: https://www.redhat.com/sysadmin/install-python-pip-linux
+[4]: https://docs.djangoproject.com/en/3.2/ref/settings/#email-backend
+
diff --git a/sources/tech/20221213.5 ⭐️⭐️ Drupal 10 is worth a fresh look.md b/sources/tech/20221213.5 ⭐️⭐️ Drupal 10 is worth a fresh look.md
new file mode 100644
index 0000000000..408b105756
--- /dev/null
+++ b/sources/tech/20221213.5 ⭐️⭐️ Drupal 10 is worth a fresh look.md
@@ -0,0 +1,79 @@
+[#]: subject: "Drupal 10 is worth a fresh look"
+[#]: via: "https://opensource.com/article/22/12/drupal-10-fresh-look"
+[#]: author: "Martin Anderson-Clutz https://opensource.com/users/mandclu"
+[#]: collector: "lkxed"
+[#]: translator: " "
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+Drupal 10 is worth a fresh look
+======
+
+The popular Drupal open source content management system (CMS) reaches a significant milestone when version 10 is released on December 14. Personally, I think Drupal X sounds way cooler, but so far, my calls to name it that haven't gotten much traction. I enlisted the help of my friend Aaron Judd of [Northern Commerce][1] to give us a sense of how cool Drupal X could look:
+
+![New Drupal 10 racing 10 logo][2]
+
+### What's a Drupal, anyway?
+
+Drupal is an open source CMS and development framework. While other CMS options focus on simple long-form content (think blogs) or entirely free-form content (like in Wix or Squarespace), Drupal has made a name for itself in handling more complex content architectures, in multiple languages, with robust content governance. Drupal sites (like this site, Opensource.com!) benefit from a strong role-based access control (RBAC) system, unlimited custom roles and workflows, and a powerful and extensible media library.
+
+Here's a rundown for anyone who hasn't kept tabs on what's coming in the newest major version.
+
+### A fresh face
+
+Most Drupal sites use custom themes to give them a unique look and feel. Still, the initial experience you have when installing a CMS matters. In Drupal, themes define the look and feel of a site, and you can use different themes for public and administrative experiences. Until recently, the Bartik and Seven themes had been the default face of Drupal for more than a decade. To put that in context, when Bartik was released, the most popular browser in the world was Internet Explorer 8. A lot has changed since then, particularly around best practices for building websites.
+
+In fact, a significant change in Drupal 10 will be the removal of support for Internet Explorer (IE), which is itself no longer supported by Microsoft and hasn't seen major updates since 2013. That may not sound like an improvement, but continued support for IE kept the community from adopting modern markup and styling. For example, thanks to being unencumbered by support for legacy browsers, Drupal 10 includes a new responsive grid layout that's so innovative it got a writeup in [CSS Tricks][3].
+
+![Responsive grid configuration][4]
+
+The new faces of Drupal are two brand new themes: Olivero for visitors and Claro for admins. In addition to being fresh and modern designs, both were developed with accessibility as a top priority.
+
+### Improvements under the hood
+
+More than a decade ago, the Drupal community decided to "Get Off the Drupal Island." That meant adopting solutions shared across popular projects and frameworks instead of ones developed and maintained exclusively by the Drupal community. Today Drupal leverages a variety of projects and libraries whose names will be familiar to open source developers who have never touched Drupal: Symfony, Composer, CKEditor, Twig, Nightwatch, and more.
+
+That has brought a variety of powerful capabilities to Drupal and allowed it to contribute back to those solutions, benefitting a broader set of developers. It has also become a determining factor for the cadence of Drupal's major version releases.
+
+To illustrate, consider that Drupal 7 was released in early 2011. Drupal 8 was released almost five years later, towards the end of 2015. Drupal 9 was released in June of 2020, with a key motivator being the move to supported versions of underlying dependencies and removing deprecated code. And now, roughly two and half years later, we're already planning to release Drupal 10. This new major version will leverage updated versions of PHP, Symfony, and Composer, among others.
+
+### An all-new editor
+
+An upgrade of particular note is the move to CKEditor 5. Although notionally an incremental update, under the hood CKEditor 5 was completely rewritten, much the same as the transition from Drupal 7 to 8. In addition to a sleeker interface, CKEditor 5 has the potential for exciting new capabilities, such as real-time collaboration. Drupal's CKEditor integration for version 5 has already been augmented with a number of UI enhancements. For example, media placed within content can be configured using an overlaid toolbar ribbon instead of needing to launch a modal dialog to access these settings. Also, the styles dropdown now includes a preview of each type available.
+
+![Real-time collaboration][5]
+
+### A look ahead
+
+Earlier in 2022, Drupal creator and project lead Dries Buytaert announced a focus on "ambitious site builders." This means that while the community will continue to work on making the developer experience better in general, moving forward there is a particular focus on making it easier to create engaging experiences in Drupal without having to write code or use command-line tools. Three strategic initiatives embody this new focus: Automatic Updates, the Project Browser, and Recipes.
+
+**Automatic Updates** will reduce the total cost of ownership for Drupal sites and help them be more secure by ensuring they always have the latest core security patches. This will be a major benefit for site owners and Drupal development teams everywhere. However, judging by personal experience, Wednesday night pizza sales may take a hit (traditionally, the Drupal security team releases updates on the third Wednesday of the month). There is now a stable release of Automatic Updates as a contrib module. Work has begun to move this into Drupal core, so all Drupal sites will eventually be able to leverage this capability.
+
+The **[Project Browser][6]** makes Drupal sites easier to build, maintain, and evolve by allowing site builders to search and browse through a subset of Drupal's vast catalog of available modules, prefiltered to the site's Drupal version, for security, stability, and more. A site builder can select, download, and install a module without leaving the site's web interface. In fact, there's an "app store" like interface meant to promote the most popular modules available that are compatible with the current site's version of Drupal. While other CMS options have had similar offerings, this advancement means you don't need to sacrifice ease-of-use to take advantage of the power of Drupal. Also, all of the thousands of modules listed are 100% free.
+
+For many years Drupal has had a concept of distributions. These are opinionated versions of Drupal designed to meet specific use cases such as media publishing, fundraising, intranet portals, and more. While distributions have proven an excellent way to accelerate initial development, in practice, they have been known to require significant work to maintain and create extra work for site owners during maintenance. The **Recipes** initiative aims to make more granular, composable functionality available when building a site. Want to add a staff directory, events calendar, or locations map to your site? In the future, this will be as easy as installing a recipe and then customizing it to meet your site's specific needs.
+
+### It's an exciting time to try Drupal
+
+Drupal 10 is the culmination of work contributed by thousands of dedicated and talented community members worldwide. If you're not already using Drupal, we hope you'll try it out for your next project. There's a common saying among Drupalists: "Come for the code, stay for the community."
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/22/12/drupal-10-fresh-look
+
+作者：[Martin Anderson-Clutz][a]
+选题：[lkxed][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/mandclu
+[b]: https://github.com/lkxed
+[1]: https://www.northern.co/
+[2]: https://opensource.com/sites/default/files/2022-12/DrupalX-RacerSticker-DrupalBlue-300ppi.png
+[3]: https://css-tricks.com/an-auto-filling-css-grid-with-max-columns
+[4]: https://opensource.com/sites/default/files/2022-11/responsive-grid-config.png
+[5]: https://opensource.com/sites/default/files/2022-11/realtime-collaboration_0.gif
+[6]: https://www.drupal.org/project/project_browser
diff --git a/sources/tech/20221213.6 ⭐️⭐️ Try this Linux web browser as your file manager.md b/sources/tech/20221213.6 ⭐️⭐️ Try this Linux web browser as your file manager.md
new file mode 100644
index 0000000000..622adb597e
--- /dev/null
+++ b/sources/tech/20221213.6 ⭐️⭐️ Try this Linux web browser as your file manager.md
@@ -0,0 +1,96 @@
+[#]: subject: "Try this Linux web browser as your file manager"
+[#]: via: "https://opensource.com/article/22/12/linux-file-manager-konqueror"
+[#]: author: "Seth Kenlon https://opensource.com/users/seth"
+[#]: collector: "lkxed"
+[#]: translator: " "
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+Try this Linux web browser as your file manager
+======
+
+Konqueror is a file manager and web browser for the KDE Plasma Desktop. In many ways, Konqueror defined "network transparency," as it applied to a personal desktop. With Konqueror, you can browse remote network files (including the Internet itself, which really is just a collection of remote files viewed through a fancy lens) just as easily as browsing your local files. Sometimes there was some configuration and setup required, depending on what kind of file share you needed to access. But ultimately, the goal of having instant access to all the data you had permission to view was a reality with Konqueror in ways no other file manager had achieved. And at its peak, the open source web engine it developed (KHTML) was adopted by both Apple and Google, and lives on today as the core library of modern web browsing and, technically, Electron app development.
+
+Today, the KDE Plasma Desktop lists Konqueror as a web browser. Officially, file management has shifted over to [Dolphin][1], but Konqueror is still capable of doing the job. For the full and classic Konqueror experience, you should try the Plasma Desktop 3.x fork [TDE][2], but in this article I use Konqueror in KDE Plasma Desktop version 5.
+
+### Install Konqueror
+
+If you're running KDE Plasma Desktop already, you may already have Konqueror installed. If not, you can install it from your distribution's software repository. On Fedora, CentOS, Mageia, OpenMandriva, and similar:
+
+```
+$ sudo dnf install -y konqueror konqueror-plugins
+```
+
+On Debian, Linux Mint, Elementary, and similar:
+
+```
+$ sudo apt install -y konqueror konqueror-plugins
+```
+
+![Image of Konqueror's file manager.][3]
+
+### Configure Konqueror as a file manager
+
+The most convenient feature of Konqueror is that it's a web browser in addition to being a file manager. Or at least, that's theoretically its most convenient feature. If you're not using Konqueror as a web browser, then you may not want the URL field or the search engine field at the top of every file manager window.
+
+As with most KDE applications, Konqueror is highly configurable. You can reposition and add and remove toolbars, add or remove buttons, and so on.
+
+To adjust what toolbars are displayed, launch Konqueror and go to the **Settings** menu and select **Toolbars Shown**. The **Main** toolbar is probably all you really need for file management. It's the toolbar with navigation buttons on it. However, you may not even need that, as long as you're happy to navigate with keyboard shortcuts or using the **Go** menu.
+
+Keyboard navigation in Konqueror is the same as in Dolphin:
+
+- **Alt+Left arrow**: Back one step
+- **Alt+Up arrow**: Move to parent directory
+- **Alt+Home**: Go to home directory
+
+### Side panel
+
+To get a side panel with a listing of common folders, press **F9** or select **Show Sidebar** from the **Settings** menu. This adds a button bar along the left side of the Konqueror window. Click the **Home** icon to display a file tree of your home directory.
+
+![Image of Konqueror with a sidebar.][4]
+
+As the button bar suggests, this side panel can serve many purposes. Instead of your home directory, you can display bookmarked locations, a history of recent locations you've visited, remote filesystems, and more.
+
+### Applications
+
+Some people are used to an application menu. It's efficient and quick, and always in the same place. Other people prefer to launch applications from the terminal.
+
+There's yet another way to view application launchers, though. Konqueror's **Go** menu allows you go to a meta location called **Applications**, which lists application launchers, by category, as files in a file manager.
+
+![Image of applications in Konqueror.][5]
+
+You can see this in Dolphin, too, by manually typing **applications:** in the location field, but of the two it's Konqueror that provides a menu option to go there directly.
+
+### Network folders
+
+Similarly, Konqueror also provides a menu selection to go to network folders. The greatest network folder of them all is the Internet, but **Network Folders** is the meta location for network protocols other than HTTP. Most remote locations require some setup because they usually require authentication to access. Most of them can be configured through **System Settings**, including file systems accessible over Bluetooth, SMB or CIFS, MTP devices, Fish (file system over SSH), and even Google Drive.
+
+### Split view
+
+You can split the Konqueror window into panes, allowing you to see two folders at once without opening two windows. There are two split options: a vertical split with one pane on the left and the other on the right, or a horizontal split with one pane above the other.
+
+To split the Konqueror window, go to the **Window** menu and select either **Split View Left/Right** or **Spit View Top/Bottom**. Each pane is independent of the other, so you can navigate around in one pane, and then drag and drop files from one to the other.
+
+### Conquering your file system
+
+Konqueror isn't _just_ a file manager, and I don't think the developers of the Plasma Desktop expect you to use it as your primary file manager. There's even an option in the **File** menu to open a location in **Dolphin**, which indicates that Konqueror is a web browser with a file manager component. But that file manager component is a nice feature to have when you need it. And if you're not a fan of all the features Dolphin offers, Konqueror could be a suitable alternative.
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/22/12/linux-file-manager-konqueror
+
+作者：[Seth Kenlon][a]
+选题：[lkxed][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/seth
+[b]: https://github.com/lkxed
+[1]: https://opensource.com/article/22/12/linux-file-manager-dolphin
+[2]: https://opensource.com/article/19/12/linux-trinity-desktop-environment-tde
+[3]: https://opensource.com/sites/default/files/2022-10/konqueror-filemanager.png
+[4]: https://opensource.com/sites/default/files/2022-10/konqueror-sidebar.png
+[5]: https://opensource.com/sites/default/files/2022-10/konqueror-applications.png
diff --git a/translated/tech/20221004 Learn the OSI model in 5 minutes.md b/translated/tech/20221004 Learn the OSI model in 5 minutes.md
new file mode 100644
index 0000000000..cd2b6d735a
--- /dev/null
+++ b/translated/tech/20221004 Learn the OSI model in 5 minutes.md
@@ -0,0 +1,100 @@
+[#]: subject: "Learn the OSI model in 5 minutes"
+[#]: via: "https://opensource.com/article/22/10/osi-model-network-communications"
+[#]: author: "Anamika https://opensource.com/users/anamika"
+[#]: collector: "lkxed"
+[#]: translator: "cool-summer-021"
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+5 分钟内了解 OSI 模型
+======
+理解OSI框架的基本概念，掌握计算机系统通信机制
+
+开放系统互联（OSI）模型是一个定义计算机、服务器和用户如何在一个系统内通信的标准。它是第一个网络通信标准模型，在20世纪80年代早期，所有主流的计算机和通信公司都采用了这个标准。
+
+OSI 模型提供了一种通用语言，用于描述网络，以及在离散的块或层中考虑相关的问题。
+
+### OSI模型的各个层
+
+该模型描述了计算机系统通过网络进行通信的七个层。
+
+1. [应用层][2]
+2. [表现层][3]
+3. [会话层][4]
+4. [传输层][5]
+5. [网络层][6]
+6. [数据链路层][7]
+7. [物理层][8]
+
+每个层都有自己的工作方式和一系列跟其他层不同的协议。本文将逐个剖析这些层级。
+
+### 应用层
+
+应用层是在软件中实现的。它是与应用程序交互的层级。
+
+考虑发送消息的例子。发送消息的程序与应用层进行交互，并发送消息。接着，应用层向 OSI 模型的下一个层级（即表现层）发送消息。
+
+### 表现层
+
+来自应用层的数据被转发到表现层。表现层接收到文字、字符、字母、数字等形式的数据，并把它们转换为机器可识读的二进制格式数据。这个过程叫做编译。
+
+在此阶段，ASCII（美国信息交换标准码） 字符被转换为扩充的二进制编码的十进制交换码（EBCDIC）。转换后的数据在继续传输前，也会进行编码和加密过程，使用SSL协议进行加密和解密。
+
+表现层的作用是抽象化，它假设下面的层级会处理它们收到的数据。它也负责压缩数据。数据的压缩可能是有损的，也有可能是无损的，这取决于很多因素，不属于本文的讨论范围。
+
+### 会话层
+
+会话层的作用是建立和管理连接。该层级的主要工作是建立会话。例如，你登录网上商城，就在你的机器和服务器之间建立了会话。
+
+会话层的作用是实现数据的发送和接收，完成后连接的会话就终止了。在一个会话建立前，会进行身份验证。与上一层类似，会话层也假设在它的工作完成后，下面的层级也会准确无误地处理数据。
+
+### 传输层
+
+传输层的作用是管理数据传输和其自身的关于数据如何传输的一些协议。从会话层传到这里的数据被分为更小的数据单元，这些数据单元称为片段。这个过程叫做“分割”。每个片段包含来源端口号、目标端口号和一个序列号。端口号用来识别发送数据的应用程序。注意，数据以块的形式传输。序列号用于把这些片段按正确的顺序排列。
+
+传输层负责控制流量或在给定的时间内传输的数据量。它也负责错误的管理，比如数据丢失、损坏等情况。它利用一种错误探测值，通常叫做校验和。传输层对每个数据片段加上校验和，就可以检查所发送的数据是否被正确接收。然后数据传输到网络层。
+
+### 网络层
+
+网络层的作用是跟其他网络进行通信。它把从一台机器接收到的数据片段传输给另一台位于不同网络的机器。路由器是作用于网络层的。
+
+网络层的功能是逻辑寻址（就是确定 IP 地址）。它为发送方和接收方分配 IP 地址，数据包附带了这个地址，就可以被传输到正确的目标机器。接着网络层对数据包进行路由。负载均衡也是在网络层进行的，旨在确保不会发生过载。下一步，数据传输到数据链路层。
+
+### 数据链路层
+
+数据链路层支持跟其他设备直接通信。
+
+它接收到来自网络层、包含发送方和接收方 IP 地址的数据包，进行物理寻址，然后将发送方和接收方的 MAC 地址分配给数据包，形成帧。
+
+### 物理层
+
+物理层由系统的所有硬件和物理设备（包括网线、导航系统、适配器等）组成。在这里，从前面层级接收到的数据都是 0 和 1 形式的。物理层把这些数据转换并通过各种方式（如果是光纤电缆，有电线、电信号、光信号；如果是 WIFI，则为无线电信号）传输至本地媒介。
+
+注意，物理层作用于接收方的一端，把接收到的信号以帧的形式传输到数据链路层（把它转换回二进制数据形式）。然后帧传输到上面的层级，最终应用层（应用软件）会接收到需要的数据。
+
+### 结语
+
+当你需要描述网络架构或排除网络问题时，OSI 模型的相关知识会对你有所帮助。我希望本文能令你对这个模型的方方面面有清晰的理解。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/22/10/osi-model-network-communications
+
+作者：[Anamika][a]
+选题：[lkxed][b]
+译者：[cool-summer-021](https://github.com/cool-summer-021)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/anamika
+[b]: https://github.com/lkxed
+[1]: https://opensource.com/sites/default/files/lead-images/code_computer_development_programming.png
+[2]: https://opensource.com/article/22/10/osi-model-network-communications#application-layer
+[3]: https://opensource.com/article/22/10/osi-model-network-communications#presentation-layer
+[4]: https://opensource.com/article/22/10/osi-model-network-communications#session-layer
+[5]: https://opensource.com/article/22/10/osi-model-network-communications#transport-layer
+[6]: https://opensource.com/article/22/10/osi-model-network-communications#network-layer
+[7]: https://opensource.com/article/22/10/osi-model-network-communications#data-link-layer
+[8]: https://opensource.com/article/22/10/osi-model-network-communications#physical-layer
diff --git a/translated/tech/20221122.2 ⭐️⭐️⭐️ Introducing Rust calls to C library functions.md b/translated/tech/20221122.2 ⭐️⭐️⭐️ Introducing Rust calls to C library functions.md
new file mode 100644
index 0000000000..c318bfa2dd
--- /dev/null
+++ b/translated/tech/20221122.2 ⭐️⭐️⭐️ Introducing Rust calls to C library functions.md
@@ -0,0 +1,287 @@
+[#]: subject: "Introducing Rust calls to C library functions"
+[#]: via: "https://opensource.com/article/22/11/rust-calls-c-library-functions"
+[#]: author: "Marty Kalin https://opensource.com/users/mkalindepauledu"
+[#]: collector: "lkxed"
+[#]: translator: "yzuowei"
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+介绍从 Rust 调用 C 库函数
+======
+
+为什么要从 Rust 调用 C 函数？简短的回答就是软件库。冗长的答案则触及到 C 在众多编程语言中的地位，特别是相对 Rust 而言。C，C++，还有 Rust 都是系统语言，这意味着程序员会访问机器层面的数据类型与操作。在这三个系统语言中，C 依然占据主导地位。现代操作系统的内核大致用 C 来写，其余部分依靠汇编语言来补充。在标准系统函数库中，输入与输出、数字处理、加密计算、安全、网络、国际化、字符串处理、内存管理，还用更多，都大体用 C 来写。这些函数库所代表的是一个庞大的基础架构，支撑着用其他语言写出来的应用。Rust 发展至今也有着可观的函数库，但是 C 的函数库——自1970年代就已存在，迄今还在蓬勃发展——是一个无法被忽视的资源。最后一点是， C 依然还是编程语言中的 [lingua franca][1]：大部分语言都与 C 交流，透过 C，语言互相交流。
+
+### 两个概念证明的例子
+
+Rust 支持 FFI （外部函数接口）用以调用 C 函数。任何 FFI 所需要面临的问题是调用方语言是否包括了被调用语言的数据类型。例如，`ctypes` 是 Python 调用 C 的 FFI，但是 Python 并没有包括 C 所支持的无符号整数类型。结果就是，`ctypes` 必须寻求解决方案。
+
+与之相对的是，Rust 包含了所有 C 中的原始（即，机器层面）类型。比如说，Rust 中的 `i32` 类对应 C 中的 `int` 类。C 特别声明了 `char` 类必须是一个字节大小，而其他类型，比如 `int`，必须至少是这个大小（LCTT 译注：原文处有评论指出 `int` 大小依照 C 标准应至少为2字节）；然而如今所有合理的 C 编译器都支持四字节的 `int`，以及八字节的 `double`（Rust 中则是 `f64` 类），以此类推。
+
+面向 C 的 FFI 所面临的另一个挑战是：FFI 是否能够处理 C 的裸指针，包括指向被看作是字符串的数组指针。C 没有字符串类型，它通过结合字符组和一个不会被打印的终止符来实现字符串，大名鼎鼎的_空终止符_。与之相对，Rust 有两个字符串类型：`String` 和 `&str` （字符串切片）。问题是，Rust FFI 是否能将 C 字符串转化成 Rust 字符串——答案是_肯定的_。
+
+出于对效率的追求，结构体指针在 C 中也很常见。一个 C 结构体在作为一个函数的参数或者返回值的时候，其默认行为是传递值（即，一个字节一个字节的复制）。C 结构体，如同它在 Rust 中的对应部分一样，可以包含数组和嵌套其他结构体，所以其大小是不定的。结构体在两种语言中的最佳用法是传递或返回引用，也就是说，传递或返回结构体的地址而不是结构体本身的复制。Rust 再一次成功处理了 C 的结构体指针，其在 C 函数库中十分普遍。
+
+第一段代码案例专注于调用相对简单的 C 库函数，比如 `abs`（绝对值）和 `sqrt`（平方根）。这些函数使用非指针标量参数并返回一个非指针标量值。第二段代码案例则涉及了字符串和结构体指针，在这里会介绍工具 [bindgen][2]，其通过 C 接口（头）文件生成 Rust 代码，比如 `math.h` 以及 `time.h`。C 头文件声明了 C 函数的调用语法并定义了会被调用的结构体。两段代码都能在[我的主页上][3]找到。
+
+### 调用相对简单的 C 函数
+
+第一段代码案例有四处 Rust 对标准数学库内的 C 函数的调用：两处分别调用了 `abs`（绝对值）和 `pow`（幂），两处重复调用了 `sqrt`（平方根）。这个程序可以直接用 `rustc` 编译器进行构建，或者使用更方便的命令 `cargo build`：
+
+```
+use std::os::raw::c_int; // 32位
+use std::os::raw::c_double; // 64位
+
+// 从标准库 libc 中引入三个函数。
+// 此处是 Rust 对三个 C 函数的声明：
+extern "C" {
+ fn abs(num: c_int) -> c_int;
+ fn sqrt(num: c_double) -> c_double;
+ fn pow(num: c_double, power: c_double) -> c_double;
+}
+
+fn main() {
+ let x: i32 = -123;
+ println!("\n{x}的绝对值是: {}.", unsafe { abs(x) });
+
+ let n: f64 = 9.0;
+ let p: f64 = 3.0;
+ println!("\n{n}的{p}次方是: {}.", unsafe { pow(n, p) });
+
+ let mut y: f64 = 64.0;
+ println!("\n{y}的平方根是: {}.", unsafe { sqrt(y) });
+
+ y = -3.14;
+ println!("\n{y}的平方根是: {}.", unsafe { sqrt(y) }); //** NaN = NotaNumber（不是数字）
+}
+```
+
+顶部的两个 `use` 声明是 Rust 的数据类型 `c_int` 和 `c_double`，对应 C 类型里的 `int` 和 `double`。Rust 标准模块 `std::os::raw` 定义了十四个类似的类型以确保跟 C 的兼容性。模块 `std::ffi` 中有十四个同样的类型定义以及对字符串的支持。
+
+位于 `main` 函数上的 `extern "C"` 区域声明了三个 C 库函数，这些函数会在 `main` 函数内被调用。每次调用都使用了标准的 C 函数名，但每次调用都必须发生在一个 `unsafe` 区域内。正如每个新接触 Rust 的程序员所发现的那样，Rust 编译器极度强制内存安全。其他语言（特别是 C 和 C++）作不出相同的保证。`unsafe` 区域其实是说：Rust 对外部调用中可能存在的不安全行为不负责。
+
+第一个程序输出为：
+
+```
+-123的绝对值是: 123.
+9的3次方是: 729.
+64的平方根是: 8.
+-3.14的平方根是: NaN.
+```
+
+输出的最后一行的 `NaN` 表示不是数字 (Not a Number)：C 库函数 `sqrt` 期待一个非负值作为参数，这使得参数-3.14生成了 `NaN` 作为返回值。
+
+### 调用涉及指针的 C 函数
+
+C 库函数为了提高效率经常在安全、网络、字符串处理、内存管理，以及其他领域中使用指针。例如，库函数 `asctime`（时间作为 ASCII 字符串）期待一个结构体指针作为其参数。Rust 调用类似 `asctime` 的 C 函数就会比调用 `sqrt` 要更加棘手一些，后者既没有牵扯到指针，也不涉及到结构体。
+
+函数 `asctime` 调用的 C 结构体类型为 `struct tm`。一个指向此结构体的指针会作为参数被传递给库函数 `mktime`（时间作为值）。此结构体会将时间拆分成诸如年、月、小时之类的单位。此结构体的字段 (fields) 类型为 `time_t`，是 `int`（32位）和 `long`（64位）的异名。两个库函数将这些破碎的时间碎片组合成了一个单一值：`asctime` 返回一个字符串用以表达时间，而 `mktime` 返回一个 `time_t` 值表示自 [_epoch_][4]，即系统时钟和时间戳被决定的那一刻，以来所经历的秒数。典型的 epoch 设置为1900年或1970年，1月1日，0时0分0秒。
+
+以下的 C 程序调用了 `asctime` 和 `mktime`，并使用了其他库函数 `strftime` 来将 `mktime` 的返回值转化成一个格式化的字符串。这个程序可被视作 Rust 对应版本的预热：
+
+```
+#include
+#include
+
+int main () {
+ struct tm sometime; /* 时间被打破细分 */
+ char buffer[80];
+ int utc;
+
+ sometime.tm_sec = 1;
+ sometime.tm_min = 1;
+ sometime.tm_hour = 1;
+ sometime.tm_mday = 1;
+ sometime.tm_mon = 1;
+ sometime.tm_year = 1;
+ sometime.tm_hour = 1; /*LCTT 译注：这里作者多敲了一行*/
+ sometime.tm_wday = 1;
+ sometime.tm_yday = 1;
+
+ printf("日期与时间: %s\n", asctime(&sometime));
+
+ utc = mktime(&sometime);
+ if( utc < 0 ) {
+ fprintf(stderr, "错误: mktime 无法生成时间\n");
+ } else {
+ printf("返回的整数值: %d\n", utc);
+ strftime(buffer, sizeof(buffer), "%c", &sometime);
+ printf("更加可读的版本: %s\n", buffer);
+ }
+
+ return 0;
+}
+```
+
+程序输出为：
+
+```
+日期与时间: Fri Feb 1 01:01:01 1901
+返回的整数值: 2120218157
+更加可读的版本: Fri Feb 1 01:01:01 1901
+```
+
+（LCTT 译注：如果你尝试在自己电脑上运行这段代码，然后得到了一行关于 `mktime` 的错误信息，然后又在网上随便找了个在线 C 编译器，复制代码然后得到了跟这里的结果有区别但是没有错误的结果，不要慌，我的电脑上也是这样的。导致本地机器上 `mktime` 失败的原因是作者没有设置 `tm_isdst`，这个是用来标记夏令时的 flag。[`tm_isdst` 大于零则夏令时生效中，等于零则不生效，小于零标记未知][5]。加入 `sometime.tm_isdst = 0` 或 `= -1` 后应该就能得到跟在线编译器大致一样的结果。不同的地方在于结果第一行我得到的是 `Mon Feb ...`，这个与作者代码中 `sometime.tm_wday = 1` 对应，这里因该是作者写错了；第二行我和作者和网上得到的数字都不一样，这大概是合理的，因为这与机器的 epoch 有关；第三行我跟作者的结果是一样的，1901年2月1日也确实是周五，这是因为 [`mktime` 其实会修正时间参数中不合理的地方][6]。至于夏令时具体是如何影响 `mktime` 这个问题，我能查到的只有 `mktime` 的计算受时区影响，更底层的原因我也不知道了。）
+
+总的来说，Rust 在调用库函数 `asctime` 和 `mktime` 时，必须处理以下两个问题：
+
+- 将裸指针作为唯一参数传递给每个库函数。
+- 把从 `asctime` 返回的 C 字符串转化为 Rust 字符串。
+
+### Rust 调用 `asctime` 和 `mktime`
+
+工具 `bindgen` 会根据类似 `math.h` 和 `time.h` 之类的 C 头文件生成 Rust 支持的代码。下面这个简化版的 `time.h` 就可以用来做例子，简化版与原版主要有两个不同：
+
+- 内置类型 `int` 被用来取代异名类型 `time_t`。工具 bindgen 可以处理 `time_t` 类但是会生成一些烦人的警告，因为 `time_t` 不符合 Rust 的命名规范：`time_t` 以下划线区分 `time` 和 `t`；Rust 更偏好驼峰式命名方法，比如 `TimeT`。
+- 出于同样的原因，这里选择 `StructTM` 作为 `struct tm` 的异名。
+
+以下是一份简化版的头文件，`mktime` 和 `asctime` 在文件底部：
+
+```
+typedef struct tm {
+ int tm_sec; /* 秒 */
+ int tm_min; /* 分钟 */
+ int tm_hour; /* 小时 */
+ int tm_mday; /* 日 */
+ int tm_mon; /* 月 */
+ int tm_year; /* 年 */
+ int tm_wday; /* 星期 */
+ int tm_yday; /* 一年中的第几天 */
+ int tm_isdst; /* 夏令时 */
+} StructTM;
+
+extern int mktime(StructTM*);
+extern char* asctime(StructTM*);
+```
+
+`bindgen` 安装好后，`%` 作为命令行提示，`mytime.h` 作为以上提到的头文件，以下命令可以生成所需的 Rust 代码并将其保存到文件 `mytime.rs`：
+
+```
+% bindgen mytime.h > mytime.rs
+```
+
+以下是 `mytime.rs` 中的重要部分：
+
+```
+/* automatically generated by rust-bindgen 0.61.0 */
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tm {
+ pub tm_sec: ::std::os::raw::c_int,
+ pub tm_min: ::std::os::raw::c_int,
+ pub tm_hour: ::std::os::raw::c_int,
+ pub tm_mday: ::std::os::raw::c_int,
+ pub tm_mon: ::std::os::raw::c_int,
+ pub tm_year: ::std::os::raw::c_int,
+ pub tm_wday: ::std::os::raw::c_int,
+ pub tm_yday: ::std::os::raw::c_int,
+ pub tm_isdst: ::std::os::raw::c_int,
+}
+
+pub type StructTM = tm;
+
+extern "C" {
+ pub fn mktime(arg1: *mut StructTM) -> ::std::os::raw::c_int;
+}
+
+extern "C" {
+ pub fn asctime(arg1: *mut StructTM) -> *mut ::std::os::raw::c_char;
+}
+
+#[test]
+fn bindgen_test_layout_tm() {
+ const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit();
+ let ptr = UNINIT.as_ptr();
+ assert_eq!(
+ ::std::mem::size_of::(),
+ 36usize,
+ concat!("Size of: ", stringify!(tm))
+ );
+ ...
+```
+
+Rust 结构体 `struct tm`，跟原本在 C 中的一样，包含了九个4字节的整型字段。这些字段名称在 C 和 Rust 中是一样的。`extern "C"` 区域声明了库函数 `astime` 和 `mktime` 分别需要只一个参数，一个指向可变实例 `extern "C"` 的裸指针。（库函数可能会通过指针改变作为参数传递的结构体。）
+
+`#[test]` 属性下的其余代码是用来测试 Rust 版的时间结构体的布局。通过命令 `cargo test` 可以进行这些测试。一个 C 不会声明的问题是编译器应该如何对结构体中的字段进行布局。比如说，C 的 `struct tm` 以字段 `tm_sec` 开头用以表示秒；但是 C 不需要编译版本遵循这个排序。不管怎样，Rust 测试应该会成功而 Rust 对库函数的调用也应如预期般工作。
+
+### 设置好第二个案例并开始运行
+
+从 `bindgen` 生成的代码不包含 `main` 函数，所以是一个天然的模块。以下是一个 `main` 函数初始化了 `StructTM` 并调用了 `asctime` 和 `mktime`：
+
+```
+mod mytime;
+use mytime::*;
+use std::ffi::CStr;
+
+fn main() {
+ let mut sometime = StructTM {
+ tm_year: 1,
+ tm_mon: 1,
+ tm_mday: 1,
+ tm_hour: 1,
+ tm_min: 1,
+ tm_sec: 1,
+ tm_isdst: -1,
+ tm_wday: 1,
+ tm_yday: 1
+ };
+
+ unsafe {
+ let c_ptr = &mut sometime; // 裸指针
+
+ // 调用，转化，并拥有
+ // 返回的 C 字符串
+ let char_ptr = asctime(c_ptr);
+ let c_str = CStr::from_ptr(char_ptr);
+ println!("{:#?}", c_str.to_str());
+
+ let utc = mktime(c_ptr);
+ println!("{}", utc);
+ }
+}
+```
+
+这段 Rust 代码可以被编译（直接用 `rustc` 或使用 `cargo`）并运行。输出为：
+
+```
+Ok(
+ "Mon Feb 1 01:01:01 1901\n",
+)
+2120218157
+```
+
+对 C 函数 `asctime` 和 `mktime` 的调用必须再一次被放在 `unsafe` 区域内，因为 Rust 编译器无法对这些外部函数的潜在内存安全风险负责。此处声明一下，`asctime` 和 `mktime` 并没有安全风险。调用的两个函数的参数是裸指针 `ptr`，其指向结构体 `sometime` （在栈 (stack) 中）的地址。
+
+`asctime` 是两个函数中调用起来更棘手的那个，因为这个函数返回的是一个指向 C `char` 的指针，如果函数返回 `Mon` 那么指针就指向 `M`。但是 Rust 编译器并不知道 C 字符串 （`char` 的空终止数组）的储存位置。是内存里的静态空间？还是堆 (heap)？`asctime` 函数内用来储存时间的文字表达的数组实际上是在内存的静态空间里。无论如何，C 到 Rust 字符串转化需要两个步骤来避免编译错误：
+
+- 调用 `Cstr::from_ptr(char_ptr)` 来将 C 字符串转化为 Rust 字符串并返回一个引用储存在变量 `c_str` 中。
+- 对 `c_str.to_str()` 的调用确保了 `c_str` 是所有者。
+
+Rust 代码不会增加从 `mktime` 返回的整型值的易读性，这一部分留作课外作业给感兴趣的人去探究。Rust 模板 `chrono::format` 也有一个 `strftime` 函数，它可以被当作 C 的同名函数来使用，两者都是获取时间的文字表达。
+
+### 使用 FFI 和 bindgen 调用 C
+
+Rust FFI 和工具 `bindgen` 都能够出色地协助 Rust 调用 C 库，无论是标准库还是第三方库。Rust 轻松地与 C 交流，并透过 C 与其他语言交流。对于调用像 `sqrt` 一样简单的库函数，Rust FFI 表现直截了当，这是因为 Rust 的原始数据类型覆盖了它们在 C 中的对应部分。
+
+对于更为复杂的交流——特别是 Rust 调用像 `asctime` 和 `mktime` 一样，会涉及到结构体和指针的 C 库函数——工具 `bindgen` 是优秀的帮手。这个工具会生成支持代码以及所需要的测试。当然，Rust 编译器无法假设 C 代码对内存安全的考虑会符合 Rust 的标准；因此，Rust 必须在 `unsafe` 区域内调用 C。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/22/11/rust-calls-c-library-functions
+
+作者：[Marty Kalin][a]
+选题：[lkxed][b]
+译者：[yzuowei](https://github.com/yzuowei)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/mkalindepauledu
+[b]: https://github.com/lkxed
+[1]: https://baike.baidu.com/item/lingua%20franka/5359711
+[2]: https://github.com/rust-lang/rust-bindgen
+[3]: https://condor.depaul.edu/mkalin
+[4]: https://baike.baidu.com/item/UNIX时间/8932323
+[5]: https://cplusplus.com/reference/ctime/tm/
+[6]: https://cplusplus.com/reference/ctime/mktime/
diff --git a/translated/tech/20221207.2 ⭐️ How to Access UEFI Settings in Linux Systems.md b/translated/tech/20221207.2 ⭐️ How to Access UEFI Settings in Linux Systems.md
new file mode 100644
index 0000000000..779ee8e4ee
--- /dev/null
+++ b/translated/tech/20221207.2 ⭐️ How to Access UEFI Settings in Linux Systems.md
@@ -0,0 +1,122 @@
+[#]: subject: "How to Access UEFI Settings in Linux Systems"
+[#]: via: "https://itsfoss.com/access-uefi-from-linux/"
+[#]: author: "Sagar Sharma https://itsfoss.com/author/sagar/"
+[#]: collector: "lkxed"
+[#]: translator: "geekpi"
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+如何在 Linux 系统中访问 UEFI 设置
+======
+
+想要在固件级别检查启动顺序或电源设置？ **你可以在系统启动时按 F2、F10 或 Del 按键访问 UEFI 设置**。
+
+这种方法的问题是你可能不知道确切的键，并且必须警惕在正确的时间按下这些键。
+
+![Mr. Bean][1a]
+
+如果你不想像上面 Gif 中的憨豆先生，你可以从 Linux 中的 [Grub bootloader][1] 也没访问 UEFI 设置。
+
+![uefi firmware settings grub linux][2]
+
+当你打开 Linux 系统时，你会看到这个页面。Fedora 和 Ubuntu 等大多数 Linux 发行版都使用 Grub，它们允许你像这样从 Grub 页面访问 UEFI 设置。
+
+如果你没有看到此页面或你的发行版不使用 Grub 怎么办？ 仍然有一些方法可以从 Linux 中访问 UEFI 设置。
+
+在你了解如何操作之前，请[确保你的系统使用 UEFI][3]。
+
+**_另一件重要的事情。你的系统将重启进入 UEFI 设置。_** _你无法从操作系统中访问和修改固件设置。_
+
+### 从 Linux 启动到 UEFI 设置
+
+此方法仅适用于具有 systemd 的 Linux 发行版。这意味着这种方法适用于任何基于 Ubuntu、Debian、Fedora 和任何主流的基于 Arch 的发行版，包括 Manjaro 和 EndeavourOS。
+
+[确保你的 Linux 发行版使用 systemd][4] 仍然是一个好主意。使用给定的命令，如果它返回 systemd，你就可以开始了：
+
+```
+ps --no-headers -o comm 1
+```
+
+![how to know if i am using systemd on linux?][5]
+
+当你发现你的发行版正在使用 systemd，你可以使用给定的命令启动到 UEFI 设置：
+
+```
+systemctl reboot --firmware-setup
+```
+
+让我首先分解使用的选项：
+
+- `reboot`：顾名思义，它将重启你的系统。
+- `--firmware-setup`: 当此选项与 `reboot` 一起使用时，它会指示系统固件启动进入固件设置界面。
+
+就是这样！ 一个命令，你将进入 UEFI 设置。我知道 Windows 允许[从 Windows 中启动进入 UEFI 固件设置][6]。很高兴在 Linux 中看到类似的东西。
+
+#### 创建桌面快捷方式以启动到 UEFI 设置（可选）
+
+如果你经常发现自己启动进入 UEFI 设置并且不记得所有命令，你可以通过创建桌面快捷方式让你的生活更轻松。这将使你可以通过单击桌面图标启动到 UEFI。
+
+_**现在，对于大多数 Linux 用户来说，这是不必要的，也不是必需的。只有当你觉得有必要时才去做。该方法需要[在命令行中编辑文件][7]。**_
+
+首先，使用给定的命令为 UEFI 设置创建桌面快捷方式文件：
+
+```
+sudo nano /usr/share/applications/uefi-reboot.desktop
+```
+
+并将以下内容粘贴到文件中：
+
+```
+[Desktop Entry]
+Name=UEFI Firmware Setup (Reboot)
+Comment=Access the motherboard configuration utility
+Exec=systemctl reboot --firmware-setup
+Icon=system-restart
+Terminal=false
+Type=Application
+Categories=System;Settings;
+```
+
+![create a desktop shortcut to boot into uefi settings][8]
+
+完成后，[保存更改并退出 nano][9] 文本编辑器。
+
+现在，你将在系统菜单中找到 UEFI 固件设置的快捷方式：
+
+![boot into uefi firmware from system menu][10]
+
+完成了！ 一种进入 UEFI 设置的巧妙方法。
+
+### 总结
+
+访问启动设置的经典方法对某些人来说可能有点不方便。grub 页面可能不会显示旧版本的 UEFI 选项。
+
+这就是 systemd 方法的亮点所在。当我的系统崩溃并且我的功能键没有响应时，我发现这种方法是救命稻草，这是启动到 UEFI 所必需的（我当时就是这么想的！）。
+
+我希望你发现它同样有用。
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/access-uefi-from-linux/
+
+作者：[Sagar Sharma][a]
+选题：[lkxed][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://itsfoss.com/author/sagar/
+[b]: https://github.com/lkxed
+[1a]: https://external-preview.redd.it/dxmsKYDmzgfb1thu3EFI8Ni-DNfprNX8W8xDtff4QWU.gif?format=mp4&s=c31204644ac6a2a348133986714ff97cf3c4a48a
+[1]: https://itsfoss.com/what-is-grub/
+[2]: https://itsfoss.com/wp-content/uploads/2022/12/uefi-firmware-settings-grub-linux.webp
+[3]: https://itsfoss.com/check-uefi-or-bios/
+[4]: https://linuxhandbook.com/check-if-systemd/
+[5]: https://itsfoss.com/wp-content/uploads/2022/12/how-to-know-if-i-am-using-systemd-on-linux.png
+[6]: https://itsfoss.com/access-uefi-settings-windows-10/
+[7]: https://learnubuntu.com/edit-files-command-line/
+[8]: https://itsfoss.com/wp-content/uploads/2022/12/create-a-desktop-shortcut-to-boot-into-uefi-settings.png
+[9]: https://linuxhandbook.com/nano-save-exit/
+[10]: https://itsfoss.com/wp-content/uploads/2022/12/boot-into-uefi-firmware-from-system-menu.png
diff --git a/translated/tech/20221208.1 ⭐️ Convert and Manipulate Images With ‘Converter’ GUI Tool in Linux.md b/translated/tech/20221208.1 ⭐️ Convert and Manipulate Images With ‘Converter’ GUI Tool in Linux.md
new file mode 100644
index 0000000000..292044c8e9
--- /dev/null
+++ b/translated/tech/20221208.1 ⭐️ Convert and Manipulate Images With ‘Converter’ GUI Tool in Linux.md
@@ -0,0 +1,87 @@
+[#]: subject: "Convert and Manipulate Images With ‘Converter’ GUI Tool in Linux"
+[#]: via: "https://itsfoss.com/converter-tool/"
+[#]: author: "Ankush Das https://itsfoss.com/author/ankush/"
+[#]: collector: "lkxed"
+[#]: translator: "geekpi"
+[#]: reviewer: " "
+[#]: publisher: " "
+[#]: url: " "
+
+在 Linux 中使用 “Converter” GUI 工具转换和操作图像
+======
+
+你可以随时在您的系统上[安装 ImageMagick][1] 来转换图像，但并不是每个人都喜欢使用终端来转换和操作图像。
+
+那么，如果你有一个 GUI 应用作为前端来帮助解决这个问题呢？ **Converter** 就是这样的工具。
+
+它是 ImageMagick 的前端。所以你不需要使用命令来转换和操作图像。
+
+请注意，大多数 Ubuntu 系统通常都预装了 ImageMagick。如果你的系统上还没有安装，你可以随时参考我们的[安装指南][1]。
+
+### Converter：ImageMagick 的图形前端
+
+![converter gui][2]
+
+转换图像不应该花费很多精力。这是一项简单的任务，而且应该如此。
+
+我不想键入命令来快速转换图像。因此，我更喜欢使我能够更快地做事的图形工具。
+
+[Converter][3] 是一个开源图形前端，可以让你做到这点。它是一个 GTK4+libadwaita 应用。
+
+你可以将图像转换为各种文件格式，包括 **png、webp、jpeg、heif、heic 和 bmp**。可以肯定地说，你获得了对最流行的图像文件格式的支持。所以，它应该会派上用场。
+
+![file format converter][4]
+
+你可以设置一个位置来保存所有文件，转换后的图像将自动存储在该位置。
+
+![customize converter][5]
+
+你还可以调整图像的质量、大小和背景颜色。要访问这些选项，请在转换图像之前单击用户界面中的“**更多选项**”。
+
+![converter more options][6]
+
+可以使用百分比、精确像素或比率自定义图像大小。对于精确操作，更改尺寸应该有所帮助。
+
+如果你希望图像缩放到一定程度，百分比或比例功能应该可以帮助你做到这一点。你还可以选择为图像添加滤镜。
+
+总体而言，您可以获得使用 Converter 调整大小、转换和优化图像质量的基本功能。
+
+你还可以[调整 Nautilus][7] 以获得[右键单击上下文菜单中的调整大小选项][8]。它不会像这个工具那样通用。
+
+### 在 Linux 上安装 Converter
+
+Converter 在 [Flathub][9] 上以 Flatpak 的形式提供，可以安装在你选择的任何 Linux 发行版上。
+
+遗憾的是，你无法在 Linux 系统上安装任何二进制包。因此，你可能需要参考我们的 [Flatpak 指南][10]来安装它。
+
+```
+flatpak install flathub io.gitlab.adhami3310.Converter
+```
+
+你可以在其 [GitLab 页面][3]上探索更多相关信息。
+
+_你对我们接下来要重点介绍的此类有趣工具有什么建议吗？ 让我们在评论中知道。_
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/converter-tool/
+
+作者：[Ankush Das][a]
+选题：[lkxed][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://itsfoss.com/author/ankush/
+[b]: https://github.com/lkxed
+[1]: https://itsfoss.com/install-imagemagick-ubuntu/
+[2]: https://itsfoss.com/wp-content/uploads/2022/12/converter-gui.png
+[3]: https://gitlab.com/adhami3310/Converter
+[4]: https://itsfoss.com/wp-content/uploads/2022/12/file-format-converter.png
+[5]: https://itsfoss.com/wp-content/uploads/2022/12/customize-converter.png
+[6]: https://itsfoss.com/wp-content/uploads/2022/12/converter-more-options.png
+[7]: https://itsfoss.com/nautilus-tips-tweaks/
+[8]: https://itsfoss.com/resize-images-with-right-click/
+[9]: https://flathub.org/apps/details/io.gitlab.adhami3310.Converter
+[10]: https://itsfoss.com/flatpak-guide/