跟读练习: Mind-bending new programming language for GPUs just dropped... - 通过视频学习英语口语

选择练习模式

每种模式都会打开全屏练习室。

60 句

如果句子过短或过长，请点击 Edit 进行调整。

Yesterday, the clouds opened up, and a weird new programming language came down to Earth, with a promise of parallelism for all thou who writeth code.

This is big if true, because parallel computing is a superpower.

It allows a programmer to take a problem that could be solved in a week, and instead solve it in seven days using seven different computers.

Unfortunately, running code in parallel is like conducting a symphony.

One wrong note, and the entire thing becomes a total disaster.

But luckily, Bend offers hope by making a bold promise.

Everything that can run in parallel, will run in parallel.

You don't need to know anything about CUDA, blocks, locks, mutexes, or regexes to write algorithms that take advantage of all 24 of your CPU cores,

or even all 16 ,000 of your GPU cores.

You just write some high -level

Python -looking code, and the rest is magic.

It is May 17th, 2024, and you're watching the Code Report.

When you write code in a language like

Python, your code runs on a single thread.

That means only one thing can happen at a time.

It's like going to a KFC with only one employee who takes the order, cleans the toilets, and cooks the food in that order.

Now, on a modern CPU, you might have a clock cycle around 4 gigahertz, and if it's handling one instruction per cycle,

you're only able to perform 4 billion instructions per second.

Now, if 4 Gips is not enough, you can modify your Python code to take advantage of multiple threads,

but it adds a lot of complexity to your code.

And there's all kinds of gotchas, like race conditions, deadlocks, thread starvation, and may even lead to conflicts with demons.

Even if you do manage to get it working, you might find that your CPU just doesn't have enough juice at

which point you look into using the thousands of CUDA cores on your GPU.

But now you'll need to write some C++ code and likely blow your leg off in the process.

Well, what if there is a language that just knew how to run things in parallel by default?

That's the promise of Bend.

Imagine we have a computation that adds two completely random numbers together.

In Python, the interpreter is going to convert this into bytecode, and then eventually run it on the Python virtual machine.

Pretty simple, but in Bend, things are a little more complex.

The elements of the computation are structured into a graph, which are called interaction combinators.

You can think of it as a big network of all the computations that need to be done.

When two nodes run into each other, the computation progresses by following a simple set of rules

that rewrite the computation in a way that can be done in parallel.

It continues this pattern until all computations are done, then merges the result back into whatever expression was returned from the function.

This concept of interaction combinators goes all the way back to the 1990s, and is implemented in a runtime called the higher -order virtual machine.

HVM is not meant to be used directly, and that's why they built

Bend, a high -level language, to interface with it.

And the language itself is implemented in Rust.

Its syntax is very similar to Python, and we can write a hello world by defining a main function that returns a string.

Now to execute this code, we can pull up the terminal and use the ben run command.

By default, this is going to use the Rust interpreter, which will execute it sequentially, just like any other boring language.

But now here's where things get interesting.

Imagine we have an algorithm that needs to count a bunch of numbers and then add them together.

The first thing that might blow your mind is that bend does not have loops.

Like, we can't just do a for loop like we would in Python.

Instead, bend has something entirely different called a fold that works like a search and replace for data types.

And any algorithm that requires a loop can be replaced with a fold.

Basically, a fold allows you to consume recursive data types in parallel, like a list or a tree.

But first, we need to construct a recursive data type.

And for that, we have the bend keyword, which is like the opposite of fold.

Now, if that's a little too mind -bending, maybe check out my back catalog for recursion in 100 seconds.

But now let's see what this looks like from a performance standpoint.

When I try to run this algorithm on a single thread, it takes forever, like 10 minutes or more.

However, I can run the same code without any modification whatsoever with the bend run C command.

When I do that, it's now utilizing all 24 threads on my CPU.

And now it only takes about 30 seconds to run the computation.

That's a huge improvement, but I think we can still do better.

Because I'm a baller, I have an NVIDIA RTX 4090, and once again, I can run this code without any modification on CUDA with bendrun -cu.

And now this code only takes one and a half seconds to run, and I'll just go ahead and drop the mic right there.

This has been the Code Report, thanks for watching, and I will see you in the next one.

下载应用

流利口语所需的一切

AI 发音评分逐句打分

音标练习掌握每个音

词汇学习建立你的词库

词汇游戏边玩边学

扫码

Download on theApp Store Get it onGoogle Play

同频道

FOR YOU

本课的词汇与口语要点

这节口语课以视频“Mind-bending new programming language for GPUs just dropped..”为素材。视频中反复出现的词有：code, bend, computation, Python, parallel。这段视频共有 60 个句子、904 个单词可供跟读。讲话部分时长为 4:00。说话人语速较快，每分钟约 226 个词，会出现较多连读和弱读。只有 77% 的单词属于英语最常用的 3,000 词，词汇难度较高。

视频中的重点词汇

视频中 15 个值得学习的单词，附发音和释义：

