什么是Unix哲学？成为更优秀的程序员

于 2024-07-31 08:00:00 发布
阅读量3.8k 收藏 50
点赞数 89
分类专栏： 软件开发 文章标签： unix 服务器 大数据 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012955829/article/details/140807731
版权

在软件开发的世界里,Unix哲学一直是一盏指引程序员前进的明灯。这套简洁而强大的设计原则不仅塑造了Unix操作系统,更影响了整个软件行业。让我们深入了解Unix哲学的核心思想及其在现代编程中的应用。
image.png

Unix哲学:简单而强大的软件设计原则

什么是Unix哲学?

Unix哲学是由Ken Thompson和Dennis Ritchie在20世纪70年代开发Unix操作系统时提出的一系列软件设计原则。这些原则强调简单性、模块化和可重用性。
image.png

Unix哲学的核心原则

  1. 做好一件事: 每个程序应该专注于做好一件特定的任务。

  2. 简洁即美: 代码应该简洁明了,易于理解和维护。

  3. 组合的力量: 小而简单的工具可以组合使用,完成复杂的任务。

  4. 文本流: 使用纯文本作为通用接口,便于程序之间的交互。

  5. 快速原型: 快速创建原型,然后不断迭代改进。
    image.png

Unix哲学在现代编程中的应用

尽管Unix哲学诞生于几十年前,但其核心思想在当今的软件开发中仍然适用:
image.png

  • 微服务架构: 将大型应用拆分成小而独立的服务,每个服务专注于特定功能。
  • 函数式编程: 强调纯函数和不可变数据,与"做好一件事"的理念相呼应。
  • DevOps实践: 使用小型、专注的工具构建自动化流程,体现了组合的力量。
  • API设计: RESTful API的设计理念与Unix的文本流思想有异曲同工之妙。

实践Unix哲学的技巧

image.png

  1. 模块化设计: 将程序分解成小的、可重用的模块。
  2. 使用管道和过滤器: 学习使用命令行工具,体验Unix哲学的魅力。
  3. 编写清晰的文档: 好的文档可以让你的工具更容易被他人理解和使用。
  4. 持续重构: 不断优化你的代码,保持简洁和高效。

Unix哲学的实际示例

image.png

让我们通过一些具体的例子来看看Unix哲学是如何在实际编程中体现的。

1. 做好一件事

Unix命令行工具是"做好一件事"原则的典范。例如:

  • ls: 仅列出目录内容
  • grep: 仅搜索文本
  • sort: 仅排序输入

这些工具各自专注于一个特定任务,但可以通过管道组合使用。

2. 组合的力量

考虑以下命令行操作:

cat log.txt | grep "ERROR" | sort | uniq -c | sort -nr

这个命令链完成了一系列复杂的操作:

  1. cat 读取日志文件
  2. grep 过滤出包含"ERROR"的行
  3. 第一个 sort 排序这些行
  4. uniq -c 计数唯一行
  5. 最后的 sort -nr 按数字逆序排序结果

每个命令都很简单,但组合起来可以完成强大的日志分析任务。

3. 使用文本流

以下Python脚本展示了如何处理文本流:

import sys

for line in sys.stdin:
    if "important" in line.lower():
        sys.stdout.write(line)

这个脚本可以与其他命令结合使用:

cat document.txt | python filter_important.py | sort > important_lines.txt

4. 快速原型

考虑以下Shell脚本,它快速实现了一个简单的待办事项管理器:

#!/bin/bash

TODO_FILE="$HOME/.todo"

case $1 in
    "add")
        echo "$2" >> "$TODO_FILE"
        ;;
    "list")
        cat "$TODO_FILE"
        ;;
    "done")
        sed -i "$2d" "$TODO_FILE"
        ;;
    *)
        echo "Usage: todo [add|list|done] [item]"
        ;;
esac

这个脚本虽然简单,但已经可以使用了。之后可以逐步添加更多功能,如优先级、截止日期等。

5. 在现代开发中的应用

微服务架构

