Fixed typos and other small things (dotnet#883)

mairaw · BillWagner · commit bb15293c569f · 2016-08-08T21:27:46.000-04:00
* fix typos/style

* readded missing line break

* fixed typo

* fixed headings

* fixed typos
diff --git a/docs/about/index.md b/docs/about/index.md
@@ -23,7 +23,7 @@ C#, F# and Visual Basic are popular languages that target and rely on the .NET p
 
 There is great diversity across these languages, in philosophy and syntax, but also symmetry provided by a shared type system. This type system is provided by the underlying runtime environment. .NET was designed around the idea of a "common language runtime" that could support the requirements of diverse languages -- for example, dynamic and statically typed languages -- and enable interoperability between them. For example, it's possible to pass a collection of `People` objects between languages with no loss in semantics or capability.
 
-Multiple [.NET implementations and products](products.md) are available, based on open [.NET Standards](https://github.com/dotnet/coreclr/blob/master/Documentation/project-docs/dotnet-standards.md) that specify the fundamentals of the platform. They are separately optimized for different application types (for example, desktop, mobile, gaming, cloud) and support many chips (e.g. x86/x64, ARM) and operating systems (e.g. Windows, Linux, iOS, Android, macOS). Open source is also an important part of the .NET ecosystem, with multiple .NET implementations and many libraries available under OSI-approved licenses.
+Multiple [.NET implementations and products](products.md) are available, based on open [.NET Standards](https://github.com/dotnet/coreclr/blob/master/Documentation/project-docs/dotnet-standards.md) that specify the fundamentals of the platform. They are separately optimized for different application types (for example, desktop, mobile, gaming, cloud) and support many chips (for example, x86/x64, ARM) and operating systems (for example, Windows, Linux, iOS, Android, macOS). Open source is also an important part of the .NET ecosystem, with multiple .NET implementations and many libraries available under OSI-approved licenses.
 
 - Learn about [.NET](../standard/index.md)
 - Learn about [C#](../csharp/index.md)
@@ -56,7 +56,7 @@ Features
 Open source
 -----------
 
-The [.NET Core](https://github.com/dotnet/core) and [Mono](https://github.com/mono/mono) implementations of .NET are open source, using the MIT license. Documentation uses the [Creative Commons CC-BY](https://creativecommons.org/licenses/by/4.0/) license. .NET Core and Mono are sponsored by Microsoft and have many contributers from the community. 
+The [.NET Core](https://github.com/dotnet/core) and [Mono](https://github.com/mono/mono) implementations of .NET are open source, using the MIT license. Documentation uses the [Creative Commons CC-BY](https://creativecommons.org/licenses/by/4.0/) license. .NET Core and Mono are sponsored by Microsoft and have many contributors from the community. 
 
 These general purpose runtimes can be used as the basis of academic research or teaching/learning or commercial products. Their open nature also means that anyone can contribute back to the upstream product code given a bug or the desire for a new feature.
 
diff --git a/docs/about/products.md b/docs/about/products.md
@@ -39,7 +39,7 @@ You can build desktop apps for Windows and macOS.
 
 ### Games
 
-You can build games for many desktop, mobile, console and virtual/agumented reality devices.
+You can build games for many desktop, mobile, console and virtual/augmented reality devices.
 
 - [Unity](http://docs.unity3d.com/Manual/index.html) with [Mono](#mono)
 - [MonoGame](http://www.monogame.net/documentation/?page=main) with [Mono](#mono)
@@ -103,7 +103,7 @@ The .NET Framework is used to build apps for Windows and Windows Server. You can
 
 [ASP.NET](http://www.asp.net/) is a web framework. It has several distinct pieces which are used to produce modern and high-performance web applications. 
 
-- [ASP.NET Web Forms](http://www.asp.net/web-forms) enables you to build a "forms over data" UI more radidly than most other Web technologies, with a designer that enables drag-and-drop of web controls. 
+- [ASP.NET Web Forms](http://www.asp.net/web-forms) enables you to build a "forms over data" UI more rapidly than most other Web technologies, with a designer that enables drag-and-drop of web controls. 
 - [ASP.NET MVC](http://www.asp.net/mvc) gives you greater control over the entire web pipeline, from the HTTP layer to the user interface. 
 - [ASP.NET WebAPI](http://www.asp.net/web-api) is a convention-based framework for creating REST services. 
 - [SignalR](http://www.asp.net/signalr) allows you to provide push-based communication to your web applications using the [WebSocket](https://en.wikipedia.org/wiki/WebSocket) protocol.
diff --git a/docs/core/deploying/index.md b/docs/core/deploying/index.md
@@ -406,4 +406,4 @@ The following is the complete `project.json` file for this project.
 
 ## <a name="crossgen"></a> Native image Generation ##
 
-NET Core uses a just in time (JIT) compiler that stores application code in an intermediate format and compiles it to native code at runtime.  To increase startup performance, the shared framework is pre-compiled using a tool called `crossgen`.  To improve performance of your application, you can use the same tool on your application's binaries.  Its performance impact is more noticeable when deploying a self-contained application, since the entire framework is part of the application. Crossgen must be run on a machine of the same platform type that you are targeting, but need not be done on the same machine, unlike ngen for the desktop framework.  If you are producing a platform-specific installer for your application, we recomend that you crossgen as part of the installer build process.
+NET Core uses a just in time (JIT) compiler that stores application code in an intermediate format and compiles it to native code at runtime.  To increase startup performance, the shared framework is pre-compiled using a tool called `crossgen`.  To improve performance of your application, you can use the same tool on your application's binaries.  Its performance impact is more noticeable when deploying a self-contained application, since the entire framework is part of the application. Crossgen must be run on a machine of the same platform type that you are targeting, but need not be done on the same machine, unlike ngen for the desktop framework.  If you are producing a platform-specific installer for your application, we recommend that you crossgen as part of the installer build process.
diff --git a/docs/core/packages.md b/docs/core/packages.md
@@ -61,7 +61,7 @@ In most cases, you will not reference the lower-level .NET Core packages directl
 Metapackages are a NuGet package convention for describing a set of packages that are meaningful together. They represent this set of packages by making them dependencies. They can optionally establish a
 framework for this set of packages by specifying a framework. 
 
-By refg a metapackage, you are, in effect, adding a reference to each of its dependent packages as a single gesture. That means that all of the libraries in those packages (refs or libs) are available for IntelliSense (or similar experience) and for publishing (libs only) your app. 
+By referencing a metapackage, you are, in effect, adding a reference to each of its dependent packages as a single gesture. That means that all of the libraries in those packages (refs or libs) are available for IntelliSense (or similar experience) and for publishing (libs only) your app. 
 
 Note: The 'lib' and 'ref' terms refer to folders in NuGet packages. 'ref' folders describe the public API of a package via assembly metadata. 'lib' folders contain the implementation of that public API for a given
 framework. 
diff --git a/docs/core/tutorials/using-on-macos.md b/docs/core/tutorials/using-on-macos.md
@@ -27,8 +27,7 @@ tools, and incorporate third-party libraries via [NuGet](http://nuget.org).
 This article uses Visual Studio Code on Mac OS. Where there are differences,
 it points out the differences for the Windows platform.
 
-Prerequisites
--------------
+## Prerequisites
 
 Before starting, you'll need to install the [.NET Core SDK](https://www.microsoft.com/net/core),
 currently in a preview release. The .NET Core SDK includes the latest release
@@ -40,8 +39,7 @@ that will improve the .NET Core development experience.
 
 You can find the links to all of these at the [.NET home page](http://dot.net).
 
-Getting Started
----------------
+## Getting Started
 
 The source for this tutorial is available on
 [GitHub](https://github.com/dotnet/core-docs/tree/master/samples/getting-started/golden).
diff --git a/docs/core/versions/index.md b/docs/core/versions/index.md
@@ -68,7 +68,7 @@ The packages described by [NETStandard.Library](https://www.nuget.org/packages/N
 
 ### Metapackages
 
-Versioning for .NET Core metapackages is based on the framework that they map to. The metapackages adopt the highest version number of the framework (for example, netstandard1.5) it maps to in its package closure. 
+Versioning for .NET Core metapackages is based on the framework that they map to. The metapackages adopt the highest version number of the framework (for example, netstandard1.6) it maps to in its package closure. 
 
 The patch version for the metapackage is used to represent updates to the metapackage to reference updated packages. Patch versions will never include an updated framework version. As a result, the metapackages are not strictly SemVer compliant because their versioning scheme doesn't represent the degree of change in the underlying packages, but primarily the API level. 
 
diff --git a/docs/csharp/async.md b/docs/csharp/async.md
@@ -52,7 +52,7 @@ And that’s it! The code expresses the intent (downloading some data asynchrono
 
 ### CPU-bound Example: Performing a Calculation for a Game
 
-Say you're writing a mobile game where pressing a button can inflict damage on many enemies on the screen.  Performing the damage calcuation can be expensive, and doing it on the UI thread would make the game appear to pause as the calculation is performed!
+Say you're writing a mobile game where pressing a button can inflict damage on many enemies on the screen.  Performing the damage calculation can be expensive, and doing it on the UI thread would make the game appear to pause as the calculation is performed!
 
 The best way to handle this is to start a background thread which does the work using `Task.Run`, and `await` its result.  This will allow the UI to feel smooth as the work is being done.
 
@@ -121,7 +121,7 @@ The following examples demonstrate various ways you can write async code in C#.
 
 This snippet downloads the HTML from www.dotnetfoundation.org and counts the number of times the string ".NET" occurs in the HTML.  It uses ASP.NET MVC to define a web controller method which performs this task, returning the number.
 
-*Note: you shouldn't ever use Regexes if you plan on doing actual HTML parsing.  Please using a parsing library if this is your aim in production code.*
+*Note: you shouldn't ever use regular expressions if you plan on doing actual HTML parsing.  Please using a parsing library if this is your aim in production code.*
 
 ```csharp
 private readonly HttpClient _httpClient = new HttpClient();
diff --git a/docs/csharp/delegate-class.md b/docs/csharp/delegate-class.md
@@ -166,7 +166,7 @@ have multiple target methods attached to a delegate object.
 
 ## Delegate and MulticastDelegate classes
 
-The language support desccribed above provides the features
+The language support described above provides the features
 and support you'll typically need to work with delegates. These
 features are built on two classes in the .NET Core
 framework: @System.Delegate and @"System.MulticastDelegate".
diff --git a/docs/csharp/event-pattern.md b/docs/csharp/event-pattern.md
@@ -332,7 +332,7 @@ private void SearchDirectory(string directory, string searchPattern)
 
 At this point, you can run the application calling the overload for
 searching all sub-directories. There are no subscribers on the new
-`OnChangeDirectory` event, but usingh the `?.Invoke()` idiom ensures
+`OnChangeDirectory` event, but using the `?.Invoke()` idiom ensures
 that this works correctly.
 
  Let's add a handler to write a line that shows the progress in the
diff --git a/docs/csharp/indexers.md b/docs/csharp/indexers.md
@@ -57,7 +57,7 @@ to indexers. The only exception to that rule is
 generate the correct storage for an indexer.
 
 The presence of arguments to reference an item in a set of items distinguishes
-indexers from properties. You may define mulitple indexers on a type, as long
+indexers from properties. You may define multiple indexers on a type, as long
 as the argument lists for each indexer is unique. Let's explore different
 scenarios where you might use one or more indexers in a class definition. 
 
diff --git a/docs/csharp/iterators.md b/docs/csharp/iterators.md
@@ -194,14 +194,14 @@ private IEnumerable<int> IteratorMethod()
 ```
  
 Look at the methods above. The first uses the standard `return` statement to return
-either an empy collection, or the iterator created by the second method. The second
+either an empty collection, or the iterator created by the second method. The second
 method uses the `yield return` statement to create the requested sequence.
 
 ## Deeper Dive into `foreach`
 
 The `foreach` statement expands into a standard idiom that uses the
 `IEnumable<T>` and `IEnumerator<T>` interfaces to iterate across all
-elements of a colleciton. It also  minimizes errors developers make
+elements of a collection. It also  minimizes errors developers make
 by not properly managing resources. 
 
 The compiler translates the `foreach` loop shown in the first
diff --git a/docs/standard/async-in-depth.md b/docs/standard/async-in-depth.md
@@ -79,7 +79,7 @@ In the second example above, a `Task<T>` object will be returned from `GetString
 
 After the System API call, the request is now in kernel space, making its way to the networking subsystem of the OS (such as `/net` in the Linux Kernel).  Here the OS will handle the networking request *asynchronously*.  Details may be different depending on the OS used (the device driver call may be scheduled as a signal sent back to the runtime, or a device driver call may be made and *then* a signal sent back), but eventually the runtime will be informed that the networking request is in progress.  At this time, the work for the device driver will either be scheduled, in-progress, or already finished (the request is already out "over the wire") - but because this is all happening asynchronously, the device driver is able to immediately handle something else!
 
-For example, in Windows an OS thread makes a call to the network device driver and asks it to perform the networking operation via an Interrupt Request Packet (IRP) which represents the operation.  The device driver recieves the IRP, makes the call to the network, marks the IRP as "pending", and returns back to the OS.  Because the OS thread now knows that the IRP is "pending", it doesn't have any more work to do for this job and "returns" back so that it can be used to perform other work.
+For example, in Windows an OS thread makes a call to the network device driver and asks it to perform the networking operation via an Interrupt Request Packet (IRP) which represents the operation.  The device driver receives the IRP, makes the call to the network, marks the IRP as "pending", and returns back to the OS.  Because the OS thread now knows that the IRP is "pending", it doesn't have any more work to do for this job and "returns" back so that it can be used to perform other work.
 
 When the request is fulfilled and data comes back through the device driver, it notifies the CPU of new data received via an interrupt.  How this interrupt gets handled will vary depending on the OS, but eventually the data will be passed through the OS until it reaches a system interop call (for example, in Linux an interrupt handler will schedule the bottom half of the IRQ to pass the data up through the OS asynchronously).  Note that this *also* happens asynchronously!  The result is queued up until the next available thread is able execute the async method and "unwrap" the result of the completed task.
 
diff --git a/docs/standard/frameworks.md b/docs/standard/frameworks.md
@@ -49,7 +49,7 @@ You can refer to a framework or targeting of a framework using long- or short-fo
 
 **Referring to a family of Frameworks**
 
-You can refer to a family of frameworks using long- or short-forms of the framework ID. Bother are equally valid in the general case.
+You can refer to a family of frameworks using long- or short-forms of the framework ID. Both are equally valid in the general case.
 
 - `.NETFramework`
 - `net`
diff --git a/styleguide/voice-tone.md b/styleguide/voice-tone.md
@@ -1,10 +1,10 @@
-# Guidelines
+# Voice and tone guidelines
 
 Developers will be reading your documents to learn .NET core, and to use it in their regular work.
 Your goal is to create useful documentation that helps the reader on their journey. Our guidelines
 help with that. Our style guide contains four recommendations:
 - [Use a Conversational Tone](#use-a-conversational-tone)
-- [Write in 2nd Person](#write-in-2nd-person)
+- [Write in Second Person](#write-in-2nd-person)
 - [Use Active Voice](#use-active-voice)
 - [Target a 5th Grade Reading Level](#target-a-5th-grade-reading-level)
 
@@ -13,16 +13,16 @@ following our guidelines to provide examples for you to follow as you build docu
 for .NET core. We also provide contrasting samples so you can see what articles look like
 when you don't follow our guidelines.
 
-# Details on each guideline
+## Details on each guideline
 
-## Use a Conversational Tone
-### Appropriate Style:
+### Use a Conversational Tone
+#### Appropriate Style:
 We want our documentation to have a conversational tone. You should feel as though you
 are having a conversation with the author as you read any of our tutorials or explanations.
 Your experience as a reader should be informal, conversational, and informative. You should
 feel as though you are listening to the author explain the concepts to you.
 
-### Inappropriate Style:
+#### Inappropriate Style:
 One might see the contrast between a conversational style and the style one finds with
 more academic treatments of technical topics. Those resources are very useful, but the authors
 have written those articles in a very different style than our documentation. When one reads
@@ -32,26 +32,26 @@ One feels that they are reading a dry account of a very dry topic.
 The first paragraph above follows our recommendation conversational style. The second
 is a more academic style. You see the difference immediately. 
 
-## Write in 2nd person
-### Appropriate Style:
+### Write in second person
+#### Appropriate Style:
 You should write your articles as though you are speaking directly to the reader. You
 should use second person often (as I just have in these two sentences). 2nd person doesn't
 always mean using the word 'you'. Write directly to the reader. Write imperative sentences.
 Tell your reader what you want them to learn.
 
-### Inappropriate Style: 
-An author could also choose to write in 3rd person. In that model, an author must find some
-pronoun or noun to use when referring to the reader. A reader might often find this 3rd
+#### Inappropriate Style: 
+An author could also choose to write in third person. In that model, an author must find some
+pronoun or noun to use when referring to the reader. A reader might often find this third
 person style less engaging and less enjoyable to read.
 
-The first paragrah follows our recommended style. The second uses 3rd person. Please write
+The first paragraph follows our recommended style. The second uses third person. Please write
 in second person. You probably found that much easier to read.
 
-## Use Active Voice
+### Use Active Voice
 
 Write your articles in active voice. Active voice means that the subject of the sentence performs
 the action (verb) of that sentence. It contrasts with passive voice, where the sentence is arranged
-such that the subject of the sentence is acted upon. Constrast these two examples:
+such that the subject of the sentence is acted upon. Contrast these two examples:
 
 >The compiler transformed source code into an executable.
 
@@ -62,7 +62,7 @@ The first sentence uses active voice. The second sentence was written in passive
 
 We recommend active voice because it is more readable. Passive voice can be more difficult to read.
 
-## Target a 5th Grade Reading Level
+### Target a Fifth Grade Reading Level
 
 We provide this final guideline because many of our readers are not native English speakers.
 You are reaching an international audience with your articles. Please take into account that

Original file line number	Diff line number	Diff line change
@@ -406,4 +406,4 @@ The following is the complete `project.json` file for this project.
`406`	`406`
`407`	`407`	`## <a name="crossgen"></a> Native image Generation ##`
`408`	`408`
`409`		-NET Core uses a just in time (JIT) compiler that stores application code in an intermediate format and compiles it to native code at runtime. To increase startup performance, the shared framework is pre-compiled using a tool called `crossgen`. To improve performance of your application, you can use the same tool on your application's binaries. Its performance impact is more noticeable when deploying a self-contained application, since the entire framework is part of the application. Crossgen must be run on a machine of the same platform type that you are targeting, but need not be done on the same machine, unlike ngen for the desktop framework. If you are producing a platform-specific installer for your application, we recomend that you crossgen as part of the installer build process.
	`409`	+NET Core uses a just in time (JIT) compiler that stores application code in an intermediate format and compiles it to native code at runtime. To increase startup performance, the shared framework is pre-compiled using a tool called `crossgen`. To improve performance of your application, you can use the same tool on your application's binaries. Its performance impact is more noticeable when deploying a self-contained application, since the entire framework is part of the application. Crossgen must be run on a machine of the same platform type that you are targeting, but need not be done on the same machine, unlike ngen for the desktop framework. If you are producing a platform-specific installer for your application, we recommend that you crossgen as part of the installer build process.