揭秘程序世界：构建更优代码的计算机原理

需积分: 31 96 浏览量更新于2024-07-17 收藏 17.89MB PDF 举报

"The Secret Life of Programs" 是一本由 Jonathan E. Steinhart 撰写的书籍，旨在深入浅出地解释计算机程序从底层硬件到高层软件的运行原理。书中涵盖了计算机系统的各个方面，帮助读者理解计算机工作原理并提升编程技能。本书内容丰富，包括了以下关键知识点： 1. **计算机系统基础**：讲解计算机硬件的基础，如处理器、内存、输入/输出设备等，以及它们如何协同工作来执行指令和处理数据。 2. **编程语言解析**：探讨不同类型的编程语言（如机器语言、汇编语言和高级语言）及其在程序设计中的作用，以及编译器和解释器的工作原理。 3. **内存管理**：介绍内存的组织结构，包括虚拟内存、堆栈和堆的分配，以及如何通过内存管理优化程序性能。 4. **操作系统原理**：讨论操作系统的功能，如进程管理、调度算法、文件系统和设备驱动，以及它们如何与应用程序交互。 5. **数据表示与计算**：阐述二进制、八进制、十进制和十六进制之间的转换，以及浮点数、整数和字符的存储方式。 6. **程序执行流程**：详细解析程序从加载到执行的全过程，包括编译、链接和加载阶段，以及程序如何在内存中布局。 7. **网络通信**：简述网络协议栈，如TCP/IP，以及网络编程的概念，如套接字和并发连接。 8. **安全与隐私**：探讨计算机安全问题，包括恶意软件、漏洞利用和数据加密，以及如何保护用户隐私。 9. **性能优化**：介绍分析和优化程序性能的方法，包括代码优化、资源管理以及并行和并发编程。 10. **软件工程实践**：讨论软件开发过程，包括版本控制、测试、调试和文档编写，强调良好的编程习惯和团队协作的重要性。这本书适合对计算机系统有浓厚兴趣的读者，无论是初学者还是经验丰富的开发者，都能从中受益。通过学习这些内容，读者不仅可以更好地理解计算机系统的内部运作，还能提升编程技能，写出更高效、更可靠的代码。技术审阅者 Aubrey Anderson 的专业审核确保了内容的准确性和实用性。书中还包含了丰富的插图和实例，如 Hanalei Steinhart 提供的 Composition 图像，以及来自 www.cadhatch.com 的砖墙图像，用以生动展示抽象概念。此外，引用了《洛基恐怖秀》的场景图，使内容更具趣味性。《The Secret Life of Programs》是理解计算机系统和提升编程能力的宝贵资源，通过深入研究，读者将能够揭示隐藏在程序背后的秘密，从而更好地驾驭这个数字化世界。

Application programs don’t talk to the computer hardware directly; that’s where system

programming comes into play. System programmers make the building blocks used by application

programmers. System programmers need to know about hardware because their code interacts

with it. One of the goals of this book is to teach you things you need to know in order to be a good

system programmer.

Computer hardware includes not only the part that does the actual computing but also how that

part connects to the world outside. Computer hardware is expressed as logic. It’s the same logic

used to write computer programs, and it’s key to understanding the workings of the computer. The

logic is constructed from various types of electronic circuits. Circuit design is beyond the scope of

this book, but you can learn more about it by studying electrical engineering. Consider a double

major in electrical engineering and computer science if you want to rule the world.

Of course, basic science underpins it all, providing everything from our understanding of electricity

to the chemistry needed to create chips.

As shown in Figure 1, each level builds on the one beneath it. This means that poor design choices

or errors at lower levels affect everything above. For example, a design error in Intel Pentium

processors circa 1994 caused some division operations to produce incorrect results. This affected

all software that used floating-point division in these processors.

As you can see, system programming is at the bottom of the software hierarchy. It’s similar to

infrastructure, like roads, electricity, and water. Being a good programmer always matters, but it

matters more if you’re a system programmer, because others rely on your infrastructure. You can

also see that system programming is sandwiched between application programming and computer

hardware, which means you need to learn something about both of those. The Sanskrit

word yoga translates to “union,” and just as yoga practitioners seek to unify their mind and body,

system programmers are techno-yogis who unify the hardware and software.

You don’t have to learn system programming in order to work at one of the other levels. But if you

don’t, you’ll have to find someone else to help you deal with issues out of your domain rather than

being able to figure them out for yourself. An understanding of the core technology also leads to