微服务体现了"做好一件事"的原则。例如,一个电子商务系统可能包括以下微服务:

  • 用户服务: 处理用户注册、认证
  • 产品服务: 管理产品目录
  • 订单服务: 处理订单创建和管理
  • 支付服务: 处理支付交易

每个服务都专注于特定功能,通过API相互通信。

函数式编程

函数式编程中的纯函数概念与Unix哲学相呼应:

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

def calculate(a, b):
    return multiply(add(a, b), b)

这些函数各自完成一个简单的任务,可以像Unix命令一样组合使用。

Unix哲学 - 深入探讨与现代应用

Unix哲学的批评与局限性

image.png

尽管Unix哲学在软件设计中广受推崇,但它也面临一些批评:

  1. 过度简化: 有时,将复杂问题分解成过于简单的部分可能导致整体效率降低。

  2. 学习曲线: 对于初学者来说,理解和掌握大量小工具的组合使用可能具有挑战性。

  3. 一致性问题: 不同工具的选项和参数可能不一致,增加了使用难度。

  4. 图形界面的局限: Unix哲学主要关注文本处理,在图形用户界面设计中可能不太适用。

  5. 性能考虑: 在某些情况下,使用管道连接多个小程序可能不如一个优化的大程序高效。

Unix哲学在现代软件开发中的演变

image.png

随着技术的发展,Unix哲学也在不断适应和演变:

  1. 容器化技术: Docker和Kubernetes等技术体现了"做好一件事"和模块化的理念。

  2. 无服务器架构: AWS Lambda等服务允许开发者专注于单一功能,符合Unix的简单性原则。

  3. API优先设计: 现代API设计强调简单、模块化和可组合性,这与Unix哲学不谋而合。

  4. 函数式编程语言: 如Haskell、Clojure等语言,其设计理念与Unix哲学有许多共通之处。

  5. DevOps文化: 强调自动化和工具链的整合,反映了Unix的组合思想。

在团队中推广Unix哲学

image.png

作为一名开发者或团队领导,你可以通过以下方式在团队中推广Unix哲学:

  1. 代码审查: 在代码审查中鼓励简单性和模块化设计。

  2. 培训和分享: 组织工作坊,分享Unix哲学的核心理念和实践经验。

  3. 工具选择: 优先选择专注于单一任务且易于集成的工具。

  4. API设计指南: 制定基于Unix哲学的API设计指南,强调简单性和可组合性。

  5. 重构倡议: 鼓励团队定期重构代码,以提高模块化程度和可维护性。

Unix哲学与软件架构模式

image.png

Unix哲学与多种现代软件架构模式有着密切的关系:

  1. 管道模式:

    def process_data(data):
    return (
        data
        .pipe(clean_data)
        .pipe(transform_data)
        .pipe(analyze_data)
    )

    这种模式直接反映了Unix命令行的管道思想。

  2. 事件驱动架构:

    eventEmitter.on('data', cleanData)
            .on('dataClean', transformData)
            .on('dataTransformed', analyzeData);

    每个处理器专注于单一任务,通过事件链接。

  3. 插件系统:

    class Application:
    def __init__(self):
        self.plugins = []
    
    def add_plugin(self, plugin):
        self.plugins.append(plugin)
    
    def run(self):
        for plugin in self.plugins:
            plugin.execute()

    插件系统允许通过组合小型、专注的模块来扩展应用功能。

Unix哲学: 从基础到高级应用 - 全面指南

Unix哲学在大规模系统设计中的应用

在大规模系统设计中,Unix哲学的原则同样适用,但需要一些额外的考虑:

  1. 服务网格:
    服务网格技术(如Istio)体现了Unix的"做好一件事"原则。它将服务间通信、安全、监控等横切关注点从业务逻辑中分离出来。

    示例配置(Istio):

    apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: my-service-route
