guys... english...

Author: ebahsini

resources/partials/blog-posts/2016-08-27-zsh-in-the-pursuit-of-efficiency.markdown

@@ -5,11 +5,11 @@ layout: blog_post
 categories: zsh
 -->
 
-__Zsh__ - a very powerful advanced shell significantly increases your efficiency as its exploration.
+__Zsh__ - a very powerful advanced shell significantly increases your efficiency as a developer.
 
 ## Zsh and iTerm2
 
-We will use zsh in combination with [iTerm2](http://iterm2.com/features.html), as well as setup zsh completions using homebrew.
+We will use zsh in combination with [iTerm2](http://iterm2.com/features.html). We will also setup zsh completions using homebrew.
 
 ```clojure
 brew update
@@ -25,35 +25,35 @@ chsh -s /usr/local/bin/zsh
 
 ## Oh My Zsh
 
-Now let's setup framework "Oh My Zsh". It includes a lot of plugins and themes, allowing customize to suit every taste. 
+Now let's setup "Oh My Zsh" framework. This framework includes a lot of plugins and themes allowing customization to suit every taste. 
 
 ```clojure
 sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
 ```
 
 
-### Choose theme
+### Choose your theme
 
-We will use "agnoster" theme as example. For iTerm2 You need to download Solarized Dark:
+We will use the "agnoster" theme as an example. For iTerm2 you will need to download Solarized Dark:
 
 ```clojure
 git clone https://github.com/CyberLight/agnoster.zsh-theme
 ```
 
-Import Solarized Dark.itermcolors from previously downloaded archive.
+Import Solarized Dark.itermcolors from the previously downloaded archive.
 
 *iTerm2 menu -> Preferences -> Profiles -> Colors -> Color Presets -> Import*
 
 <img src="https://s3.amazonaws.com/blog-images.epxlabs.com/7/iterm_profiles_colors.png" width="600">
 
-After import it should appear in list of presets:
+After the import it should appear in a list of presets:
 
 <img src="https://s3.amazonaws.com/blog-images.epxlabs.com/7/iterm_profiles_colors_presets.png" width="200">
 
 
 #### Install fonts
 
-Some themes, like "agnoster" in our case, need to install additional fonts. Run next script to do this:
+Some themes, like "agnoster" in our case, need to install additional fonts. Run the next script to do this:
 
 ```clojure
 git clone https://github.com/powerline/fonts.git
@@ -73,7 +73,7 @@ done
 ./install.sh
 ```
 
-Change Font in iTerm2:
+Change the font in iTerm2:
 
 *iTerm2 menu -> Preferences -> Profiles -> Text -> Change Font (for Regular font and for Non-ASCII)*
 

resources/partials/blog-posts/2016-09-03-cost-savings-in-serverless-world.markdown

@@ -7,45 +7,44 @@ categories: serverless
 
 # Cost Savings: Vol. 1 - Cost Savings in a Serverless World
 
-EPX Labs loves to save money. Saving our clients money is a win-win proposition.
+EPX Labs loves to save money. Saving our client's money is a win-win proposition.
 
 We typically engage clients with a requirements gathering and infrastructure analysis technical spike.
 
-Our analysis provides us with the data to target major cost centers of our clients cloud deployments and produce coherent strategies for rolling out cost saving infrastructure enhancements.
+Our analysis provides us with the data to target major cost centers of our client's cloud deployments and produce coherent strategies for rolling out cost saving infrastructure enhancements.
 
 Some of the enhancements and major cost centers we have encountered in the past:
 
  - Unnecessary database caching
- - Over-provisioned cloud components (EC2, RDS, DynamoDB, S3)
+ - Over-provisioned cloud components (EC2, RDS, DynamoDB, etc.)
  - Poor infrastructure design leading to inefficient data transfer operations
  - Improper capacity planning
  - Missed auto-scaling opportunities
  - Lack of applying Serverless design principles (leveraging AWS Lambda, API Gateway, Google Cloud Functions, IBM OpenWhisk, Azure Functions, et. al.)
- - Levering the best technologies available which are optimized for speed and cost (reducing legacy overhead and technical debt simultaneously)
+ - Leveraging the best technologies available which are optimized for speed and cost (reducing legacy overhead and technical debt simultaneously)
  - Moving long term storage and backups with disaster recovery to more cost effective solutions
 
-Opening up IT budget grants us the ability to focus on enhancing the end-users experience and providing customers with more value.
+Opening up IT budget grants us the ability to focus on enhancing the end-user's experience and providing customers with more value.
 
 Typically after our first cost savings iteration smiles turn to improved budgets and plans/wishes turn into projects.
 
 On a recent engagement EPX Labs - through a DevOps, Clojure and Pursuit of Serverless strategy - reduced a clients monthly cloud costs by more than half.
 
-Imagine what you could do if you cloud bill was less than half of your current monthly expenditure (give much deserved raises to your best employees, hire more personnel, enhance your marketing and sales budget, reallocate the savings to your product development, move your product into more verticals, etc.)
-
-Here is a snap of EPX Labs curtailing cloud infrastructure spend by more than half on AWS (amazon web services):
+Imagine what you could do if your cloud bill was less than half of your current monthly cloud expenditure (give much deserved raises to your best employees, hire more personnel, enhance your marketing and sales budget, reallocate the savings to your product development, move your product into more verticals, etc.)
 
+Here is a snap of EPX Labs curtailing cloud infrastructure spend by more than half on AWS (Amazon Web Services):
 
 ![image-1]~*serverless-cost-savings-1.jpg*~ 
 
 And the same bar chart in linear fashion.
 
 ![image-2]~*serverless-cost-savings-2.jpg*~
 
-For AWS costs you can refer to AWS pricing: [https://aws.amazon.com/pricing/](https://aws.amazon.com/pricing/)
+For AWS costs you can refer to [AWS pricing](https://aws.amazon.com/pricing/)
 
 Take special note of the AWS free tier which is heavily exploited when applying serverless design principles (AWS Lambda et al.): [https://aws.amazon.com/free/](https://aws.amazon.com/free/)
 
-A great calculator for thinking about Serverless cost savings can be found here: [http://serverlesscalc.com/](http://serverlesscalc.com/) by Peter Sbarski [@acloudguru](https://twitter.com/acloudguru)
+A great calculator for thinking about Serverless cost savings can be found [here](http://serverlesscalc.com/) by Peter Sbarski [@acloudguru](https://twitter.com/acloudguru)
 
 
 

resources/partials/blog-posts/2016-09-04-serverless-where-do-i-start.markdown

@@ -11,14 +11,14 @@ We field many inquiries and the general questioning follows the path:
 
 "Okay, we agree, Serverless is awesome, but a complete rewrite at this time sounds expensive - where should we start?"
 
-For this we recommend developing a infrastructure strategy that couples cost savings with Serverless component implementations overtime.
+For this we recommend developing an infrastructure strategy that couples cost savings with Serverless component implementations overtime.
 
 A general format for this type of engagement:
 
- - Requirements gathering and Infrastructure cost center anaylsis (we figure out where we can save money off the bat)
+ - Requirements gathering and Infrastructure cost center analysis (we figure out where we can save money off the bat)
  - Select the lowest hanging fruit to be converted, cost-effectively, to Serverless systems
- - Roll-out cost savings or Serverless enhancements in Agile sprints: [https://en.wikipedia.org/wiki/Scrum_(software_development)](https://en.wikipedia.org/wiki/Scrum_(software_development)) or following the Kanban method: [https://en.wikipedia.org/wiki/Kanban](https://en.wikipedia.org/wiki/Kanban)
+ - Roll-out cost savings or Serverless enhancements in [Agile sprints:](https://en.wikipedia.org/wiki/Agile_software_development) or following the [Kanban method:](https://en.wikipedia.org/wiki/Kanban)
  - Accrue cost savings, plan further enhancements, rinse and repeat
 
-Also see our Blog post [Cost Savings: Vol. 1 - Cost Savings in a Serverless World](http://staging.epxlabs.com/blog/2016-09-03-cost-savings-in-serverless-world/).
+Also see our Blog post [Cost Savings: Vol. 1 - Cost Savings in a Serverless World](http://www.epxlabs.com/blog/2016-09-03-cost-savings-in-serverless-world/).
 

resources/partials/blog-posts/2016-09-05-serverless-nyc-the-serverless-landscape.markdown

@@ -7,10 +7,10 @@ categories: serverless
 
 # Serverless NYC - "The Serverless Landscape" 
 
-EPX Labs is now co-organizing [Serverless NYC](http://www.meetup.com/Serverless-NYC/events/233736279/)
+EPX Labs is now co-organizing [Serverless NYC](http://www.meetup.com/Serverless-NYC/events/233736279/).
 
 With a keen eye on turning the conversations into technical how-to's and implementation strategies, please join us on September 15th, 2016 for drinks, food, and tech talks by some of the first to the Serverless scene.
 
-If you are interested in giving a talk, please reach out to [email protected] 
+If you are interested in giving a talk, please reach out to: [email protected]
 
-If you are interested in sponsoring or contributing to the Serverless NYC group please email evan@epxlabs.com
+If you are interested in sponsoring or contributing to the Serverless NYC group please email: hello@epxlabs.com

resources/partials/blog-posts/2016-10-25-an-introduction-to-clojure-spec.markdown

@@ -1,24 +1,23 @@
 # An Introduction to Clojure.Spec
 ##### By Alex Martin
 
-[Clojure.spec](http://clojure.org/about/spec) is a great tool for adding some tests and validation to your clojure project. I recently used it in a project that required validating data as it came into the database. 
+[Clojure.spec](http://clojure.org/about/spec) is a great tool for adding some tests and validation to your clojure project. 
 
-To begin, you require clojure.spec in one of your clj files.
+To begin require clojure.spec in your clj namespace.
 
 ```clojure
 (ns your-file.core
     (:require [clojure.spec :as s])
 ```
 
-You now have access to all the methods that this library provides to you.
-To begin with, you need to defining specs by associating them with a keyword and a validation, like so:
+To begin let's define specs by associating them with a keyword and a validation, like so:
 
 ```clojure
 (s/def ::first-name string?)
 
 ```
 
-Many times, you will want a more specific validation, such as one that requires regex. You'd do this by first defining the regex separately, and then calling it using an anonymous function as the second argument in a spec definition.
+Many times, you will want a more specific validation such as one that requires regex. You can accomplish this (non-clojure best practices) by first defining the regex separately and then calling it using an anonymous function as the second argument in a spec definition.
 
 ```clojure
 (def id-regex #"^\d{6}$")
@@ -32,19 +31,19 @@ What happens if you want multiple validations for one spec? You can use the `and
 (s/def ::time-type (s/and string? #(re-matches time-regex %)))
 ```
 
-This spec will only return true if both validations are required. Of course, `or` can be used if you only need for one of several validations to true.
+This spec will only return true if both validations are required. Of course, `or` can be used if you only require one of several validations to be true.
 
 ```clojure
 (s/def ::day (s/or "1" "2" "3" "4" "5" "6" "7"))
 ```
 
-Another, cleaner way of writing the above spec would be to pass in a set as the second argument. The spec would return true if the entry were included in the set, and false otherwise.
+Another, cleaner way of writing the above spec would be to pass in a set as the second argument. The spec would return true if the entry was included in the set, and false otherwise.
 
 ```clojure
 (s/def ::day #{"1" "2" "3" "4" "5" "6" "7"})
 ```
 
-You have several options for methods to test whether an entry would pass a validation or not. The best is `valid?`, which will return true or false depending on whether the entry passes.
+You have several options for testing whether an  entry passes validation. The best is `valid?`, which returns true or false.
 
 ```clojure
 (s/def ::first-name string?)
@@ -54,7 +53,7 @@ You have several options for methods to test whether an entry would pass a valid
 => false
 ```
 
-Another option is `conform`, which will return the entry itself if it meets the validation, and false otherwise.
+Another option is `conform`, which returns the validated data if true and false otherwise.
 
 ```clojure
 (s/def ::day #{"1" "2" "3" "4" "5" "6" "7"})
@@ -64,14 +63,14 @@ Another option is `conform`, which will return the entry itself if it meets the
 => false
 ```
 
-Once you've defined a set of specs that you want to use to test a given object, you then must create an **entity map** for that object. We use the `keys` method to define all specs the given object should be validated for, specifying which ones are optionnal or required with `:req` and `:opt`.
+Once you've defined a set of specs that you want to use to test a given object you then can create an **entity map** for that object. We use the `keys` method to define all specs that the data should be validated for. You may specify which ones are optional or required with `:req` and `:opt`.
 
 ```clojure
 (s/def ::person (s/keys :req [::first-name ::last-name ::email]
                         :opt [::phone]))
 ```
 
-You can then pass in maps to either of the validation methods we saw earlier, to find out whether or not your data is valid. It's that easy!
+You can also pass maps to either `conform` or `valid?` to find out whether or not your data is valid. It's that easy!
 
 ```clojure
 (s/valid? ::person (::first-name "Alex" ::last-name "Martin" ::email "[email protected]")

resources/partials/blog-posts/2016-10-25-stripe-clojure-blog-post.markdown

@@ -395,7 +395,7 @@ This returns a success response with the updated customer object to show that th
 
 ### Taking it a step further
 
-The [stripe-clojure](https://github.com/prachetasp/stripe-clojure) library lays the foundation fora Stripe disruption in a functional environment. It contains all of the tools needed to build complex payment and customer management systems and is a great fit for building a serverless solution to payment processing. If you would like to know more about going Serverless contact EPX Labs to find out how you could improve application reliability while cutting costs. #webscale!
+The [stripe-clojure](https://github.com/prachetasp/stripe-clojure) library lays the foundation for a Stripe disruption in a functional environment. It contains all of the tools needed to build complex payment and customer management systems and is a great fit for building a serverless solution to payment processing. If you would like to know more about going Serverless contact EPX Labs to find out how you could improve application reliability while cutting costs. #webscale!
 
 *********************