better solutions at higher levels. This isn’t just my opinion; check out the 2014 blog post “The

Resource Leak Bug of Our Civilization” by Ville-Matias Heikkilä for a similar view.

This book also aims to cover a lot of retro history. Most programmers aren’t learning the history of

their craft because there is so much material to cover. The result is that a lot of people are making

mistakes that have already been made. Knowing some of the history allows you to at least make

new and better mistakes rather than repeat past ones. Bear in mind that the hot new technology

you’re using today will quickly become retro tomorrow.

Speaking of history, this book is jam-packed with interesting technologies and the names of their

inventors. Take some time to learn more about both the technologies and the people. Most of the

people mentioned solved at least one interesting problem, and it’s worth learning about how they

perceived their world and the way in which they approached and solved problems. There’s a great

exchange in Neal Stephenson’s 2008 novel Anathem:

“Our opponent is an alien starship packed with atomic bombs. We have a protractor.”

“Okay, I’ll go home and see if I can scrounge up a ruler and a piece of string.”

Note the reliance on fundamentals. It’s not “Let’s look up what to do on Wikipedia” or “I’ll post a

question on Stack Overflow” or “I’ll find some package on GitHub.” Learning to solve problems that

nobody else has solved is a crucial skill.

Many of the examples in this book are based on old technology such as 16-bit computers. That’s

because you can learn almost everything you need to know from them and they’re easier to fit on a

page.

WHAT’S IN THIS BOOK

The book is conceptually divided into three parts. The first part explores computer hardware, both

what it is and how it’s built. The second part examines the behavior of software running on

hardware. The last part covers the art of programming—working with others to produce good

programs.

Chapter 1: The Internal Language of Computers

This chapter starts exploring the three-year-old mentality. Computers are bit players; they herd

bits for a living. You’ll learn what they are and what can be done with them. We’ll play make-believe

to ascribe meaning to bits and to collections of bits.

Chapter 2: Combinatorial Logic

This chapter examines the rationale for using bits instead of digits and explores the justification for

digital computers. This includes a discussion of some of the older technologies that paved the way

for what we have today. It covers the basics of combinatorial logic. You’ll learn how to build more

complicated functionality from bits and logic.

Chapter 3: Sequential Logic

Here you’ll learn how to use logic to build memory. This includes learning how to generate time,

because memory is nothing but state that persists over time. This chapter covers the basics of

sequential logic and discusses various memory technologies.

Chapter 4: Computer Anatomy

This chapter shows how computers are constructed from the logic and memory elements discussed

in the earlier chapters. A number of different implementation methodologies are examined.

Chapter 5: Computer Architecture

In this chapter, we’ll explore some of the add-ons to the basic computer that we saw in Chapter 4.

You’ll learn how they provide essential functionality and efficiency.

Chapter 6: Communications Breakdown

Computers need to interact with the outside world. This chapter covers input and output. It also

revisits the difference between digital and analog and how we get digital computers to work in an

analog world.

Chapter 7: Organizing Data

Now that you’ve seen how computers work, we’ll look at how to use them effectively. Computer

programs manipulate data in memory, and it’s important to map the way memory is used to the

problem being solved.

Chapter 8: Language Processing

Languages have been invented to make programming computers easier for people. This chapter

looks at the process of converting languages into something that actually runs on computers.

Chapter 9: The Web Browser

THE INTERNAL LANGUAGE OF COMPUTERS

The whole point of language is to be able to communicate information. Your job as a programmer is

to give instructions to computers. They don’t understand our language, so you have to learn theirs.

Human language is the product of thousands of years of evolution. We don’t know a lot about how it

evolved, since early language development wasn’t advanced to the point that history could be

recorded. (Apparently nobody wrote ballads about language development.) Computer languages

are a different story, as they’re a fairly recent invention that occurred long after the development of

human language, which enables us to write about them.

Human and computer languages share many of the same elements, such as written symbols and

rules for their proper arrangement and usage. One thing that they don’t share is nonwritten

language forms; computers have written language only.

In this chapter, you’ll start to learn the language of computers. This process happens in stages just

like with human language. We have to start with letters before building up to words and sentences.

Fortunately, computer languages are much simpler than their human counterparts.

WHAT IS LANGUAGE?

Language is a convenient shortcut. It allows us to communicate complex concepts without having to

demonstrate them. It also allows concepts to be conveyed at a distance, even via intermediaries.

Every language—whether written, spoken, or expressed in a series of gestures or by banging two