spec:
  hosts:
  - my-service
  http:
  - route:
    - destination:
        host: my-service
        subset: v1
      weight: 90
    - destination:
        host: my-service
        subset: v2
      weight: 10

  2. 领域驱动设计(DDD):
    DDD的界限上下文(Bounded Context)概念与Unix的模块化思想相呼应,每个上下文专注于特定的业务领域。

  3. 事件溯源:
    事件溯源将系统状态变化记录为一系列事件,这与Unix的日志处理哲学相似。

    示例代码:

    class BankAccount:
    def __init__(self):
        self.balance = 0
        self.events = []

    def apply_event(self, event):
        if event['type'] == 'DEPOSIT':
            self.balance += event['amount']
        elif event['type'] == 'WITHDRAW':
            self.balance -= event['amount']
        self.events.append(event)

    def deposit(self, amount):
        self.apply_event({'type': 'DEPOSIT', 'amount': amount})

    def withdraw(self, amount):
        if self.balance >= amount:
            self.apply_event({'type': 'WITHDRAW', 'amount': amount})

Unix哲学在数据处理和分析中的应用

image.png

数据处理和分析领域也可以受益于Unix哲学:

  1. 数据管道:
    使用类似Unix管道的概念构建数据处理流程。

    使用Apache Beam的示例:

    import apache_beam as beam

def clean_data(element):
    # 数据清洗逻辑
    return cleaned_element

def transform_data(element):
    # 数据转换逻辑
    return transformed_element

def analyze_data(element):
    # 数据分析逻辑
    return analyzed_element

with beam.Pipeline() as p:
    (p
     | beam.io.ReadFromText('input.txt')
     | beam.Map(clean_data)
     | beam.Map(transform_data)
     | beam.Map(analyze_data)
     | beam.io.WriteToText('output.txt'))

  2. 函数式数据处理:
    使用函数式编程范式处理数据,每个函数专注于一个转换。

    使用Pandas的示例:

    import pandas as pd

def load_data(file_path):
    return pd.read_csv(file_path)

def clean_data(df):
    return df.dropna().drop_duplicates()

def calculate_metrics(df):
    return df.groupby('category').agg({'sales': 'sum', 'quantity': 'mean'})

def main():
    data = (
        load_data('sales.csv')
        .pipe(clean_data)
        .pipe(calculate_metrics)
    )
    return data

if __name__ == '__main__':
    result = main()
    print(result)

Unix哲学在前端开发中的应用

image.png

虽然Unix哲学最初针对的是后端和系统开发,但其原则也可以应用于前端开发:

  1. 组件化开发:
    React等库的组件概念与Unix的"做好一件事"原则相符。

    React组件示例:

    const Button = ({ onClick, children }) => (
  <button onClick={onClick}>{children}</button>
);

const Input = ({ value, onChange }) => (
  <input value={value} onChange={onChange} />
);

const Form = () => {
  const [value, setValue] = useState('');
  const handleSubmit = () => {
    // 处理提交逻辑
  };

  return (
    <div>
      <Input value={value} onChange={(e) => setValue(e.target.value)} />
      <Button onClick={handleSubmit}>Submit</Button>
    </div>
  );
};

  2. 状态管理:
    Redux等状态管理库采用了类似Unix管道的数据流概念。

    Redux示例:

    // Action
const incrementCounter = () => ({ type: 'INCREMENT' });

// Reducer
const counterReducer = (state = 0, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return state + 1;
    default:
      return state;
  }
};

// Store
const store = createStore(counterReducer);

// 使用
store.dispatch(incrementCounter());

Unix哲学在DevOps实践中的应用

DevOps领域大量借鉴了Unix哲学的思想:

  1. 基础设施即代码(IaC):
    使用简单、可组合的配置文件管理基础设施。

    Terraform示例:

    resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  tags = {
    Name = "WebServer"
  }
}

resource "aws_security_group" "allow_http" {
  name        = "allow_http"
  description = "Allow HTTP inbound traffic"
  
  ingress {
    description = "HTTP from VPC"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

  2. CI/CD管道:
    构建简单、独立的步骤,然后将它们组合成完整的CI/CD管道。

    Jenkins Pipeline示例:

    pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'mvn clean package'
      }
    }
    stage('Test') {
      steps {
        sh 'mvn test'
      }
    }
    stage('Deploy') {
      steps {
        sh 'ansible-playbook deploy.yml'
      }
    }
  }
}

