incorportaing @craftloops notes, they've been awesome

Author: shnewto

_drafts/2017-rust-impl-period.md

@@ -10,66 +10,71 @@ path: 2017/rust-impl-period
 
 The [Rust programming language](https://www.rust-lang.org) is a self-declared
 "systems programming language that runs blazingly fast, prevents segfaults, and
-guarantees thread safety." It's 
+guarantees thread safety." Its
 [impl period](https://internals.rust-lang.org/t/the-final-impl-period-newsletter/6408)
 is a sort of seasonal community Rust project, or organization of projects.
 To paraphrase [Aaron Turon](https://internals.rust-lang.org/t/announcing-the-impl-period-sep-18-dec-17/5676),
 it is a time for the Rust community to come together to focus on implemenation 
 work rather than design/RFC work. 
 
-I've been lucky enough to have had the opportunity learn Rust in order to write
-it at work over the last year or so. [PolySync](https://polysync.io/) is
+I've been lucky enough to have had the opportunity to learn Rust in order to write
+it at work at [PolySync](https://polysync.io/) over the last year or so. 
+[PolySync](https://polysync.io/)'s
 [a friend of Rust](https://www.rust-lang.org/en-US/friends.html) and we've been
 moving from _using_ Rust to _favoring_ it. My experience with the language at
-work drove me to explore the ecosystem on my own and to eventually to write
-Rust for myself, outside of work. I recently published a crate I'm reasonably 
-proud of called [bnf](https://crates.io/crates/bnf), a library for parsing 
-Backus–Naur form context-free grammars. I also recently participated in
- _the impl period_, something I'm reasonably proud of as well.
+work drove me to explore the ecosystem independently and to eventually to write
+Rust for myself, outside of work. I'm reasonably
+proud of a recently published crate [bnf](https://crates.io/crates/bnf), a library for parsing 
+Backus–Naur form context-free grammars. Participating in the
+ _the impl period_ is something I'm reasonably proud of as well.
 
 ## A quickchecking crate
 
 My part in Rust's _the impl period_ project was work for
 [bindgen](https://github.com/rust-lang-nursery/rust-bindgen), a tool that makes
 life better for Rust developers that need to use C or C++ by automatically 
-genertating bindings to existing libraries. It's something I'd used in the 
+generating bindings to existing libraries. It's something I'd used in the 
 past for exactly that, writing Rust code that interfaces with existing C. 
 It did everything it promised and I'm incredibly glad it's in the ecosystem.
 
-Though I didn't directly touch any of _bindgen's_ functionality, the work I 
-did will hopefully help contribute to its growth. I took on the call to 
-[add property based testing with quickcheck](https://github.com/rust-lang-nursery/rust-bindgen/issues/970).
-For anyone unfamiliar, some of the power of property testing might be boiled 
-down to it's efficiency in testing an exahustive set of inputs. One property test 
+Though not directly affecting any of _bindgen's_ functionality, the 
+[quickchecking crate](https://github.com/rust-lang-nursery/rust-bindgen/tree/master/tests/quickchecking)
+written to tackle the
+_[Add property based testing with quickcheck](https://github.com/rust-lang-nursery/rust-bindgen/issues/970)_ 
+issue will hopefully help contribute to its growth.
+Some of the power of property testing might be boiled 
+down to its efficiency in testing an exhaustive set of inputs. One property test 
 has the potential to excercise what in other paradigms, often requires an 
 impractical or even impossible number of individual tests. 
 [quickcheck](https://github.com/BurntSushi/quickcheck) is a Rust package that 
 enables writing property tests 
 (in the vein of [the original QuickCheck written in Haskell](https://en.wikipedia.org/wiki/QuickCheck)) 
 for Rust projects.
 
-My contributions were the following PRs:
+My contributions were captured by the following pull requests made to the 
+[rust-lang-nursery/rust-bindgen](https://github.com/rust-lang-nursery/rust-bindgen) 
+GitHub repository:
 
 * [Property testing with quickcheck](https://github.com/rust-lang-nursery/rust-bindgen/pull/1159)
 * [Quickchecking crate CLI](https://github.com/rust-lang-nursery/rust-bindgen/pull/1177)
 * [Enable Cargo features for quickchecking crate](https://github.com/rust-lang-nursery/rust-bindgen/pull/1180)
 
-I count my experience as a success. Not because I was able to see three PRs 
-merged and the corresponding issues closed but becasue I was noticed by 
-[@steveklabnik](https://twitter.com/steveklabnik) (haha who does a pretty damn good
-job summing up the work I did with, "bindgen uses quickcheck to generate random 
-c header files and then tries to parse them".). 
+I count my experience as a success. Mostly because three PRs were
+merged and the corresponding issues closed and a little bit because the 
+crate was noticed by [@steveklabnik](https://twitter.com/steveklabnik) 
+(who does a pretty damn good job summing up its function, "bindgen uses 
+quickcheck to generate random c header files and then tries to parse them".). 
 
 <blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">bindgen uses quickcheck to generate random c header files and then tries to parse them <a href="https://t.co/HYftqPra7L">https://t.co/HYftqPra7L</a></p>&mdash; Some(@steveklabnik) (@steveklabnik) <a href="https://twitter.com/steveklabnik/status/939238891118350337?ref_src=twsrc%5Etfw">December 8, 2017</a></blockquote>
 <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
 
 Check [this gist](https://gist.github.com/snewt/1b0ca76207139681d98b4d709b8c09ed) 
 for a peek into what a couple randomly generated C headers look like.
 
-While I wasn't able to meet the goal of uncovering 
+While unable to meet the goal of uncovering 
 ["many hidden issues via fuzzing"](https://paper.dropbox.com/doc/bindgen-xTXplHlfqJpnDvPhMqmfW), the 
 [quickchecking crate](https://github.com/rust-lang-nursery/rust-bindgen/tree/master/tests/quickchecking) 
-has caught [one new bug](https://github.com/rust-lang-nursery/rust-bindgen/issues/1153), 
+has caught [one new bug](https://github.com/rust-lang-nursery/rust-bindgen/issues/1153)
 and is able to regularly catch a couple others, 
 [#550](https://github.com/rust-lang-nursery/rust-bindgen/issues/550)
 and [#684](https://github.com/rust-lang-nursery/rust-bindgen/issues/684). To me
@@ -88,31 +93,31 @@ that went right that may be out of the ordinary.
 
 * I live in Portland, OR where [the sponsor of the Rust project](https://research.mozilla.org/rust/) Mozilla has a presence.
 
-* I was able to go to an impl period Meetup and pick [@fitzgen](https://github.com/fitzgen)'s brain in person, the impl period's [bindgen](https://github.com/rust-lang-nursery/rust-bindgen) project lead.
+* There was an impl period Meetup nearby where I was able to pick [@fitzgen](https://github.com/fitzgen)'s brain in person, the impl period's [bindgen](https://github.com/rust-lang-nursery/rust-bindgen) project lead.
 
 It's also worth noting the things that I expect apply more generally.
 
-* The presence of a Gitter channel influenced my decision to contribute. I didn't actually use it much but it allowed me to wave, say hi and get a wave back. It was some human interaction that helped reinforce that my work would be seen and that if I did need somthing, it would be there.
+* The presence of [a Gitter channel](https://gitter.im/rust-impl-period/WG-dev-tools-bindgen) influenced the decision to contribute. While I didn't actually use it much, it allowed me to wave, say hi and get a wave back. It was some human interaction that helped reinforce that my work would be seen and that if I did need something, it would be there.
 
 * I loved the newsletters.
 
-* I went to an impl period Meetup and my engagement with the Rust community was enormously positive. 
+* My engagement with the Rust community was enormously positive. 
 
-* The impl period documentation was really, really great. The volume of it all was a bit daunting at first but I ended up appreciating that I was able to browse until something felt right. I was able to settle on a problem that sounded interesing to me and represented a chance to learn.
+* The impl period documentation was really, really great. The volume of it all was a bit daunting at first but ended up allowing me to browse until something felt right. I was able to settle on a problem that sounded interesting and represented a chance to learn.
 
-* When I took on the project I had a clear idea of how to tackle it and that clear idea was __completely__ misguided. Mapping out a new solution and implementing it really scratched the itch.
+* When I took on the project it was with a clear idea of how to tackle it and that clear idea was __completely__ misguided. Mapping out a new solution and implementing it really scratched the itch.
 
 
-I had a fantastic time participating and I hope the impl period is an every year 
-thing. I also feel like I genuinely leveled up as a Rust developer, in some part 
-because I had a new problem to solve but largely because of the incredibly 
-thourough and thoughtful feedback I got from 
+Participating was a fantastic experience, I hope the impl period is an every year 
+thing. It provided a feeling of genuinely leveling up as a Rust developer, 
+in some part because it was a new problem to solve but largely because of the incredibly 
+thorough and thoughtful feedback from 
 [@fitzgen](https://github.com/fitzgen) who reviewed my PRs.
 
 For more info on implementation details I'll probably do a follow up 
-post, but in the meantime, if you're interested in knowing more about it I'll 
-recommend checking out the conversations in the PRs linked to above or 
-reaching out on Twitter, I'm [@shnewto](https://twitter.com/shnewto). 
+post, but in the meantime, if you're interested in knowing more about it check out 
+the conversations in the PRs linked to above or 
+reaching out on Twitter, [@shnewto](https://twitter.com/shnewto). 
 
 I'd like to offer a really enthusiastic thank you to the Rust community and 
 everyone involved in organizing and running the impl period for 2017. I'm glad 

posts/2017-cobalt-and-now.md

@@ -24,55 +24,55 @@ areas that I don't have much experience. That part of me won out.
 
 I've had some positive experiences with [Hugo](https://gohugo.io/) which made a
 lot of the work seem
-approachable but I wanted to explore alternative options, namely what Rust had
+approachable but wanted to explore alternative options, namely what Rust had
 to offer in the arena. A quick browser search for "static site generator rust"
 turns up a handful of options, but out of those, two seemed especially
-suited to what I was interested in.
+suited to the task.
 [Gutenberg](https://github.com/Keats/gutenberg) and
 [cobalt.rs](https://github.com/cobalt-org/cobalt.rs).
 
 ### Decisions
 The docs for both seemed approachable so I felt optimistic that either choice
 would be manageable with effort. Because my experience is especially slim in
 design, my choice ultimately came down to finding an existing site built with
-either of the tools that had an aesthetic I liked and could pull from.
+either of the tools that had a relatable aesthetic to pull from.
 
 [Matthias Endler's blog](https://matthias-endler.de/) sold me, it's beautiful.
 Walking through [that code base](https://github.com/mre/mre.github.io) was a
 fantastic tutorial on using cobalt.rs and _this_ site, especially
 my CSS, leans pretty heavily on what I learned there.
 
 ### Lessons
-Initially I didn't appreciate the `.md` and `.liquid` interchangeability. My
+Initially I didn't appreciate the `.md` and `.liquid` interchangeability. The
 first pass only used Markdown but then I wanted to incorporate styling... That's
 where the `.liquid` extension comes in! It lets you incorporate raw HTML,
 and all the power that comes with it, into any page (which in my mind is magical
-CSS and JavaScript ha). I love that I'm not constrained to Markdown but have it
+CSS and JavaScript ha). I love that not being constrained to Markdown but having it
 in the toolbox.
 
 ### It's built, now what?
-Okay, I dug in, hacked some CSS, learned what I could and couldn't do with
+Okay, I dug in, hacked some CSS, learned what was and wasn't possible with
 Markdown, fought the urge to duplicate the `.liquid` files in the `_layouts`
 directory without gaining anything from it and finally had something I thought
 I could run with.
 But now what? I've been getting paid to write software
 for a few years now and I've never had to learn or cemented how to go from local
 files to a live website. 🙃. Where does all that happen? Do I need a _hosting_
 account?
-Which one? I've heard the words _Digital Ocean droplet_, that's probably
-something... Then I remembered a video I'd been recommended by a friend ages
+Which one? The words _Digital Ocean droplet_, probably mean
+something... Then a memory surfaced of video I'd been recommended by a friend ages
 ago on [now & next](https://www.youtube.com/watch?v=__b6k2pR3Tg&t=5s),
 Node.js packages that I didn't really have an application for
-at the time. I thought I'd try it out. And damn, `now` is a super power.
+at the time. I tried it out and damn, `now` is a super power.
 
 Here were the steps I took to get my blog up and running during development:
 1. Install [now](https://zeit.co/download#now-cli).
 1. What does `now -h` give me? Ah `deploy` seems promising.
 1. Build the side with `cobalt build`
 1. `now deploy _site`? Bam! Live website with a generated URL.
 
-Totally, totally, sold, I ended up springing for the step above free account
-so I could associate my custom domains with the deploys and also support
+Totally, totally, sold, I ended up springing for the step above a free account to 
+associate custom domains with the deploys and also support
 something that blew my mind.
 
 ### Final thoughts

posts/2017-embedded-elm.liquid

@@ -10,13 +10,13 @@ path: 2017/embedded-elm
 <p>
 I've been interested in dipping my toes into the Elm language for some time
 and also, curious about whether it was possible / reasonable to integrate
-something I wrote in Elm into the Cobaly tooling used to generate this blog.
+something written in Elm into the Cobalt tooling used to generate this blog.
 <br><br>
 Integration was trivial so major points to Cobalt. After generating the 
-JavaScript (<i>elm-make Bob.elm --output=embedded-elm.js</i>), I was
-able to use raw HTML in this post's <i>.liquid</i> file to embed that
-script like any other <i>.js</i> file... Or almost. This post's window into Elm
-is accomplished as follows:
+JavaScript (<i>elm-make Bob.elm --output=embedded-elm.js</i>), it was 
+embedded script like any other <i>.js</i> file in the raw HTML of this 
+post's <i>.liquid</i> file... Or almost. The HTML + Elm was accomplished 
+as follows:
 
 <pre>
 <code>&lt;head&gt;
@@ -31,22 +31,21 @@ is accomplished as follows:
 
 <br><br>
 Learning enough Elm to make something happen was the difficulty. I love
-language learning tooling like <a href="http://exercism.io">exercism.io</a> so I started there.
+language learning tooling like <a href="http://exercism.io">exercism.io</a> so started there.
 Dusting off the functional programming brain was much less painful using their
 examples and I'm a total sucker for getting tests to pass.
 <br><br>
 Next was asking for help, something I'm trying to get better at. While the 
-comiler and documentation is really helpful, sometimes I have to admit that
-learning from someone who's been through some of it is really invaluable. The
-freeCodeCamp mantra 
-[Read, Search, (Don’t Be Afraid to) Ask](https://medium.freecodecamp.org/read-search-dont-be-afraid-to-ask-743a23c411b4)
+compiler and documentation is really helpful, it's sometimes worth admittinh that
+learning from someone who's been through it already is invaluable. The
+<a href="https://www.freecodecamp.org/">freeCodeCamp</a> mantra
+<a href="https://medium.freecodecamp.org/read-search-dont-be-afraid-to-ask-743a23c411b4">Read, Search, (Don’t Be Afraid to) Ask</a>
 has influeced me in that.
-I did find some guidance from <a href="https://twitter.com/CrockAgile">@CrockAgile</a>,
-a friend who had been through some of the learning process. He helped me a ton in 
-sorting out the requirements of implementing standalone Elm beyond what I was 
-albe to glean from toy the first couple <a href="http://exercism.io">exercism.io</a>
+<a href="https://twitter.com/CrockAgile">@CrockAgile</a>,
+a friend who had been through some of the learning process provided some really great guidance in sorting 
+out the implementation details I's been unable to glean from the first couple <a href="http://exercism.io">exercism.io</a>
 exercises. Things like the following code block that I'm likely to revisit for 
-every Elm application I write.
+any future Elm application I write.
 
 <pre>
 <code>type Msg