跟讀練習: 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秒緊跟說話者的影子。與被動聽力或語法練習不同,跟讀法強迫您的大腦和口腔肌肉同時處理並模模擬實的講話模式。研究表明它能顯著提高發音準確性,語調,節奏,連讀,聽力理解和口語流利度——使其成為雅思口語備考和真實英語交流最有效的方法之一。