Unix哲学: 从经典原则到现代软件工程的全面指南

Unix哲学在新兴技术领域的应用

image.png

随着技术的不断发展,Unix哲学的原则在新兴技术领域也找到了自己的位置:

1. 人工智能和机器学习

在AI和ML领域,Unix哲学的模块化和组合原则同样适用:

  1. 模型管道:
    使用简单、可组合的组件构建ML管道。

    使用scikit-learn的示例:

    from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC())
])

pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)

  2. 特征工程:
    创建专注于单一任务的特征转换器。

    自定义转换器示例:

    from sklearn.base import BaseEstimator, TransformerMixin

class LogTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, columns):
        self.columns = columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        X_ = X.copy()
        for col in self.columns:
            X_[col] = np.log1p(X_[col])
        return X_

2. 区块链和去中心化系统

区块链技术在某些方面体现了Unix哲学的原则:

  1. 智能合约:
    每个智能合约专注于特定功能,可以组合使用。

    Solidity智能合约示例:

    pragma solidity ^0.8.0;

contract Token {
    mapping(address => uint256) public balances;

    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[to] += amount;
    }
}

contract Exchange {
    Token public token;

    constructor(address _token) {
        token = Token(_token);
    }

    function swap(address to, uint256 amount) public payable {
        require(msg.value >= amount, "Insufficient ETH sent");
        token.transfer(to, amount);
    }
}

3. 物联网(IoT)

在IoT系统中,Unix哲学的简单性和模块化原则特别重要:

  1. 传感器数据处理:
    使用简单的处理单元组合成复杂的数据处理管道。

    示例代码:

    def read_sensor():
    # 读取传感器数据
    return sensor_data

def filter_noise(data):
    # 过滤噪声
    return filtered_data

def aggregate_data(data_list):
    # 聚合数据
    return aggregated_data

def main():
    raw_data = read_sensor()
    clean_data = filter_noise(raw_data)
    result = aggregate_data([clean_data])
    send_to_cloud(result)

if __name__ == '__main__':
    main()

Unix哲学在软件开发生命周期中的应用

image.png

Unix哲学不仅适用于编码阶段,还可以贯穿整个软件开发生命周期:

1. 需求分析

  • 用户故事拆分: 将大的用户需求拆分成小的、独立的用户故事,每个故事专注于一个具体功能。

示例:

大需求: 实现用户认证系统
拆分后的用户故事:
1. 用户可以注册新账户
2. 用户可以登录已有账户
3. 用户可以重置密码
4. 用户可以通过邮箱验证身份

2. 系统设计

  • 组件化设计: 将系统设计为一系列松耦合的组件,每个组件负责特定功能。

示例系统架构图:

[用户界面] <-> [API网关]
                 |
        +--------+--------+
        |        |        |
 [认证服务] [用户服务] [内容服务]
        |        |        |
        +--------+--------+
                 |
             [数据库]

3. 开发

  • 代码模块化: 编写功能单一、接口清晰的函数和类。

示例代码:

class UserService:
    def __init__(self, db):
        self.db = db

    def create_user(self, username, email, password):
        # 创建用户逻辑

    def authenticate_user(self, username, password):
        # 用户认证逻辑

    def update_user_profile(self, user_id, profile_data):
        # 更新用户资料逻辑

4. 测试

  • 单元测试: 为每个小的功能单元编写独立的测试。

示例测试代码:

import unittest

class TestUserService(unittest.TestCase):
    def setUp(self):
        self.user_service = UserService(MockDB())

    def test_create_user(self):
        result = self.user_service.create_user("testuser", "test@example.com", "password123")
        self.assertTrue(result)

    def test_authenticate_user(self):
        self.user_service.create_user("testuser", "test@example.com", "password123")
        result = self.user_service.authenticate_user("testuser", "password123")
        self.assertTrue(result)

5. 部署

  • 持续部署管道: 构建由多个简单步骤组成的部署管道。

