Update README.md

Author: piotrwitek

README.md

@@ -1,25 +1,30 @@
 # React & Redux in TypeScript - Static Typing Guide
-A comprehensive guide to static typing in "React & Redux" apps using TypeScript.
+This guide is **NOT** about _"How to write type declarations for every possible variable and expression to have 100% type covered code and waste a lot of time"_.  
+This guide is about **_"How to write type declarations to only the minimum necessary amount of JavaScript code and still get all the benefits of Static Typing"_**.
+
 > found it usefull, want some more? [give it a :star:](https://github.com/piotrwitek/react-redux-typescript-patterns/stargazers)
 
+---
+
+### Announcements
+
 - #### Working with TypeScript v2.3 - [Check the Roadmap](https://github.com/Microsoft/TypeScript/wiki/Roadmap)
-- #### (Update for TypeScript v2.4 - in progress)
+- #### (Update for TypeScript v2.4 + v2.5 - fat PR on the way, lot of changes, almost there!)
 
 ### Introduction
-This guide is aimed for strict setup of TypeScript compiler which will provide most complete type safety and best DX.
-With a little bit of effort by adding explicit type annotations where necessary and most of the time leveraging smart [Type Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html), what we will get is this:
+This guide is aimed to use `strict` configuration of TypeScript compiler to provide the best static-typing experience with strict null checking. We want to spent a minimal amount of effort to write explicit type annotations and most of the time to leverage smart [Type Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html).
+
+Benefits of this setup and static-typing in general:
 - refactoring capabilities with the power equal to strongly typed languages (not "stringly" typed like Webstorm IDE)  
 - when making changes in your code, precise insight of the impact on the entire codebase (by showing all the references in the codebase for any given piece of code)  
 - minimal surface area for errors when implementing new features (compiler validate all props injected to connected components, action creator params, payload object structure and state/action objects passed to a reducer - showing all possible JavaScript errors)  
 
-This power will make the process of improving your codebase by refactoring, minimizing abstractions levels and cleaning unused code much simpler, and give you confidence that you will not break any working production code.
-
->**NB:** This setup will give the most benefit if you are working on rapidly changing project and cannot afford writing unit tests (because of the cost of updating them constantly). I successfully benefit from this setup without any single unit-tests on a decent size React/Redux SPA Application and zero production exceptions. The only possible exception source is network, (like failed API calls) which are easily handled.  
-Furthermore by providing Interface declarations describing your API contracts you'll be safe from all possible `null` / `undefined` exceptions coming from API responses.  
+The power of static-typing will make processes of improving your codebase, refactorings, and cleaning dead code much simpler, and give you a confidence that you will not break your working production code.
 
+>**NB:** This setup is very beneficial for rapidly changing projects, expecting a lot of refactorings, who is mostly skipping writing unit tests (because of the additinal costs of updating them). This setup ensure zero production exceptions, with only possible source of exception coming from network and I/O operations, but you can handle them in a typed manner as well (e.g. by providing `interface` declarations describing your API contracts you'll be safe from all possible `null` / `undefined` exceptions coming from API responses).  
 ### Goals:
-- Complete type safety, without failing to `any` type
-- Minimize amount of manually typing annotations by leveraging [Type Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)
+- Complete type safety with strict null checking, without failing to `any` type
+- Minimize amount of manually writing type declarations by leveraging [Type Inference](https://www.typescriptlang.org/docs/handbook/type-inference.html)
 - Reduce boilerplate with [simple utility functions](https://github.com/piotrwitek/react-redux-typescript) using [Generics](https://www.typescriptlang.org/docs/handbook/generics.html) and [Advanced Types](https://www.typescriptlang.org/docs/handbook/advanced-types.html) features
 
 ### Table of Contents