From a76daa7831c63a65cb6fb44dd01654efbc12cd5d Mon Sep 17 00:00:00 2001
From: Vlad Faust <mail@vladfaust.com>
Date: Sat, 29 Aug 2020 14:53:37 +0300
Subject: [PATCH] wip: fix grammar

---
 posts/2020-08-07-hello-world.md               |  14 +-
 .../2020-08-16-system-programming-in-2k20.md  | 188 +++++++++---------
 ...020-08-20-the-onyx-programming-language.md |  84 ++++----
 posts/2020-08-27-sponsoring-onyx.md           |  54 ++---
 4 files changed, 172 insertions(+), 168 deletions(-)

diff --git a/posts/2020-08-07-hello-world.md b/posts/2020-08-07-hello-world.md
index 29d37bc..b0a31c5 100644
--- a/posts/2020-08-07-hello-world.md
+++ b/posts/2020-08-07-hello-world.md
@@ -4,8 +4,8 @@ location: Moscow, Russia
 ---
 
 How many years of programming experience is needed to be qualified to start a tech blog?
-Ten, fiveteen?
-I see many blogging even with [zero](https://dev.to/), so I decided to give it a try as well.
+Ten, fifteen?
+I see much blogging even with [zero](https://dev.to/), so I decided to give it a try as well.
 
 Time for an introductory post!
 
@@ -35,7 +35,7 @@ In 2016, I fell in love with Ruby with the help of the famous the Michael the Ha
   * [Bitcoinpay](https://github.com/vladfaust/bitcoinpay-client)
   * [Blockchain::Api](https://github.com/vladfaust/blockchain-api)
 
-I did truly enjoy Ruby on Rails, but after some time I began wondering if there were more performant alterntatives.
+I did truly enjoy Ruby on Rails, but after some time, I began wondering if there were more performant alternatives.
 So I went from Rails to Hanami, and then to Roda and Sequel, and then occasionally run into <s>Assembler</s> [Crystal](https://crystal-lang.org/).
 
 I instantly got _addicted to Crystal_.
@@ -56,7 +56,7 @@ Throughout the next two years, I've developed a number of very useful shards:
 I even managed to build my [own web framework](https://onyxframework.org/) featuring a [REST server](https://onyxframework.org/http), a database-agnostic [SQL ORM](https://onyxframework.org/sql) and even an [EDA platform](https://onyxframework.org/eda)!
 I've also built a (now defunct) [Crystal Jobs](https://github.com/crystaljobs) website and the [RealWorld implementation](https://github.com/vladfaust/crystalworld) in Crystal.
 
-I've left the Crystal ecosystem, unfortunately <s>for Crystal</s>, because this is not the language I've always dreamt of.
+Unfortunately <s>for Crystal</s>, I've left the Crystal ecosystem, because this is not the language I've always dreamt of.
 And because of [some](https://github.com/asterite){.secret-link} [other](https://github.com/RX14){.secret-link} reasons, but more on that later.
 
 In June 2019, I began working on my own programming language, [Onyx](/posts/2020-08-20-the-onyx-programming-language).
@@ -79,12 +79,12 @@ Anyone?
 
 Human creation is what I enjoy a lot.
 I love listening to good music and examine great drawings.
-I can play ukulele and willing to learn piano and singing.
+I can play ukulele and willing to learn the piano and singing.
 I'm also experimenting with 3D modelling and digital art.
 
 > [I'll try anything once.](https://gamepedia.cursecdn.com/overwatch_gamepedia/8/81/Echo_-_I%27ll_try_anything_once.ogg){.secret-link}
 
-Some time in the future I plan to work on a strong AI implementation, which you can share music and watch movies together with.
+Sometime in the future, I plan to work on a strong AI implementation, which you can share music and watch movies together with.
 This is where [Onyx](/posts/2020-08-20-the-onyx-programming-language) comes into play!
 
 As a pragmatic person, I wrote some seemingly depressive articles "revealing the truth":
@@ -100,5 +100,5 @@ On my 24^th^ birthday, I've recorded a [video](https://www.youtube.com/watch?v=q
 I think that's enough for an introductory post.
 Now you know a little bit more about yourself.
 
-See you a round,<br>
+See you around,<br>
 Vlad.
diff --git a/posts/2020-08-16-system-programming-in-2k20.md b/posts/2020-08-16-system-programming-in-2k20.md
index 1fdc30d..ccbf8ab 100644
--- a/posts/2020-08-16-system-programming-in-2k20.md
+++ b/posts/2020-08-16-system-programming-in-2k20.md
@@ -3,7 +3,7 @@ title: System Programming in 2k20
 location: Moscow, Russia
 ---
 
-System programming is still important, but is seems to be much harder than application programming.
+System programming is still essential, but it seems to be much harder than application programming.
 Why is that and how to overcome this -- these are the questions I'll try to find answers for in this article.
 
 <!-- excerpt -->
@@ -17,25 +17,25 @@ ${toc}
 ## Introduction
 
 A hundred years ago, a person could not imagine to be able to play any musical instrument they want, to create new interactive worlds, or to launch cars into space.
-A life was simply not enough.
+Life was simply not enough.
 
-Then machines came.
+Then the machines came.
 Silicon computations allowed us, mere mortals, prolong our lives virtually and literally.
 
 Music creation software, game development engines, 2D and 3D editors, neural networks, AI and machine learning, motion capturing, navigation, medicine, wearable devices, smartphones...
 Thanks to these, a person now can do a lot of things while having more free time during their lifespan.
 
 It all happened because a human learned to communicate with machines with means of programming languages.
-Early inventors of the future were extremely intelligent people able to coin fundamentally new concepts which last until today.
+Early inventors of the future were brilliant people able to coin fundamentally new concepts which last until today.
 
 But this is the how the humanity evolves: we accumulate knowledge and pack, shortcut it.
-We don't need to keep in head proofs of every mathematical theorem, and we don't need to fully undrestand the nature of an axiom.
+We don't need to keep in head proofs of every mathematical theorem, and we don't need to fully understand the nature of an axiom.
 Instead, we store theorem and axiom statements.
 With that in mind, we have more space to solve new problems.
 
 The same applies to programming.
 Those brilliant people inevitably become old, as real system programming knowledge fades away.
-On the surface, the amount of those who really understands how machines work seems to shrink.
+On the surface, the amount of those who really understand how machines work seems to shrink.
 
 <figure>
   <blockquote class="twitter-tweet" data-lang="en" data-dnt="true">
@@ -61,13 +61,13 @@ System programming is the foundation of the development of the human civilizatio
 :::
 
 Regardless of its importance, system programming seems to be less popular than application programming, because it's known to be harder to both learn and master.
-It is definetely easier to spin up a web server, connect it to a database, set up some Stripe integration, drink smoothie and proudly call yourself an enterpruener.
+It is definitely easier to spin up a web server, connect it to a database, set up some Stripe integration, drink a smoothie and proudly call yourself an entrepreneur.
 
-But that does not invest into the the human civialization's progress on the Kardashov's scale.
+But that does not invest in the human civilization's progress on the Kardashov's scale.
 <mark>The humanity will still depend on system programming in the foreseeable future.</mark>
 And we need new, fresh blood there.
 
-In this article, I'll try to take a peek on the current state of the system programming, find out why it's not that popular and and choose the best system programming language for the Next Big But Fairly-Low-Level Project (tm).
+In this article, I'll try to take a peek on the current state of the system programming, find out why it's not that popular and choose the best system programming language for the Next Big But Fairly-Low-Level Project (tm).
 
 ## Choosing the Right Language
 
@@ -75,15 +75,17 @@ When choosing a serious language for serious system programming, the choice is b
 
 ### C
 
-C is great at its simplicity, but bigger projects require higher level language features, such as [memory control](https://twitter.com/jfbastien/status/1289305925199650816), object hierarchy, lambdas etc.; therefore, C is out of competition here.
+C is excellent at its simplicity, but bigger projects require higher-level language features, such as [memory control](https://twitter.com/jfbastien/status/1289305925199650816), object hierarchy, lambdas etc.; therefore, C is out of competition here.
+
+Ditto applies to C "replacements", such as [Ẕ̴̰̥̔͝i̷̥̣̍̓̉ġ̷̢̪͌̾́](https://ziglang.org/) and [Patreon-lang](https://vlang.io/).
 
-Ditto applies to C "replacements", such as [Ẕ̴̰̥̔͝i̷̥̣̍̓̉ġ̷̢̪͌̾́](https://ziglang.org/) and [Patreon-lang](https://vlang.io/).
 
 ### C++
 
+
 C++ is the grandfather of higher-level system programming.
 
-It offers powerful features with a grain of Unix epoch practices and great amount of undefined behaviour.
+It offers powerful features with a grain of Unix epoch practices and a great amount of undefined behaviour.
 Funnily enough, an experienced C++ programmer shall aware of not what C++ is, but of what it is not, i.e. undefined behaviour of the language.
 
 That said, developing on C++ is pain, and it is easy to shoot your lower parts off by, say, returning a lambda with a closured local variable.
@@ -97,13 +99,13 @@ One may argue that backwards compatibility is a good thing, but let me postpone
 Rust is a fairly young programming language with a reputable mission: empower everyone to build reliable and efficient software.
 Let's deconstruct the statement.
 
-One of the game-changing features of Rust is separation between safe and unsafe code.
+One of the game-changing features of Rust is the separation between safe and unsafe code.
 The ability to isolate volatile code worths a lot: if anything goes wrong, then you simply `grep` your codebase with `unsafe` filter and voilà -- all the dangerous invocations are at your hand sight.
-It also allows _the_ implementation to perform crazy optimizations, say, by entirely removing parts of code; and it's fine, because there is no unsafe access to that code.
+It also allows _the_ implementation to perform crazy optimizations, say, by entirely removing parts of code; and it's fine because there is no unsafe access to that code.
 As a result, focusing on volatile code becomes easier, and nasty bugs are squashed faster.
 
 Otherwise, _the_ Rust compiler would yell at you, pointing at your mistakes in the safe code area.
-And those yells are detailed enough, so most of the time you have a clean picture on why you're wrong and what to do with that.
+And those yells are detailed enough, so most of the time you have a clear picture on why you're wrong and what to do with that.
 
 Compared to C++, Rust compilation process is much friendlier and catches more bugs before you face them in runtime.
 
@@ -111,7 +113,7 @@ Compared to C++, Rust compilation process is much friendlier and catches more bu
 
 Another good thing about Rust is macros.
 Well, what's good is the idea of macros; the implementation of macros in Rust is um... questionable.
-Nevertheless, macros allow to write code in code with much greater flexibility than with C++ preprocessor and constant expressions.
+Nevertheless, macros allow writing code in code with much greater flexibility than with C++ preprocessor and constant expressions.
 Nuff said, macros are must-have in modern languages.
 
 The built-in crates system Rust has brings powerful abstractions into the ecosystem.
@@ -129,15 +131,17 @@ But, there are always some "but<sub>t</sub>s".
 First of all, only a few may say Rust has friendly syntax.
 In the maniacal pursuit for the absolute memory safety, the language introduces plethora of abstractions such as borrow checker, six string types (hey, we're making a language here, not a guitar), `Mut`, `Box`, `Arc`, `Trait`, requiring to do those ubiquitous `unwrap()`, `as_ref()` and `borrow()` (often chained) literally before every access.
 
-Some may call it "hipster thinking", but those small spikes like mandatory semicolons\*, curly brackets wrapping, and othwerwise unintuitive design decisions like constantly "screaming code" with ubiquitous bangs (`!`) and overloaded documentation semantics — they make writing and reading Rust code harder.
-Definetely harder than Ruby or, say,
-J̸̧̨̹͈̦̏̅͒̈́͂͐̄̾͟͟ͅȃ̡͎̯̟̦͉͂͊̿̈́v̢̡͖͍̻̳̞͌͌̈̋̐͌̆͜a̴͖̱̟̩̹̘̺͊̃̋̇̾̀̀͐̊͐ͅS̶͚̣̥͚͈̥̤͔̾̎̎̿̔͊̋̉̓c̶̡̧̗̻̊̈̋̍̔̂̅̓̚͘͢ŗ̰͖̲̙͖͕̂̏̍͑̊̋ḯ̸̛̤̦̠͈̩̙̯̘̥̖̅́̊̀͑̕͠͠p̸̨̧̨̧̡̛̮̯͖̹͈̉̑̿͛̎̀͌̾͞ț̸̩͕͈̊͐̏̏̕͡ͅ
+Some may call it "hipster thinking", but those small spikes like mandatory semicolons\*, curly brackets wrapping, and otherwise unintuitive design decisions like constantly "screaming code" with ubiquitous bangs (`!`) and overloaded documentation semantics — they make writing and reading Rust code harder.
+Definitely harder than Ruby or, say,
+J̸̧̨̹͈̦̏̅͒̈́͂͐̄̾͟͟ͅȃ̡͎̯̟̦͉͂͊̿̈́v̢̡͖͍̻̳̞͌͌̈̋̐͌̆͜a̴͖̱̟̩̹̘̺͊̃̋̇̾̀̀͐̊͐ͅS̶͚̣̥͚͈̥̤͔̾̎̎̿̔͊̋̉̓c̶̡̧̗̻̊̈̋̍̔̂̅̓̚͘͢ŗ̰͖̲̙͖͕̂̏̍͑̊̋ḯ̸̛̤̦̠͈̩̙̯̘̥̖̅́̊̀͑̕͠͠p̸̨̧̨̧̡̛̮̯͖̹͈̉̑̿͛̎̀͌̾͞ț̸̩͕͈̊͐̏̏̕͡ͅ
 .
 
 
 ::: off
 
-\* In fact, semicolons are not mandatory _everywhere_, which brings even more confusion.
+\* In fact, semicolons are not mandatory
+_everywhere_
+, which brings even more confusion.
 
 From [StackOverflow](https://stackoverflow.com/questions/26665471/are-semicolons-optional-in-rust):
 
@@ -149,9 +153,9 @@ From [StackOverflow](https://stackoverflow.com/questions/26665471/are-semicolons
 
 A [wise man](https://en.wikipedia.org/wiki/Jason_Statham){.secret-link} once said:
 
-> The complexity of a language feature is proportional to the amount of articles explaining the feature.
+> The complexity of a language feature is proportional to the number of articles explaining the feature.
 
-Here goes a tiny fraction of reads on why Rust is not even nearly to an intuitive language:
+Here go a tiny fraction of reads on why Rust is not even nearly to an intuitive language:
 
   1. [Common Rust Lifetime Misconceptions](https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md)
 
@@ -240,10 +244,10 @@ Now, instead of keeping in mind of where C++ might blow, one shall be aware all
 That said, the "for everyone" clause in the mission statement seems unfair to me now.
 It takes great effort to become fluent in Rust.
 
-Regarding to other two clauses in the Rust's mission, I still have no claims on them.
-Rust programs are known to be fairly performant (<small>if you ever manage to wait until `rustc` compiles with optimizations turned on</small>), and there is even the academia-grade [RustBelt](https://plv.mpi-sws.org/rustbelt/) organization ensuring the UB-safety.
+Regarding other two clauses in the Rust's mission, I still have no claims on them.
+Rust programs are known to be reasonably performant (<small>if you ever manage to wait until `rustc` compiles with optimizations turned on</small>), and there is even the academia-grade [RustBelt](https://plv.mpi-sws.org/rustbelt/) organization ensuring the UB-safety.
 
-You can always find more on what's good, bad and ugly about Rust, but the main point is that <mark>the language is not ideal</mark>, and there is definitely room for improvements.
+You can always find more on what's the good, the bad and the ugly about Rust, but the main point is that <mark>the language is not ideal</mark>, and there is definitely room for improvements.
 Plus one point to the justifying.
 
 ### Challengers Worth Mentioning
@@ -279,16 +283,16 @@ I love the core idea behind Crystal.
 I don't like its implementation.
 
 They are saying that [Crystal](https://crystal-lang.org/) is a general-purpose programming language, but that's not true.
-The language and its core team are focused on their needs, which is solely an amd64-linux platform.
+The language and its core team are focused on their needs, which is solely an `amd64-linux` platform.
 
 The standard library is bloated with heavy dependencies like `libxml` and `libyaml`, the language itself has GC, event loop and unwinding-based exceptions (i.e. a runtime) built-in, and it's therefore hardly possible to ship an executable for purposes other than serving requests over HTTP.
 
-After almost 10 years in development, the core team still has disagreements in the fundamental design, and you may commonly see controversial claims by its officials regarding to the Crystal's future on the forum.
+After almost 10 years in development, the core team still has disagreements in the fundamental design, and you may commonly see controversial claims by its officials regarding Crystal's future on the forum.
 They even can not decide if Crystal is a compiled Ruby or something else.
 
 <!-- TODO: Reference example issues and posts here. -->
 
-Regarding to the amount of bugs the only implementation has...
+Regarding the number of bugs the only implementation has...
 Once you dig a little bit deeper, it all begins to explode.
 Macros, generics, unions, interoperability: it may blow up anywhere.
 A core team [representative](https://github.com/asterite){.secret-link} without "core team" badge will then appear telling you that <small>it's not a bug, or wait, it is a bug, but it can not be fixed, oh wait, it can be fixed, but it's not a bug, issue closed, thanks</small>.
@@ -298,25 +302,25 @@ A core team [representative](https://github.com/asterite){.secret-link} without
 The recently introduced multi-threading brings even more problems due to the lack of proper addressing of the data races in the language.
 As most of the other design decisions in Crystal, this one has been taken somewhere in Manas without any open discussion.
 
-I've spent two years in the Crystal ecosystem, and it did not moved forward a bit, only backwards (bye, [Serdar](https://twitter.com/sdogruyol), bye [Julien](https://twitter.com/ysbaddaden)).
+I've spent two years in the Crystal ecosystem, and it did not move forward a bit, only backwards (bye, [Serdar](https://twitter.com/sdogruyol), bye [Julien](https://twitter.com/ysbaddaden)).
 A brilliant idea is buried by lack of focusing on the community needs.
 A hard lesson to learn.
 It's time for (_spoiler alert_) Crystal done right.
 
 ## Backwards Compatibility
 
-One would now jump into proudly announcing another language they've come up with, an utopia-grade solution to replace both C++ and Rust once and forever.
+One would now jump into proudly announcing another language they've come up with, a utopia-grade solution to replace both C++ and Rust once and forever.
 
 But the "forever" claim is kinda sloppy.
 
 Remember how I mentioned earlier that backwards compatibility is not _that_ good?
-The truth is that there will always be unforeseeable new features at some point, which have to be implemented so a language stays competitive.
+The truth is that there will always be unforeseeable new features at some point, which have to be implemented, so a language stays competitive.
 For example, coroutines, a term coined in 1958, were not much of interest until 2010's...
 
 A product aiming to preserve backwards compatibility has to somehow insert new features into existing rules without introducing breaking changes.
 
-C++ is a great primer on how not to.
-Constrained by existing implementations, they add overly complicated `co_await` functionality into the standard library with auxiliary garbage, which instead should have been built into the language itself (the functionality, not the garbage).
+C++ is an excellent primer on how not to.
+Constrained by existing implementations, they add overly complicated `co_await` functionality into the standard library with extra garbage, which instead should have been built into the language itself (the functionality, not the garbage).
 
 Another ad-hoc example is C++20 concepts.
 Instead of allowing to restrict generic arguments in-place, a new `requires` syntax is added, which is quite cumbersome: see [this](https://akrzemi1.wordpress.com/2020/01/29/requires-expression/) and [this](https://akrzemi1.wordpress.com/2020/03/26/requires-clause/).
@@ -326,16 +330,16 @@ What's the state of support of SIMD vectors, tensors or half-precision floats in
 Oh please.
 Instead of being incorporated into the standard, implementations come with their own solutions, which further invests into the chaos.
 
-But breaking changes are always painful, you would argue, because on one side you want to use all the shiny new features, but on the other you don't want spend a dime rewriting your code.
+But breaking changes are always painful, you would argue because on one side you want to use all the shiny new features, but on the other, you don't want to spend a dime rewriting your code.
 It becomes even worse when an open-source library author you're depending on decides that they will not support the older major version of a language; or, instead, they won't move on to the newer version.
 
-Given the amount of open-source libraries your project depends on, you are in trouble, as library versions become stale or incompatible.
+Given the number of open-source libraries your project depends on, you are in trouble, as library versions become stale or incompatible.
 
-All what's left is to visit a library's bugtracker and leave a "what's the status of this?" or "+1" comment, or maybe even put a little bit more effort:
+All that's left is to visit a library's bug tracker and leave a "what's the status of this?" or "+1" comment, or maybe even put a little bit more effort:
 
-[![I'm sorry for putting my Patreon account link in a MIT-licensed repository 😔](/public/img/posts/2020-08-16-system-programming-in-2k20/are-you-still-there.png "Are you still there??" =100%x)](https://github.com/vladfaust/unity-wakatime/issues/25)
+[![I'm sorry for putting my Patreon account link in an MIT-licensed repository 😔](/public/img/posts/2020-08-16-system-programming-in-2k20/are-you-still-there.png "Are you still there??" =100%x)](https://github.com/vladfaust/unity-wakatime/issues/25)
 
-When deciding on which language to built your next big project™ in, what you (or your PM) really want is that it accounts for all the present and future software and hardware features, has ultimate performance, maintainability, and never introduces any breaking changes, so you constantly reap the rich choice of forever-actual libraries.
+When deciding on which language to build your next big project™ in, what you (or your PM) really want is that it accounts for all the present and future software and hardware features, has ultimate performance, maintainability, and never introduces any breaking changes, so you constantly reap the rich choice of forever-actual libraries.
 
 Of course, such a language should be free as beer, as all of the forever-actual libraries.
 What's the point otherwise?
@@ -350,21 +354,21 @@ Wait a minute.
 
 At 32:15, Carol says:
 
-> When I first heard of that idea, I thought it sounds terrible from the compiler maintainance point of view: you have to maintain two ways to use every feature forever, because we wanted to commit to all editions being supported forever. But it's actually not that bad.
+> When I first heard of that idea, I thought it sounds terrible from the compiler maintenance point of view: you have to maintain two ways to use every feature forever because we wanted to commit to all editions being supported forever. But it's actually not that bad.
 
 Then they take a good thinking sip of water and prove that it is indeed that bad.
 
 [![MFW I realize something's wrong but the slides are already there (clickable)](../../../public/img/posts/2020-08-16-system-programming-in-2k20/carol-knows.png "Carol knows the truth" =100%x)](https://youtu.be/A3AdN7U24iU?t=1822)
 
-Effecitively, the "forever `~> 1`" policy limits the amount of fundamental features Rust MIR can have changed.
+Effectively, the "forever `~> 1`" policy limits the number of fundamental features Rust MIR can have changed.
 According to the talk, only a few keywords are to differ between editions.
 
-So what we have in the dry run is a never-really-changing language with a number of slightly-different dialects to support.
-Occasionally, an implementation would opt-out of supporting an edition, and consequentely all the libraries written in this edition become unusable.
+So what we have in the dry run is a never-really-changing language with some slightly-different dialects to support.
+Occasionally, an implementation would opt-out of supporting an edition, and consequently all the libraries written in this edition become unusable.
 No ecosystem split, huh?
 
 The editions problem could be addressed by supporting multiple editions in a single library.
-But what if a library author you're depending on decides that they will not support a certain edition...
+But what if a library author you're depending on decides that they will not support a specific edition...
 Um.
 
 > [Ever got that feeling of déjà vu?](https://static.wikia.nocookie.net/overwatch_gamepedia/images/c/c0/Tracer_-_Ever_get_that_feeling_of_d%C3%A9j%C3%A0_vu.ogg){.secret-link}
@@ -376,15 +380,15 @@ Oh those lazy open-source, free, OSI-licensed library maintainer bastards, they
 
 For some, programming is just a job.
 
-For others, programming is a form of an artistic expression.
-For artists, writing open-source software facilicates the top two levels of the Maslow's hierarchy: self-actualization and esteem.
+For others, programming is a form of artistic expression.
+For artists, writing open-source software facilitates the top two levels of the Maslow's hierarchy: self-actualization and esteem.
 They enjoy writing clean, well-documented code, so anyone using it could feel the same.
 
-Guess who creates (a big portion of) quality open-source software?
+Guess who creates (a significant portion of) quality open-source software?
 
 ![Us, the artists!](../../../public/img/posts/2020-08-16-system-programming-in-2k20/it-was-me.jpg =100%x)
 
-The above certainly applies to myself.
+The above certainly applies to me.
 
 I used to maintain a [number](https://github.com/vladfaust?tab=repositories&q=&type=&language=crystal) of Crystal projects, most of which were well-documented and optimally performant.
 I enjoyed writing [documentation](http://github.vladfaust.com/mini_redis/index.html) and [compiling changelogs](https://github.com/vladfaust/mini_redis/releases/tag/v0.2.0).
@@ -398,7 +402,7 @@ You can find out more about my journey in programming in the [introductory post]
 
 ### Primitive Needs to Be Ashamed Of
 
-An artist, as any other human, has more needs to satisfy, though.
+An artist, like any other human, has more needs to satisfy, though.
 These are safety and psychological needs.
 In other words, a man gotta pay his bills.
 
@@ -412,45 +416,45 @@ At the best times, my salary as an Open-Source engineer was pathetic $70.
 
 ![Earnings BEFORE TAX](/public/img/posts/2020-08-16-system-programming-in-2k20/patreon-income.png "A Patreon income graph with an extremum of $70" =100%x)
 
-I did receive some "tokens of appreciation" from companies a couple of times, but those were not regular and I could certainly not have a decent living even with them.
+I did receive some "tokens of appreciation" from companies a couple of times, but those were not regular, and I could certainly not have a decent living even with them.
 
-You may argue that it was my fault to choose a young promising language with sweet syntax and native performance to invest my time into, but read this sentence again.
+You may argue that it was my fault to choose a promising young language with sweet syntax and native performance to invest my time in, but reread this sentence.
 
 ----
 
 Is it easy to pay your bills when you're a poet?
 
-Poetry is a fundamental form of art, but only a few, from many talented, poets can make their living doing what they love.
-Given the same talent level, it takes a big luck to become recognized and earn enough to pay rent.
+Poetry is a basic form of art, but only a few, from many talented, poets can make their living doing what they love.
+Given the same talent level, it takes big luck to become recognized and earn enough to pay rent.
 
 Some poets may come to streets and start reciting their poetry, hoping for a dime donated.
-Some are more than happy to be hired by a children book publishing companiy which needs lots of similar poems...
+Some are more than happy to be hired by a children book publishing company which needs lots of similar poems...
 As the individualism fades away.
 
 <!-- TODO: I can't remember a Javascript repository with brilliant sentences like "if you liked the code, maybe check out my patreon 😂😂😂, but if you want 😂😂😂, sorry 😂😂😂". -->
 
-There is a number of paths for an open-source maintainer:
+There are several paths for an open-source maintainer:
 
   1. To spend their time entirely for free.
   1. To spend their time entirely for free, but put a link to their pitiful $0.0002/week Liberapay account, which would inevitably infuriate some Rabadash8820.
-  It is also required to always wrap the links with "😂" emojis and constantly [feel bad](https://clips.twitch.tv/RacyImpossibleTubersWTRuck) about asking to compensate your time.
+  It is also required to always wrap the links with "😂" emojis and constantly [feel bad](https://clips.twitch.tv/RacyImpossibleTubersWTRuck) about asking to compensate for your time.
   The fuck?
   1. To sell their time as a software consultant and provide direct support for their libraries.
   These are often sold under the donations sauce and imply the same shameful constraints.
   1. To choose one of the explicit business model paths, such as open-core, where the product is not an open-source anymore, but a real business with marketing, cold calls, email spam, free trials etc.
 
-Regarding to working for free (paths 1 and 2), I love this quote by myself:
+Regarding working for free (paths 1 and 2), I love this quote by myself:
 
 > Companies rely on those spending their precious time for free in the hope of being hired by those companies.
 > A Saṃsāra's circle to break.
 
 Compared to poetry, the consultancy path (3) is like giving interviews and explaining your poems to others verse-by-verse. Which is not that bad.
 Although sometimes you want to spend your time on writing new poems instead of explaining the old ones.
-Moreover, some precious time has already been put into an old poem, and shall be compensated as well.
+Moreover, some precious time has already been put into an old poem and shall be compensated as well.
 Musicians do not tend to give their already written songs for free, do they?
 
-Regarding to an explicit business path (4), I believe that it has the same consequences for software as for poetry or music.
-An artist starts to think about money more than art, which inevitable leads to worse quality.
+Regarding an explicit business path (4), I believe that it has the same consequences for software as for poetry or music.
+An artist starts to think about money more than art, which inevitably leads to worse quality.
 For example, in the open-core model, a maintainer spends resources on consciously deciding which features are to be deleted from the "open" part, and how to glue them with the paid part.
 
 That being said, are there any other ways to sustain open-source, <mark>to make open-sourcing a _real job_</mark>?
@@ -461,19 +465,19 @@ For musicians, there are platforms like Spotify, where a listener pays a fixed a
 
 Can it be applied to model open-source sustainability?
 
-One of the problems arising is how to determine "popularity" of an open-source library.
-Is that the amount of unique downloads ("launches")?
+One of the problems arising is how to determine the "popularity" of an open-source library.
+Is that the number of unique downloads ("launches")?
 Or maybe some sort of manually-triggered endorsements?
 
 Also, a library may still be useful, but too specific, hence not "popular".
-Its maintainance would still require comparable amount of resources.
+Its maintenance would still require a comparable amount of resources.
 
 The solution may be an algorithm taking into consideration both downloads from, say, unique IP addresses, per month, and manual endorsement actions like claps on Medium.
 Unfortunately, highly-narrowed, hence unpopular, libraries would still have to look for other sources of funding.
 
 Okay, this looks like a good plan.
 But.
-In the music world, an artist becoming obsessed with the amount of streams rather than with the quality of their music, either loses its popularity, or changes trends towards <s>shitty</s> lesser-quality music.
+In the music world, an artist becoming obsessed with the number of streams rather than with the quality of their music, either loses its popularity or changes trends towards <s>shitty</s> lesser-quality music.
 
 ![I don't know who is it](../../../public/img/posts/2020-08-16-system-programming-in-2k20/a-famous-mumbler.jpg "A 6ix9ine photo" =100%x)
 
@@ -482,10 +486,10 @@ Yes.
 A greedy (or lucky) programmer may create a ton of `is-even()`-like libraries to be occasionally present as a dependency in a plethora of libraries.
 Do they deserve to be rewarded?
 Absolutely.
-They do create value recognized by dependants, and this shall be propely rewarded.
-Does it make overall situation worse?
-Yes, because there eventually is a bigger amount of libraries to be aware of and put into dependency lists.
-Generally, the more dependencies there is, [the worse](https://blog.carlmjohnson.net/post/2020/avoid-dependencies/).
+They do create value recognized by dependants, and this shall be properly rewarded.
+Does it make the overall situation worse?
+Yes, because there eventually is a larger amount of libraries to be aware of and put into dependency lists.
+Generally, the more dependencies there are, [the worse](https://blog.carlmjohnson.net/post/2020/avoid-dependencies/).
 
 ::: spoiler A classic meme
 
@@ -500,20 +504,20 @@ It would be unfair to award a single "use" of an `is-even()` library equally to
 How to clearly determine the value then?
 
 I bet on the number of characters in a library's source code, including those commented (because documentation matters) and in binary files.
-As a result, it would be more profitable to release big libraries: a user would likely require only the files they need (making an overall library size irrelevalt to the compilation time), but the algorithm would still count the total amount of lines of code in a library, regardless of which files are required.
+As a result, it would be more profitable to release big libraries: a user would likely require only the files they need (making an overall library size irrelevant to the compilation time), but the algorithm would still count the total amount of lines of code in a library, regardless of which files are required.
 
 One may argue that such a design would encourage Indian-style coding, with lots of repetitions and other crazy practices.
-But libraries are normally designed for re-use and continuous maintainance, which means periodically adding new bugs and removing features.
+But libraries are typically designed for reuse and continuous maintenance, which means periodically adding new bugs and removing features.
 This is not a one-time freelance job.
 
 Even if one decides to go sneaky and publish lots of hardly maintainable code, then, well, they will lose the competition, because they will not be able to maintain the code themselves.
 
 Given a choice, a business shall choose a library whichever is maintained and documented better, and whichever compiles and runs faster.
-This is not about music taste getting worse, when a user would continue listening to whatever <s>shitty</s> low-effort product is released. It is about clearly defined business needs, when compile time and runtime cost actual money.
+This is not about music taste getting worse, when a user would continue listening to whatever <s>shitty</s> low-effort product is released. It is about clearly defined business needs when compile-time and runtime cost actual money.
 
 Moreover, when a maintainer has a decent user base paying the bills, hence reputation, they (a maintainer) would take on security [more seriously](https://qz.com/646467/how-one-programmer-broke-the-internet-by-deleting-a-tiny-piece-of-code/).
 
-<!-- Oh, and manual endorsements should only be made possible from those "paying" customers, so that only actual users of an endorsed library affect its funding. -->
+<!-- Oh, and manual endorsements should only be made possible from those "paying" customers so that only actual users of an endorsed library affect its funding. -->
 
 The model seems win-win to me, at least theoretically.
 I don't know if it would work in reality, but I guess it's worth trying.
@@ -528,11 +532,11 @@ What benefits would the language experience?
 A real market with healthy competition attracts new library authors and incentivizes the old ones to continue maintenance to stay competitive.
 That means more libraries in general and less stale issues.
 
-A rich, constantly growing ecosystem attracts new developers, which in turn implement libraries for their own usage, and maybe occasionaly publish them.
+A rich, constantly growing ecosystem attracts new developers, which in turn implement libraries for their own usage, and maybe occasionally publish them.
 
 <mark>**A healthy competition in the ecosystem frees the language from the backwards compatibility burden.**</mark>
 Once it (the language) introduces a breaking change, it's up to library authors to support the new version.
-If they decide to drop support for a major language version which is in use, other will likely take the spot.
+If they decide to drop support for a major language version which is in use, others will likely take the spot.
 
 Wow.
 Let's try applying the model to existing languages.
@@ -555,30 +559,30 @@ _Not great, not terrible._
 
 Anyway, the only relevant (and alive) projects I could find are [Conan](https://conan.io/), [Buckaroo](https://buckaroo.pm/), [Hunter](https://github.com/cpp-pm/hunter), [VCPKG](https://github.com/Microsoft/vcpkg) and [Pacm](https://sourcey.com/pacm/).
 Neither of which is centralized.
-They all propose to either set up own package server or download packages directly from sources.
+They all propose to either set up their own package server or download packages directly from sources.
 
 But what about observability?
 How does one find C++ packages to use in their projects?
 What I if want, for example, an HTTP server package?
 My variants are either [Googling](https://lmgtfy.com/?q=c%2B%2B+http+server+library), [GitHubbing](https://github.com/search?q=c%2B%2B+http+library), asking on [Reddit](https://www.reddit.com/r/cpp/comments/cjj9t5/what_c_web_server_library_one_should_use_nowadays/), lurk through manually maintainted [lists of libs](https://en.cppreference.com/w/cpp/links/libs)...
-There is definetely a pain to solve!
+There is definitely a pain to solve!
 
 ::: off
 
-While working on this article, I've tried VCPKG, and it's pretty damn good in current stage.
-It has its problems like inability to select a compiler on Windows, or select a compiler in principle, which leads to standard compatibility issues.
+While working on this article, I've tried VCPKG, and it's pretty damn good in the current stage.
+It has its problems like inability to select a compiler on Windows or select a compiler in principle, which leads to standard compatibility issues.
 The latter is more of the loose- C++ -standard issue.
 
 :::
 
-Imagine a shiny new world <s>order</s> with a centralized repository of C++ libraries with good searching features, tags, compatibility information etc!
+Imagine a shiny new world <s>order</s> with a centralized repository of C++ libraries with good searching features, tags, compatibility information etc.!
 
 Would it actually change anything in <s>current government</s> C++?
 I doubt so.
 
 C++ is archaic by itself!
 
-Breaking changes to C++ aren't possible even if there was a centralized on-demand library manager solving the library funding problem.
+Breaking changes to C++ aren't possible even if a centralized on-demand library manager was solving the library funding problem.
 There is no fresh blood in C++, most of the youngsters do not want to bear with poor design the language imposes by itself.
 The amount of time needed to convince Stroustrup-aged C++ committee members to push breaking changes into the ISO-governed standard...
 I don't think it's feasible by any means.
@@ -597,7 +601,7 @@ _Another younger-looking gentleman steps onto the scene._
 
 Ahem.
 As we can see, there is no point in spending time on implementing a C++ package manager, as it would never be standardized (unless you're a Microsoft), hence widely adopted.
-C++ itself would become a history sooner than it happens.
+C++ itself would become history sooner than it happens.
 But you, a reader, can try it for yourself.
 I don't mind.
 
@@ -610,33 +614,33 @@ The ([upcoming](http://smallcultfollowing.com/babysteps/blog/2020/01/09/towards-
 All they need to do is to implement the Algorithm.
 
 With such a platform implemented, Rust the language would be free to introduce breaking changes.
-I'm not sure about whether the editions concept should remain, though.
+I'm not sure about whether the concept of editions should remain, though.
 But anyway.
 
 Even if I, as an individual, manage to implement a crates.io on-demand competitor earlier than the Rust Foundation does, they will inevitably take over, [thanking me](https://keivan.io/the-day-appget-died/) for the beta-test of the idea.
 Therefore, there is no motivation for me to spend time on a crates.io competition.
 
 Moreover, I've already stated above why I don't like the Rust language itself.
-Convincing Rust maintainers to satisfy my complaints in a an already stabilized language is harder than standardizing a new one.
+Convincing Rust maintainers to satisfy my complaints in an already stabilized language is more challenging than standardizing a new one.
 
 #### An Implementation
 
 The same applies for Javascript with [recently РЁРёСЂРѕРєР-acquired NPM](https://github.blog/2020-03-16-npm-is-joining-github/) and my desire for a system programming language rather than... Javascript.
 
 Big guys owning existing centralized package distribution platforms might try solving the Open Source sustainability problem with the source-on-demand model.
-Until then, no smaller company or individual would dare implementing a competitor, and the suffer continues.
+Until then, no smaller company or individual would dare to implement a competitor, and the suffering continues.
 
 But if I were to implement a new system programming language, I'd then have enough power to experiment with the model.
 Plus one point to justifying.
 
 <!-- Is that a monopoly?
-May be it is.
+Maybe it is.
 
-EU headquaters are enraged by Facebook acquiring Instagram, but when a single company owns both GitHub and NPM, which effectively covers 80% of the world's software -- that's alright. -->
+EU headquarters are enraged by Facebook acquiring Instagram, but when a single company owns both GitHub and NPM, which effectively covers 80% of the world's software -- that's alright. -->
 
 ## On Standardization
 
-Wikipedia does a good job at explaining how [standardization affects technology](https://en.wikipedia.org/wiki/Standardization#Effect_on_technology):
+Wikipedia does an excellent job of explaining how [standardization affects technology](https://en.wikipedia.org/wiki/Standardization#Effect_on_technology):
 
 > Increased adoption of a new technology as a result of standardization is important because rival and incompatible approaches competing in the marketplace can slow or even kill the growth of the technology (a state known as market fragmentation).
 > The shift to a modularized architecture as a result of standardization brings increased flexibility, rapid introduction of new products, and the ability to more closely meet individual customer's needs.
@@ -665,7 +669,7 @@ For example, some company may need a compiler for their exotic target.
 
 Take [Zig](https://ziglang.org/).
 Andrew has to work on [supporting many targets](https://ziglang.org/#Wide-range-of-targets-supported) at once.
-Instead, he could delegate the implementation job to someone else and focus on the language specification instead.
+Instead, he could delegate the implementation job to someone else and focus on the language specification.
 This would speed up the maturing process.
 
 ![At first you be like](../../../public/img/posts/2020-08-16-system-programming-in-2k20/andrew-happy.png =100%x)
@@ -677,9 +681,9 @@ This would speed up the maturing process.
 :::
 
 Apart from standardizing the language itself, its ecosystem shall also be standardized, including package management.
-This would <mark>allow competing implementations to remain compatible</mark>, giving a end-user more freedom in choosing of right tooling.
+This would <mark>allow competing implementations to remain compatible</mark>, giving an end-user more freedom in choosing of right tooling.
 
-If I _were_ working on a language, standardization would matter more than implementation for me.
+If I _were_ working on a language, standardization would matter more than an implementation for me.
 
 ## Wrapping up
 
@@ -693,14 +697,14 @@ Creating a new language and applying the source-on-demand model to its canonical
 
 Standardization of the language and its ecosystem implies a greater selection of compatible implementations and tooling for the end-user.
 
-With the language's ecosystem being properly funded, the language itself stays flexible, allowing for breaking changes.
+With the language's ecosystem being adequately funded, the language itself stays flexible, allowing for breaking changes.
 A flexible language stays modern, forever.
 
 Worths a shot, doesn't it?
 
 ## The New Beginnings
 
-Finally, it's the time to proudly announce another language I've come up with, an utopia-grade solution to replace both C++ and Rust once and forever!
+Finally, it's the time to proudly announce another language I've come up with, a utopia-grade solution to replace both C++ and Rust once and forever!
 
 So, what are the goals defined for the new language?
 
@@ -760,4 +764,4 @@ Read more about it in [the Onyx Programming Language](/posts/2020-08-20-the-onyx
 
 In this article, I've come to a conclusion that the world needs (yet) another system programming language with a solid foundation and funding of its ecosystem, which would potentially solve all the existing problems.
 
-I have formulated the goals for the new language and its ecosystem, and even began working on the implementation, which you can read about more in the [next article](/posts/2020-08-20-the-onyx-programming-language).
+I have formulated the goals for the new language and its ecosystem and even began working on the implementation, which you can read about more in the [next article](/posts/2020-08-20-the-onyx-programming-language).
diff --git a/posts/2020-08-20-the-onyx-programming-language.md b/posts/2020-08-20-the-onyx-programming-language.md
index 244b68f..f0fb3bf 100644
--- a/posts/2020-08-20-the-onyx-programming-language.md
+++ b/posts/2020-08-20-the-onyx-programming-language.md
@@ -24,12 +24,12 @@ Onyx is a general-purpose statically typed programming language suitable both fo
 
 Onyx syntax is inspired by **C-family** languages, such as Ruby, C++ and even <s>Rust</s> <small>I'm sorry</small>.
 
-Onyx imposes powerful **inference** mechanisms.
+Onyx imposes robust **inference** mechanisms.
 The rule is generally "infer unless ambiguous", with meaningful defaults.
 
 Onyx is a **memory-safe** language.
 There are multiple levels of enforced safety, with `unsafe` being the minimum safety level allowing for extreme optimizations.
-This opens great opportuinites for powerful abstractions.
+This opens great opportunities for powerful abstractions.
 
 Unlike [_other_](https://www.rust-lang.org/){.secret-link} languages, Onyx treats **pointer arithmetic** as a first-class use-case, but with memory safety.
 The concept is expressed in raw but typed pointers containing a memory scope.
@@ -37,7 +37,7 @@ For example, it is not possible to safely pass a local pointer to an outer scope
 Moreover, pointers preserve low-level features like address spacing and alignment.
 
 It is extremely easy to do **interoperability** in Onyx.
-In fact, Onyx is similar to C++ in this sense: C code is considered a part of the program (with minor differences), and it is simple to export Onyx code as a shared library.
+Onyx is similar to C++ in this sense: C code is considered a part of the program (with minor differences), and it is simple to export Onyx code as a shared library.
 
 Programs written in Onyx are **cross-platform** by default in the sense of that there are no target-dependent features in the language itself: no threading, no memory control.
 But fear not, thanks to powerful abstractions, these are likely to be already implemented by someone else!
@@ -46,17 +46,17 @@ Onyx introduces **powerful macros** written in Lua.
 It allows to re-use existing Lua code and have full access to the compilation context thanks to easy debugging with Lua.
 
 Onyx has **<u>[simple-to-understand](https://twitter.com/vladfaust/status/1299116755596566528){.secret-link}</u> lifetime and moving** concepts naturally built into the language.
-Instead of fighting with a borrow checker, simply get an address of a variable: a compiler would not allow you to mis-use it.
+Instead of fighting with a borrow checker, simply get an address of a variable: a compiler would not allow you to misuse it.
 
 Classes may have a finalizer defined and thus have **automatic resource control**.
 
 Onyx implements real **traits** as [composable units of behaviour](https://en.wikipedia.org/wiki/Trait_(computer_programming)) thanks to powerful function management tools like aliasing, implementation transferring, un-declaring and renaming.
 
-Classes and traits together impose **object-oriented** capatibilites of the language.
+Classes and traits together impose **object-oriented** capabilities of the language.
 
 Onyx has a concept of **generics**.
-Specializations of generic types may have different members, and evaluate delayed macros.
-Specializations of functions with generic arguments may return differnt values and also evaluate delayed macros.
+Specializations of generic types may have different members and evaluate delayed macros.
+Specializations of functions with generic arguments may return different values and also evaluate delayed macros.
 
 Functions may be **overloaded** by arguments and return values.
 
@@ -64,7 +64,7 @@ Onyx has a concept of **annotations**, which may be applied to variables and fun
 
 The language defines a set of now-commonly used **arithmetic types**, including SIMD vectors, matrices and tensors, floating and fixed binary and decimal numbers, brain and tensor floats, ranges and ratios.
 
-Onyx contains a number of **utility types**, such as unions, variants, tuples, anonymous structs, lambdas and runnable blocks of code.
+Onyx contains several **utility types**, such as unions, variants, tuples, anonymous structs, lambdas and runnable blocks of code.
 
 Exceptions are designed to be truly **zero-cost** to enable exception flow in Onyx programs.
 
@@ -91,41 +91,41 @@ In the example, a C header named `"stdio.h"` was imported into the Onyx program.
 Now Onyx is aware of assembly functions declared by this header.
 
 Later on, one of these functions, `puts` is called directly from Onyx.
-An Onyx compiler can not give any safety guarantees in regard to called assembly functions, therefore the call must be wrapped in an `unsafe!` statement.
+An Onyx compiler can not give any safety guarantees about called assembly functions. Therefore the call must be wrapped in an `unsafe!` statement.
 
 If something weird happens, a developer may simply `grep` the program source code for `unsafe!` statement to quickly narrow to potentially hazardous areas of code.
 
 Imported entities are referenced with preceding `$` symbol to distinguish them from those declared in Onyx context.
 
-A constant named `msg` is defined by the `final` statement.
+The `final` statement defines a constant named `msg`.
 The type of `msg` is inferred to be `String<UTF8, 14>`, i.e. a [UTF-8](https://en.wikipedia.org/wiki/UTF-8)-encoded array of [code units](https://en.wikipedia.org/wiki/Code_unit) containing 14 elements.
 
-Then, address of the `msg` constant is taken.
+Then, the address of the `msg` constant is taken.
 The resulting object of taking an address would be `String<UTF8, 14>*lr0`, which is a shortcut to `Pointer<Type: String<UTF8, 14>, Scope: :local, Readable: true, Writeable: false, Space: 0>`.
 
 Do not be intimidated, though!
-Thanks to inference, shortucts and meaningful defaults, you'll rarely have to use full types.
+Thanks to inference, shortcuts and meaningful defaults, you'll rarely have to use full types.
 
 The pointer to `msg` is then coerced to C type `char*`.
-Such a coercion would be unsafe, and a compiler would normally panic.
+Such coercion would be unsafe, and a compiler would typically panic.
 
-However, the coercion is already within unsafe context itself thanks to the wrapping `unsafe!` statement.
+However, the coercion is already within the unsafe context itself thanks to the wrapping `unsafe!` statement.
 No need to write `unsafe!` again.
 
 The program above is normally compiled by an Onyx compiler, such as [`fnxc`](https://github.com/fancysofthq/fnxc), into an object file.
-The object file declares the exported `int main(void)` prototype, which must be pointed to at as a entry function by a system linker.
+The object file declares the exported `int main(void)` prototype, which must be pointed to at as an entry function by a system linker.
 Thankfully, this tedious operation is likely to be automatically handled by a higher-level build tool, such as [`fnx`](https://github.com/fancysofthq/fnx).
 
 Note that Onyx does not have any implicit `__onyx_main` function, which effectively restricts non-trivial automatic static variable initialization and finalization.
-But in return it makes the emitted code predictable and portable.
+But in return, it makes the emitted code predictable and portable.
 
 #### Using a standard library
 
 An Onyx compiler is not required to implement any sort of OS-specific standard library.
 Instead, the standard library Standard is specified elsewhere (spoiler alert: by [the Onyx Software Foundation](#the-onyx-software-foundation)).
 
-A standard library is ought to be used as a common package and required as any other from your code.
-Again, by default an Onyx program does not depend on any OS-specific features.
+A standard library ought to be used as a typical package and required like any other from your code.
+Again, by default, an Onyx program does not depend on any OS-specific features.
 
 The example above could be abstracted into this when using a standard library implementation:
 
@@ -144,10 +144,10 @@ export void main() {
 ```
 
 Now, the code is perfectly safe.
-Even passing of `&msg` is allowed, because `Std.puts` has an overload accepting a `String*cr`, i.e. a read-only pointer with _caller_ scope, and a pointer with _local_ scope may be safely cast to to _caller_ scope upon passing to a function!
+Even passing of `&msg` is allowed, because `Std.puts` has an overload accepting a `String*cr`, i.e. a read-only pointer with _caller_ scope, and a pointer with _local_ scope may be safely cast to _caller_ scope upon passing to a function!
 
 Also note that `msg` is now a variable, as it is defined with `let` statement.
-Taking address of `msg` would return `String<UTF8, 14>*lrw0`.
+Taking the address of `msg` would return `String<UTF8, 14>*lrw0`.
 Notice the `w` part?
 The pointer is now writeable.
 And it is perfectly legit to pass a writeable pointer as a read-only argument: it would be coerced down to a read-only pointer within the callee.
@@ -155,12 +155,12 @@ And it is perfectly legit to pass a writeable pointer as a read-only argument: i
 #### Exceptions
 
 We had to wrap the `Std.puts` call into the `try` block, as it could throw some system exception.
-The cause is that an `export`ed function must guarantee to never throw an exception, that's why we wrapped it.
+The cause is that an `export`ed function must guarantee never to throw an exception, that's why we wrapped it.
 The `Std.exit` function is declared as `nothrow`, so we can leave it as-is.
 
 But what if we wanted to inspect the backtrace of the possible exception?
 Well, the language Standard states that a backtrace object must implement `Endful<Location>` trait.
-This is a truncated source code of the trait:
+This is truncated source code of the trait:
 
 ```text
 struct Location
@@ -312,14 +312,14 @@ Now we can inspect the exception backtrace!
 
 #### An HTTP server example
 
-It is considred a good tone to demonstrate on how to build a simple echoing HTTP web server in your language.
+It is considered a good tone to demonstrate how to build a simple echoing HTTP web server in your language.
 This would also be my "sorry" for the big-ass `Stack` implementation above.
 
 The thing is that running a web server is architecturally different on different target platforms.
 An implementation on Linux could make use of raw sockets, an implementation on Windows could make use of the win32 `"http.h"` header etc.
 
 Therefore, the standard library would not contain a web server implementation.
-Instead, some third-party package should be used, which would inevitably be a plenty of!
+Instead, some third-party package should be used, which would inevitably be plenty of!
 
 Let's imagine we've found one satisfying our needs.
 That's how it could look like:
@@ -362,7 +362,7 @@ export int main () {
 }
 ```
 
-Thanks to powerful abstractions and type inference, you won't need to manualy use `socket` each time you want to spin up a web server on Linux!
+Thanks to powerful abstractions and type inference, you won't need to manually use `socket` each time you want to spin up a web server on Linux!
 
 Oh, by the way, did you notice the `\@{{ e }}` thing?
 It was me, <s>Dio</s> macro!
@@ -370,10 +370,10 @@ It was me, <s>Dio</s> macro!
 #### Macros
 
 A fundamental feature of Onyx is macros.
-Macro is basically a Lua code generating Onyx code (or another macro code).
+Macro is a Lua code generating Onyx code (or another macro code).
 Yes, recursive macros are allowed, but more on that later.
 
-Let's examine a very simple macro example.
+Let's examine a straightforward macro example.
 
 ```text
 import "stdio.h"
@@ -403,14 +403,14 @@ This is a fully-fledged dynamic language, right within your compilation context.
 Think of reading and parsing files during compilation, accessing system configuration...
 The possibilities are endless.
 
-You may concern about safety of macros.
+You may concern about the safety of macros.
 Well, yes, you have to trust the code you run.
 You do trust C libraries you link to your programs, right?
 
 However, you won't trust an NPM package, because an NPM package author does not care about their reputation, and because NPM does not have auditing features.
 This is the Open-Source sustainability problem addresses in the [previous article]((/posts/2020-08-16-system-programming-in-2k20)) and potentially solved by the aforementioned [Onyx Software Foundation](#the-onyx-software-foundation).
 
-As a result, given that you do have access to code you require, authors of packages your program depends on are properly rewarded for their work, and the Foundation sponsors audition of selected packages, you should be safe.
+As a result, given that you do have access to code you require, authors of packages your program depends on are appropriately rewarded for their work, and the Foundation sponsors audition of selected packages, you should be safe.
 
 ----
 
@@ -419,7 +419,7 @@ Macro use-cases include:
 
 ::: hero
 
-**Delegating computations to compile time**
+**Delegating computations to compile-time**
 
 :::
 
@@ -715,7 +715,7 @@ This means that you can debug your compilation, even with breakpoints from an ID
     @assert(@sizeof(c) == 4)
     ```
 
-  * Distinct aliasing allows to have a type with different methods, but the same layout.
+  * Distinct aliasing allows having a type with different methods, but the same layout.
   For example, the `String` type is a distinct alias to an array of codeunits:
 
     ```text
@@ -731,21 +731,21 @@ This means that you can debug your compilation, even with breakpoints from an ID
 
 ----
 
-I could continue digging into Onyx features and examples, but for an introductory post that should be enough.
+I could continue digging into Onyx features and examples, but for an introductory post, that should be enough.
 
-However, a good language by itself is only a half successfull endeavour.
-Any new language needs a good foundation ensuring growth of its ecosystem.
+However, a good language by itself is only a half successful endeavour.
+Any new language needs a good foundation, ensuring the growth of its ecosystem.
 This is where the Onyx Software Foundation comes into play.
 
 ## The Onyx Software Foundation
 
-The Onyx Software Foundation (NXSF) is to be an official 501 \(c\) non-profit organization, so donations made to it are tax-excemptive.
+The Onyx Software Foundation (NXSF) is to be an official 501 \(c\) non-profit organization, so donations made to it are tax-exemptive.
 
 All NXSF processes are going to be transparent and open.
 
 ### Standards
 
-The Foundation will be governing a number of major and auxillary standard specifications related to Onyx:
+The Foundation will be governing several major and auxiliary standard specifications related to Onyx:
 
   1. [The Onyx Programming Language Specification](https://github.com/nxsf/onyx).
   The specification includes the following:
@@ -770,7 +770,7 @@ The Foundation will be governing a number of major and auxillary standard specif
   This includes versioning algorithms and, for example, requiring third-party auditions.
 
   1. The Onyx Compiler Interface Specification.
-  So different compiler implementations had unified interface to interact with, using DSON.
+  So different compiler implementations had a unified interface to interact with, using DSON.
 
   1. [Dead-Simple Object Notation (DSON) Specification](https://github.com/nxsf/dson).
   This format is intended to be used in CLI to describe complex object structures.
@@ -778,8 +778,8 @@ The Foundation will be governing a number of major and auxillary standard specif
   1. [DSON Schema Specification.](https://github.com/nxsf/dson-schema)
   The standard to describe objects in DSON.
 
-Standardization process will be official, with responsible committees consiting of community-elected members called _community champions_, and businesses sponsoring the Foundation.
-The votes will be split evenly between community and businesses to fairly represent both sides.
+Standardization process will be official, with responsible committees consisting of community-elected members called _community champions_, and businesses sponsoring the Foundation.
+The votes will be split evenly between community and businesses to represent both sides fairly.
 
 ### Package Hosting
 
@@ -799,8 +799,8 @@ Apart from funding packages, the Foundation will sponsor projects and events rel
 
 Onyx is the perfect balance between productivity and performance, a language understandable well both by humans and machines.
 
-Thanks to powerful abstraction mechanisms and inference, the areas of appliance are truly endless.
-I heartfully believe that Onyx may be that new lingua franca for decades until the humanity learns to transfer thoughts directly into machines.
+Thanks to powerful abstraction mechanisms and inference, the areas of the appliance are truly endless.
+I heartfully believe that Onyx may be that new lingua franca for decades until humanity learns to transfer thoughts directly into machines.
 
 Follow [NXSF](https://nxsf.org) to stay updated, and...
 
@@ -814,4 +814,4 @@ Follow [NXSF](https://nxsf.org) to stay updated, and...
 
 ----
 
-P.S: Until the Foundation is officialy established, you may consider [sponsoring me directly]().
+P.S: Until the Foundation is officially established, you may consider [sponsoring me directly](/posts/2020-08-27-sponsoring-onyx/).
diff --git a/posts/2020-08-27-sponsoring-onyx.md b/posts/2020-08-27-sponsoring-onyx.md
index 741b070..bb500b2 100644
--- a/posts/2020-08-27-sponsoring-onyx.md
+++ b/posts/2020-08-27-sponsoring-onyx.md
@@ -23,23 +23,23 @@ ${toc}
 
 I've been working on the [Onyx programming language](/posts/2020-08-20-the-onyx-programming-language) full-time for the past year.
 The work includes standardization and implementation.
-The process is _near to completion_, and there is a solid chance for you to write your name in history.
+The process is _near to completion_, and there is a substantial chance for you to write your name in history.
 
 In this post, I'll try to justify my eager will to grab your money with some proof of work.
 
-By the way, I assume you've read my recent [post on System Programming](/posts/2019-08-16-system-programming-in-2k20), there is a [section](/posts/2019-08-16-system-programming-in-2k20/#on-open-source-sustainability) regarding to the open-source sustainability; as long as all my work is open, I'm also, um, an open-source engineer and thus need finanical support.
+By the way, I assume you've read my recent [post on System Programming](/posts/2019-08-16-system-programming-in-2k20), there is a [section](/posts/2019-08-16-system-programming-in-2k20/#on-open-source-sustainability) regarding to the open-source sustainability; as long as all my work is open, I'm also, um, an open-source engineer and thus need financial support.
 
 ## Deeds Already Done
 
-The onyxlang.com domain name was registered at June 20^th^ 2019.
-As I have a sin of registering domains as soon as I have a solid idea, the day may be treated as the Onyx birth day.
+The onyxlang.com domain name was registered on June 20^th^ 2019.
+As I have a sin of registering domains as soon as I have a solid idea, the day may be treated as the Onyx birthday.
 
 Today is August 27^th^ 2020, and I've already spent a plethora of time on Onyx.
 You can see it for yourself in [NXSF](https://github.com/nxsf) and [FancySoft](https://github.com/fancysofthq) organization repositories!
 
 ### Tracked Time
 
-From June 20^th^ 2019 until August 27^th^ 2020, this is the total time I've spent on *coding* Onyx specificaiton, reference(s) and implementation(s):
+From June 20^th^ 2019 until August 27^th^ 2020, this is the total time I've spent on *coding* Onyx specification, reference(s) and implementation(s):
 
 ::: hero
 
@@ -47,7 +47,7 @@ From June 20^th^ 2019 until August 27^th^ 2020, this is the total time I've spen
 
 :::
 
-I've had hard _time_ on maintaining a single project across machines, so there is a lots of them (projects).
+I've had hard _time_ on maintaining a single project across machines, so there is a lot of them (projects).
 You may click on a project's name to see a detailed timing per file.
 
 _Due to WakaTime limitations, I have to split the periods._
@@ -98,9 +98,9 @@ In fact, implementing before giving a good thought may lead to [tragic results](
 
 ![[Shower](https://www.reddit.com/r/Showerthoughts/) is the general sponsor of Onyx](../../../public/img/posts/2020-08-27-sponsoring-onyx/thinking-meme.jpg "A 'programming is mostly thinking' meme" =60%x)
 
-I've destroyed a number of notebooks while deciding on either using `do` / `end` or tabs.
+I've destroyed several notebooks while deciding on either using `do` / `end` or tabs.
 <small>There has been a double of them throughout the year, but who's gonna believe in it?</small>
-Would you dare to calculate the amount of sleepless hours I've spent on _thinking_?
+Would you dare to calculate the number of sleepless hours I've spent on _thinking_?
 
 ![](../../../public/img/posts/2020-08-27-sponsoring-onyx/some-notebooks-1.png "A pile of three notebooks" =49%x)
 ![](../../../public/img/posts/2020-08-27-sponsoring-onyx/some-notebooks-2.png "Contents of one of the notebooks" =49%x)
@@ -121,9 +121,9 @@ Would you dare to calculate the amount of sleepless hours I've spent on _thinkin
 
 ## Sponsoring the Development
 
-So, the idea is simple: I want to be able to pay my bills while working on a thing both I enjoy working on and being useful for the humanity.
+So, the idea is simple: I want to be able to pay my bills while working on a thing both I enjoy working on and being useful for humanity.
 
-Later on, I'm planning to make [NXSF](https://nxsf.org) an official 501 \(c\) non-profit organization, so donations made to it would be tax-excemptive, and I will have an official salary (_finally!_).
+Later on, I'm planning to make [NXSF](https://nxsf.org) an official 501 \(c\) non-profit organization, so donations made to it would be tax-exemptive, and I will have an official salary (_finally!_).
 However, this would only happen when the language moves to the alpha stage (see the roadmap).
 
 Right now, Onyx is in the pre-alpha stage.
@@ -133,33 +133,33 @@ Nothing is publicly stable, work-in-progress etcetera.
 
 Note that theoretically I could've tried applying to Open Collective right now, but:
 
-  1. It implies free-will donations, but what I'm proposing here is clearly a purchase of placement in history;
+  1. It implies free-will donations, but what I'm proposing here is clearly purchase of placement in history;
 
   1. I don't think Onyx is currently "popular" enough;
 
-  1. They take **huge** comissions.
+  1. They take **huge** commissions.
 
 :::
 
 ----
 
 But I still need to pay my bills.
-And as I haven't got a real job for a long, long time, my financial cushion is quite thin.
+And as I haven't got a real job for a long, long time, my financial cushion is relatively thin.
 
-As a copyright holder, I'm planning on licensing the Onyx Standard Specification and auxilliary standards with a free, open-source license requiring an attribution.
+As a copyright holder, I'm planning on licensing the Onyx Standard Specification and auxiliary standards with a free, open-source license requiring attribution.
 
 Therefore, I can offer you, a potential sponsor, a **perpetual**\* attribution in the standards I'll be working on during the pre-alpha development stage.
 Your name or company logo with an optional link would be put into according "early contributors" sections of the standards.
 
 \* As long as my attribution is required.
-For example, if a standard is rewritten from scratch by an NXSF committee without infriging my patent rights, it then stops being a derivation of my work.
+For example, if a standard is rewritten from scratch by an NXSF committee without infringing my patent rights, it then stops being a derivation of my work.
 
 ### The Dark Scheme
 
 First of all, what I'm proposing is not a _donation_.
 It is a _purchase_ of placement in my attribution texts, a _sponsorship contribution_.
 
-Of course, you're free to pitch your ideas informally, but you will not have any voting rights in the standards development with this sponsorhsip.
+Of course, you're free to pitch your ideas informally, but you will not have any voting rights in the standards development with this sponsorship.
 
 ----
 
@@ -179,14 +179,14 @@ There are three sponsorship tiers:
 I want to incentivize early contributions, so the <s>pyramind</s> scheme is as follows.
 
 I learned the hard way that estimating time on completing such a big project as a <big>language specification</big> is _quite_ hard.
-Nonetheless, I'm planning moving on to the alpha stage in **3-6 months** from today (August 27^th^ 2020).
+Nonetheless, I'm planning to move on to the alpha stage in **3-6 months** from today (August 27^th^ 2020).
 
-The eariler you contribute, the more belief you have in me, the more you shall be rewarded.
+The earlier you contribute, the more belief you have in me, the more you shall be rewarded.
 And higher reward means higher placement in the contributors list!
 
 The placement of your attribution depends on your _contribution score_, which is based on the amount you've contributed.
-Each month from today until the alpha stage the score multiplier is reduced proportionally.
-The multiplier stays the same for you throghout the months if you contribute sequantially, i.e. without cancellations.
+Each month from today until the alpha stage, the score multiplier is reduced proportionally.
+The multiplier stays the same for you throughout the months if you contribute sequentially, i.e. without cancellations.
 
 ::: spoiler An example
 
@@ -217,9 +217,9 @@ In case of argument, the day a contribution was made matters: making a contribut
 
 
 Note that to be actually listed in the contributors list, you have to contribute the minimum corresponding sponsorship tier amount **at least once** during the pre-alpha stage.
-For example, even if you're continiously sponsoring with $24 per month, but never contributed $25+, your name will not be listed.
+For example, even if you're continuously sponsoring with $24 per month, but never contributed $25+, your name will not be listed.
 
-Also note that individual tier contributors are listed separately from business tier contributors.
+Also, note that individual tier contributors are listed separately from business tier contributors.
 
 ### My Soundcloud
 
@@ -228,7 +228,7 @@ Neither is preferred, choose whichever you like most.
 I'm not planning on creating paid posts etc.
 The difference is that BMC only has a single tier, but allows one-time contributions, which are counted as well.
 
-Direct Bitcoin donations are also accepted, but they are not eligeble for listing.
+Direct Bitcoin donations are also accepted, but they are not eligible for listing.
 
 ### Everlasting Dev
 
@@ -236,8 +236,8 @@ I want to assure you that I have no long-term plans on living on these sponsorsh
 I'm neither a [YandereDev](https://knowyourmeme.com/memes/people/yanderedev) nor some [Alex Medvednikov](https://vlang.io/).
 The sponsorship opportunity is in effect exclusively during the pre-alpha stage.
 
-Once the Foundation is established, you'll be guided to put your money there instead in form of donations.
-This implies tax excemption and voting rights.
+Once the Foundation is established, you'll be guided to put your money there instead, in the form of donations.
+This implies tax exemption and voting rights.
 
 [Fancy Software LLC](https://fancysoft.xyz) is a for-profit company and I as no other else want Onyx to be complete, so I can start working on my premium packages, self-hosted, gaming and AI products.
 No Patreon sponsorship or non-profit salary can buy me a house.
@@ -246,8 +246,8 @@ No Patreon sponsorship or non-profit salary can buy me a house.
 
 ----
 
-Until then, I want to be able to pay my bills and may be purchase a newer graphics card.
-In return, you get a chance to be immortalized as a visioner invested in better future.
+Until then, I want to be able to pay my bills and maybe purchase a newer graphics card.
+In return, you get a chance to be immortalized as a visioner invested in a better future.
 
 Follow me on [Twitter](https://twitter.com/vladfaust) and [GitHub](https://github.com/vladfaust), and also follow [NXSF](https://nxsf.org/) and [FancySoft](https://fancysoft.xyz/) to stay updated about the progress made.