示例Jenkins管道:

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/user/repo.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
        stage('Deploy to Staging') {
            steps {
                sh 'ansible-playbook deploy-staging.yml'
            }
        }
        stage('Integration Tests') {
            steps {
                sh 'run-integration-tests.sh'
            }
        }
        stage('Deploy to Production') {
            steps {
                sh 'ansible-playbook deploy-prod.yml'
            }
        }
    }
}

结语

Unix哲学,尽管诞生于计算机技术的早期,但其核心原则在现代软件工程中依然具有强大的生命力和广泛的适用性。从传统的系统编程到新兴的AI和区块链技术,从代码编写到整个软件开发生命周期,Unix哲学都在指导我们创建更简洁、更模块化、更易于理解和维护的系统。

在追求技术创新的同时,我们不应忘记这些基本原则。实际上,正是这些简单而强大的思想,使我们能够在复杂的技术世界中保持清晰的思路,构建出真正优秀的软件系统。

作为开发者,我们应该:

  1. 始终追求简单性,但不要过度简化。
  2. 设计模块化的系统,但要注意模块间的接口设计。
  3. 重视代码的可组合性,但也要考虑整体性能。
  4. 专注于做好一件事,但不要忽视与其他组件的协作。

记住,Unix哲学不是一套僵硬的规则,而是一种思考方式。在实际应用中,我们需要根据具体情况灵活运用这些原则。通过不断实践和反思,我们可以将Unix哲学的精髓融入到我们的日常工作中,成为更优秀的软件工程师。

让我们携手前行,在Unix哲学的指引下,共同创造出更加优雅、高效、可靠的软件系统,为这个数字世界贡献我们的智慧和力量。
Unix哲学知识点详细总结.png

数据小羊
关注
  • 89
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 17
    评论
