分类 技术 下的文章

最近,我首次尝试了 Mac。直至现在,我注意到的最大缺点是其软件包管理比 Linux 差很多。一段时间以来,我对于 homebrew 感到相当不满,因为每次我安装新的软件包时,它大部分时间都花在了升级上。于是,我萌生了试试 nix 包管理器的想法!

公认的,nix 的使用存在一定困惑性(甚至它有自己单独的编程语言!),因此,我一直在努力以最简洁的方式掌握使用 nix,避开复杂的配置文件管理和新编程语言学习。以下是我至今为止学习到的内容, 敬请期待如何进行:

  • 使用 nix 安装软件包
  • 为一个名为 paperjam 的 C++ 程序构建一个自定义的 nix 包
  • 用 nix 安装五年前的 hugo 版本

如同以往,由于我对 nix 的了解还停留在入门阶段,本篇文章可能存在一些表述不准确的地方。甚至我自己也对于我是否真的喜欢上 nix 感到模棱两可 —— 它的使用真的让人相当困惑!但是,它帮我成功编译了一些以前总是难以编译的软件,并且通常来说,它比 homebrew 的安装速度要快。

nix 为何引人关注?

通常,人们把 nix 定义为一种“声明式的包管理”。尽管我对此并不太感兴趣,但以下是我对 nix 的两个主要欣赏之处:

  • 它提供了二进制包(托管在 https://cache.nixos.org/ 上),你可以迅速下载并安装
  • 对于那些没有二进制包的软件,nix 使编译它们变得更容易

我认为 nix 之所以擅长于编译软件,主要有以下两个原因:

  • 在你的系统中,可以安装同一库或程序的多个版本(例如,你可能有两个不同版本的 libc)。举个例子,我当前的计算机上就存在两个版本的 node,一个位于 /nix/store/4ykq0lpvmskdlhrvz1j3kwslgc6c7pnv-nodejs-16.17.1,另一个位于 /nix/store/5y4bd2r99zhdbir95w5pf51bwfg37bwa-nodejs-18.9.1
  • 除此之外,nix 在构建包时是在隔离的环境下进行的,只使用你明确声明的依赖项的特定版本。因此,你无需担心这个包可能依赖于你的系统里的其它你并不了解的包,再也不用与 LD_LIBRARY_PATH 战斗了!许多人投入了大量工作,来列出所有包的依赖项。

在本文后面,我将给出两个例子,展示 nix 如何使我在编译软件时遇到了更小的困难。

我是如何开始使用 nix 的

下面是我开始使用 nix 的步骤:

  • 安装 nix。我忘记了我当时是如何做到这一点,但看起来有一个官方安装程序 和一个来自 zero-to-nix.com非官方安装程序。在 MacOS 上使用标准的多用户安装卸载 nix 的 教程 有点复杂,所以选择一个卸载教程更为简单的安装方法可能值得。
  • ~/.nix-profile/bin 添加到我的 PATH
  • nix-env -iA nixpkgs.NAME 命令安装包
  • 就是这样。

基本上,是把 nix-env -iA 当作 brew install 或者 apt-get install

例如,如果我想安装 fish,我可以这样做:

nix-env -iA nixpkgs.fish

这看起来就像是从 https://cache.nixos.org 下载一些二进制文件 - 非常简单。

有些人使用 nix 来安装他们的 Node 和 Python 和 Ruby 包,但我并没有那样做 —— 我仍然像我以前一样使用 npm installpip install

一些我没有使用的 nix 功能

有一些 nix 功能/工具我并没有使用,但我要提及一下。我最初认为你必须使用这些功能才能使用 nix,因为我读过的大部分 nix 教程都讨论了它们。但事实证明,你并不一定要使用它们。

我不去深入讨论它们,因为我并没真正使用过它们,而且网上已经有很多详解。

安装软件包

nix 包在哪里定义的?

我认为 nix 包主仓库中的包是定义在 https://github.com/NixOS/nixpkgs/

你可以在 https://search.nixos.org/packages 查找包。似乎有两种官方推荐的查找包的方式:

  • nix-env -qaP NAME,但这非常缓慢,并且我并没有得到期望的结果
  • nix --extra-experimental-features 'nix-command flakes' search nixpkgs NAME,这倒是管用,但显得有点儿冗长。并且,无论何种原因,它输出的所有包都以 legacyPackages 开头

我找到了一种我更喜欢的从命令行搜索 nix 包的方式:

  • 运行 nix-env -qa '*' > nix-packages.txt 获取 Nix 仓库中所有包的列表
  • 编写一个简洁的 nix-search 脚本,仅在 packages.txt 中进行 grep 操作(cat ~/bin/nix-packages.txt | awk '{print $1}' | rg "$1"

所有的东西都是通过符号链接来安装的

nix 的一个主要设计是,没有一个单一的 bin 文件夹来存放所有的包,而是使用了符号链接。有许多层的符号链接。比如,以下就是一些符号链接的例子:

  • 我机器上的 ~/.nix-profile 最终是一个到 /nix/var/nix/profiles/per-user/bork/profile-111-link/ 的链接
  • ~/.nix-profile/bin/fish 是到 /nix/store/afkwn6k8p8g97jiqgx9nd26503s35mgi-fish-3.5.1/bin/fish 的链接

当我安装某样东西的时候,它会创建一个新的 profile-112-link 目录并建立新的链接,并且更新我的 ~/.nix-profile 使其指向那个目录。

我认为,这意味着如果我安装了新版本的 fish 但我并不满意,我可以很容易地退回先前的版本,只需运行 nix-env --rollback,这样就可以让我回到之前的配置文件目录了。

卸载包并不意味着删除它们

如果我像这样卸载 nix 包,实际上并不会释放任何硬盘空间,而仅仅是移除了符号链接:

$ nix-env --uninstall oil

我尚不清楚如何彻底删除包 - 我试着运行了如下的垃圾收集命令,这似乎删除了一些项目:

$ nix-collect-garbage
...
85 store paths deleted, 74.90 MiB freed

然而,我系统上仍然存在 oil 包,在 /nix/store/8pjnk6jr54z77jiq5g2dbx8887dnxbda-oil-0.14.0

nix-collect-garbage 有一个更具攻击性的版本,它也会删除你配置文件的旧版本(这样你就不能回滚了)。

$ nix-collect-garbage -d --delete-old

尽管如此,上述命令仍无法删除 /nix/store/8pjnk6jr54z77jiq5g2dbx8887dnxbda-oil-0.14.0,我不明白原因。

升级过程

你可以通过以下的方式升级 nix 包:

nix-channel --update
nix-env --upgrade

(这与 apt-get update && apt-get upgrade 类似。)

我还没真正尝试升级任何东西。我推测,如果升级过程中出现任何问题,我可以通过以下方式轻松地回滚(因为在 nix 中,所有事物都是不可变的!):

nix-env --rollback

有人向我推荐了 Ian Henry 的 这篇文章,该文章讨论了 nix-env --upgrade 的一些令人困惑的问题 - 也许它并不总是如我们所料?因此,我会对升级保持警惕。

下一个目标:创建名为 paperjam 的自定义包

经过几个月使用现有的 nix 包后,我开始考虑制作自定义包,对象是一个名为 paperjam 的程序,它还没有被打包封装。

实际上,因为我系统上的 libiconv 版本不正确,我甚至在没有 nix 的情况下也遇到了编译 paperjam 的困难。我认为,尽管我还不懂如何制作 nix 包,但使用 nix 来编译它可能会更为简单。结果证明我的想法是对的!

然而,理清如何实现这个目标的过程相当复杂,因此我在这里写下了一些我实现它的方式和步骤。

构建示例包的步骤

在我着手制作 paperjam 自定义包之前,我想先试手构建一个已存在的示例包,以便确保我已经理解了构建包的整个流程。这个任务曾令我头痛不已,但在我在 Discord 提问之后,有人向我阐述了如何从 https://github.com/NixOS/nixpkgs/ 获取一个可执行的包并进行构建。以下是操作步骤:

步骤 1: 从 GitHub 的 nixpkgs 下载任意一个包,以 dash 包为例:

wget https://raw.githubusercontent.com/NixOS/nixpkgs/47993510dcb7713a29591517cb6ce682cc40f0ca/pkgs/shells/dash/default.nix -O dash.nix

步骤 2:with import <nixpkgs> {}; 替换开头的声明({ lib , stdenv , buildPackages , autoreconfHook , pkg-config , fetchurl , fetchpatch , libedit , runCommand , dash }:)。我不清楚为何需要这样做,但事实证明这么做是有效的。

步骤 3: 运行 nix-build dash.nix

这将开始编译该包。

步骤 4: 运行 nix-env -i -f dash.nix

这会将该包安装到我的 ~/.nix-profile 目录下。

就这么简单!一旦我完成了这些步骤,我便感觉自己能够逐步修改 dash 包,进一步创建属于我自己的包了。

制作自定义包的过程

因为 paperjam 依赖于 libpaper,而 libpaper 还没有打包,所以我首先需要构建 libpaper 包。

以下是 libpaper.nix,我基本上是从 nixpkgs 仓库中其他包的源码中复制粘贴得到的。我猜测这里的原理是,nix 对如何编译 C 包有一些默认规则,例如 “运行 make install”,所以 make install 实际上是默认执行的,并且我并不需要明确地去配置它。

with import <nixpkgs> {};

stdenv.mkDerivation rec {
  pname = "libpaper";
  version = "0.1";

  src = fetchFromGitHub {
    owner = "naota";
    repo = "libpaper";
    rev = "51ca11ec543f2828672d15e4e77b92619b497ccd";
    hash = "sha256-S1pzVQ/ceNsx0vGmzdDWw2TjPVLiRgzR4edFblWsekY=";
  };

  buildInputs = [ ];

  meta = with lib; {
    homepage = "https://github.com/naota/libpaper";
    description = "libpaper";
    platforms = platforms.unix;
    license = with licenses; [ bsd3 gpl2 ];
  };
}

这个脚本基本上告诉 nix 如何从 GitHub 下载源代码。

我通过运行 nix-build libpaper.nix 来构建它。

接下来,我需要编译 paperjam。我制作的 nix 包 的链接在这里。除了告诉它从哪里下载源码外,我需要做的主要事情有:

  • 添加一些额外的构建依赖项(像 asciidoc
  • 在安装过程中设置一些环境变量(installFlags = [ "PREFIX=$(out)" ];),这样它就会被安装在正确的目录,而不是 /usr/local/bin

我首先从散列值为空开始,然后运行 nix-build 以获取一个关于散列值不匹配的错误信息。然后我从错误信息中复制出正确的散列值。

我只是在 nixpkgs 仓库中运行 rg PREFIX 来找出如何设置 installFlags 的 —— 我认为设置 PREFIX 应该是很常见的操作,可能之前已经有人做过了,事实证明我的想法是对的。所以我只是从其他包中复制粘贴了那部分代码。

然后我执行了:

nix-build paperjam.nix
nix-env -i -f paperjam.nix

然后所有的东西都开始工作了,我成功地安装了 paperjam!耶!

下一个目标:安装一个五年前的 Hugo 版本

当前,我使用的是 2018 年的 Hugo 0.40 版本来构建我的博客。由于我并不需要任何的新功能,因此我并没有感到有升级的必要。对于在 Linux 上操作,这个过程非常简单:Hugo 的发行版本是静态二进制文件,这意味着我可以直接从 发布页面 下载五年前的二进制文件并运行。真的很方便!

但在我的 Mac 电脑上,我遇到了一些复杂的情况。过去五年中,Mac 的硬件已经发生了一些变化,因此我下载的 Mac 版 Hugo 二进制文件并不能运行。同时,我尝试使用 go build 从源代码编译,但由于在过去的五年内 Go 的构建规则也有所改变,因此没有成功。

我曾试图通过在 Linux docker 容器中运行 Hugo 来解决这个问题,但我并不太喜欢这个方法:尽管可以工作,但它运行得有些慢,而且我个人感觉这样做有些多余。毕竟,编译一个 Go 程序不应该那么麻烦!

幸好,Nix 来救援!接下来,我将介绍我是如何使用 nix 来安装旧版本的 Hugo。

使用 nix 安装 Hugo 0.40 版本

我的目标是安装 Hugo 0.40,并将其添加到我的 PATH 中,以 hugo-0.40 作为命名。以下是我实现此目标的步骤。尽管我采取了一种相对特殊的方式进行操作,但是效果不错(可以参考 搜索和安装旧版本的 Nix 包 来找到可能更常规的方法)。

步骤 1: 在 nixpkgs 仓库中搜索找到 Hugo 0.40。

我在此链接中找到了相应的 .nix 文件 https://github.com/NixOS/nixpkgs/blob/17b2ef2/pkgs/applications/misc/hugo/default.nix

步骤 2: 下载该文件并进行构建。

我下载了带有 .nix 扩展名的文件(以及同一目录下的另一个名为 deps.nix 的文件),将文件的首行替换为 with import <nixpkgs> {};,然后使用 nix-build hugo.nix 进行构建。

虽然这个过程几乎无需进行修改就能成功运行,但我仍然做了两处小调整:

  • with stdenv.lib 替换为 with lib
  • 为避免与我已安装的其他版本的 hugo 冲突,我把包名改为了 hugo040

步骤 3:hugo 重命名为 hugo-0.40

我编写了一个简短的后安装脚本,用以重命名 Hugo 二进制文件。

postInstall = ''
    mv $out/bin/hugo $out/bin/hugo-0.40
  '';

我是通过在 nixpkgs 仓库中运行 rg 'mv ' 命令,然后复制和修改一条看似相关的代码片段来找到如何实施此步骤。

步骤 4: 安装。

我通过运行 nix-env -i -f hugo.nix 命令,将 Hugo 安装到了 ~/.nix-profile/bin 目录中。

所有的步骤都顺利运行了!我把最终的 .nix 文件存放到了我自己的 nixpkgs 仓库 中,这样我以后如果需要,就能再次使用它了。

可重复的构建过程并非神秘,其实它们极其复杂

我觉得值得一提的是,这个 hugo.nix 文件并不是什么魔法——我之所以能在今天轻易地编译 Hugo 0.40,完全归功于许多人长期以来的付出,他们让 Hugo 的这个版本得以以可重复的方式打包。

总结

安装 paperjam 和这个五年前的 Hugo 版本过程惊人地顺利,实际上比没有 nix 来编译它们更简单。这是因为 nix 极大地方便了我使用正确的 libiconv 版本来编译 paperjam 包,而且五年前就已经有人辛苦地列出了 Hugo 的确切依赖关系。

我并无计划详细深入地使用 nix(真的,我很可能对它感到困扰,然后最后选择回归使用 homebrew!),但我们将拭目以待!我发现,简单入手然后按需逐步掌握更多功能,远比一开始就全面接触一堆复杂功能更容易掌握。

我可能不会在 Linux 上使用 nix —— 我一直都对 Debian 基础发行版的 apt 和 Arch 基础发行版的 pacman 感到满意,它们策略明晰且少有混淆。而在 Mac 上,使用 nix 似乎会有所得。不过,谁知道呢!也许三个月后,我可能会对 nix 感到不满然后再次选择回归使用 homebrew。

(题图:MJ/f68aaf37-4a34-4643-b3a1-8728d49cf887)


via: https://jvns.ca/blog/2023/02/28/some-notes-on-using-nix/

作者:Julia Evans 选题:lkxed 译者:ChatGPT 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

如果你是关注计算机领域最新趋势的学生或从业者,你应该听说过人工智能、数据科学、机器学习、深度学习等术语。作为人工智能系列文章的第一篇,本文将解释这些术语,并搭建一个帮助初学者入门的简易教学平台。

如今,计算机科学领域的学生和从业者绝对有必要了解 人工智能 artificial intelligence 数据科学 data science 机器学习 machine learning 深度学习 deep learning 方面的基本知识。但是应该从哪里开始呢?

为了找到答案,我浏览了大量人工智能的教材和教程。它们有的从大量数学理论开始,有的用编程语言无关的方式(不要求你了解某一门特定的编程语言)讲解,有的假设你是线性代数、概率论和统计学专家。在很大程度上,它们都很有用。但它们都没有回答最重要的问题:真正的初学者应该从哪里开始学习人工智能?

开始学习人工智能的方式多种多样,但是我对它们各有担忧。涉及太多的数学会让人分心,但如果数学介绍得太少就好像驾驶员不知道汽车引擎在哪里一样。对于未来的人工智能工程师和数据科学家来说,从进阶概念开始讲解是最有效率的方式,因为他们精通线性代数、概率论和统计学。如果从基础知识开始,然后在中间某个地方结束也可以,只要学员想要在这里结束学习。考虑到所有这些事实,我认为初学者的人工智能教程应该从基础知识开始,并以一个实际的人工智能项目结束。这个项目可能很小,但是在相同任务上它将会超越任何传统项目。

本系列将从最基础的知识讲到中等水平内容。除了讨论人工智能,我还希望对相关的话题进行一些澄清,因为人们对人工智能、机器学习、数据科学等术语有很多困惑。人工智能程序是必要的,因为我们每天会产生海量的数据。根据互联网上查询到的结果,我们每天大约会产生 2.5x10 18 字节的数据。但是,这些数据中的大多数与我们完全无关,包括大量没有价值的 YouTube 视频,不经思考就发送的电子邮件,琐碎的新闻报道等等。然而,这片浩瀚的数据海洋中同样蕴含着无价的宝贵知识。传统软件无法完成处理这些数据的艰巨任务。人工智能是少数能够应对这种信息过载的技术之一。

当谈到到人工智能时,我们还需要区分事实和假象。我记得几年前听一位人工智能专家的演讲。他讲述了一个人工智能图像识别系统,它能近乎绝对准确地分辨西伯利亚雪橇犬和西伯利亚雪狼的图像。在互联网上搜索一下,你会看到这两种动物有多么相似。如果这个系统确实那么准确,它将是人工智能的奇迹。可惜的是,事实并非如此。该图像识别系统只是对图像的背景进行了分类。西伯利亚雪橇犬是家养动物,它的图像背景中几乎总会有一些矩形或圆形的物体。而西伯利亚雪狼是野生动物,它所在的背景中有雪。这些例子导致近年来人们对人工智能提出了准确性担保要求。

确实,最近几年人工智能展现了一些真正的力量。举个简单例子就是 YouTube、Amazon 等网站的推荐系统。很多时候我惊讶于它们的推荐结果,就好像它们会读心术一样。然而不论这些推荐的质量如何,“人工智能到底是好是坏?”都是一个很热门话题。我认为,一个像《终结者》中机器有意识地攻击人类的未来还遥遥无期。然而,前面那句话中的“有意识地”一词非常重要。目前的人工智能系统可能发生故障,并且意外地伤害到人类。但是,许多号称具有人工智能能力的系统实际上只是包含大量分支和循环的常规软件。因此目前可以安全地说,我们还没有在日常生活中看到人工智能的真正威力。不论是好的影响(如治愈癌症),还是坏的影响(合成的世界领导人视频导致的暴动和战争),我们都只能拭目以待了。就个人而言,我相信人工智能是一种福祉,并将大大提高未来几代人的生活质量。

什么是人工智能?

在我们进一步探讨之前,让我们试着理解人工智能(AI)、机器学习(ML)、深度学习(DL)、数据科学(DS)等之间的联系和区别。这些术语经常被误用为同义词。图 1 表示了人工智能、机器学习、深度学习和数据科学之间的关系。当然这不是唯一的划分方式,你可能会看到其它的划分图。但在我看来,图 1 是最贴切的,它能够最大程度地概括这些领域之间关系。

图 1:人工智能体系结构和数据科学

在本系列的第一篇文章中,我不会对每个术语定义进行精确的定义。我认为在现阶段,精确地定义它们是适得其反的,是浪费时间。但在后续的文章中,我们将重新讨论这些术语并正式定义它们。目前我们可以暂时把人工智能看作是可以在某种程度上模仿人类智能的程序。那人类智能又是指什么呢?

想象一下你的人工智能程序是一个一岁大的婴儿。这个宝宝会通过听周围人说话来学习母语。他/她将很快学会识别形状,颜色,物体等,没有任何困难。此外,他/她将能够对周围人的情绪做出反应。例如,任何一个三岁的婴儿都知道如何用甜言蜜语让父母给他/她巧克力和棒棒糖。同样,人工智能程序也将能够感知并适应环境,就像婴儿一样。然而,这种真正的人工智能只能在遥远的未来实现。

图 1 显示机器学习是人工智能的真子集,它也是实现人工智能系统的技术之一。机器学习是使用大量数据来训练程序的技术,以便有效地执行必要的任务。它的准确性随着训练集的增大而增加。请注意,还有其它技术用于开发人工智能系统,如基于布尔逻辑的系统,基于模糊逻辑的系统,基于遗传编程的系统等。然而,如今机器学习是实现人工智能系统的最主流的技术。图 1 还显示深度学习是机器学习的真子集,它只是众多机器学习技术中的一种。但目前实际上大多数严肃的机器学习技术都用到了深度学习。在这一点上,我甚至避免尝试定义深度学习。请记住,深度学习涉及到使用大型人工神经网络。

那数据科学(图 1 中的红圈)是做什么的呢?数据科学是计算机科学/数学领域中的一门处理和解读大规模数据的学科。我说的“大”,有多大呢?早在 2010 年,Facebook 等一些企业巨头就声称它们的服务器可以处理几 Pb 的数据。当我们说大数据时,通常指的是 Tb 或 Pb 级的数据规模,而不是 Gb 级的。许多数据科学应用涉及人工智能、机器学习和深度学习技术的使用。因此,当我们讨论人工智能时,很难不提到数据科学。数据科学也使用很多传统的编程和数据库管理技术,比如使用 Apache Hadoop 进行大数据分析。

本系列的讨论将主要集中在人工智能和机器学习上,并涉及数据科学。

教学环境搭建

在表明了本系列文章的主题后,现在说说本教程的前置条件。你需要一台 Linux 电脑(当然 Windows 或 macOS 机器也可以,只是在一些安装步骤上可能需要额外的协助),并了解基本的数学和计算机编程知识。我希望在细心地阅读本系列文章后,你会感受到人工智能的强大。

用编程语言无关的方式来学习人工智能是可能的,但本系列将基于一门编程语言并涉及大量的编程。在决定使用哪一门编程语言之前,我们先来回顾一下人工智能、机器学习、深度学习和数据科学领域流行的编程语言。Lisp 是一种函数式编程语言,它是最早用于开发人工智能程序的语言之一。Prolog 是一种逻辑编程语言,在 20 世纪 70 年代也被用于同样的目的。我们将在接下来的介绍人工智能历史的文章中更详细地介绍 Lisp 和 Prolog。

如今,Java、C、C++、Scala、Haskell、MATLAB、R、Julia 等编程语言也被用于开发人工智能程序。Python 在人工智能程序开发中被广泛使用,这使我们选择它作为本教程的编程语言。但我必须声明,从这里开始做的选择(更确切地说,是我替你做的选择),主要考虑的因素是易用性、受欢迎程度、(在少数情况下)我自己对该软件/技术的适应和熟悉程度、对本教程效率的提升。但同时,我也鼓励你尝试其它的编程语言、软件和工具。也许从长远来看,它们对你来说可能是更好的选择。

现在我们需要立即做出另一个选择:使用 Python 2 还是 Python 3?考虑到本系列有许多年轻的读者,他们还有漫长的职业生涯,我将选择使用 Python 3。在 Ubuntu 系统终端中执行命令 sudo apt install python3 安装最新版本的 Python 3(你的系统中可能已经安装了 Python 3)。在其它 Linux 发行版、Windows 和 macOS 机器上安装 Python 3 也非常容易。执行下面的命令查看安装的 Python 3 的版本:

python3 --version
Python 3.8.10

在后续的教程中,我们需要安装许多 Python 包,所以需要一个包管理器。目前主流的包管理器有 pip、Conda 和 Mamba 等。我选择 pip 作为包在本教程的管理器。它相对简单,也是推荐的 Python 安装工具。我认为 Conda 和 Mamba 是比 pip 更强大的工具,你可以尝试一下它们。运行命令 sudo apt install python3-pip 将在 Ubuntu 系统中安装 pip。pip、Conda 和 Mamba 是跨平台软件,它们可以安装在 Linux、Windows 和 macOS 系统上。运行命令 pip3 --version 查看系统中安装的 pip 版本,如下所示:

pip 20.0.2 from /usr/lib/python3/dist-packages/pip (python 3.8)

现在我们需要一个 Python 集成开发环境(IDE)。IDE 能帮助程序员更容易地编写、编译、调试和执行代码。PyCharm、IDLE、Spyder 等都是流行的 Python IDE。然而,由于我们的主要目的是开发人工智能和数据科学程序,这里考虑另外两个强有力的竞争者 —— JupyterLab 和谷歌 Colab。严格地说,它们不仅仅是 IDE;它们是非常强大的基于网络的交互式开发环境。两者都可以在网络浏览器上工作,并提供强大的功能。JupyterLab 是由非营利组织 Project Jupyter 支持的免费开源软件。谷歌 Colab 遵循 免费增值 freemium 模式,即基本功能免费,附加功能收费。我认为谷歌 Colab 比 JupyterLab 功能更强大。但是由于谷歌 Colab 的免费增值模式,以及我相对缺乏谷歌 Colab 的使用经验,在本教程中我选择 JupyterLab。但我仍然强烈建议你去了解一下谷歌 Colab。

可以使用命令 pip3 install JupyterLab 在本地安装 JupyterLab。执行命令 jupyter-lab 将在系统的默认网络浏览器中运行 JupyterLab。Project Jupyter 还提供一个更老的类似系统,称为Jupyter Notebook。可以通过 pip3 install Notebook 命令在本地安装 Jupyter Notebook,用Jupyter Notebook 运行它。但 Jupyter Notebook 的功能不如 JupyterLab 强大,且官方宣布它最终会被 JupyterLab 取代。在本教程中,我们将在合适的阶段使用 JupyterLab。但在开始阶段,我们将使用 Linux 终端来运行 Python 程序,因此急需的是包管理器 pip。

Anaconda 是一个非常流行的 Python 和 R 编程语言发行版,它主要用于机器学习和数据科学领域。作为未来的人工智能工程师和数据科学家,熟悉使用 Anaconda 也是一个不错的选择。

现在我们需要确定最重要的一点 —— 本教程的风格。有大量人工智能开发相关的 Python 库,比如 NumPy、SciPy、Pandas、Matplotlib、Seaborn、TensorFlow、Keras、Scikit-learn 和 PyTorch。许多关于人工智能、机器学习和数据科学的教材和教程都是基于对其中一个或多个库的完整讲解。尽管对特定包的功能进行这样的覆盖讲解是一种高效的方式,但我的教程是更面向数学的。我们将首先讨论开发人工智能程序所需的数学概念,然后再介绍需要的 Python 基础知识和 Python 库。我们会为了探索实现这些数学概念所需的特性而不断回顾这些 Python 库。有时我也会要求你自己学习一些 Python 和数学的基本概念。

在完成这些准备工作之后,如果我们就在这里结束,任何代码或数学概念都不讲,那将是一种罪过。因此,我们将继续学习人工智能和机器学习中最重要的数学概念:向量和矩阵。

向量和矩阵

矩阵是按行和列排列的数字、符号或数学表达式构成的矩形阵列。图 2 显示了一个 2 × 3 矩阵,它有 2 行和 3 列。如果你熟悉编程,在许多流行的编程语言中这个矩阵可以表示为一个二维数组。只有一行的矩阵称为行向量,只有一列的矩阵称为列向量。 就是一个行向量。

图 2:一个: A 2 × 3 的矩阵

为什么矩阵和向量在人工智能和机器学习中如此重要呢?人工智能和机器学习中广泛使用线性代数,而矩阵和向量是线性代数的核心。几个世纪以来,数学家们一直在研究矩阵和向量的性质和应用。高斯、欧拉、莱布尼茨、凯利、克莱姆和汉密尔顿等数学家在线性代数和矩阵论领域都有以他们的名字命名的定理。多年来,线性代数中发展出了许多分析矩阵和向量性质的技术。

复杂的数据通常可以很容易用向量或矩阵来表示。举一个简单的例子,从一个人的医疗记录中,可以得到详细的年龄、身高(厘米)、体重(公斤)、收缩压、舒张压和空腹血糖(毫克/分升)。这些信息可以很容易用行向量来表示, 。人工智能和机器学习的第一个挑战来了:如果医疗记录有十亿条怎么办?即使动用成千上万的专业人员从中手动提取数据,这项任务也是无法完成的。因此,人工智能和机器学习利用程序来提取数据。

人工智能和机器学习的第二个挑战是数据解读。这是一个广阔的领域,有许多技术值得探索。我将在后续文章中介绍相关内容。人工智能和机器学习应用除了面临数学/计算方面的挑战外,还面临硬件方面的挑战。随着处理的数据量的增加,数据存储、处理器速度、功耗等也成为人工智能应用面临的重要挑战。但现在让我们先抛开这些挑战,动手编写第一行人工智能代码。

我们将编写一个简单的 Python 脚本,用来将两个向量相加。我们将用到名为 NumPy 的 Python 库,它支持多维矩阵(数组)的数学运算。用命令 pip3 install numpy 为 Python 3 安装 NumPy 包。如果你使用的是 JupyterLab、谷歌 Colab 或 Anaconda,那么 NumPy 应该已经被预安装了。但是为了演示,在本系列的前几篇文章中,我们都将在 Linux 终端上操作。在 Linux 终端上执行命令 python3 进入 Python 控制台。在这个控制台中可以逐行执行 Python 代码。图 3 展示了在控制台中逐行运行 Python 代码,将两个向量相加,并输出结果。

图 3:两个向量求和的 Python 代码

首先,让我们试着逐行理解这些代码。由于本教程假定的编程经验很少,所以我将代码行标记为【基本】或【AI】。标记为【基本】的行是经典 Python 代码,标记为【AI】的行是用于开发人工智能程序的代码。通过区分基本和进阶的 Python 代码,我希望具有基本知识和中级编程技能的程序员都能够高效地使用本教程。

import numpy as np         #【基本】
a = np.array([11, 22, 33]) #【AI】
b = np.array([44, 55, 66]) #【AI】
c = np.add(a, b)           #【AI】
print(c)                   #【基本】

import numpy as np 导入 numpy 库并将其命名为 np。Python 中的 import 语句类似于在 C/C++ 用 #include 来包含头文件,或者在 Java 中用import 来使用包。

a = np.array([11, 22, 33])b = np.array([44, 55, 66]) 分别创建了名为 ab 的一维数组(为了便于理解,目前假设向量等价于一维数组)。

c = np.add(a, b) 将向量 ab 相加,并将结果存储在名为 c 的向量中。当然,用 abc 作为变量名是一种糟糕的编程实践,但数学家倾向于将向量命名为 等。如果你完全没有 Python 编程经验,请自行了解 Python 变量的相关知识。

print(c) 在终端上打印对象的值,即向量 [55 77 99]。你可以暂时这样理解向量相加, c = [55=11+44 77=22+55 99=33+66]。如果你想正式地了解向量和矩阵是如何相加的,但手头又没有相关的教材,我建议阅读维基百科上关于矩阵加法的文章。在网上搜索一下就会发现,用经典的 C/C++ 或 Java 程序来实现向量相加需要更多的代码。这说明 Python 很适合处理向量和矩阵。当我们执行越来越复杂的向量运算时,Python 的强大将进一步显现。

在我们结束本文之前,我要做两个声明。第一,上面讨论的示例只处理了两个行向量(确切地说是 1 x 3 的矩阵)的相加,但真正的机器学习应用可能要处理 1000000 X 1000000 的矩阵。但不用担心,通过练习和耐心,我们将能够处理这些问题。第二,本文中给出许多定义包含了粗略的简化和不充分的描述。但如前面所说,在本系列结束之前,我将给这些模糊的术语下一个正式的定义。

现在我们该结束这篇文章了。我希望所有人都安装文中提到的必要软件,并运行本文中的代码。在下一篇文章中,我们将首先讨论人工智能的历史、范畴和未来,然后深入探讨线性代数的支柱——矩阵论。

(题图:MJ/25071901-abc4-4144-bf27-4d98bb1d9301/)


via: https://www.opensourceforu.com/2022/08/artificial-intelligence-explaining-the-basics/

作者:Deepu Benson 选题:lkxed 译者:toknow-gh 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

我一直在慢慢地撰写关于 Git 工作原理的文章。尽管我曾认为自己对 Git 非常了解,但像往常一样,当我尝试解释某事的时候,我又学到一些新东西。

现在回想起来,这些事情都不算太令人吃惊,但我以前并没有清楚地思考过它们。

事实是:

  • “索引”、“暂存区” 和 -cached 是一回事
  • 隐匿文件就是一堆提交
  • 并非所有引用都是分支或标签
  • 合并提交不是空的

下面我们来详细了解这些内容。

“索引”、“暂存区” 和 -cached 是一回事

当你运行 git add file.txt,然后运行 git status,你会看到类似以下的输出:

$ git add content/post/2023-10-20-some-miscellaneous-git-facts.markdown
$ git status
Changes to be committed:
    (use "git restore --staged <file>..." to unstage)
    new file:   content/post/2023-10-20-some-miscellaneous-git-facts.markdown

人们通常称这个过程为“暂存文件”或“将文件添加到暂存区”。

当你使用 git add 命令来暂存文件时,Git 在后台将文件添加到其对象数据库(在 .git/objects 目录下),并更新一个名为 .git/index 的文件以引用新添加的文件。

Git 中的这个“暂存区”事实上有 3 种不同的名称,但它们都指的是同一个东西(即 .git/index 文件):

  • git diff --cached
  • git diff --staged
  • .git/index 文件

我觉得我早该早点认识到这一点,但我之前并没有,所以在这里提醒一下。

隐匿文件就是一堆提交

当我运行 git stash 命令来保存更改时,我一直对这些更改究竟去了哪里感到有些困惑。事实上,当你运行 git stash 命令时,Git 会根据你的更改创建一些提交,并用一个名为 stash 的引用来标记它们(在 .git/refs/stash 目录下)。

让我们将此博客文章隐匿起来,然后查看 stash 引用的日志:

$ git log stash --oneline
6cb983fe (refs/stash) WIP on main: c6ee55ed wip
2ff2c273 index on main: c6ee55ed wip
... some more stuff

现在我们可以查看提交 2ff2c273 以查看其包含的内容:

$ git show 2ff2c273  --stat
commit 2ff2c273357c94a0087104f776a8dd28ee467769
Author: Julia Evans <[email protected]>
Date:   Fri Oct 20 14:49:20 2023 -0400

    index on main: c6ee55ed wip

    content/post/2023-10-20-some-miscellaneous-git-facts.markdown | 40 ++++++++++++++++++++++++++++++++++++++++

毫不意外,它包含了这篇博客文章。这很合理!

实际上,git stash 会创建两个独立的提交:一个是索引提交,另一个是你尚未暂存的改动提交。这让我感到很振奋,因为我一直在开发一款工具,用于快照和恢复 Git 仓库的状态(也许永远不会发布),而我提出的设计与 Git 的隐匿实现非常相似,所以我对自己的选择感到满意。

显然 stash 中的旧提交存储在 reflog 中。

并非所有引用都是分支或标签

Git 文档中经常泛泛地提到 “引用”,这使得我有时觉得很困惑。就个人而言,我在 Git 中处理 “引用” 的 99% 时间是指分支或 HEAD,而剩下的 1% 时间是指标签。事实上,我以前完全不知道任何不是分支、标签或 HEAD 的引用示例。

但现在我知道了一个例子—— stash 是一种引用,而它既不是分支也不是标签!所以这太酷啦!

以下是我博客的 Git 仓库中的所有引用(除了 HEAD):

$ find .git/refs -type f
.git/refs/heads/main
.git/refs/remotes/origin/HEAD
.git/refs/remotes/origin/main
.git/refs/stash

人们在本帖回复中提到的其他一些参考资料:

  • refs/notes/*,来自 git notes
  • refs/pull/123/headrefs/pull/123/head` 用于 GitHub 拉取请求(可通过 git fetch origin refs/pull/123/merge 获取)
  • refs/bisect/*,来自 git bisect

合并提交不是空的

这是一个示例 Git 仓库,其中我创建了两个分支 xy,每个分支都有一个文件(x.txty.txt),然后将它们合并。让我们看看合并提交。

$ git log --oneline
96a8afb (HEAD -> y) Merge branch 'x' into y
0931e45 y
1d8bd2d (x) x

如果我运行 git show 96a8afb,合并提交看起来是“空的”:没有差异!

git show 96a8afb
commit 96a8afbf776c2cebccf8ec0dba7c6c765ea5d987 (HEAD -> y)
Merge: 0931e45 1d8bd2d
Author: Julia Evans <[email protected]>
Date:   Fri Oct 20 14:07:00 2023 -0400

    Merge branch 'x' into y

但是,如果我单独比较合并提交与其两个父提交之间的差异,你会发现当然差异:

$ git diff 0931e45 96a8afb   --stat
    x.txt | 1 +
    1 file changed, 1 insertion(+)
$ git diff 1d8bd2d 96a8afb   --stat
    y.txt | 1 +
    1 file changed, 1 insertion(+)

现在回想起来,合并提交并不是实际上“空的”(它们是仓库当前状态的快照,就像任何其他提交一样),这一点似乎很明显,只是我以前从未思考为什么它们看起来为空。

显然,这些合并差异为空的原因是合并差异只显示冲突 —— 如果我创建一个带有合并冲突的仓库(一个分支在同一文件中添加了 x,而另一个分支添加了 y),然后查看我解决冲突的合并提交,它看起来会像这样:

$ git show HEAD
commit 3bfe8311afa4da867426c0bf6343420217486594
Merge: 782b3d5 ac7046d
Author: Julia Evans <[email protected]>
Date:   Fri Oct 20 15:29:06 2023 -0400

    Merge branch 'x' into y

diff --cc file.txt
index 975fbec,587be6b..b680253
--- a/file.txt
+++ b/file.txt
@@@ -1,1 -1,1 +1,1 @@@
- y
    -x
++z

这似乎是在告诉我,一个分支添加了 x,另一个分支添加了 y,合并提交通过将 z 替代冲突解决了它。但在前面的示例中,没有冲突,所以 Git 并未显示任何差异。

(感谢 Jordi 告诉我合并差异的工作原理)

先这样吧

些写到这里吧,也许我将在学到更多 Git 知识时撰写另一篇关于 Git 的知识的博客文章。

(题图:MJ/03bfecc3-944e-47a0-a4fd-575293d2ba92)


via: https://jvns.ca/blog/2023/10/20/some-miscellaneous-git-facts/

作者:Julia Evans 选题:lujun9972 译者:KaguyaQiang 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

大家好!前段时间我写了一篇关于“如何用 Go 语言建立一个简易的 DNS 解析器”的帖子。

那篇帖子里我没写有关“如何生成以及解析 DNS 查询请求”的内容,因为我觉得这很无聊,不过一些伙计指出他们不知道如何解析和生成 DNS 查询请求,并且对此很感兴趣。

我开始好奇了——解析 DNS 花多大功夫?事实证明,编写一段 120 行精巧的 Ruby 语言代码组成的程序就可以做到,这并不是很困难。

所以,在这里有一个如何生成 DNS 查询请求,以及如何解析 DNS 响应报文的速成教学!我们会用 Ruby 语言完成这项任务,主要是因为不久以后我将在一场 Ruby 语言大会上发表观点,而这篇博客帖的部分内容是为了那场演讲做准备的。?

(我尽量让不懂 Ruby 的人也能读懂,我只使用了非常基础的 Ruby 语言代码。)

最后,我们就能制作一个非常简易的 Ruby 版本的 dig 工具,能够查找域名,就像这样:

$ ruby dig.rb example.com
example.com    20314    A    93.184.216.34

整个程序大概 120 行左右,所以 并不 算多。(如果你想略过讲解,单纯想去读代码的话,最终程序在这里:dig.rb。)

我们不会去实现之前帖中所说的“一个 DNS 解析器是如何运作的?”,因为我们已经做过了。

那么我们开始吧!

如果你想从头开始弄明白 DNS 查询是如何格式化的,我将尝试解释如何自己弄明白其中的一些东西。大多数情况下的答案是“用 Wireshark 去解包”和“阅读 RFC 1035,即 DNS 的规范”。

生成 DNS 查询请求

步骤一:打开一个 UDP 套接字

我们需要实际发送我们的 DNS 查询,因此我们就需要打开一个 UDP 套接字。我们会将我们的 DNS 查询发送至 8.8.8.8,即谷歌的服务器。

下面是用于建立与 8.8.8.8 的 UDP 连接,端口为 53(DNS 端口)的代码。

require 'socket'
sock = UDPSocket.new

sock.bind('0.0.0.0', 12345)
sock.connect('8.8.8.8', 53)

关于 UDP 的说明

关于 UDP,我不想说太多,但是我要说的是,计算机网络的基础单位是“ 数据包 packet ”(即一串字节),而在这个程序中,我们要做的是计算机网络中最简单的事情:发送 1 个数据包,并接收 1 个数据包作为响应。

所以 UDP 是一个传递数据包的最简单的方法。

它是发送 DNS 查询最常用的方法,不过你还可以用 TCP 或者 DNS-over-HTTPS。

步骤二:从 Wireshark 复制一个 DNS 查询

下一步:假设我们都不知道 DNS 是如何运作的,但我们还是想尽快发送一个能运行的 DNS 查询。获取 DNS 查询并确保 UDP 连接正常工作的最简单方法就是复制一个已经正常工作的 DNS 查询!

所以这就是我们接下来要做的,使用 Wireshark (一个绝赞的数据包分析工具)。

我的操作大致如下:

  1. 打开 Wireshark,点击 “ 捕获 capture ” 按钮。
  2. 在搜索栏输入 udp.port == 53 作为筛选条件,然后按下回车。
  3. 在我的终端运行 ping example.com(用来生成一个 DNS 查询)。
  4. 点击 DNS 查询(显示 “Standard query A example.com”)。 (“A”:查询类型;“example.com”:域名;“Standard query”:查询类型描述)
  5. 右键点击位于左下角面板上的 “ 域名系统(查询) Domain Name System (query) ”。
  6. 点击 “ 复制 Copy ” ——> “ 作为十六进制流 as a hex stream ”。
  7. 现在 b96201000001000000000000076578616d706c6503636f6d0000010001 就放到了我的剪贴板上,之后会用在我的 Ruby 程序里。好欸!

步骤三:解析 16 进制数据流并发送 DNS 查询

现在我们能够发送我们的 DNS 查询到 8.8.8.8 了!就像这样,我们只需要再加 5 行代码:

hex_string = "b96201000001000000000000076578616d706c6503636f6d0000010001"
bytes = [hex_string].pack('H*')
sock.send(bytes, 0)

# get the reply
reply, _ = sock.recvfrom(1024)
puts reply.unpack('H*')

[hex_string].pack('H*') 意思就是将我们的 16 位字符串转译成一个字节串。此时我们不知道这组数据到底是什么意思,但是很快我们就会知道了。

我们还可以借此机会运用 tcpdump ,确认程序是否正常进行以及发送有效数据。我是这么做的:

  1. 在一个终端选项卡下执行 sudo tcpdump -ni any port 53 and host 8.8.8.8 命令
  2. 在另一个不同的终端指标卡下,运行 这个程序ruby dns-1.rb

以下是输出结果:

$ sudo tcpdump -ni any port 53 and host 8.8.8.8
08:50:28.287440 IP 192.168.1.174.12345 > 8.8.8.8.53: 47458+ A? example.com. (29)
08:50:28.312043 IP 8.8.8.8.53 > 192.168.1.174.12345: 47458 1/0/0 A 93.184.216.34 (45)

非常棒 —— 我们可以看到 DNS 请求(”这个 example.com 的 IP 地址在哪里?“)以及响应(“在93.184.216.34”)。所以一切运行正常。现在只需要(你懂的)—— 搞清我们是如何生成并解析这组数据的。

步骤四:学一点点 DNS 查询的格式

现在我们有一个关于 example.com 的 DNS 查询,让我们了解它的含义。

下方是我们的查询(16 位进制格式):

b96201000001000000000000076578616d706c6503636f6d0000010001

如果你在 Wireshark 上搜索,你就能看见这个查询它由两部分组成:

  • 请求头b96201000001000000000000
  • 语句本身076578616d706c6503636f6d0000010001

步骤五:制作请求头

我们这一步的目标就是制作字节串 b96201000001000000000000(借助一个 Ruby 函数,而不是把它硬编码出来)。

(LCTT 译注: 硬编码 hardcode 指在软件实现上,将输出或输入的相关参数(例如:路径、输出的形式或格式)直接以常量的方式撰写在源代码中,而非在运行期间由外界指定的设置、资源、数据或格式做出适当回应。)

那么:请求头是 12 个字节。那些个 12 字节到底意味着什么呢?如果你在 Wireshark 里看看(亦或者阅读 RFC-1035),你就能理解:它是由 6 个 2 字节大小的数字串联在一起组成的。

这六个数字分别对应查询 ID、标志,以及数据包内的问题计数、回答资源记录数、权威名称服务器记录数、附加资源记录数。

我们还不需要在意这些都是些什么东西 —— 我们只需要把这六个数字输进去就行。

但所幸我们知道该输哪六位数,因为我们就是为了直观地生成字符串 b96201000001000000000000

所以这里有一个制作请求头的函数(注意:这里没有 return,因为在 Ruby 语言里,如果处在函数最后一行是不需要写 return 语句的):

def make_question_header(query_id)
  # id, flags, num questions, num answers, num auth, num additional
  [query_id, 0x0100, 0x0001, 0x0000, 0x0000, 0x0000].pack('nnnnnn')
end

上面内容非常的短,主要因为除了查询 ID ,其余所有内容都由我们硬编码写了出来。

什么是 nnnnnn?

可能能想知道 .pack('nnnnnn') 中的 nnnnnn 是个什么意思。那是一个向 .pack() 函数解释如何将那个 6 个数字组成的数据转换成一个字节串的一个格式字符串。

.pack 的文档在 这里,其中描述了 n 的含义其实是“将其表示为” 16 位无符号、网络(大端序)字节序’”。

(LCTT 译注: 大端序 Big-endian :指将高位字节存储在低地址,低位字节存储在高地址的方式。)

16 个位等同于 2 字节,同时我们需要用网络字节序,因为这属于计算机网络范畴。我不会再去解释什么是字节序了(尽管我确实有 一幅自制漫画尝试去描述它)。

测试请求头代码

让我们快速检测一下我们的 make_question_header 函数运行情况。

puts make_question_header(0xb962) == ["b96201000001000000000000"].pack("H*")

这里运行后输出 true 的话,我们就成功了。

好了我们接着继续。

步骤六:为域名进行编码

下一步我们需要生成 问题本身(“example.com 的 IP 是什么?”)。这里有三个部分:

  • 域名(比如说 example.com
  • 查询类型(比如说 A 代表 “IPv4 Address”)
  • 查询类(总是一样的,1 代表 INternet)

最麻烦的就是域名,让我们写个函数对付这个。

example.com 以 16 进制被编码进一个 DNS 查询中,如 076578616d706c6503636f6d00。这有什么含义吗?

如果我们把这些字节以 ASCII 值翻译出来,结果会是这样:

076578616d706c6503636f6d00
 7 e x a m p l e 3 c o m 0

因此,每个段(如 example)的前面都会显示它的长度(7)。

下面是有关将 example.com 翻译成 7 e x a m p l e 3 c o m 0 的 Ruby 代码:

def encode_domain_name(domain)
  domain
    .split(".")
    .map { |x| x.length.chr + x }
    .join + "\0"
end

除此之外,,要完成问题部分的生成,我们只需要在域名结尾追加上(查询)的类型和类。

步骤七:编写 make\_dns\_query

下面是制作一个 DNS 查询的最终函数:

def make_dns_query(domain, type)
  query_id = rand(65535)
  header = make_question_header(query_id)
  question =  encode_domain_name(domain) + [type, 1].pack('nn')
  header + question
end

这是目前我们写的所有代码 dns-2.rb —— 目前仅 29 行。

接下来是解析的阶段

现在我尝试去解析一个 DNS 查询,我们到了硬核的部分:解析。同样的,我们会将其分成不同部分:

  • 解析一个 DNS 的请求头
  • 解析一个 DNS 的名称
  • 解析一个 DNS 的记录

这几个部分中最难的(可能跟你想的不一样)就是:“解析一个 DNS 的名称”。

步骤八:解析 DNS 的请求头

让我们先从最简单的部分开始:DNS 的请求头。我们之前已经讲过关于它那六个数字是如何串联在一起的了。

那么我们现在要做的就是:

  • 读其首部 12 个字节
  • 将其转换成一个由 6 个数字组成的数组
  • 为方便起见,将这些数字放入一个类中

以下是具体进行工作的 Ruby 代码:

class DNSHeader
  attr_reader :id, :flags, :num_questions, :num_answers, :num_auth, :num_additional
  def initialize(buf)
    hdr = buf.read(12)
    @id, @flags, @num_questions, @num_answers, @num_auth, @num_additional = hdr.unpack('nnnnnn')
  end
end

注: attr_reader 是 Ruby 的一种说法,意思是“使这些实例变量可以作为方法使用”。所以我们可以调用 header.flags 来查看@flags变量。

我们也可以借助 DNSheader(buf) 调用这个,也不差。

让我们往最难的那一步挪挪:解析一个域名。

步骤九:解析一个域名

首先,让我们写其中的一部分:

def read_domain_name_wrong(buf)
  domain = []
  loop do
    len = buf.read(1).unpack('C')[0]
    break if len == 0
    domain << buf.read(len)
  end
  domain.join('.')
end

这里会反复读取一个字节的数据,然后将该长度读入字符串,直到读取的长度为 0。

这里运行正常的话,我们在我们的 DNS 响应头第一次看见了域名(example.com)。

关于域名方面的麻烦:压缩!

但当 example.com 第二次出现的时候,我们遇到了麻烦 —— 在 Wireshark 中,它报告上显示输出的域的值为含糊不清的 2 个字节的 c00c

这种情况就是所谓的 DNS 域名压缩,如果我们想解析任何 DNS 响应我们就要先把这个实现完。

幸运的是,这没那么难。这里 c00c 的含义就是:

  • 前两个比特(0b11.....)意思是“前面有 DNS 域名压缩!”
  • 而余下的 14 比特是一个整数。这种情况下这个整数是 120x0c),意思是“返回至数据包中的第 12 个字节处,使用在那里找的域名”

如果你想阅读更多有关 DNS 域名压缩之类的内容。我找到了相关更容易让你理解这方面内容的文章: 关于 DNS RFC 的释义

步骤十:实现 DNS 域名压缩

因此,我们需要一个更复杂的 read_domain_name 函数。

如下所示:

domain = []
loop do
  len = buf.read(1).unpack('C')[0]
  break if len == 0
  if len & 0b11000000 == 0b11000000
    # weird case: DNS compression!
    second_byte = buf.read(1).unpack('C')[0]
    offset = ((len & 0x3f) << 8) + second_byte
    old_pos = buf.pos
    buf.pos = offset
    domain << read_domain_name(buf)
    buf.pos = old_pos
    break
  else
    # normal case
    domain << buf.read(len)
  end
end
domain.join('.')

这里具体是:

  • 如果前两个位为 0b11,那么我们就需要做 DNS 域名压缩。那么:

    • 读取第二个字节并用一点儿运算将其转化为偏移量。
    • 在缓冲区保存当前位置。
    • 在我们计算偏移量的位置上读取域名
    • 在缓冲区存储我们的位置。

可能看起来很乱,但是这是解析 DNS 响应的部分中最难的一处了,我们快搞定了!

一个关于 DNS 压缩的漏洞

有些人可能会说,有恶意行为者可以借助这个代码,通过一个带 DNS 压缩条目的 DNS 响应指向这个响应本身,这样 read_domain_name 就会陷入无限循环。我才不会改进它(这个代码已经够复杂了好吗!)但一个真正的 DNS 解析器确实会更巧妙地处理它。比如,这里有个 能够避免在 miekg/dns 中陷入无限循环的代码

如果这是一个真正的 DNS 解析器,可能还有其他一些边缘情况会造成问题。

步骤十一:解析一个 DNS 查询

你可能在想:“为什么我们需要解析一个 DNS 查询?这是一个响应啊!”

但每一个 DNS 响应包含它自己的原始查询,所以我们有必要去解析它。

这是解析 DNS 查询的代码:

class DNSQuery
  attr_reader :domain, :type, :cls
  def initialize(buf)
    @domain = read_domain_name(buf)
    @type, @cls = buf.read(4).unpack('nn')
  end
end

内容不是太多:类型和类各占 2 个字节。

步骤十二:解析一个 DNS 记录

最让人兴奋的部分 —— DNS 记录是我们的查询数据存放的地方!即这个 “rdata 区域”(“记录数据字段”)就是我们会在 DNS 查询对应的响应中获得的 IP 地址所驻留的地方。

代码如下:

class DNSRecord
  attr_reader :name, :type, :class, :ttl, :rdlength, :rdata
  def initialize(buf)
    @name = read_domain_name(buf)
    @type, @class, @ttl, @rdlength = buf.read(10).unpack('nnNn')
    @rdata = buf.read(@rdlength)
  end

我们还需要让这个 rdata 区域更加可读。记录数据字段的实际用途取决于记录类型 —— 比如一个“A” 记录就是一个四个字节的 IP 地址,而一个 “CNAME” 记录则是一个域名。

所以下面的代码可以让请求数据更可读:

def read_rdata(buf, length)
  @type_name = TYPES[@type] || @type
  if @type_name == "CNAME" or @type_name == "NS"
    read_domain_name(buf)
  elsif @type_name == "A"
    buf.read(length).unpack('C*').join('.')
  else
    buf.read(length)
  end
end

这个函数使用了 TYPES 这个哈希表将一个记录类型映射为一个更可读的名称:

TYPES = {
  1 => "A",
  2 => "NS",
  5 => "CNAME",
  # there are a lot more but we don't need them for this example
}

read.rdata 中最有趣的一部分可能就是这一行 buf.read(length).unpack('C*').join('.') —— 像是在说:“嘿!一个 IP 地址有 4 个字节,就将它转换成一组四个数字组成的数组,然后数字互相之间用 ‘.’ 联个谊吧。”

步骤十三:解析 DNS 响应的收尾工作

现在我们正式准备好解析 DNS 响应了!

工作代码如下所示:

class DNSResponse
  attr_reader :header, :queries, :answers, :authorities, :additionals
  def initialize(bytes)
    buf = StringIO.new(bytes)
    @header = DNSHeader.new(buf)
    @queries = ([email protected]_questions).map { DNSQuery.new(buf) }
    @answers = ([email protected]_answers).map { DNSRecord.new(buf) }
    @authorities = ([email protected]_auth).map { DNSRecord.new(buf) }
    @additionals = ([email protected]_additional).map { DNSRecord.new(buf) }
  end
end

这里大部分内容就是在调用之前我们写过的其他函数来协助解析 DNS 响应。

如果 @header.num_answers 的值为 2,代码会使用了 ([email protected]_answers).map 这个巧妙的结构创建一个包含两个 DNS 记录的数组。(这可能有点像 Ruby 魔法,但我就是觉得有趣,但愿不会影响可读性。)

我们可以把这段代码整合进我们的主函数中,就像这样:

sock.send(make_dns_query("example.com", 1), 0) # 1 is "A", for IP address
reply, _ = sock.recvfrom(1024)
response = DNSResponse.new(reply) # parse the response!!!
puts response.answers[0]

尽管输出结果看起来有点辣眼睛(类似于 #<DNSRecord:0x00000001368e3118>),所以我们需要编写一些好看的输出代码,提升它的可读性。

步骤十四:对于我们输出的 DNS 记录进行美化

我们需要向 DNS 记录增加一个 .to_s 字段,从而让它有一个更良好的字符串展示方式。而者只是做为一行方法的代码在 DNSRecord 中存在。

def to_s
  "#{@name}\t\t#{@ttl}\t#{@type_name}\t#{@parsed_rdata}"
end

你可能也注意到了我忽略了 DNS 记录中的 class 区域。那是因为它总是相同的(IN 表示 “internet”),所以我觉得它是个多余的。虽然很多 DNS 工具(像真正的 dig)会输出 class

大功告成!

这是我们最终的主函数:

def main
  # connect to google dns
  sock = UDPSocket.new
  sock.bind('0.0.0.0', 12345)
  sock.connect('8.8.8.8', 53)

  # send query
  domain = ARGV[0]
  sock.send(make_dns_query(domain, 1), 0)

  # receive & parse response
  reply, _ = sock.recvfrom(1024)
  response = DNSResponse.new(reply)
  response.answers.each do |record|
    puts record
  end

我不觉得我们还能再补充什么 —— 我们建立连接、发送一个查询、输出每一个回答,然后退出。完事儿!

$ ruby dig.rb example.com
example.com   18608   A   93.184.216.34

你可以在这里查看最终程序:dig.rb。可以根据你的喜好给它增加更多特性,就比如说:

  • 为其他查询类型添加美化输出。
  • 输出 DNS 响应时增加“授权”和“可追加”的选项
  • 重试查询
  • 确保我们看到的 DNS 响应匹配我们的查询(ID 信息必须是对的上的!)

另外如果我在这篇文章中出现了什么错误,就 在推特和我聊聊吧。(我写的比较赶所以可能还是会有些错误)

(题图:MJ/449d049d-6bdd-448b-a61d-17138f8551bc)


via: https://jvns.ca/blog/2022/11/06/making-a-dns-query-in-ruby-from-scratch/

作者:Julia Evans 选题:lujun9972 译者:Drwhooooo 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

用途广泛的 VLC 可以做很多事情。屏幕录制就是其中之一。

VLC 不仅仅是一个视频播放器。它还是一款多功能视频工具,具有普通用户永远无法了解的众多功能。

你可以 使用 VLC 下载 YouTube 视频,甚至可以用它修剪视频。

VLC 的另一个不寻常用途是屏幕录制。

我仍然建议使用合适的屏幕录像机来完成此任务,欢迎你探索这个 VLC 功能以获取乐趣。

使用 VLC 进行屏幕录制

? 虽然我可以使用 VLC 录制桌面屏幕,但无法录制任何声音和鼠标光标。在我看来,它并不能替代合适的屏幕录制工具。

要使用 VLC 录制屏幕,请打开它并单击 “ 媒体 Media ”,然后选择 “ 转换/保存… Convert/Save... ”。(或者直接点击 “ 媒体 Media ”→“ 打开采集设备… Open Capture Device... ”)

Select Convert/ Save option

转到 “ 捕获设备 Capture Device ” 选项卡,然后从 “ 捕获模式 Capture Mode ” 下拉列表中选择桌面。

Capture Mode: Desktop

现在,这里为你的录制提供了一些帧率。10、24 fps 等都不错,如果你需要更高的质量,请选择更高的。请注意,这会增加文件大小和系统要求。然后,按 “ 转换/保存 Convert/Save ” 按钮。

Set Frame Rate

在下一页上,从下拉列表中选择一个配置文件,然后单击相邻的按钮来编辑该配置文件。

Set Output Profile

设置你需要的视频格式,然后按 “ 保存 Save ”。

Edit the Output Profile

现在,你需要给出目标文件名。单击 “ 浏览 Browse ”按钮,选择位置,然后输入输出文件的名称。单击 “ 保存 Save ”。

Output file location and Name

按 “ 开始 Start ” 按钮,开始录制屏幕。

Start Recording

这将开始录制。完成录制后,使用面板按钮停止。

Stop Recording

或者单击 VLC 上的停止按钮。

Stop Button in VLC

就是这样。你可以在保存屏幕录像的位置查看屏幕录像。

Output File

总结

如你所见,虽然可以使用 VLC 录制桌面屏幕,但它并不能替代 专用屏幕录制工具。缺乏录音是一个重大的遗憾。

仅当你没有任何其他选项时才使用 VLC 进行屏幕录制。你怎么认为?

(题图:MJ/f48c22e9-a2d1-4567-a265-6c3aaf147aff)


via: https://itsfoss.com/vlc-record-screen/

作者:Sreenath 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

Nix 软件包管理器可以安装在任何 Linux 发行版上。具体方法如下。

人们喜欢使用不可变的 NixOS 的原因之一是它的 Nix 包管理器。

它有超过 80,000 个软件包,这可能与 Debian 软件包的数量相差比较大,但仍然令人印象深刻。

好处是你不必仅仅为了包管理器而 安装 NixOS。与 Homebrew 和 Rust 的 Cargo 包管理器 一样,你可以在当前发行版中使用 Nix 包管理器。

为什么要这么做?因为有时,你可能会发现仅以 Nix 打包格式提供的新应用。这种情况很少见,但有可能。

在本教程中,我将引导你完成以下内容:

  • 安装 Nix 包管理器
  • 搜索并安装包
  • 尝试/测试软件包而不安装它们
  • 更新包
  • 删除包

在其他 Linux 发行版上安装 Nix 包管理器

Nix 包管理器有两种安装方式:全局安装和本地安装。

? 全局安装意味着系统上的每个可用用户都可以访问 nix 包管理器,而本地安装仅适用于当前用户。Nix 官方文档 建议你使用全局安装。

全局安装

如果你想全局安装 Nix 包管理器,那么,你需要执行以下命令:

sh <(curl -L https://nixos.org/nix/install) --daemon

执行上述命令后,需要输入 y 键并按回车键:

完成后,关闭当前终端,因为它不会在当前终端会话上运行。

本地安装

如果你更喜欢本地安装并且不想每次都使用 sudo,则执行以下命令:

sh <(curl -L https://nixos.org/nix/install) --no-daemon

输入 y 并在要求确认时按回车键。

完成后,关闭当前终端会话并启动一个新终端会话以使用 Nix 包管理器。

搜索并安装包

安装 Nix 包管理器后,下一步是搜索包。

首先,访问 Nix 搜索的官方页面 并输入你要安装的软件包的名称。

从给定的描述中,你可以找到所需的软件包,然后选择 nix-env 进行永久安装。

在这里,你可以添加一些额外的关键字以获得更好的搜索结果。例如,在这里,我搜索 “Firefox browser”:

我上面提到的最后一步(“复制命令”)什么也不做,只是为你提供了一个用于安装的命令。

现在,你所要做的就是在终端中执行该命令。

就我而言,它给了我以下命令来安装 Firefox:

nix-env -iA nixpkgs.firefox

完成后,你可以使用以下命令列出已安装的软件包:

nix-env -q

使用包而不安装它们

到目前为止,这是 Nix 包管理器的最佳功能,因为你可以使用/测试包甚至不用安装它!

为此,你可以使用 Nix Shell,它允许你将交互式 Shell 与指定的包一起使用,关闭后,你将无法再访问该包。

很酷,对吧?

要使用 nix-shell 访问你喜欢的软件包,请使用以下命令语法:

nix-shell -p <package_name>

例如,我想使用一次 neofetch,所以我使用了以下命令:

nix-shell -p neofetch

要退出 Shell,你所要做的就是执行 exit 命令:

exit

使用 Nix 包管理器更新包

使用 Nix 包管理器更新包非常简单。

要更新软件包,首先,你需要使用以下命令更新频道:

nix-channel --update

接下来,你可以通过试运行更新命令来列出过时的软件包:

nix-env --upgrade --dry-run

就我而言,Firefox 浏览器已经过时,需要更新!

要更新单个包,请使用以下命令:

nix-env -u <Package_name>

如果你想一次更新所有软件包,请使用以下命令:

nix-env -u

使用 Nix 包管理器删除包

要删除软件包,你只需按以下方式执行 nix-env 命令即可:

nix-env --uninstall [package_name]

例如,如果我想删除 Firefox 浏览器,那么,我将使用以下命令:

nix-env --uninstall firefox

通过 NixOS 释放其全部潜力

如果你喜欢 Nix 包管理器背后的想法,请相信我,你一定会喜欢 NixOS

仅使用一个配置文件来复制整个系统就足以说服我切换到 NixOS,但还有更多原因:

我喜欢 NixOS。以至于我写了整个系列,这样你就不必阅读文档(基础知识):

NixOS 系列

我希望你能像我一样喜欢使用它。

(题图:MJ/da586165-eadb-4ed7-9a0b-9c92903344d5)


via: https://itsfoss.com/ubuntu-install-nix-package-manager/

作者:Sagar Sharma 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出