单词	发音	释义
bend 动词	/bɛnd/	彎 /弯
parallel 形容词	/ˈpæ.ɹəˌlɛl/	平行的
thread 名词	/ˈθɹɛd/	線 /线
fold 动词	/ˈfəʊld/	摺 /折, 折疊 /折叠
algorithm 名词	/ˈælɡəɹɪðm̩/	算法, 演算法
loop 名词	/luːp/	圈, 環 /环
solve 动词	/sɒlv/	解決 /解决
default 名词	/dɪˈfɔlt/	違約 /违约, 暴雷
interaction 名词	/ˌɪn.təˈɹæk.ʃən/	相互作用
implement 动词	/ˈɪmpləmənt/	實施 /实施, 執行 /执行
instruction 名词	/ɪnˈstɹʌkʃən/	教導 /教导
execute 动词	/ˈɛksɪˌkjuːt/	處決 /处决, 處死 /处死
cloud 名词	/ˈklaʊ̯d/	йүн, 雲 /云
element 名词	/ˈɛləmənt/	要素
string 名词	/stɹɪŋ/	線 /线

视频中出现的短语动词

单词	发音	释义
check out 动词		退房
go ahead 动词	/ˌɡoʊ əˈhɛd/	請便 /请便

视频中的语法

说话人最常用的结构，并附上视频中的原话：

结构	视频中的用法
被动语态 be + 过去分词 — 强调发生了什么，而不是谁做的	could be solved · are structured · be done
定语从句 who / which + 从句 — 补充说明人或事物	graph, which are · interpreter, which will · keyword, which is

需要注意的发音

说话人用了 8 次缩略和弱读形式，例如 you're, can't, doesn't。请按听到的简短形式来说。

“th” 音: thread /ˈθɹɛd/, algorithm /ˈælɡəɹɪðm̩/
“sh” 和 “zh” 音: interaction /ˌɪn.təˈɹæk.ʃən/, instruction /ɪnˈstɹʌkʃən/, modification /ˌmɑdɪfɪˈkeɪʃən/, starvation /stɑɹˈveɪʃən/, computation /ˌkɑmpjʊˈteɪʃn̩/
长单词——注意重音位置: interaction /ˌɪn.təˈɹæk.ʃən/, modification /ˌmɑdɪfɪˈkeɪʃən/, interpreter /ɪnˈtɝ.pɹɪ.tɚ/, complexity /kəmˈplɛk.sɪ.ti/, whatsoever /ˌ(h)wʌtsoʊˈɛvɚ/

中文母语者容易读错的音：

/v/ — 不要读成 /w/，上齿轻触下唇: solve /sɒlv/, virtual /ˈvɜɹt͡ʃuəl/, convert /kənˈvɝt/, whatsoever /ˌ(h)wʌtsoʊˈɛvɚ/, starvation /stɑɹˈveɪʃən/
词尾辅音 — 要读清楚，后面不要加元音: bend /bɛnd/, thread /ˈθɹɛd/, fold /ˈfəʊld/, loop /luːp/, solve /sɒlv/
/r/ 和 /l/ 的区别: parallel /ˈpæ.ɹəˌlɛl/, algorithm /ˈælɡəɹɪðm̩/, virtual /ˈvɜɹt͡ʃuəl/, parallelism /ˈpaɹəlɛlɪz(ə)m/

如何用这段视频练习

先完整听一遍视频，不要开口，记下不认识的单词。
先用 0.75 倍速逐句跟读，熟练之后再回到正常速度。
录下自己的声音并与原声对比，特别注意 bend, parallel, thread 这类单词。

什么是跟读法？

跟读法 (Shadowing) 是一种有科学依据的语言学习技巧，最初开发用于专业口译员的培训，并由多语言者Alexander Arguelles博士普及。这个方法简单而强大：您在听英语母语原声的同时立即大声重复——就像是一个延迟1-2秒紧跟说话者的影子。与被动听力或语法练习不同，跟读法强迫您的大脑和口腔肌肉同时处理并模仿真实的讲话模式。研究表明它能显着提高发音准确性，语调，节奏，连读，听力理解和口语流利度——使其成为雅思口语备考和真实英语交流最有效的方法之一。

影子跟读法: 阅读完整分步指南 →

跟读练习: Mind-bending new programming language for GPUs just dropped... - 通过视频学习英语口语

选择练习模式

下载应用

PostgreSQL in 100 Seconds

A $6.3 billion open-weight model just got embarrassed by the French...

Every app on Earth is now open source... whether it likes it or not

OpenAI’s lead engineer was secretly a spy...

Intel chips can’t possibly be this bad… 100% crash rate?

Did Google just kickstart the intelligence explosion?

Godot in 100 Seconds

The most interesting "hack" in history...

Grok 4 pushes humanity closer to AGI… but there’s a problem

Array Map in 100 Seconds

Docker in 100 Seconds

The one OpenAI announcement that can actually make you money...

How to NOT Fail a Technical Interview

OpenAI’s new browser feels familiar…

10 weird OSS projects you need right now...

Firefox and Tor hit with 9.8 critical level exploit

5 open source tools that replaced my $320/mo AI stack...

25 crazy software bugs explained

C++ in 100 Seconds

DHH has gone completely off the rails...

How To Learn To Code In 2026

Why Memory Prices Are Crazy High

Linus Torvalds Explains What Makes Linux So Fast

Amazon Athena explained in 120 seconds💡

NVIDIA GTC 2025 - Keynote Highlights by NVIDIA CEO Jensen Huang

Did Anthropic Kill Git?

We Can Now Simulate a Human Brain, Scientists Show

GitHub Copilot now controls your command line...

Go’s Big Mistake

What is Python? Why Python is So Popular?

The Engineering that Runs the Digital World 🛠️⚙️💻 How do CPUs Work?