专栏目录
UNIX 设计哲学：Do one thing and do it well
程序员光剑
05-01 1万+
一次只做一件事，并做到极致。 《UNIX编程艺术》一书，提出的17条编程原则，经过时间和实践的锤炼，发展成为Unix哲学17条原则，在维基百科能搜到。 下面就来说说我对这17要原则的解读—— 1、模块化原则(Rule of Modularity) 原文：开发人员应该使用定义良好的界面连接简单的部分来构建程序，所以问题是本地的，部分程序可以在未来的版本中替换以支持新的功能。此规则旨在节省调试复杂.........
设计模式 - 漫谈软件编程背后的系统化思维
热门推荐
小工匠
06-06 1万+
文章目录概述分层思维工程思维对象思维迭代思维 概述 Unix 操作系统诞生于 20 世纪 60 年代，经过几十年的发展，技术日臻成熟。在这个过程中，Unix 独特的设计哲学和美学也深深地吸引了一大批技术开发人员，他们在维护和使用 Unix 的同时，Unix 也影响了他们的思考方式和看待世界的角度。 Unix 哲学是一套基于 Unix 操作系统顶级开发者们的经验所提出的软件开发的准则和理念。 也就是说，Unix 哲学并不是正统的计算机科学理论，它的形成更多是以经验为基础。你一定听说过模块化、解耦、高内
【操作系统】Unix的哲学
编程哲学家的专栏
02-15 1115
Douglas McIlroy是Unix系统上管道机制的发明者，也是Unix文化的缔造者之一。他归纳的Unix哲学如下： 程序应该只关注一个目标，并尽可能把它做好。让程序能够互相协同工作。应该让程序处理文本数据流，因为这是一个通用的接口 总的来说是："简单原则"----尽量用简单的方法解决问题----是"Unix哲学"的根本原则。这也就是著名的KISS（keep it simple, stupi...
unix 哲学.pdf
07-26
Unix 哲学 Unix 哲学 Unix 哲学 Unix 哲学 Unix 哲学 Unix 哲学 Unix 哲学
Unix编程艺术——Unix哲学
persuit的专栏
08-01 1122
Unix编程艺术——Unix哲学 http://blog.leezhong.com/reading/2010/12/21/the-art-of-unix-programming.html   Unix编程艺术主要介绍了Unix系统领域中的设计和开发哲学、思想文化体系、原则与经验。此文大致摘录了Unix的哲学。 web程序员也应该看看此书，软件开发和web开发很多地方都是相通的。看完之后
Unix哲学
FireOfStar的专栏
05-26 1667
<br />Unix操作系统以及以后的Linux系统鼓励的一些编程风格：<br />1.简单：大多数常用的Unix工具都是很简单的，并且很短小而且容易理解。<br />2.聚焦（关注一点）：通常一个执行单一任务的程序要比包含了很多功能的程序要好，拥有大而全功能的程序难已使用并且难以维护。<br />3.可复用的组件：要是应用程序的核心成为有效的类库，一个好的类库应该拥有简单而灵活的编程接口。<br />4.过滤器：很多的Unix程序能够作为过滤器来使用，也就是说，给它们传入输入，它们就能产生输出。<br /
关于Unix哲学
nba520pz的专栏
06-30 349
先讲两个很老的小故事。 第一个故事。 有一家日本最大的化妆品公司，收到了用户的投诉。用户抱怨买来的肥皂盒是空的。这家公司为了防止再发生这样的事故，很辛苦地发明了一台X光检查器，能够透视每一个出货的肥皂盒。 同样的事故，发生在一家小公司。他们的解决方法是买一台强力的工业电扇，对着肥皂盒猛吹，被吹走的就是空肥皂盒。 第二个故事。 美国太空总署（NASA）发现在太空失重状态...
UNIX程序员手册 不错
02-28
UNIX系统的设计哲学强调简洁、模块化和可扩展性，这些特点使其成为现代操作系统的基石之一。 ### 2. 第七版手册的历史背景 第七版的UNIX程序员手册出版于1979年，标志着UNIX系统的发展进入了一个新的阶段。虽然这...
UNIX-system-kernel.rar_unix kernel_unix系统
最新发布
09-24
学习UNIX系统内核不仅有助于理解操作系统原理，也是成为一名优秀的系统程序员或管理员的基础。通过深入研究这个课件中的"第6章 UNIX系统内核.ppt"，初学者可以逐步掌握这一领域的核心概念和实践技能。
unix操作 文档.doc
02-14
此外，Unix的开放源代码精神催生了开源运动，如GNU项目和Linux操作系统，它们继承了Unix的设计哲学，使得Unix的理念和工具在21世纪继续繁荣。 总的来说，Unix操作系统以其高效、灵活和强大的特点，以及对网络和多...
Unix程序设计的原则(转)
weixin_30463341的博客
12-23 116
1. 模块原则：使用简洁的接口拼合简单的部件。2. 清晰原则：清晰胜于机巧。3. 组合原则：设计时考虑拼接组合。4. 分离原则：策略同机制分离，接口同引擎分离。5. 简洁原则：设计要简洁，复杂度能低则低。6. 吝啬原则：除非确无它法，不要编写庞大的程序。7. 透明性原则：设计要可见，以便审查和调试。8. 健壮原则：健壮源于透明与简洁。9. 表示原则：把知识叠入数据以求逻辑质朴而健壮。10...
[总结]Unix设计哲学 <<Unix编程艺术>>
求索
05-29 5514
学习了第一章关于哲学的部分, 做个汇总. 现在已经对精简设计, 舍弃华而不实是被普遍认可的.但早在Unix发展的时期, 这一条原则却是在实践中不断提炼出来的. 这就是最为根本的一条:   KISS - Keep it Simple, Stupid!  精神上可以相较于"大智若愚"。Unix最为崇尚的是实用至上, 拿来主义。
Unix程序设计哲学-KISS
zhangxinrun的专栏
04-25 2415
转载：http://blog.chinaunix.net/uid-253939-id-2458682.html Rule of Modularity: Write simple parts connected by clean interfaces. Rule of Clarity: Clarity is better than cleverness. Rule
Unix设计哲学
feichideche的专栏
10-22 523
Everything (including hardware) is a file. 所有的事物（甚至硬件本身）都是一个文件。 Configuration data stored in text. 以文本形式储存配置数据。 Small, single-purpose program. 程序尽量朝向小而单一的目标设计 Avoid captive user interfaces. 尽量避免令人困...
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

数据小羊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值