From 2676db5960dde4fbd8192034fc4833efe10b064c Mon Sep 17 00:00:00 2001 From: Eduardo Sandalo Porto Date: Thu, 16 May 2024 16:32:53 -0300 Subject: [PATCH] Fix tiny grammar mistakes --- GUIDE.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/GUIDE.md b/GUIDE.md index 263b96c2..f91d7a17 100644 --- a/GUIDE.md +++ b/GUIDE.md @@ -6,7 +6,7 @@ feels like Python, but scales like CUDA. It runs on CPUs and GPUs, and you don't have to do anything to make it parallel: as long as your code isn't "helplessly sequential", it **will** use 1000's of threads! -While cool, Bend far from perfect. In absolute terms it is still not so fast. +While cool, Bend is far from perfect. In absolute terms it is still not so fast. Compared to SOTA compilers like GCC or GHC, our code gen is still embarrassingly bad, and there is a lot to improve. That said, it does scale horizontally with cores - and that's really cool. So, if you'd like to be an early adopter of this @@ -251,7 +251,7 @@ def main: return is_even(7) ``` -Which is immutable. If that's sound annoying, that's because **it is**. Don't +Which is immutable. If that sounds annoying, that's because **it is**. Don't let anyone tell you otherwise. We are aware of that, and we have many ideas on how to improve this, making Bend feel even more Python-like. For now, we have to live with it. But, wait... if variables are immutable... how do we even do @@ -267,7 +267,7 @@ def sum(x): Here, the entire way the algorithm works is by mutating the `total` variable. Without mutability, loops don't make sense. The good news is Bend has *something -else* that is equally as - actually, mode - powerful. And learning it is really +else* that is equally as - actually, more - powerful. And learning it is really worth your time. Let's do it! Folds and Bends @@ -312,8 +312,8 @@ As usual, for now, we'll live with the longer version. Now, here's a question: how do we *sum* the elements of a tree? In Python, we could just use a loop. In Bend, we don't have loops. Fortunately, there is -another construct we can use: is called `fold`, and it works like a *search and -replace* for datatypes. For example, consider the code below: +another construct we can use: it's called `fold`, and it works like a *search +and replace* for datatypes. For example, consider the code below: ```python @@ -490,7 +490,7 @@ for i in range(8): sum += i ``` -Is actually just a short way to write: +Is actually just a similar way to write: ```python sum = (0 + (1 + (2 + (3 + (4 + (5 + (6 + 7))))))) @@ -532,7 +532,7 @@ So, how do you write a parallel program in Bend? **Just write algorithms that aren't helplessly sequential.** -That's all there is to it. As long as you write programs like that one, and +That's all there is to it. As long as you write programs like that one, then unlike the former one, they will run in parallel. And that's why `bend` and `fold` are core features: they're, essentially, parallelizable loops. For example, to add numbers in parallel, we can write: @@ -569,8 +569,8 @@ That's **18x faster**! Can we do better? Sure: let's use the **C compiler** now: bend gen-c main.bend >> main.c ``` -This command converts your `bend` file in a small, dependency-free C file that -does the same computation much faster. You can compile it to an executable: +This command converts your `bend` file into a small, dependency-free C file +that does the same computation much faster. You can compile it to an executable: ``` gcc main.c -o main -O2 -lm -lpthread # if you're on Linux @@ -753,7 +753,7 @@ has an entire "secret" Haskell-like syntax that is compatible with old HVM1. For example, [here](https://gist.github.com/VictorTaelin/9cbb43e2b1f39006bae01238f99ff224) is an implementation of the Bitonic Sort with Haskell-like equations. We'll -document it syntax here soon! +document its syntax here soon! Community ---------