跟读练习: Insane Computer Science Concepts - 通过视频学习英语口语
选择练习模式
每种模式都会打开全屏练习室。
173 句
如果句子过短或过长,请点击 Edit 进行调整。
1
Computer science and space.
2
They share a long history because sending humans to space is pretty hard,
3
so we use computers to help us or to completely operate things like rovers or probes on their own.
4
But how do you build something that can explore the unknown when it can't rely on you?
5
Well the first problem is that we can't even build it like a normal computer.
6
For example, let's look at the modern phone.
7
Inside of it are billions of tiny transistors, little electronic switches that computers use to process information.
8
By controlling electrical signals, these transistors help represent the ones and zeros that make up everything your computer does.
9
Your photos, messages, games, even this video, at the lowest level, all of it is represented by binary information.
10
And modern chips have become ridiculously good at processing it.
11
We keep shrinking transistors and packing more computing power into our devices.
12
But the smaller these components become, the more sensitive they can be to certain kinds of electrical disturbances.
13
And in space, there's a lot of electrical disturbances.
14
High -energy particles from cosmic rays can interact with spacecraft electronics, sometimes an interaction can literally flip a bit in memory,
15
which is known as a single -event effect.
16
And depending on where it happens, it can corrupt data, disrupt a computation, or even damage a component.
17
And this is exactly why space missions use heavily tested components, radiation -hardened technology, all of which they pretty much have to do from scratch,
18
and it can last for years.
19
And so that's the philosophy of space hardware.
20
Work extremely hard to get it right because once it's out there, it's pretty difficult to fix if anything goes wrong.
21
And this is exactly why we have to be extremely careful about the software too.
22
NASA's Jet Propulsion Laboratory, which builds and operates many of NASA's robotic spacecraft, has a set of guidelines for writing reliable,
23
mission -critical software known as the Power of 10.
24
To list a few of them, recursion isn't allowed under these guidelines,
25
whether directly or indirectly, and every loop also needs a provable upper bound on how many times it can execute,
26
because an infinite loop on another planet is probably the end of the mission.
27
Another rule is that a function shouldn't be longer than what fits on a single printed page, so roughly 60 lines.
28
This is to ensure that a human reviewer can actually hold the entire thing in their head and verify that it's correct.
29
But even if we build the most reliable computer and software imaginable, there's still another problem.
30
It has to communicate with us.
31
You see, at its core, a computer works in binary, ones and zeros, so when we want a spacecraft to do something,
32
we can encode commands into binary data and transmit them through NASA's Deep Space Network,
33
a collection of enormous radio antennas designed to communicate with spacecraft across the solar system.
34
So for example, if you wanted a probe to take a picture, you'd send a command telling it to capture an image.
35
The spacecraft receives the command, interprets the data, and executes the instruction.
36
Then its camera captures the image and represents it as numerical pixel values.
37
Those numbers are encoded into binary data, transmitted back through radio signals and decode it on Earth into a picture like this.
38
So in a sense, we're sending ones at zeroes through space using radio waves.
39
But getting those ones and zeroes to their destination isn't as simple as it sounds.
40
Radio signals become fainter as they travel farther from their source.
41
They can be affected by noise and interference
42
and the receiver has to distinguish the actual message from everything that might obscure it.
43
And when you're receiving a very faint signal from a spacecraft millions of miles away, even a little uncertainty matters.
44
But luckily, before
45
Before this was a problem for space, it was a problem for Earth, one which we solved using error -corrected codes,
46
which is the practice of building extra information into a message.
47
So the receiver has a way to detect or recover from errors.
48
For example, suppose I want to send you a single bit.
49
Instead of sending it once, I could send it three times.
50
Now let's say noise corrupts one of those bits and you receive 101, so what was I trying to tell you?
51
Well, two of the three bits are 1, so you can take a majority vote and conclude that I probably meant to send a 1.
52
This is called a repetition code, it's an extremely simple example and real communication systems use much more sophisticated codes, but the principle is the same.
53
You build the ability to recover from mistakes into the message before it ever leaves earth.
54
So we can send information across enormous distances and even if something goes wrong we can recover.
55
But there's one thing that we can't fix, the speed of light.
56
Even though radio signals travel at the speed of light, that speed is finite and the farther away your spacecraft is,
57
the longer it takes for your messages to get there.
58
For example, at the time of its encounter with Pluto, NASA's New Horizons spacecraft was receiving signals that took several hours to travel one way.
59
At roughly four and a half hours for the trip in one direction, a command and its response could take around nine hours.
60
Imagine trying to drive a car like that.
61
You see an obstacle, send a message asking what you should do, and wait hours for an answer.
62
And that's the fundamental problem.
63
So if we want our spacecraft to explore the unknown, eventually we have to let them do some of the work themselves.
64
Which is exactly what we're doing with the Perseverance rover on Mars.
65
You see, when a rover needs to drive somewhere, we don't want it to have to stop for a human to examine every obstacle
66
or rock and decide whether it can drive around it.
67
So we give it a system called AutoNav, which lets the rover plan and execute much of its short distance driving on its own.
68
And it's a whole pipeline of computer vision and path planning algorithms, so bear with me for a sec - Perseverance has stereo navigation cameras,
69
meaning it can take images of the same scene from two slightly different viewpoints.
70
It's the same basic trick your eyes use to perceive depth, which you can actually test right now.
71
If you look at an object with one eye closed, then switch to the other eye,
72
you'll notice that nearby objects appear to shift more than objects that are far away.
73
A computer can use a similar idea.
74
It compares features in the two images and measures how much they shift between the two viewpoints.
75
This produces what's called a disparity map, where the amount of displacement gives clues about how far away different parts of the scene are.
76
From there, the system can reconstruct a three -dimensional representation of the terrain, which is known as a point cloud,
77
a collection of points representing locations in physical space.
78
And because we don't necessarily need an incredibly detailed model of every pebble, that information can be simplified into a height mass,
79
essentially a grid describing how high or low the terrain is at different locations.
80
Now the rover has a useful representation of the world in front of it, but knowing what the terrain looks like is only half the problem,
81
it still needs to decide where to drive.
82
So the system generates a collection of possible paths.
83
Rather than committing to a single route immediately, it can consider different curved trajectories the rover might follow.
84
Then it scores these functions using a cost function.
85
The cost function gives each potential path a numerical score based on things like terrain roughness, slope, and steering effort.
86
A steep or dangerous route gets penalized, whereas a smoother, safer route gets a lower cost.
87
But even the best looking path could still be dangerous, so Perseverance then uses a method called Approximate Clearance Evaluation,
88
or ACE, to evaluate candidate paths against the rover's physical geometry and the terrain.
89
In simplified terms, the system checks whether the rover's body
90
and wheels could collide with the ground or encounter an unsafe configuration as it travels along a proposed path.
91
Then the system selects a suitable low -cost path that passes these checks, begins driving, and then replans as it moves.
92
So that's AutoNav, we can have a rover move around obstacles on its own, but what if we wanted to find aliens?
93
Well, one of Perseverance's goals is to investigate rocks
94
that might reveal clues about Mars' geological history and its potential to have supported ancient microbial life.
95
But we don't want the rover to have to send every image back to Earth
96
and wait for scientists to examine it before doing any action on its own.
97
We want it to be able to identify certain kinds of targets and carry out some scientific observations on its own.
98
That's where a system called Aegis comes in, autonomous exploration for gathering increased science.
99
The idea is to let the rover select targets based on criteria that scientists have specified in advance.
100
But how do you teach a computer to recognize a rock?
101
Well, at its most basic level, an image is just an array of numbers.
102
A grayscale image, for example, can represent every pixel with a brightness value.
103
A dark pixel might have a low value, while a bright pixel has a high one.
104
So one approach is to look for boundaries.
105
Think about where a dark rock sits against a lighter patch of ground.
106
As you move across the pixels, you might encounter a sudden change in brightness.
107
That change could indicate an edge.
108
And so this algorithm is known as Rockster, named fittingly for finding rocks.
109
And first, it smooths the image to reduce any small fluctuations that aren't meaningful.
110
Then it detects strong changes in brightness between neighboring pixels and connects edge fragments into outlines in order to properly identify rocks.
111
And once it has candidate rocks, Aegis can measure properties such as their size, shape, brightness, and apparent distance.
112
Then it can rank and select a target.
113
Perseverance then can use an instrument like supercam to fire a laser at it, because the laser creates a small amount of plasma,
114
which the instrument can analyze to help determine which chemical elements are present.
115
All of this can happen without waiting for a scientist on Earth to individually select the target.
116
So we programmed AutoNav to let the rover avoid hazards and move around its environment,
117
and we use Aegis to let it choose certain targets for scientific investigation.
118
And now we're starting to use AI in this process too.
119
In January 2026, NASA announced that Perseverance had completed drives on Mars using routes planned with generative AI.
120
And to understand why this is interesting, think about what human rover planners normally have to do.
121
They have to manually examine terrain images, identify obstacles, evaluate slopes, and potentially hazardous areas in order to decide which way the rover should travel.
122
And once they've examined a ton of information, they can then create a route using a series of waypoints.
123
But this takes a lot of time because the terrain is unfamiliar,
124
the rover is expensive, and you need to think carefully about what could go wrong.
125
Which is why, in 2025, NASA decided to use a vision language model for all of this work.
126
The model was able to analyze and identify features such as boulders, rocky outcrops, sand ripples, and potentially hazardous terrain,
127
and then generated a route using waypoints all by itself.
128
So, in other words, it was help carrying out work that human planners had traditionally performed manually.
129
And so, just to be clear, this wasn't an AI that had been unleashed on Mars and given complete control over the rover,
130
the AI planning took place on Earth, and engineers checked the proposed commands before sending them to Perseverance.
131
But imagine how the future will look like when we eventually tested
132
and verified our AI systems enough to the point where maybe they can be unleashed on Mars or even further.
133
But AI isn't just helping us with autonomy, it's also helping us identify planets.
134
Because for decades we've been collecting data trying to identify planets outside of our solar system.
135
And we do this using the transit method, where we basically wait for and identify when a star's brightness drops.
136
Because this can mean that a planet passed in front of the star, blocking a tiny fraction of its light.
137
But the issue is, there's a lot of other things that cause brightness to dip as well.
138
So astronomers have to examine the data and distinguish genuine exoplanets from false positives.
139
And when you're dealing with enormous collections of observations from space telescopes, that becomes a substantial computational problem,
140
which is where a project called ExoMiner comes in.
141
ExoMiner uses deep learning, specifically a neural network, to help identify genuine exoplanets from telescope data.
142
You see, Rockstar is a good example of the foundations of computer vision,
143
where we described a process involving explicitly designed image processing techniques to identify potential rock boundaries.
144
But what you probably know as computer vision is instead of describing every visual pattern
145
or signal with a manually written set of rules, we can train a neural network using examples.
146
For ExoMiner, that means giving the system data associated with previously confirmed planets and examples of false positives.
147
The model uses those examples during training to learn patterns that help distinguish the two.
148
And all of this helped us validate 301 additional planets in the Kepler solar system.
149
And something similar to this also happened last year with a high school student named Matteo Paz.
150
He developed a machine learning approach to analyze data collected by NASA's Neowise Space Telescope.
151
The dataset contained nearly 200 billion detections accumulated over more than a decade,
152
and Paz made an algorithm to identify about 1 .5 million previously unknown objects in this data.
153
And so that's what I think is one of the coolest parts about computer science and space exploration.
154
You don't need to be an astronaut or work at NASA, and you definitely don't need to build a spacecraft.
155
You can literally contribute to space exploration with the same fundamental ideas you're learning
156
when you study things like algorithms or process data or build a computer vision system or train a neural network,
157
all of it can help us investigate worlds that we can't reach ourselves.
158
And if you wanna actually understand code and make programs that work, check out Brilliant, today's sponsor.
159
It has tons of practical examples and problem solving that teaches you how to read code,
160
see how a program fits together and debug what's not working.
161
And we all know AI has completely changed what coding looks like, which is why
162
Brilliant focuses on the skills that still matter, like figuring out what to build, designing the solution, and proving it actually works.
163
You got it.
164
And learning to code can feel overwhelming, which is exactly why
165
Brilliant starts with logic and real -world use cases so you ramp up fast.
166
I've been using
167
Brilliant to build up my skills for coding projects, and what I love is how visual and hands -on it is.
168
I'm actually solving problems myself instead of watching someone else do it.
169
So click the link below or scan the QR code to get started with Brilliant for free.
170
You can upgrade a premium for full tutoring support and unlimited access to everything on Brilliant.
171
And right now, Lattice viewers can save 20 % off an annual premium subscription at brilliant .org slash Lattice.
172
So thank you to everyone for watching.
173
If you liked the video, please subscribe, leave a comment, and thank you.
同频道
FOR YOU
推荐视频
本课的词汇与口语要点
这节口语课以视频“Insane Computer Science Concepts”为素材。 视频中反复出现的词有:rover, computer, space, example。 这段视频共有 173 个句子、2666 个单词可供跟读。 讲话部分时长为 12:53。 说话人语速较快,每分钟约 207 个词,会出现较多连读和弱读。 只有 78% 的单词属于英语最常用的 3,000 词,词汇难度较高。
视频中的重点词汇
视频中 15 个值得学习的单词,附发音和释义:
| 单词 | 发音 | 释义 |
|---|---|---|
| spacecraft 名词 | /ˈspeɪsˌkɹæft/ | 航天器 |
| terrain 名词 | /təˈɹeɪn/ | 地域, 地形 |
| pixel 名词 | /ˈpɪk.səl/ | 像素 |
| brightness 名词 | /ˈbɹaɪtnəs/ | 明亮 |
| examine 动词 | /ɪɡˈzæmɪn/ | 检查, 调查 |
| algorithm 名词 | /ˈælɡəɹɪðm̩/ | 算法, 演算法 |
| binary 形容词 | /ˈbaɪ.nə.ɹi/ | 二進 /二进 |
| obstacle 名词 | /ˈɑbstəkəl/ | 障礙 /障碍, 妨礙 /妨碍 |
| select 动词 | /sɪˈlɛkt/ | 選 /选, 挑選 /挑选 |
| solve 动词 | /sɒlv/ | 解決 /解决 |
| component 名词 | /kəmˈpoʊ.nənt/ | 元件, 部件 |
| recover 动词 | /ɹɪˈkʌvɚ/ | 追回, 收复 |
| encounter 动词 | /ɪnˈkaʊntɚ/ | 遇到, 遇見 /遇见 |
| enormous 形容词 | /ɪˈnɔː.məs/ | 巨大的 |
| exploration 名词 | /ˌɛkspləˈɹeɪʃən/ | 勘探, 勘察 |
视频中出现的短语动词
| 单词 | 发音 | 释义 |
|---|---|---|
| carry out 动词 | /ˈkæ.ɹi aʊt/ | 進行 /进行 |
| check out 动词 | 退房 | |
| figure out 动词 | 弄清楚 | |
| make up 动词 | /ˌmeɪk ˈʌp/ | 組成 /组成 |
视频中的语法
说话人最常用的结构,并附上视频中的原话:
| 结构 | 视频中的用法 |
|---|---|
| 现在完成进行时 have/has been + -ing — 以前开始、现在仍在继续的动作 | we've been collecting · I've been using |
| 被动语态 be + 过去分词 — 强调发生了什么,而不是谁做的 | is represented · is known · isn't allowed |
| 现在完成时 have/has + 过去分词 — 过去发生但与现在仍有关联的事 | have become · have specified · they've examined |
| 定语从句 who / which + 从句 — 补充说明人或事物 | terrain, which is · like, which is · overwhelming, which is |
需要注意的发音
说话人用了 28 次缩略和弱读形式,例如 don't, can't, isn't。请按听到的简短形式来说。
- “th” 音: algorithm /ˈælɡəɹɪðm̩/, gather /ˈɡæðɚ/
- “sh” 和 “zh” 音: exploration /ˌɛkspləˈɹeɪʃən/, distinguish /dɪˈstɪŋ.ɡwɪʃ/, potentially /pəˈtɛnʃ(ə)li/, representation /ˌɹɛp.ɹə.zɛnˈteɪ.ʃən/, observation /ˌɑbzɚˈveɪʃn̩/
- 长单词——注意重音位置: electrical /ɪˈlɛktɹɪkəl/, exploration /ˌɛkspləˈɹeɪʃən/, manually /ˈmænj(u)əliː/, potentially /pəˈtɛnʃ(ə)li/, representation /ˌɹɛp.ɹə.zɛnˈteɪ.ʃən/
中文母语者容易读错的音:
- /v/ — 不要读成 /w/,上齿轻触下唇: rover /ˈɹoʊvɚ/, solve /sɒlv/, recover /ɹɪˈkʌvɚ/, investigate /ɪnˈvɛs.tə.ɡeɪt/, observation /ˌɑbzɚˈveɪʃn̩/
- 词尾辅音 — 要读清楚,后面不要加元音: spacecraft /ˈspeɪsˌkɹæft/, brightness /ˈbɹaɪtnəs/, select /sɪˈlɛkt/, solve /sɒlv/, component /kəmˈpoʊ.nənt/
- /r/ 和 /l/ 的区别: algorithm /ˈælɡəɹɪðm̩/, electrical /ɪˈlɛktɹɪkəl/, exploration /ˌɛkspləˈɹeɪʃən/, neural /ˈnʊɹəl/, roughly /ˈɹʌf.li/
如何用这段视频练习
- 先完整听一遍视频,不要开口,记下不认识的单词。
- 先用 0.75 倍速逐句跟读,熟练之后再回到正常速度。
- 录下自己的声音并与原声对比,特别注意 spacecraft, terrain, pixel 这类单词。
什么是跟读法?
跟读法 (Shadowing) 是一种有科学依据的语言学习技巧,最初开发用于专业口译员的培训,并由多语言者Alexander Arguelles博士普及。这个方法简单而强大:您在听英语母语原声的同时立即大声重复——就像是一个延迟1-2秒紧跟说话者的影子。与被动听力或语法练习不同,跟读法强迫您的大脑和口腔肌肉同时处理并模仿真实的讲话模式。研究表明它能显着提高发音准确性,语调,节奏,连读,听力理解和口语流利度——使其成为雅思口语备考和真实英语交流最有效的方法之一。