rocks together—is meaning encoded as a set of symbols. Encoding meaning as symbols isn’t enough,

though. Language only works if all communicating parties have the same context, so they can assign

the same meaning to the same symbols. For example, the word Toto might suggest the dog from The

Wizard of Oz to many people, while others might think of the Japanese manufacturer of heated

toilet seats. I recently encountered much confusion while discussing clothing with my French

exchange student. It turns out that the common interpretation of the word camisole in America is

undershirt, but in France it’s straitjacket! In both of these examples, the same symbols can be

distinguished only by context, and that context is not always readily discernible. Computer

languages have this issue too.

WRITTEN LANGUAGE

Written language is a sequence of symbols. We form words by placing symbols in a particular order.

For example, in English we can form the word yum by placing three symbols (that is, letters) in

order from left to right as follows: y u m.

There are many possible symbols and combinations. There are 26 basic symbols (A–Z) in English—

if we ignore things like upper- and lowercase, punctuation, ligatures, and so on—which native

English speakers learn as toddlers. Other languages have different types and numbers of symbols.

Some languages, such as Chinese and Japanese as written in kanji, have a very large number of

symbols where each symbol is a word unto itself.

Languages also use different ordering, such as reading right to left in Hebrew and vertically in

Chinese. Symbol order is important: d o g is not the same as g o d.

Although style can in some ways be considered a language unto itself, we don’t distinguish symbols

based on typeface: a, a, and a are all the same symbol.

Three components frame the technology of written language, including computer language:

• The containers that hold symbols

• The symbols that are allowed in the containers

• The ordering of the containers

Some languages include more complicated rules that constrain the permitted symbols in containers

based on the symbols in other containers. For example, some symbols can’t occupy adjacent

containers.

THE BIT

We’ll begin with the container. This might be called a character in a human language and a bit for

computers. The term bit is an awkward marriage between binary and digit. It’s awkward

because binary is a word for something with two parts, whereas digit is a word for one of the 10

symbols (0–9) that make up our everyday number system. You’ll learn why we use bits in the next

chapter; for now, it’s enough to know that they’re cheap and easy to build.

A bit is binary, which means a bit container can hold only one of two symbols, kind of like the dot

and dash from Morse code. Morse code uses just two symbols to represent complex information by

stringing those symbols together in different combinations. The letter A is dot-dash, for

example. B is dash-dot-dot-dot, C is dash-dot-dash-dot, and so on. The order of the symbols is

important just like in a human language: dash-dot means N, not A.

The concept of symbols is abstract. It really doesn’t matter what they stand for; they could be off

and on, day and night, or duck and goose. But remember, language doesn’t work without context.

Things would get weird fast if a sender thought they were saying U (dot-dot-dash), but the recipient

heard duck-duck-goose.

In the remainder of this chapter, you’ll learn about some of the common ways in which meaning is

assigned to bits for computing. Keep in mind that there is a lot of make-believe involved—for

example, you may run into things like, “Let’s pretend that this bit means blue.” Programming

actually works that way, so even though you’ll be learning some standard bit uses, don’t be afraid to

invent your own when appropriate.

LOGIC OPERATIONS

One use of bits is to represent the answers to yes/no questions such as “Is it cold?” or “Do you like

my hat?” We use the terms true for yes and false for no. Questions like “Where’s the dog party?”

don’t have a yes/no answer and can’t be represented by a single bit.

In human language, we often combine several yes/no clauses into a single sentence. We might say,

“Wear a coat if it is cold or if it is raining” or “Go skiing if it is snowing and it’s not a school day.”

Another way of saying those things might be “Wear coat is true if cold is true or raining is true” and

剩余457页未读，继续阅读

anglezhu

粉丝: 2
资源: 21

揭秘程序世界：构建更优代码的计算机原理

The Secret Life of Programs (2019).pdf

Springer.The.Developer’s.Guide.to.Debugging.2008.pdf

某室外景观亮化工程施工方案_secret_cn50Hz.pdf

Give me a C++ code to solve the bulls and cows problem

为什么是使用代码KeyGenerator keyGenerator = KeyGenerator.getInstance(AES); keyGenerator.init(128); SecretKey secretKey = keyGenerator.generateKey(); byte[] encodedKey = key.getBytes(); return new SecretKeySpec(encodedKey, AES);还是会报错key length not 128/192/256

1.What are the essential ingredients of a symmetric cipher?

php实现SecretKey secretKey = kgen.generateKey();

最新资源