os系统好用的学术笔记软件

by Shubheksha

通过Shubheksha

可靠软件系统的设计方法：学术文章摘要 (A Design Methodology For Reliable Software Systems: An Academic Article Summary)

Let’s dig into A Design Methodology For Reliable Software Systems published by Barbara Liskov in 1972.

让我们深入探讨Barbara Liskov在1972年发布的《 可靠软件系统设计方法论》 。

The focus of this paper is on how to make reliable software systems and the techniques that can help us achieve that.

本文的重点是如何制作可靠的软件系统以及可以帮助我们实现这一目标的技术。

Reliability here implies that a system works as expected under a given set of conditions.

这里的可靠性意味着系统在给定的条件下可以按预期工作。

The unfortunate fact is that the standard approach to building

不幸的是，标准的建筑方法

Although improvements in debugging techniques may lead to the detection of more errors, this does not imply that all errors will be found.

尽管调试技术的改进可以导致更多错误的检测，但这并不意味着将发现所有错误。

There certainly is no guarantee of this implicit in debugging: as Dijkstra said, “Program testing can be used to show the presence of bugs, but never to show their absence.”

肯定不能保证在调试中会隐含这种错误：正如Dijkstra所说，“程序测试可用于显示错误的存在，但从不显示错误的存在。”

To be confident that our system works correctly, we need testing that meets the following conditions:

为了确信我们的系统正常运行，我们需要满足以下条件的测试：

1. We can generate a minimal set of relevant test cases.我们可以生成最少的相关测试用例集。
2. All test cases in the set can be generated.可以生成集合中的所有测试用例。

The solutions to these problems do not lie in the domain of debugging, which has no control over the sources of the problems.

这些问题的解决方案不属于调试领域，而调试领域无法控制问题的根源。

Instead, since it is the system design which determines how many test cases there are and how easily they can be identified, the problems can be solved most effectively during the design process. The need for exhaustive testing must influence the design.

取而代之的是，由于系统设计确定了多少个测试用例以及如何轻松地识别它们，因此可以在设计过程中最有效地解决问题。 详尽测试的需求必须影响设计。

The paper further argues that reliability is a major issue with complex systems. It goes on to define complex systems as follows:

该论文进一步指出，可靠性是复杂系统的主要问题。 然后继续定义复杂的系统，如下所示：

1. The system has many states and it’s difficult to organize program logic to handle them correctly.系统具有许多状态，很难组织程序逻辑来正确处理它们。
2. It requires several people working together in a coordinated manner.它需要几个人以协调的方式一起工作。

良好设计的标准： (Criteria for a Good Design:)

To tame the design of a complex system, we need to use modularization.

要驯服复杂系统的设计，我们需要使用模块化。

Divide the program into several modules (sub-programs, referred to as partitions in the paper to avoid overloading the term “modules”) which can be compiled separately, but are connected to other modules.

将程序分为几个模块(子程序，为避免过载“模块”，在本文中称为分区)，这些模块可以单独编译，但可以连接到其他模块。

The connections are defined by Parnas as follows:

连接由Parnas定义如下：

The connections between modules are the assumptions which the modules make about each other.

模块之间的连接是模块之间相互联系的假设。

Although the idea of modularity sounds like a great tool for building large complex software systems, it can introduce additional complexity if not done right.

尽管模块化的概念听起来像是构建大型复杂软件系统的绝佳工具，但如果处理不当，它可能会带来额外的复杂性。

The success of modularity depends directly on how well modules are chosen.

模块化的成功直接取决于选择模块的方式。

Some common issues are:

一些常见的问题是：

1. A module does too many things.一个模块做太多的事情。
2. A common function is distributed among many different modules.通用功能分布在许多不同的模块中。
3. A module behaves unexpectedly with common data.模块对公共数据的行为异常。

The next question that arises is: What is good modularity?

出现的下一个问题是：什么是好的模块化？

We use two techniques to answer that: levels of abstraction to tackle the inherent complexity of the system, and structured programming to represent the design in software.

我们使用两种技术来回答这个问题：抽象层次以解决系统固有的复杂性，结构化编程以软件形式表示设计。

抽象级别： (Levels of abstraction:)

Levels of abstraction…provide a conceptual framework for achieving a clear and logical design for a system. The entire system is conceived as a hierarchy of levels, the lowest levels being those closest to the machine.

抽象级别……提供了用于实现系统的清晰逻辑设计的概念框架。 整个系统被认为是层次结构的层次，最低层次是最接近机器的层次。

A group of related functions make up a level of abstraction. Each level can have the following two types of functions:

一组相关的功能构成了一个抽象级别。 每个级别可以具有以下两种类型的功能：

1. External: These functions can be called by functions in other levels.外部：这些功能可以由其他级别的功能调用。
2. Internal: These functions do a common task within the level and cannot be called by other functions in a different level.内部：这些功能在级别中执行一项常见任务，并且不能由不同级别中的其他功能调用。

Levels of abstraction are governed by the following two rules:

抽象级别受以下两个规则支配：

1. Each level has exclusive control over some kind of resource.每个级别都对某种资源具有独占控制权。
2. Lower levels aren’t aware of higher levels and can’t reference them in any way. But, higher levels can ask lower levels to perform an action.较低级别不了解较高级别，因此无法以任何方式引用它们。 但是，较高的级别可以要求较低的级别执行操作。

结构化编程： (Structured Programming:)

A structured program defines the way control passes among various partitions in a system.

结构化程序定义了控制在系统中各个分区之间传递的方式。

It is defined by the following rules:

它由以下规则定义：

1. The program is developed in a top-down format and divided into levels. The notion of levels here is different from that of levels of abstraction because the first rule isn’t satisfied.该程序以自上而下的格式开发，并分为多个级别。 此处的级别概念与抽象级别的概念不同，因为不满足第一个规则。

2. Only the following control structures can be used: concatenation, selection

   只能使用以下控制结构：串联，选择

   of the next statement based on the testing of a condition,

   根据条件测试得出的下一个陈述，

   and iteration. Jumping using

   和迭代。 跳跃使用

   goto isn’t permitted.

   不允许goto 。

Back to the question that was posed earlier: how do we define good modularity?

回到前面提出的问题： 我们如何定义良好的模块化 ？

In a modular system that is also reliable, the connections between partitions are limited as follows:

在同样可靠的模块化系统中，分区之间的连接受到如下限制：

1. They need to follow the rules imposed by levels of abstraction and structured programming.他们需要遵循抽象和结构化编程级别强加的规则。
2. Passing of data between partitions should be done using explicit arguments. The arguments are passed to external functions of another partition.分区之间的数据传递应使用显式参数完成。 参数被传递到另一个分区的外部函数。

3. Partitions should be logically independent. The functions within a partition should support its own abstraction only

   分区在逻辑上应该是独立的。 分区中的功能应仅支持其自身的抽象

The next question that arises after we’ve figured out how to defined good modularity is — how do we achieve it in our design?

在弄清楚如何定义好的模块化之后出现的下一个问题是：我们如何在设计中实现它 ？

The traditional technique for modularization is to analyze the execution-time flow of the system and organize the system structure around each major sequential task.

模块化的传统技术是分析系统的执行时间流，并围绕每个主要的顺序任务组织系统结构。

This technique leads to a structure which has very simple connections in control, but the connections in data tend to be complex.

这种技术导致结构的控制连接非常简单，但是数据中的连接往往很复杂。

Partitions supports abstractions that a system designer finds helpful when thinking about the system.

分区支持系统设计者在考虑系统时发现有用的抽象。

Abstractions are introduced in order to make what the system is doing clearer and more understandable; an abstraction is a conceptual simplification because it expresses what is being done without specifying how it is done.

引入抽象是为了使系统正在做的事情更加清晰和易于理解。 抽象是概念上的简化，因为它表示正在执行的操作而不指定执行的方式。

The paper then presents some guidelines for identifying different types of abstractions while designing a system:

然后，本文提出了一些在设计系统时识别不同类型抽象的准则：

1. Abstraction of resources: for every hardware resource on the system. We can map characteristics of the abstract resource to the underlying resource.资源抽象：系统上的每个硬件资源。 我们可以将抽象资源的特征映射到基础资源。
2. Abstract characteristics of data: how it is stored.数据的抽象特征：如何存储。
3. Simplification via limiting the information the partition needs to know or has access to.通过限制分区需要知道或可访问的信息来简化。
4. Simplification via generalization by identifying functions that perform a common task. Such functions can be grouped together in one partition. “The existence of such a group simplifies other partitions, which need only appeal to the functions of the lower partition rather than perform the tasks themselves.”通过识别执行共同任务的功能，通过归纳进行简化。 这些功能可以组合在一个分区中。 “这样一个组的存在简化了其他分区，这些分区仅需要吸引下层分区的功能，而无需自己执行任务。”
5. System maintenance and modification: functions performing a task whose definition is prone to changes in the future should be part of independent partitions. For example, functions which deal with connecting to a particular kind of storage back-end so that if a different back-end is used in the future, only functions in that partition will be affected.系统维护和修改：执行其定义将来可能会更改的任务的功能应成为独立分区的一部分。 例如，处理连接到特定类型的存储后端的功能，因此，如果将来使用其他后端，则仅会影响该分区中的功能。

Now that we have some idea about how we can achieve good modularity while designing our system, how do we proceed with it?

现在，我们对在设计系统时如何实现良好的模块化有了一些想法， 如何进行 ？

The first phase is to identify a set of abstractions that represent the eventual behavior of the system in a general way. The next phase “establishes the data connections between the partitions and describes the flow of control among the partitions”.

第一个阶段是识别一组抽象，这些抽象以一般的方式代表系统的最终行为。 下一阶段“在分区之间建立数据连接，并描述分区之间的控制流程”。

The second phase occurs concurrently with the first; as abstractions are proposed, their utility and practicality are immediately investigated.

第二阶段与第一阶段同时进行。 当提出抽象时，将立即研究其实用性和实用性。

A partition has been adequately investigated when its connections with the rest of the system are known and when the designers are confident that they understand

当一个分区与系统其余部分的连接已知并且设计人员确信他们了解该分区时，已经对它进行了充分的研究。

The next question one would ask is: how do we identify when the design is finished?

下一个要问的问题是： 如何确定设计何时完成 ？

1. All major abstractions have been identified and been linked to a partition. The system resources have been divided among the various partitions and their positions in the hierarchy have been defined已经识别了所有主要抽象并将其链接到一个分区。 系统资源已划分到各个分区中，并且它们在层次结构中的位置已定义
2. The interfaces and flow of control among the partitions is clearly defined. The test cases for each partition have been identified分区之间的接口和控制流​​已明确定义。 每个分区的测试用例已经确定
3. A basic user guide for the system can be written可以编写系统的基本用户指南

翻译自: https://www.freecodecamp.org/news/a-design-methodology-for-reliable-software-systems-a-summary-394dfd0dcbc2/

os系统好用的学术笔记软件