document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-02-03 23:40:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/LCTT/TranslateProject into translating

Browse Source
This commit is contained in:
geekpi 2022-04-20 09:28:25 +08:00
commit 9bb8ac7561
10 changed files with 1007 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
translated/news/20220415 Elon Musk Believes Twitter Algorithm Should Be Open-Source.md → published/20220415 Elon Musk Believes Twitter Algorithm Should Be Open-Source.md
View File

@ -3,16 +3,20 @@
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lujun9972"
[#]: translator: "lkxed"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
[#]: reviewer: "wxy"
[#]: publisher: "wxy"
[#]: url: "https://linux.cn/article-14491-1.html"
埃隆·马斯克认为推特的算法应该开源
======
> 埃隆·马斯克希望推特开源他们的算法。这会促进言论自由吗？以下是他的说法。
![](https://news.itsfoss.com/wp-content/uploads/2022/04/elon-musk-twitter-algorithm-opensource.jpg)
没错，埃隆·马斯克又搞了一个大新闻，这已经算是他的日常操作了。
然而，这一次的新闻非常有趣。他提出了要以大约 **430 亿美元**收购推特。
然而，这一次的新闻非常有趣。他提出了要以大约 **430 亿美元** 收购推特。
从技术上讲，他的报价远远超过了市场价格，这也就是为什么许多媒体称他这是在试图“恶意收购”。
@ -32,15 +36,15 @@
这里引用他的原话：
> _因此，我认为推特应该做的事情之一就是开源它的算法，所有推文的修改都应该是透明的，任何人都可以看到这个修改，哪怕是加粗一段文字或是取消加粗它。这样一来，幕后操纵将不复存在，无论是算法还是人工。_”
> “因此，我认为推特应该做的事情之一就是开源它的算法，所有推文的修改都应该是透明的，任何人都可以看到这个修改，哪怕是加粗一段文字或是取消加粗它。这样一来，幕后操纵将不复存在，无论是算法还是人工。”
另一方面，当我们把推特当作一个某种程度上的开源平台来谈论时，我不由自主地想到了 [Mastodon][7]。你也可以在[Mastodon][8] 上找到我们，如果你还没有用过它的话。
另一方面，当我们把推特当作一个某种程度上的开源平台来谈论时，我不由自主地想到了 [Mastodon][7]。你也可以在 [Mastodon][8] 上找到我们，如果你还没有用过它的话。
诚然，推特有很大的增长潜力，无论好坏，它都在不断扩张。但是，开源理念能否帮助这个平台？我个人认为可以，但这是一个巨大的变革，不能指望一夜之间就能实现。
当然，即使埃隆·马斯克成功地收购了推特，也没有人能够预测他会对推特做什么。说实话，他就像任何复杂算法一样不可预测。
_那么，你是如何看待这个新闻的呢？你相信埃隆·马斯克说的话吗？欢迎在下面的评论中分享你的想法。_
那么，你是如何看待这个新闻的呢？你相信埃隆·马斯克说的话吗？欢迎在下面的评论中分享你的想法。
--------------------------------------------------------------------------------
@ -49,7 +53,7 @@ via: https://news.itsfoss.com/elon-musk-twitter-open-source/
作者：[Ankush Das][a]
选题：[lujun9972][b]
译者：[lkxed](https://github.com/lkxed)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

106
published/20220415 How to Upgrade to Ubuntu 22.04 -Jammy Jellyfish- From Ubuntu 20.04 LTS.md Normal file
View File

@ -0,0 +1,106 @@
[#]: subject: "How to Upgrade to Ubuntu 22.04 “Jammy Jellyfish” From Ubuntu 20.04 LTS"
[#]: via: "https://www.debugpoint.com/2022/04/upgrade-ubuntu-22-04-from-20-04/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lujun9972"
[#]: translator: "robsean"
[#]: reviewer: "wxy"
[#]: publisher: "wxy"
[#]: url: "https://linux.cn/article-14490-1.html"
如何从 Ubuntu 20.04 LTS 升级到 Ubuntu 22.04 “Jammy Jellyfish”
======
![](https://img.linux.net.cn/data/attachment/album/202204/20/081835mfrb93flhqrz9dou.jpg)
s
> 本文介绍从 Ubuntu 20.04 LTS 升级到 Ubuntu 之前，你所需要采取的完整步骤和预防措施。
[Ubuntu 22.04 LTS Jammy Jellyfish][1] 将在 2022 年 4 月 21 日发布。我建议你在该日期之后的一两个月后再升级。理想的情况下，如果你在第一次修正版本发布后，才计划升级到任意主要版本，这会是最好的选择。
但是，如果你迫切想要体验 Ubuntu 22.04 带来的令人震惊的更改和特色功能，那么，接下来请阅读用于完美升级过程的步骤。
### 在升级前
在任何升级前，遵循一些最佳的惯例总是更加明智的。这会防止出现一些升级后的问题，并引领通往成功的升级流程。
* 备份你的家目录中的数据到另一个驱动器或 USB 存储器，包括：图片、视频或其他的个人文件。
* 如果你遇到一个不稳定的系统行，请保留一个准备好的 [Ubuntu 的现场 USB][2]。
* 如果你打算升级 GNOME 工作站，请先禁用所有的 GNOME 扩展，因为这些扩展与 GNOME 3.36+ 不兼容。
* 在成功的升级后，你可以逐一启用这些扩展。
* 运行命令 `sudo apt update && sudo apt upgrade` 以确保你的系统是最新的软件包。
* 关闭所有你正在运行的应用程序。
* 重新启动你的系统。
说到这里，如果你准备好了，接下来遵循下面的说明来从 Ubuntu 20.04 LTS 升级到 Ubuntu 22.04 。
### 从 Ubuntu 20.04 和 Ubuntu 21.10 升级到 Ubuntu 22.04
#### 在 2022 年 4 月 21 日之前
如果你想在发布日期前升级，打开一个终端窗口，并运行下面的命令。
```
sudo do-release-upgrade -d
```
![Upgrade to Ubuntu 22.04 LTS from Ubuntu 20.04 LTS][3]
上面的命令将使用 “jammy” 来覆盖系统中的 “focal” 分支，以获取新的软件包。不仅如此，这个命令也会禁用你这些年可能添加的所有的第三方 PPA 。
此外，这个命令将花费一些时间才完成，这主要取决于你的网速。
除此之外，注意终端上偶尔出现的提示，它需要你输入 `Y` 或 `N` 。另外，如果你中途取消升级过程，这些第三方 PPA 也不会被启用，你必须手动启用它们。
![Summary of the upgrade][4]
最后，这个命令将计算升级系统所需软件包的大小，并估算所需时间，摘要如下图所示。请仔细地阅读它，并允许升级到 Ubuntu 22.04 LTS Jammy Jellyfish。
在升级过程完成后，重新启动你的系统，享受令人兴奋的 Ubuntu 22.04 LTS 。
#### 在 2022 年 4 月 21 日之后
在 2022 年 4 月 21 日当天或之后，直到 2022 年 07 月第一次修正版本发布，Ubuntu 都不会给予你任何可视化的升级提示，因为第一个修改版本被认为是初始错误被消除后最稳定的版本。
这意味着，你要么等到 7 月，你要么强制升级。如何强制升级？打开“<ruby>软件和更新<rt>Software and Updates</rt></ruby>”，转到“<ruby>更新<rt>Updates</rt></ruby>”标签页。更改“<ruby>通知我有新的 Ubuntu 版本<rt>Settings notify me of new ubuntu version</rt></ruby>” 为 “<ruby>任意新的 Ubuntu 版本<rt>any new version</rt></ruby>”。
在完成后，你应该会在桌面上看到一个升级提示。遵循屏幕上的指示，接着继续升级过程。
这个提示也会计算升级系统所列软件包所需的时间，因此，仔细的阅读更新程序的输出内容。在你准备好了以后，开始升级过程。
最后，在升级过程完成后，重新启动系统，享受全新的 Ubuntu 22.04 LTS Jammy Jellyfish 。
#### 从 Ubuntu 21.10 升级到 Ubuntu 22.04
针对 Ubuntu 21.10 ，你也可以参考上面确切说明来升级。从 Ubuntu 21.10 升级到 Ubuntu 22.04 不需要额外的步骤。
#### 升级到 Ubuntu 22.04 的过程需要多长的时间?
根据我的测试，在默认安装的情况下，整个升级过程需要 30 多分钟。根据你安装的软件包的数量和安装的年限，你的系统可能会更多。因此，相应地计划你的时间。
### 总结
最后，我希望这些步骤能帮助你成功地升级你的 Ubuntu 系统到 Jammy Jellyfish 。如果你正在打算升级，祝你一切顺利。
请在下面的评论区中告诉我升级过程是如何进行的。
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/04/upgrade-ubuntu-22-04-from-20-04/
作者：[Arindam][a]
选题：[lujun9972][b]
译者：[robsean](https://github.com/robsean)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.debugpoint.com/author/admin1/
[b]: https://github.com/lujun9972
[1]: https://releases.ubuntu.com/22.04/
[2]: https://www.debugpoint.com/2018/09/how-to-create-ubuntu-linux-os-bootable-usb-in-windows/
[3]: https://www.debugpoint.com/wp-content/uploads/2022/04/Upgrade-to-Ubuntu-22.04-LTS-from-Ubuntu-20.04-LTS-1024x540.jpg
[4]: https://www.debugpoint.com/wp-content/uploads/2022/04/Summary-of-the-upgrade-1024x581.jpg
[5]: https://www.debugpoint.com/2021/10/ubuntu-22-04-daily-builds/
[6]: https://t.me/debugpoint
[7]: https://twitter.com/DebugPoint
[8]: https://www.youtube.com/c/debugpoint?sub_confirmation=1
[9]: https://facebook.com/DebugPoint

99
sources/news/20220413 Razer and Lambda Team Up to Unveil a Linux Laptop for Deep Learning.md
View File

@ -1,99 +0,0 @@
[#]: subject: "Razer and Lambda Team Up to Unveil a Linux Laptop for Deep Learning"
[#]: via: "https://news.itsfoss.com/tensorbook-razer-lambda/"
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lujun9972"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Razer and Lambda Team Up to Unveil a Linux Laptop for Deep Learning
======
Razer is known for its gaming peripherals and hardware.
On the other hand, Lambda offers workstations, servers, and GPU clusters equipped with their software stack to facilitate deep learning as conveniently as possible.
They have collaborated to present a sleek-looking modern laptop (powered by Ubuntu 20.04) tailored for deep learning on the go.
And, it isn’t like any [other Linux laptops][1] available.
In case you are curious, deep learning is a type of machine learning where you teach a computer to process information similar to how humans do (by example). You can explore [Wikipedia][2] for more details.
### Tensorbook: The Deep Learning Laptop
![][3]
The Tensorbook is a Linux-powered laptop with state-of-the-art specifications to help you efficiently work with deep learning training/development anywhere. And, Lambda’s software stack supports all the tools to conveniently update PyTorch, Tensorflow, CUDA, etc., with just a single command.
Of course, the name isn’t a surprise, considering tensor cores help speed up the machine learning training/process.
![][4]
Razer did not add any of their usual signature patterns with this laptop, like a green accent/color, logo, or RGB elements. Well, for the greater good, this is tailored for deep learning. So, it is only fair that it isn’t too flashy.
You only find the lambda logo as the primary on the lid and a Razer x Lambda text on the bottom bezel of the screen. And, the purple accent goes all over, Lambda taking the lead on its branding here.
The specifications for the laptop involve:
* **GPU**: GeForce RTX 3080 Max-Q 16 GB VRAM
* **CPU:** Intel i7-11800H
* **RAM:** 64 GB 3200 MHz DDR4
* **Storage:** 2 TB NVMe PCIe 4.0
* **Display:** 165 Hz 1440p 15.6-inch
In addition to the solid core configuration, the connectivity options include:
* 3 x USB 3.2 Gen 2 Type-A ports
* 1 x HDMI 2.1
* 1 x UHS-III SD Card Reader
* 3.5 mm Headphone/Microphone jack
* 2 x Thunderbolt 4 ports
* Wi-Fi 6E
* Bluetooth 5.2
Undoubtedly, the laptop is a sleek powerhouse with all the components packed in it.
The RTX 3080 GPU should be capable enough to help with your deep learning tasks, whether you are a professional or a beginner.
Of course, it isn’t pitched for gaming, but with what you have, along with a high refresh rate screen, you can comfortably game on it when you want.
![][5]
The machine learning training benchmarks claim that it is way ahead of the M1 Max chip.
So, you will not have any trouble with training models.
### Pricing and Availability
It is a premium offering, so the price tag suits the same, starting at **$3499**. You can customize it for enterprise settings to pack in Windows 10 and Ubuntu.
An extended warranty and premium support is available if you want to pay the extra.
You can customize and proceed with the purchase on Lambda’s official website.
[Tensorbook][6]
--------------------------------------------------------------------------------
via: https://news.itsfoss.com/tensorbook-razer-lambda/
作者：[Ankush Das][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://news.itsfoss.com/author/ankush/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/get-linux-laptops/
[2]: https://en.wikipedia.org/wiki/Deep_learning
[3]: https://i.ytimg.com/vi/wMh6Dhq7P_Q/hqdefault.jpg
[4]: data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjgwMCIgd2lkdGg9IjcyMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB2ZXJzaW9uPSIxLjEiLz4=
[5]: data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjYwMCIgd2lkdGg9IjgyMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB2ZXJzaW9uPSIxLjEiLz4=
[6]: https://lambdalabs.com/deep-learning/laptops/tensorbook

232
sources/tech/20220414 A guide to JVM parameters for Java developers.md Normal file
View File

@ -0,0 +1,232 @@
[#]: subject: "A guide to JVM parameters for Java developers"
[#]: via: "https://opensource.com/article/22/4/jvm-parameters-java-developers"
[#]: author: "Jayashree Huttanagoudar https://opensource.com/users/jayashree-huttanagoudar"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
A guide to JVM parameters for Java developers
======
By understanding and using JVM and JVM parameters, both developers and end users can diagnose failures and improve the performance of a Java application.
![young woman working on a laptop][1]
Image by:
CC BY 3.0 US Mapbox Uncharted ERG
When you write source code, you're writing code for humans to read. Computers can't execute source code until the code is compiled into *machine language*, a generic term referring to any number of languages required by a specific machine. Normally, if you compile code on Linux, it runs on Linux, and if you compile code on Windows, it runs on Windows, and so on. However, Java is different. It doesn't target an actual machine. It targets something called the Java Virtual Machine (JVM), and so it can run on any machine.
Java source code gets compiled into bytecode which is run by a JVM installed on a computer. The JVM is an execution engine, but it's not one you usually interact with directly. It runs quietly, processing Java bytecode. Most people don't need to think or even know about the JVM, but it can be useful to understand how the JVM works so you can debug and optimize Java code. For example:
* In the production environment, you might find a deployed application needs a performance boost.
* If something goes wrong in an application you've written, both the developer and end-user have options to debug the problem.
* Should you want to know the details of the Java Development Kit (JDK) being used to develop or run a Java application, you can get those details by querying the JVM.
In the production environment, you might find a deployed application needs a performance boost.
If something goes wrong in an application you've written, both the developer and end-user have options to debug the problem.
Should you want to know the details of the Java Development Kit (JDK) being used to develop or run a Java application, you can get those details by querying the JVM.
This article introduces some basic JVM parameters to help in these scenarios…
![Jvm parameters][2]
Image by:
(Jayashree Huttanagoudar CC BY-SA 4.0)
### What's the difference between a JVM, JDK, and JRE?
Java has a lot of J-acronyms, including JVM, JDK, and JRE.
* A Java Developer Kit (JDK) is accessed by programmers who need development libraries to use in their code.
* The Java Runtime Environment (JRE) is employed by people who want to run a Java application.
* The Java Virtual Machine (JVM) is the component that runs Java bytecode.
A Java Developer Kit (JDK) is accessed by programmers who need development libraries to use in their code.
The Java Runtime Environment (JRE) is employed by people who want to run a Java application.
The Java Virtual Machine (JVM) is the component that runs Java bytecode.
The JDK contains both a JRE and a JVM, but some Java distributions provide an alternate download containing a JRE (including a JVM).
![JDK][3]
Image by:
(Jayashree Huttanagoudar CC BY-SA 4.0)
Java is open source, so different companies build and distribute JDKs. You can install more than one on your system, which can be helpful when you're working on or using different Java projects, some of which might use an old JDK.
To list the JDKs on your Linux system, you can use the alternatives command:
```
$ alternatives --config java
There are 2 programs that provide java.Selection Command-----------------------------------------------*+ 1 java-11-openjdk.x86_64 (/usr/lib/jvm/java-11-openjdk-11.0.13.0.8-2.fc35.x86_64/bin/java)2 java-1.8.0-openjdk.x86_64 (/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.312.b07-2.fc35.x86_64/jre/bin/java)
Enter to keep the current selection[+], or type selection number:
```
To switch between available JDKs, run the command again:
```
$ sudo alternatives --config java
```
Another option is to use [SDKMan][4], which helps you download, update, and manage the JDKs on your system.
### What is JVM tuning?
Tuning a JVM is the process of adjusting JVM parameters to improve the performance of the Java application. It also helps to diagnose application failure.
In general, it's important to consider these points before tuning:
* Cost : Sometimes, improving the hardware running your code can improve an application's performance. That might seem like a "cheat" but consider how much time you're willing to spend tuning the JVM parameters. Sometimes, an application requires more memory to perform as desired, and no amount of software hacking will change that.
* Desired Outcome: Stability is more important than performance in the long run. If your tuning affects the stability, it's probably better to wisely choose your tuning parameters.
* Underlying issues : Sometimes, the issue could be an underlying issue with the host operating system. Before tuning the JVM, ensure that the JVM's platform is working as expected.
* Memory leaks: If you find yourself using Garbage Collection (GC) tuning parameters, there are likely memory leaks that need to get fixed in the application code.
**Cost** : Sometimes, improving the hardware running your code can improve an application's performance. That might seem like a "cheat" but consider how much time you're willing to spend tuning the JVM parameters. Sometimes, an application requires more memory to perform as desired, and no amount of software hacking will change that.
**Desired Outcome**: Stability is more important than performance in the long run. If your tuning affects the stability, it's probably better to wisely choose your tuning parameters.
**Underlying issues** : Sometimes, the issue could be an underlying issue with the host operating system. Before tuning the JVM, ensure that the JVM's platform is working as expected.
**Memory leaks**: If you find yourself using Garbage Collection (GC) tuning parameters, there are likely memory leaks that need to get fixed in the application code.
### Types of JVM Parameters
JVM parameters are grouped under three categories: Standard options, Non-standard, and Advanced.
#### Standard options
All JVM implementations support standard options. Run the 'java' command in a terminal to see a list of standard options.
```
$ java
Usage: java [options] <mainclass> [args...]
        (to execute a class)
   or  java [options] -jar <jarfile> [args...]
        (to execute a jar file)
 where options include:
        -cp <class search path of directories and zip/jar files>
        -classpath <class search path of directories and zip/jar files>
        --class-path <class search path of directories and zip/jar files>
                A : separated list of directories, JAR archives,
                and ZIP archives to search for class files.
        --enable-preview
                allow classes to depend on preview features of this release
To specify an argument for a long option, you can use --<name>=<value> or--<name> <value>.
```
These are all standard options included with any JVM, and you can safely use them as you use any [command-line option][5]. For example, to validate command options for configuration, and create a VM and load a main class without executing the main class, use:
```
$ java --dry-run <classfile>
```
#### Non-standard options
Non-standard options start with `-X`. These are for general purpose use and are specific to a particular implementation of JVM. To list these options:
```
$ java -X-Xbatch disable background compilation-Xbootclasspath/a:<directories and zip/jar files separated by :>
append to end of bootstrap class path-Xinternalversion
displays more detailed JVM version information than the-version option-Xloggc:<file> log GC status to a file with time stamps[...]
```
These extra options are subject to change without notice and are not supported by all JVM implementations.
A JVM built by Microsoft may have different options than one built by Red Hat, and so on.
To get detailed JVM version information, use the following option:
```
$ java -Xinternalversion --version
OpenJDK 64-Bit Server VM (11.0.13+8) for linux-amd64 JRE (11.0.13+8), built on Nov 8 2021 00:00:00 by "mockbuild" with gcc 11.2.1 20210728 (Red Hat 11.2.1-1)
```
To get the property setting use:
```
$ java -XshowSettings:properties --version
```
#### Advanced options
These options are not for casual use and are used for tuning the specific areas of the Hotspot VM. These options are subject to change, and there is no guarantee that all JVM implementations will support it.
These options start with -XX. To list these options, use the following command:
```
$ java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version
```
For example, to trace the class loading then use the below command:
```
$ java -XX:+TraceClassLoading Hello
```
The Hello.java has:
```
$ cat Hello. javapublic class Hello {
  public static void main(String[] args) {
    System.out.println("Inside Hello World!");
  }}
```
Another common problem you might face is OOM (Out Of Memory) errors, which can happen without much debug information. To solve such a problem, you might use the debug option -XX:+HeapDumpOnOutOfMemoryError, which creates a .hprof file with debug information.
```
$ cat TestClass. java
import java.util.ArrayList;
import java.util.List;
public class TestClass {
public static void main(String[] args) {
List<Object> list = new ArrayList<Object>();
for (int i = 0; i < 1000; i++) {
list.add(new char[1000000]);
}
}
}
$ Javac TestClass.java
$ java -XX:+HeapDumpOnOutOfMemoryError -Xms10m -Xmx1g TestClass
java.lang.OutOfMemoryError: java heap space
Dumping heap to java_pid444496.hprof ...
Heap dump file created [1018925828 bytes in 1.442 secs]
Exception in thread "main" java.lang.OutOfMemoryError: java heap space
at TestClass.main(TestClass.Java:8)
```
[There are tools][6] to look at this .hprof file to understand what went wrong.
### Conclusion
By understanding and using JVM and JVM parameters, both developers and end users can diagnose failures and improve the performance of a Java application. The next time you're working with Java, take a moment to look at the options available to you.
--------------------------------------------------------------------------------
via: https://opensource.com/article/22/4/jvm-parameters-java-developers
作者：[Jayashree Huttanagoudar][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/jayashree-huttanagoudar
[b]: https://github.com/lkxed
[1]: https://opensource.com/sites/default/files/lead-images/lenovo-thinkpad-laptop-window-focus.png
[2]: https://opensource.com/sites/default/files/2022-03/java-jvm-parameters.jpg
[3]: https://opensource.com/sites/default/files/2022-03/jdk.jpg
[4]: https://opensource.com/%5Bhttps%3A//opensource.com/article/22/3/manage-java-versions-sdkman%5D%28https%3A//opensource.com/article/22/3/manage-java-versions-sdkman%29
[5]: https://opensource.com/%5Bhttps%3A//opensource.com/article/21/8/linux-terminal%5D%28https%3A//opensource.com/article/21/8/linux-terminal%29
[6]: https://opensource.com/%5Bhttps%3A//docs.oracle.com/javase/7/docs/technotes/tools/share/jhat.html%5D%28https%3A//docs.oracle.com/javase/7/docs/technotes/tools/share/jhat.html%29

267
sources/tech/20220414 My favorite build options for Go.md Normal file
View File

@ -0,0 +1,267 @@
[#]: subject: "My favorite build options for Go"
[#]: via: "https://opensource.com/article/22/4/go-build-options"
[#]: author: "Gaurav Kamathe https://opensource.com/users/gkamathe"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
My favorite build options for Go
======
These handy Go build options can help you understand the Go compilation process better.
![GitHub launches Open Source Friday][1]
(Image by: Opensource.com)
One of the most gratifying parts of learning a new programming language is finally running an executable and getting the desired output. When I discovered the programming language Go, I started by reading some sample programs to get acquainted with the syntax, then wrote small test programs. Over time, this approach helped me get familiar with compiling and building the program.
The build options available for Go provide ways to gain more control over the build process. They can also provide additional information to help break the process into smaller parts. In this article, I will demonstrate some of the options I have used. Note: I am using the terms build and compile to mean the same thing.
### Getting started with Go
I am using Go version 1.16.7; however, the command given here should work on most recent versions as well. If you do not have Go installed, you can download it from the [Go website][2] and follow the instructions for installation. Verify the version you have installed by opening a prompt command and typing:
```
$ go version
```
The response should look like this, depending on your version.
```
go version go1.16.7 linux/amd64
$
```
### Basic compilation and execution of Go programs
I'll start with a sample Go program that simply prints "Hello World" to the screen.
```
$ cat hello.go
package main
import "fmt"
func main() {
        fmt.Println("Hello World")}
$
```
Before discussing more advanced options, I'll explain how to compile a sample Go program. I make use of the `build `option followed by the Go program source file name, which in this case is `hello.go`.
```
$ go build hello.go
```
If everything is working correctly, you should see an executable named `hello` created in your current directory. You can verify that it is in ELF binary executable format (on the Linux platform) by using the file command. You can also execute it and see that it outputs "Hello World."
```
$ ls
hello  hello.go
$
$ file ./hello
./hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$
$ ./hello
Hello World
$
```
Go provides a handy `run` option in case you do not want to have a resulting binary and instead want to see if the program works correctly and prints the desired output. Keep in mind that even if you do not see the executable in your current directory, Go still compiles and produces the executable somewhere, `run`s it, then removes it from the system. I'll explain in a later section of this article.
```
$ go run hello.go
Hello World
$
$ ls
hello.go
$
```
### Under the hood
The above commands worked like a breeze to run my program with minimal effort. However, if you want to find out what Go does under the hood to compile these programs, Go provides a `-x` option that prints everything Go does to produce the executable.
A quick look tells you that Go creates a temporary working directory within `/tmp`, produces the executable, and then moves it to the current directory where the source Go program was present.
```
$ go build -x hello.goWORK=/tmp/go-build1944767317mkdir -p $WORK/b001/<< snip >>mkdir -p $WORK/b001/exe/cd ./usr/lib/golang/pkg/tool/linux_amd64/link -o $WORK \/b001/exe/a.out -importcfg $WORK/b001 \/importcfg.link -buildmode=exe -buildid=K26hEYzgDkqJjx2Hf-wz/\
nDueg0kBjIygx25rYwbK/W-eJaGIOdPEWgwC6o546 \/K26hEYzgDkqJjx2Hf-wz -extld=gcc /root/.cache/go-build /cc \/cc72cb2f4fbb61229885fc434995964a7a4d6e10692a23cc0ada6707c5d3435b-d/usr/lib/golang/pkg/tool/linux_amd64/buildid -w $WORK \/b001/exe/a.out # internalmv $WORK/b001/exe/a.out hellorm -r $WORK/b001/
```
This helps solve the mysteries when a program runs but no resulting executable is created within the current directory. Using `-x `shows that the executable file was indeed created in a` /tmp `working directory and was executed. However, unlike the `build` option, the executable did not move to the current directory, making it appear that no executable was created.
```
$ go run -x hello.gomkdir -p $WORK/b001/exe/cd ./usr/lib/golang/pkg/tool/linux_amd64/link -o $WORK/b001 \/exe/hello -importcfg $WORK/b001/importcfg.link -s -w -buildmode=exe -buildid=hK3wnAP20DapUDeuvAAS/E_TzkbzwXz6tM5dEC8Mx \/7HYBzuaDGVdaZwSMEWAa/hK3wnAP20DapUDeuvAAS -extld=gcc \/root/.cache/go-build/75/ \
7531fcf5e48444eed677bfc5cda1276a52b73c62ebac3aa99da3c4094fa57dc3-d$WORK/b001/exe/hello
Hello World
```
### Mimic compilation without producing the executable
Suppose you don't want to compile the program and produce an actual binary, but you do want to see all steps in the process. You can do so by using the `-n` build option, which prints the steps that it would normally run without actually creating the binary.
```
$ go build -n hello.go
```
### Save temp directories
A lot of work happens in the `/tmp` working directory, which is deleted once the executable is created and run. But what if you want to see which files were created in the compilation process? Go provides a ``-work`` option that can be used when compiling a program. The ``-work`` option prints the working directory path in addition to running the program, but it doesn't delete the working directory afterward, so you can move to that directory and examine all the files created during the compile process.
```
$ go run -work hello.goWORK=/tmp/go-build3209320645
Hello World
$
$ find /tmp/go-build3209320645/tmp/go-build3209320645/tmp/go-build3209320645/b001/tmp/go-build3209320645/b001/importcfg.link/tmp/go-build3209320645/b001/exe/tmp/go-build3209320645/b001/exe/hello
$
$ /tmp/go-build3209320645/b001/exe/hello
Hello World
$
```
### Alternative compilation options
What if, instead of using the build/run magic of Go, you want to compile the program by hand and end up with an executable that can be run directly by your operating system (in this case, Linux)? This process can be divided into two parts: compile and link. Use the `tool` option to see how it works.
First, use the `tool compile` option to produce the resulting `ar` `ar`chive file, which contains the `.o` intermediate file. Next, use the `tool link` option on this hello`.o` file to produce the final executable, which can then run.
```
$ go tool compile hello.go
$
$ file hello.o
hello.o: current ar archive
$
$ ar t hello.o
__.PKGDEF
_go_.o
$
$ go tool link -o hello hello.o
$
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$
$ ./hello
Hello World
$
```
To peek further into the link process of producing the executable from the `hello.o` file, you can use the `-v` option, which searches for the `runtime.a` file included in every Go executable.
```
$ go tool link -v -o hello hello.o
HEADER = -H5 -T0x401000 -R0x1000
searching for runtime.a in /usr/lib/golang/pkg/linux_amd64/runtime.a82052 symbols, 18774 reachable
        1 package symbols, 1106 hashed symbols, 77185 non-package symbols, 3760 external symbols81968 liveness data
$
```
### Cross-compilation options
Now that I've explained the compilation of a Go program, I'll demonstrate how Go allows you to `build` an executable targeted at different hardware architectures and operating systems by providing two environment variables—GOOS and GOARCH—before the actual `build` command.
Why does this matter? You can see an example when an executable produced for the ARM (aarch64) architecture won't run on an Intel (x86_64) architecture and produces an Exec format error.
These options make it trivial to produce cross-platform binaries.
```
$ GOOS=linux GOARCH=arm64 go build hello.go
$
$ file ./hello
./hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, not stripped
$
$ ./hello
bash: ./hello: cannot execute binary file: Exec format error
$
$ uname -m
x86_64
$
```
You can read my earlier blog post about my experiences with [cross-compilation using Go][3] to learn more.
### View underlying assembly instructions
The source code is not directly converted to an executable, though it generates an intermediate assembly format which is then assembled into an executable. In Go, this is mapped to an intermediate assembly format rather than the underlying hardware assembly instructions.
To view this intermediate assembly format, use `-gcflags` followed by `-S` given to the build command. This command shows the assembly instructions.
```
$ go build -gcflags="-S" hello.go# command-line-arguments"".main STEXT size=138 args=0x0 locals=0x58 funcid=0x0
        0x0000 00000 (/test/hello.go:5) TEXT    "".main(SB), ABIInternal, $88-0
        0x0000 00000 (/test/hello.go:5) MOVQ    (TLS), CX
        0x0009 00009 (/test/hello.go:5) CMPQ    SP, 16(CX)
        0x000d 00013 (/test/hello.go:5) PCDATA  $0, $-2
        0x000d 00013 (/test/hello.go:5) JLS     128<< snip >>
$
```
You can also use the `objdump -s` option, as shown below, to see the assembly instructions for an executable program that was already compiled.
```
$ ls
hello  hello.go
$
$
$ go tool objdump -s main.main hello
TEXT main.main(SB) /test/hello.go
  hello.go:5            0x4975a0                64488b0c25f8ffffff      MOVQ FS:0xfffffff8, CX                 
  hello.go:5            0x4975a9                483b6110                CMPQ 0x10(CX), SP                      
  hello.go:5            0x4975ad                7671                    JBE 0x497620                           
  hello.go:5            0x4975af                4883ec58                SUBQ $0x58, SP                         
  hello.go:6            0x4975d8                4889442448              MOVQ AX, 0x48(SP)                       << snip >>
$
```
### Strip binaries to reduce their size
Go binaries are typically large. For example, a simple Hello World program produces a 1.9M-sized binary.
```
$ go build hello.go
$
$ du -sh hello
1.9M    hello
$
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$
```
To reduce the size of the resulting binary, you can strip off information not needed during execution. Using `-ldflags` followed by `-s -w` flags makes the resulting binary slightly lighter, at 1.3M.
```
$ go build -ldflags="-s -w" hello.go
$
$ du -sh hello
1.3M    hello
$
$ file hello
hello: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, stripped
$
```
### Conclusion
I hope this article introduced you to some handy Go build options that can help you understand the Go compilation process better. For additional information on the build process and other interesting options available, refer to the help section:
```
$ go help build
```
--------------------------------------------------------------------------------
via: https://opensource.com/article/22/4/go-build-options
作者：[Gaurav Kamathe][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/gkamathe
[b]: https://github.com/lkxed
[1]: https://opensource.com/sites/default/files/lead-images/build_structure_tech_program_code_construction.png
[2]: https://go.dev/doc/install
[3]: https://opensource.com/article/21/1/go-cross-compiling

115
sources/tech/20220415 How to Upgrade to Ubuntu 22.04 -Jammy Jellyfish- From Ubuntu 20.04 LTS.md
View File

@ -1,115 +0,0 @@
[#]: subject: "How to Upgrade to Ubuntu 22.04 “Jammy Jellyfish” From Ubuntu 20.04 LTS"
[#]: via: "https://www.debugpoint.com/2022/04/upgrade-ubuntu-22-04-from-20-04/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lujun9972"
[#]: translator: "robsean"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
How to Upgrade to Ubuntu 22.04 “Jammy Jellyfish” From Ubuntu 20.04 LTS
======
HERE ARE THE COMPLETE STEPS AND PRECAUTIONS YOU NEED TO TAKE BEFORE
UPGRADING TO UBUNTU 22.04 LTS FROM UBUNTU 20.04 LTS.
[Ubuntu 22.04 LTS Jammy Jellyfish][1] releases on April 21, 2022. I recommend you wait for a month or two after April 21st to upgrade. Ideally, it would be best if you plan to Upgrade to any major release after the first point release.
But if you are in a hurry or want to experience the stunning changes and features that Ubuntu 22.04 brings to the table, then read below the steps required for a flawless upgrade process.
### Before Upgrade
For any upgrade, it is always wiser to follow some best practices. These prevent some post-upgrade problems and lead to a successful upgrade process.
* Backup data to another drive or USB storage from your home directory includes your pictures, videos, or other personal files.
* Keep a [LIVE USB ready with Ubuntu][2] if you run into an unstable system.
* If you upgrade to a GNOME workstation, disable all the GNOME extensions because they will be incompatible as they work with GNOME 3.36+.
* After a successful upgrade, you can enable the extensions one at a time.
* Ensure that your system is up to date with packages by running the command `sudo apt update && sudo apt upgrade`
* Close all your running applications.
* Restart your system.
With that said, if you are ready, then follow the instructions below to Upgrade to Ubuntu 22.04 From Ubuntu 20.04 LTS.
### Upgrade to Ubuntu 22.04 from Ubuntu 20.04 and Ubuntu 21.10
#### Before April 21, 2022
If you want to upgrade before the release day, open a terminal window and run the following command.
```
sudo do-release-upgrade -d
```
![Upgrade to Ubuntu 22.04 LTS from Ubuntu 20.04 LTS][3]
The above command will override the system “focal” branches with “jammy” to get the new packages. Not only that, but the command will also disable all third-party PPA that you may have added over the years.
Furthermore, the command will take some time to finish depending on your internet speed.
In addition to that, keep a watch on the terminal for occasional prompts which require your input as Y/N. Also, if you cancel the upgrade process midway, the third party PPA will not be enabled. So, you have to enable them manually.
![Summary of the upgrade][4]
Finally, the command will calculate the size of the upgrade and give you the estimated time required with a summary as shown below. Please read it carefully and give your permission to upgrade to Ubuntu 22.04 LTS Jammy Jellyfish.
[][5]
SEE ALSO:   Ubuntu 22.04 Jammy Jellyfish Daily Builds Are Now Available
After the upgrade process is complete, restart your system and enjoy the exciting Ubuntu 22.04 LTS.
#### After April 21, 2022
On the day or after April 21, 2022, Ubuntu will not give you any visual upgrade prompt for an upgrade until the first point release in July 2022 because the first point release is considered the most stable version after initial bugs are ironed out.
That said, you either wait until July, or you can force the upgrade. How? Open the Software and Updates, and go to the Updates tab. And change “notify me of new ubuntu version” to “any new version”.
Once you do that, you should see a prompt for an upgrade on the desktop. Follow the on-screen instructions and continue with the upgrade process.
The prompt also calculates the list of packages required to upgrade with the needed time, so read the updater output carefully. Once you are ready, start the process.
Finally, after the upgrade process is finished, reboot the system to enjoy the brand new Ubuntu 22.04 LTS Jammy Jellyfish.
#### Upgrade to Ubuntu 22.04 from Ubuntu 21.10
You can follow the above exact instructions for Ubuntu 21.10 as well. There are no extra steps required to Upgrade to Ubuntu 22.04 from Ubuntu 21.10.
#### How long does the upgrade to the Ubuntu 22.04 process take?
As per my test, the default install requires a little more than 30 minutes of total time to finish the entire upgrade process. It might be higher for your system based on how many software of packages you installed plus the age of your installation. So plan your time accordingly.
### Conclusion
Finally, I hope these steps help you successfully upgrade your Ubuntu system to Jammy Jellyfish. If you are planning to upgrade, I wish you all the best.
Do let me know in the comment box below how the upgrade process goes.
* * *
We bring the latest tech, software news and stuff that matters. Stay in touch via [Telegram][6], [Twitter][7], [YouTube][8], and [Facebook][9] and never miss an update!
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/04/upgrade-ubuntu-22-04-from-20-04/
作者：[Arindam][a]
选题：[lujun9972][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/lujun9972
[1]: https://releases.ubuntu.com/22.04/
[2]: https://www.debugpoint.com/2018/09/how-to-create-ubuntu-linux-os-bootable-usb-in-windows/
[3]: https://www.debugpoint.com/wp-content/uploads/2022/04/Upgrade-to-Ubuntu-22.04-LTS-from-Ubuntu-20.04-LTS-1024x540.jpg
[4]: https://www.debugpoint.com/wp-content/uploads/2022/04/Summary-of-the-upgrade-1024x581.jpg
[5]: https://www.debugpoint.com/2021/10/ubuntu-22-04-daily-builds/
[6]: https://t.me/debugpoint
[7]: https://twitter.com/DebugPoint
[8]: https://www.youtube.com/c/debugpoint?sub_confirmation=1
[9]: https://facebook.com/DebugPoint

2
sources/tech/20220416 Disable Animations in Cinnamon Desktop to Slightly Speed Up Your Linux Mint System.md
View File

@ -2,7 +2,7 @@
[#]: via: "https://itsfoss.com/disable-animations-cinnamon-desktop/"
[#]: author: "Abhishek Prakash https://itsfoss.com/author/abhishek/"
[#]: collector: "lujun9972"
[#]: translator: " "
[#]: translator: "lkxed"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "

176
sources/tech/20220419 Difference Between Ubuntu 22.04 and Ubuntu 20.04 LTS.md Normal file
View File

@ -0,0 +1,176 @@
[#]: subject: "Difference Between Ubuntu 22.04 and Ubuntu 20.04 LTS"
[#]: via: "https://www.debugpoint.com/2022/04/difference-ubuntu-22-04-20-04/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lujun9972"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Difference Between Ubuntu 22.04 and Ubuntu 20.04 LTS
======
A LIST OF 10 SIGNIFICANT FEATURE DIFFERENCES BETWEEN UBUNTU 20.04 AND
UBUNTU 22.04 LTS FOR FOLKS TRANSITIONING FROM LTS TO LTS.
If you are a [Ubuntu 20.04 LTS Focal Fossa][1] user and plan to upgrade or install the latest [Ubuntu 22.04 LTS “Jammy Jellyfish”][2], this guide is for you. The primary aspect is there are significant and structural changes between these two LTS versions which is somewhat rare in terms of LTS releases. In one go, a lot changed if you compare both the LTS releases.
So, with that in mind, in this guide, we give you ten pointers that address the fundamental changes from an average user perspective and give you a heads up before you try the new Jammy Jellyfish.
### Ubuntu 22.04 LTS vs Ubuntu 20.04 LTS – Feature Difference
#### 1\. Logo, Colors and Plymouth
The first visual change that you notice is the base accent colour of Ubuntu changes to more “Orange” compared to two earlier “brown-orange”. Also, Canonical changed the Ubuntu official logo from this release onwards, and it is visible right from the Plymouth animation while booting. The new logo may look a little strange while you look at it for the first time, but it grows into you, eventually. I feel it’s a distinct logo in its way.
![New Ubuntu logo and Plymouth][3]
#### 2\. Installation
The default Ubuntu installer did not see any additional changes. We hoped that the new [Flutter based installer][4] would land, but it didn’t. With that said, the steps to installation remain the same. The only difference you may notice is the accent colour and cosmetic changes on the dialogue boxes and controls. Functionality wise, there is no change in the installation steps.
![Colour differences between two LTS Versions][5]
#### 3\. Lock and Login Screen, Desktop First look and Wallpaper
Furthermore, the lock and login screen colour gradient changes with more fine and borderless controls for the password box. The apparent difference is the stunning Jammy Jellyfish default wallpaper when you first log in. The desktop “Home” shortcut is renamed as Home than that of your username, and the Trash shortcut now goes to the left dock with a separator in the new Ubuntu 22.04 LTS.
In addition to that, the top bar didn’t change much. However, the system tray menu is little organised with more spacing and separators. There are mainly the changes coming from the [GNOME 42][6] changes.
The Calendar menu remained almost the same between both the LTS versions.
![Ubuntu 20.04 Vs Ubuntu 22.04 – Login Screen][7]
![Ubuntu 20.04 Vs Ubuntu 22.04 – Lock Screen][8]
![Difference between Ubuntu 20.04 and Ubuntu 22.04 – default look][9]
#### 4\. Desktop Layouts and GNOME Version Upgrades
The significant difference that users would see visually is the GNOME version change – GNOME 3.36 vs the GNOME 42. This is the significant difference that all users migrating to current LTS would face. The Ubuntu 22.04 LTS with GNOME 42 brings a horizontal workspace view alongside the horizontal application view. So, it would be a little weird to feel first time migrating from vertical to horizontal gestures. But you get used to it within a day or two.
If you use touch-based Laptops or screens, then the GNOME 42 gestures would give you some fluid feel with a bit of learning. Here’s how the desktop, applications and workspace view looks side by side.
![Activities View Difference – Ubuntu 20.04 and 22.04][10]
![Application View Difference – Ubuntu 20.04 and 22.04][11]
#### 5\. New Appearance Style with Accent Color
Moreover, one particular change which I would like to highlight here is new settings for light and dark modes. Earlier Ubuntu had three options for desktop looks – light, dark and a mixed one – Standard. This is completely changed and replaced by the GNOME 42’s built-in light and dark mode. In addition to that, a new Accent colour option is introduced (which is not part of vanilla GNOME 42) that enables you to change the colour across the desktop based on a selection of palettes.
However, you can not choose the custom accent colour yet, like KDE Plasma 🥰. Most of these changes come with the recent libadwaita and GTK4 port of GNOME Shell and native applications.
When you apply the dark mode in Ubuntu 22.04 – it applies automatically to all the supported applications. This is one of the fundamental differences with the Ubuntu 20.04 LTS.
![Accent Color and other changes][12]
![How Accent colour change impact looks in Ubuntu 22.04 LTS][13]
#### 6\. File Manager
The Files file manager version changes from 3.36.x to 42 in this release. The difference you see is the more compact design, well-defined spacing between controls and texts, and the top bar widgets style, thanks to GTK4 and underlying bug fixes. The address bar in Files is a little different, with a separator between directories, and the hamburger menu is at the end. Although, these minor changes would not impact much, and you may not feel much difference between the two LTS releases.
![Files Difference – Ubuntu 20.04 vs 22.04][14]
#### 7\. Screenshot Workflow difference between Ubuntu 22.04 and 20.04
Another notable change that requires a little learning for migrating users is how screenshots are captured. It changes completely. Earlier, you hit print-screen from the keyboard to take a screenshot and save the image file automatically in your Pictures folder. The workflow is different now with GNOME 42’s built-in screenshot and screen-recorder tool.
[][15]
SEE ALSO:   Ubuntu Budgie 22.04 LTS - New Features and Release Details
So, when you try to take a screenshot in Ubuntu 22.04 LTS, you see a screen below which gives you all the options, such as a screenshot of an area, an entire desktop or a specific window. Moreover, you have the option to show the cursor in a screenshot or want to record the screen. And when you hit the capture button, the tool saves the image file in the Pictures folder and in your clipboard.
![New Screenshot tool in Ubuntu 22.04 LTS][16]
Overall, an additional step change for your earlier workflow.
You get a new context menu, “Take a screenshot”, on the top bar right-click menu of all the application windows.
![Take Screenshot option in top bar menu][17]
#### 8\. Firefox Web Browser as Snap in Ubuntu 22.04
In addition to the above changes, the Firefox is now a snap version in Ubuntu 22.04 LTS if you compare it with the prior LTS version. The Firefox 97 in Ubuntu 20.04 was a deb package. So, if you are an average user, you may not see much difference.
However, Firefox Snap runs in a sandbox mode, which means users may face trouble while installing GNOME Extensions and may feel slow performance due to Snap in the same hardware used by Ubuntu 20.04 LTS.
I think it would be interesting to see how this significant snap migration of the most used applications of Ubuntu plays out in the coming days.
#### 9\. Difference in Settings Window between Ubuntu 22.04 and 20.04
Furthermore, a new panel is introduced in Settings, i.e. Multitasking. The Multitasking panel gives you options to tweak the hot corners and active screen edges. In addition to that, you can now specify the fixed number of workspace you want with the option to remove the empty workspace automatically. Other than that, if you use multiple displays, you have now options to show workspaces in the primary display or all displays.
![New Multitasking Panel in Settings][18]
#### 10\. Flavours and Application Updates
In addition to the above differences, the Software application changes bring different responsive looks and adapt to any form factor. The Software also brings a more different home page with the arrangement of applications as per categories and editor choice section.
Furthermore, the details page of any software shows essential information in a distinguishable manner with details such as total download size, ratings, safe marker and image carousels.
![GNOME Software – Home page difference][19]
![GNOME Software – Details page difference][20]
Finally, the under the hood differences between these two releases are spread across the packages, official desktop environment flavours and bug fixes. Here’s a quick summary of important packages.
**20.04** | **22.04**
---|---
GCC 10.3 | GCC 11.2
Hplip 3.20.3 | Hplip 3.21.12
LibreOffice 6.4.7 | LibreOffice 7.3.2
[not introduced] | Pipewire 0.3.48
Python3 3.8.2 | Python3 3.10.1
Samba 4.13 | Samba 4.15
Systemd 245.4 | Systemd 249.11
### Summary
To conclude the difference between Ubuntu 20.04 LTS and Ubuntu 22.04, I am compelled to say; that it is one of the biggest LTS releases from Ubuntu in terms of visual and feature changes.
I hope this guide showing the difference between Ubuntu 20.04 LTS and Ubuntu 22.04 gives you and many users a starting point on what to expect on their journey of Ubuntu 22.04 LTS and beyond.
Cheers.
* * *
We bring the latest tech, software news and stuff that matters. Stay in touch via [Telegram][21], [Twitter][22], [YouTube][23], and [Facebook][24] and never miss an update!
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/04/difference-ubuntu-22-04-20-04/
作者：[Arindam][a]
选题：[lujun9972][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/lujun9972
[1]: https://www.debugpoint.com/2021/08/ubuntu-20-04-3-release/
[2]: https://www.debugpoint.com/2022/01/ubuntu-22-04-lts/
[3]: https://www.debugpoint.com/wp-content/uploads/2022/01/New-Ubuntu-logo-and-playmouth.jpg
[4]: https://github.com/canonical/ubuntu-desktop-installer
[5]: https://www.debugpoint.com/wp-content/uploads/2022/04/Colour-differences-between-two-LTS-Versions.jpg
[6]: https://www.debugpoint.com/2022/03/gnome-42-release/
[7]: https://www.debugpoint.com/wp-content/uploads/2022/04/Ubuntu-20.04-Vs-Ubuntu-22.04-Lock-and-Login-Screen-1024x431.jpg
[8]: https://www.debugpoint.com/wp-content/uploads/2022/04/Ubuntu-20.04-Vs-Ubuntu-22.04-Lock-Screen-1024x408.jpg
[9]: https://www.debugpoint.com/wp-content/uploads/2022/04/Difference-between-Ubuntu-20.04-and-Ubuntu-22.04-default-look-1024x421.jpg
[10]: https://www.debugpoint.com/wp-content/uploads/2022/04/Activities-View-Difference-Ubuntu-20.04-and-22.04-1024x425.jpg
[11]: https://www.debugpoint.com/wp-content/uploads/2022/04/Application-View-Difference-Ubuntu-20.04-and-22.04-1024x420.jpg
[12]: https://www.debugpoint.com/wp-content/uploads/2022/04/Accent-Color-and-other-changes-1024x417.jpg
[13]: https://www.debugpoint.com/wp-content/uploads/2022/04/How-Accent-colour-change-impact-looks-in-Ubuntu-22.04-LTS.jpg
[14]: https://www.debugpoint.com/wp-content/uploads/2022/04/Files-Difference-Ubuntu-20.04-vs-22.04-1024x359.jpg
[15]: https://www.debugpoint.com/2022/04/ubuntu-budgie-22-04-lts/
[16]: https://www.debugpoint.com/wp-content/uploads/2022/04/New-Screenshot-tool-in-Ubuntu-22.04-LTS.jpg
[17]: https://www.debugpoint.com/wp-content/uploads/2022/04/Take-Screenshot-option-in-top-bar-menu.jpg
[18]: https://www.debugpoint.com/wp-content/uploads/2022/04/New-Multitasking-Panel-in-Settings.jpg
[19]: https://www.debugpoint.com/wp-content/uploads/2022/04/GNOME-Software-Home-page-difference-1024x416.jpg
[20]: https://www.debugpoint.com/wp-content/uploads/2022/04/GNOME-Software-Details-page-difference-1024x417.jpg
[21]: https://t.me/debugpoint
[22]: https://twitter.com/DebugPoint
[23]: https://www.youtube.com/c/debugpoint?sub_confirmation=1
[24]: https://facebook.com/DebugPoint

114
sources/tech/20220420 Nushell- Cross-platform Shell That Gives You More Clarity on Error Messages.md Normal file
View File

@ -0,0 +1,114 @@
[#]: subject: "Nushell: Cross-platform Shell That Gives You More Clarity on Error Messages"
[#]: via: "https://itsfoss.com/nushell/"
[#]: author: "Marco Carmona https://itsfoss.com/author/marco/"
[#]: collector: "lujun9972"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Nushell: Cross-platform Shell That Gives You More Clarity on Error Messages
======
_**Brief:** Nushell is a unique type of shell that provides easy-to-read error messages and offers cross-platform support. Find out more about it here._
Even if you are not interested in using the terminal, the Linux terminal often makes some of the heavy lifting more effortless and lets you fix stuff. So, is safe to say that the Linux terminal is pretty powerful if you know what you’re doing.
And that is true! But the problem appears when you get an error. If you don’t have enough experience using it, you won’t know how to solve it.
While the error messages try to convey the best meaning of the problem, not every user can easily decode the fix. It usually takes a bit of research for beginners. But, if the error can have more clarity, the user could be able to fix it sooner.
Not just limited to the error message, the structure of the output you get in your terminal to browse files, for example, is not the prettiest.
![Terminal listing several files][1]
**Do you see what I mean?** Of course, this could become more complex when you have more files of distinct types. And, you get no idea about file permissions, groups, etc with the output you get with the basic ls command.
That’s where Nushell tries to solve the problem.
### Nushell: A Shell That Provides User-Friendly Output by Default
![Nushell example screenshot][2]
Nu, as it’s also called, it takes its philosophy and inspiration from projects like [PowerShell][3], functional programming languages, and modern [CLI][4] tools.
Let me give you an example, imagine you want to list only the output with a type equal to the file inside your home directory, including the hidden files. Well, to achieve this it is as easy as just typing the following command:
```
ls -a | where type == 'file'
```
![Listing only files with Nushell][5]
Observe how clear and simple its syntax is; now imagine how easy it could be to find the process and name ID, its status, and CPU or memory consumed with the Nushell. **It’s part of its magic!**
It tries its best to provide user-friendly output for the commands you enter, organized in a specific structure.
### Features of Nushell
![Error messages in Nu, one of its primary highlights][6]
As per the official information available, some of its most popular features include:
* **Pipelines to control any OS.** Nu works on Linux, macOS, and Windows. In other words, being a flexible cross-platform shell with a modern feel.
* **Everything is data.** Nu pipelines use structured data, so you can safely select, filter, and sort the same way every time.
* **Powerful plugins.** It’s easy to extend Nu functionalities using a powerful plugin system.
* **Easy to read error messages.** Nu operates on typed data, so it catches bugs that other shells don’t. And when things break, Nu tells you exactly where and why.
* Clean IDE support.
You can take a look at its [official documentation][7] for a thorough look at its features and usage.
### Installing Nushell in your system
Unfortunately, if you’re an Ubuntu user like me, you won’t find an apt repository to install Nushell. But, you can build it by installing the required dependencies, as per its instructions on [GitHub][8].
Fortunately, there is a way to install it on any distro, using **Homebrew**. Head to its official website to explore more installation options.
[Nushell][9]
You can refer to our tutorial on [installing and using Homebrew Package Manager on Linux][10]. Once you successfully set it up on Linux, you need to type in the following command to install Nushell:
```
brew install nushell
```
![Installing nushell with Homebrew][11]
Once the process is finished, just type `nu` to start the Nushell shell. **That’s it!**
If you’d like to set Nushell as your default shell, you can do it with the command **chsh**, but remember, it is still in development, that’s why we do not recommend it for everyday use.
However, you can explore more about it on its website or the [GitHub page][8] before you decide to try it.
What do you think about this interesting shell? Let me know your thoughts in the comments down below.
--------------------------------------------------------------------------------
via: https://itsfoss.com/nushell/
作者：[Marco Carmona][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/marco/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/wp-content/uploads/2022/04/Terminal-with-several-files-800x477.png
[2]: https://itsfoss.com/wp-content/uploads/2022/04/Nushell-example-800x475.jpg
[3]: https://itsfoss.com/microsoft-open-sources-powershell/
[4]: https://itsfoss.com/gui-cli-tui/
[5]: https://itsfoss.com/wp-content/uploads/2022/04/Listing-only-files-with-nushell-800x246.png
[6]: https://itsfoss.com/wp-content/uploads/2022/04/Error-messages-in-Nu-800x259.png
[7]: https://www.nushell.sh/book/
[8]: https://github.com/nushell/nushell
[9]: https://www.nushell.sh/
[10]: https://itsfoss.com/homebrew-linux/
[11]: https://itsfoss.com/wp-content/uploads/2022/04/Installing-nushell-with-brew-800x470.png

99
translated/news/20220413 Razer and Lambda Team Up to Unveil a Linux Laptop for Deep Learning.md Normal file
View File

@ -0,0 +1,99 @@
[#]: subject: "Razer and Lambda Team Up to Unveil a Linux Laptop for Deep Learning"
[#]: via: "https://news.itsfoss.com/tensorbook-razer-lambda/"
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lujun9972"
[#]: translator: "wxy"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
雷蛇与 Lambda 联手推出用于深度学习的 Linux 笔记本电脑
======
> Razer 与一家专注于深度学习的硬件公司合作，以时尚的外形、昂贵的价格提供了最新和最伟大的产品。
![](https://news.itsfoss.com/wp-content/uploads/2022/04/tensorbook-linux-ml-laptop.jpg)
<ruby>雷蛇<rt>Razer</rt></ruby> 以其游戏外设和硬件而闻名。
另一方面，Lambda 提供配备了他们的软件栈的工作站、服务器和 GPU 集群，以尽可能方便地促进深度学习。
他们合作推出了一款外观时尚的现代笔记本电脑（由 Ubuntu 20.04 驱动），专为随时随地的深度学习而设计。
它不同于 [其他 Linux 笔记本电脑][1]。
顺便说一句，深度学习是一种机器学习，你通过实例教给计算机学会类似人类处理信息的方式。你可以查看 [维基百科][2] 以了解更多细节。
### Tensorbook：深度学习笔记本电脑
[![][3]](https://youtu.be/wMh6Dhq7P_Q)
Tensorbook 是一款由 Linux 驱动的笔记本电脑，具有最先进的规格，可以帮助你在任何地方高效地进行深度学习训练/开发。而且，Lambda 的软件栈支持各种工具，只需一个命令就能方便地更新 PyTorch、Tensorflow、CUDA 等。
当然，这个名字并不令人意外，因为张量核心有助于加快机器学习训练/过程。
![][4]
雷蛇没有在这台笔记本电脑上添加任何他们惯用的标志性图案，比如绿色的点缀/颜色、标志或 RGB 元素。好吧，毕竟这是为深度学习而定制的。所以，它不太浮华是公平的。
你只能在盖子上找到 lambda 主要标志，在屏幕的底边框上找到 Razer x Lambda 的文字。而且，紫色的风格贯穿始终，Lambda 在这里主导了其品牌宣传。
这款笔记本电脑的规格涉及：
* GPU：GeForce RTX 3080 Max-Q 16 GB VRAM
* CPU：Intel i7-11800H
* 内存：64 GB 3200 MHz DDR4
* 存储：2 TB NVMe PCIe 4.0
* 显示：165 Hz 1440p 15.6 英寸
除了可靠的核心配置外，连接选项包括：
* 3 个 USB 3.2 Gen 2 Type-A 端口
* 1 x HDMI 2.1
* 1 个 UHS-III SD 卡阅读器
* 3.5 毫米耳机/麦克风插孔
* 2 个雷电 4 端口
* Wi-Fi 6E
* 蓝牙 5.2
毋庸置疑，这款笔记本电脑是一个时尚的动力源，将这些组件容纳于其中。
RTX 3080 GPU 应该有足够的能力来帮助你完成深度学习任务，无论你是专业人士还是初学者。
当然，它不是为游戏而设计的，但以你所拥有的配置以及高刷新率的屏幕，你可以在需要的时候在上面舒适地玩游戏。
![][5]
其机器学习训练基准声称，它远远领先于 M1 Max 芯片。
因此，你在训练模型方面不会有任何问题。
### 定价和可用性
这是一款高端产品，所以价格标签也一样，起价为 **3499 美元**。你可以为企业设置定制它，以便安装上 Windows 10 和 Ubuntu。
如果你支付额外的费用，还可以获得延长保修和高级支持。
你可以在 Lambda 的官方网站上定制并进行购买。
> [Tensorbook][6]
--------------------------------------------------------------------------------
via: https://news.itsfoss.com/tensorbook-razer-lambda/
作者：[Ankush Das][a]
选题：[lujun9972][b]
译者：[wxy](https://github.com/wxy)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://news.itsfoss.com/author/ankush/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/get-linux-laptops/
[2]: https://en.wikipedia.org/wiki/Deep_learning
[3]: https://i.ytimg.com/vi/wMh6Dhq7P_Q/hqdefault.jpg
[4]: https://news.itsfoss.com/wp-content/uploads/2022/04/tensorbook-1.jpg
[5]: https://news.itsfoss.com/wp-content/uploads/2022/04/tensorbook-2.jpg
[6]: https://lambdalabs.com/deep-learning/laptops/tensorbook