Fix a bunch of markdownlint warnings

.markdownlint.json

@@ -13,5 +13,6 @@
     "MD006": false,
     "MD007": false,
     "MD030": false,
-    "MD032": false
+    "MD032": false,
+    "MD046": false
 }

_posts/2018-12-06-souper.md

@@ -12,7 +12,7 @@ optimizations in our emitted code. The .NET community may have software
 projects that benefit from using Souper directly to generate code, rather
 than waiting for us to find ways to automate those optimizations ourselves.
 This algorithm can generate code that would be very challenging
-for a traditional compiler to find. 
+for a traditional compiler to find.
 
 The Mono .NET VM is a rather nimble beast. Rather than requiring all
 users to live with the performance characteristics of a given policy, we
@@ -97,9 +97,9 @@ commandline flags named there into the `---aot=llvmopts=` argument.
 
 As of the time of this writing, that is
 
+```bash
+llvmopts="-load /path/to/libsouperPass.so -souper -z3-path=/usr/bin/z3"
 ```
-llvmopts="-load /path/to/libsouperPass.so -souper -z3-path=/usr/bin/z3" 
-``` 
 
 Mono will then allow Souper to step in during the middle of the LLVM
 compilation and try it's best at brute-forcing some better code. If
@@ -114,6 +114,4 @@ flexibility of LLVM as a code generation framework and to Mono as an embedded ru
 Embedders using Mono should consider
 using our LLVM backend with this and other third-party LLVM optimization passes.
 Feedback about the impact of our research on real-world programs will help us decide what we
-should be using by default. 
-
-
+should be using by default.

_posts/_TEMPLATE.md

@@ -1,7 +1,7 @@
 ---
 layout: blog
 title: ""
-author: 
+author:
 tags: []
 ---
 
@@ -10,10 +10,10 @@ The blog post goes here...
 To complete your blog post, simply follow the steps below. (don't edit original `_TEMPLATE.md` file).
 
 1. Fill out the above fields: title, author, and tags.
-	-layout: Leave it with blog. 
-	-title: Title of your blog post
-	-author: Your name or the person who wrote this post.
-	-tags: tag of the blog post. 
+    -layout: Leave it with blog.
+    -title: Title of your blog post
+    -author: Your name or the person who wrote this post.
+    -tags: tag of the blog post.
 
 2. Delete all of this instructional text and replace it with the actual content.
 
@@ -22,6 +22,6 @@ To complete your blog post, simply follow the steps below. (don't edit original
 Hint: This file uses Markdown formatting. You can use Markdown to add emphasis
 to your text, link to projects you've worked on, or link to files you'd like to
 share such as your resume. Here are some resources on learning Markdown:
-  - https://guides.github.com/features/mastering-markdown/ - a reference
+  - <https://guides.github.com/features/mastering-markdown/> - a reference
     guide
-  - http://www.markdowntutorial.com/ - a more comprehensive tutorial
+  - <http://www.markdowntutorial.com/> - a more comprehensive tutorial

community/google-summer-of-code/projects.md

@@ -185,15 +185,15 @@ Optional:
 
 **Complexity:** Hard
 
-Superoptimization is a method for generating provably-optimal code for short segments of logical operations. The process of stitching these together had classically been seen as intractable, but modern optimizations of the process makes it doable, if a bit slow. 
+Superoptimization is a method for generating provably-optimal code for short segments of logical operations. The process of stitching these together had classically been seen as intractable, but modern optimizations of the process makes it doable, if a bit slow.
 
-Production applications sometimes would benefit from much faster code, even at the cost of compilation time and the audibility of compilation. 
+Production applications sometimes would benefit from much faster code, even at the cost of compilation time and the audibility of compilation.
 
-This project would see the student do further build and automation work to enable us to use Souper out-of-the box. Creation of some diagrams and benchmarks showing the cost and improvements with Souper would be one deliverable as well. 
+This project would see the student do further build and automation work to enable us to use Souper out-of-the box. Creation of some diagrams and benchmarks showing the cost and improvements with Souper would be one deliverable as well.
 
 This student can hope to gain some familiarity with binding LLVM and working with the LLVM tooling ecosystem.
 
-https://www.mono-project.com/news/2018/12/06/souper/
+<https://www.mono-project.com/news/2018/12/06/souper/>
 
 **Mentors:** Alexander Kyte
 
@@ -217,10 +217,10 @@ Flatpak is all the rage these days in the Open Source and GNOME community. It's
 
 Ideas for Flatpak + Mono tools:
 
-- An extension for MonoDevelop that turns any C# project into a Flatpak
-- A flatpak-builder extension that includes the Mono runtime to save time/space when compiling a bundle
-- A tool that uses mkbundle to statically link the entire app and keep mono based flatpak bundles small
-- Templates for easy inclusion of open source NuGets
+* *An extension for MonoDevelop that turns any C# project into a Flatpak
+* *A flatpak-builder extension that includes the Mono runtime to save time/space when compiling a bundle
+* *A tool that uses mkbundle to statically link the entire app and keep mono based flatpak bundles small
+* *Templates for easy inclusion of open source NuGets
 
 **Deliverables**: An end-to-end experience for creating a Flatpak from a  MonoDevelop project
 
@@ -232,7 +232,7 @@ Ideas for Flatpak + Mono tools:
 
 A proof of concept has been demonstrated using Julia's [LLVM C Backend](https://github.com/JuliaComputing/llvm-cbe) with Mono to generate C code from a managed executable. This would allow using Mono on older/limited/exotic platforms where it cannot currently be used.
 
-For details, see https://github.com/mono/mono/issues/11940
+For details, see <https://github.com/mono/mono/issues/11940>
 
 The project is to make this more complete and stable. A key part of this would be to make the backend use Mono's intrinsics instead of LLVM-CBE's Julia-specific intrinsics.
 
@@ -273,12 +273,12 @@ Notes: it does not have to use (or hack around) the latest Cecil, e.g. it could
 **Complexity:** Hard
 
 There was some initial bootstrapping done for RISC-V:
-https://github.com/mono/mono/pull/11593
+<https://github.com/mono/mono/pull/11593>
 
 I see two projects possible around this area:
 
-- (1) continue implementing the JIT backend. I wouldn't expect a student to get it to a "complete" state after two months, but the delivery can be reduced to "make the mini regression test suite work", which is a huge achievement, but not a fully working runtime.
-- (2) get the interpreter working on this target. This needs some low-level hacking in terms of writing RISC-V assembly. However, it's a fairly contained work item and as a reward it should be able to run almost anything (as the interpreter itself is pretty complete).
+* (1) continue implementing the JIT backend. I wouldn't expect a student to get it to a "complete" state after two months, but the delivery can be reduced to "make the mini regression test suite work", which is a huge achievement, but not a fully working runtime.
+* (2) get the interpreter working on this target. This needs some low-level hacking in terms of writing RISC-V assembly. However, it's a fairly contained work item and as a reward it should be able to run almost anything (as the interpreter itself is pretty complete).
 
 Note1: I would not recommend using the LLVM backend, because it needs the regular JIT backend as a fallback.
 
@@ -413,41 +413,41 @@ What if we used a database (such as SQLlite or [LMDB](https://github.com/LMDB/lm
 
 RR is a debugger that allows for recording of execution in a way that can be replayed later in a debugger. The results of syscalls are fed back into the program to replicate the environment the program saw over time.
 
-The runtime can be debugged with RR on linux, but this is mostly useful for low-level debugging. 
+The runtime can be debugged with RR on linux, but this is mostly useful for low-level debugging.
 
 We have two options here: We can expose managed logging and heap/stack snapshotting to the debugger-agent and do this is a managed way. This allows us to work on ARM, linux, windows, ios, etc. The downside is that we don't get to replay state changes in unmanaged code.
 
-Alternatively, we can have the student create glue code for using rr to debug the entire runtime remotely, and add in the hooks to get the information on managed methods from the runtime. Someone can then record a crash on their machine as it is happening, and submit it with a bug report. 
+Alternatively, we can have the student create glue code for using rr to debug the entire runtime remotely, and add in the hooks to get the information on managed methods from the runtime. Someone can then record a crash on their machine as it is happening, and submit it with a bug report.
 
-I believe that the latter idea would make bug reports an order of magnitude more useful. By removing the difficulty of reproducing crashes, we may save our own developers a lot of time. 
+I believe that the latter idea would make bug reports an order of magnitude more useful. By removing the difficulty of reproducing crashes, we may save our own developers a lot of time.
 
 Deliverables:
 
-- Get RR debugging of mono working interactively
-- Create automated RR client that records and replays mono
-- Create infrastructure to use RR client and create self contained "debug me" blob
+* Get RR debugging of mono working interactively
+* Create automated RR client that records and replays mono
+* Create infrastructure to use RR client and create self contained "debug me" blob
 
 **Mentors:** Bernhard Urban
 
 ### Succinct data structure implementations to replace glib dependencies
 
 **Complexity:** Medium
 
-Bitmask-driven data structures allow for SIMD operations on the data structure's top-level structure schema. They're space-efficient, cache-efficient, and they're easy to debug after a crash because the bitmask and the data structure have a minimal number of pointers. 
+Bitmask-driven data structures allow for SIMD operations on the data structure's top-level structure schema. They're space-efficient, cache-efficient, and they're easy to debug after a crash because the bitmask and the data structure have a minimal number of pointers.
 
 Offering succinct arrays (no nulls) and other data structures as drop-in replacements might be ways to significantly reduce memory footprint for some specific use cases.
 
 Benchmarking is necessary to find those use-cases.
 
 Deliverables:
 
-- Implement full replacement for GArray and ensure passes GLib GArray tests.
+* Implement full replacement for GArray and ensure passes GLib GArray tests.
 
-- Benchmark high-allocation places and see if the succinct replacement helps
+* Benchmark high-allocation places and see if the succinct replacement helps
 
-- (Optional) Implement replacement for ghashtable which supports bare minimum of operations, using CTries
+* (Optional) Implement replacement for ghashtable which supports bare minimum of operations, using CTries
 
-- (Optional) Use CTries in high-contention environments or high-allocation environments and benchmark uses that have savings
+* (Optional) Use CTries in high-contention environments or high-allocation environments and benchmark uses that have savings
 
 **Mentors:** Alexander Kyte
 
@@ -473,11 +473,11 @@ This effort would use the Dart compiler to process the Flutter API and output th
 **Complexity:** Medium
 
 We have a C# binding for the SEAL homomorphic encryption library.
-https://www.microsoft.com/en-us/research/project/simple-encrypted-arithmetic-library/
+<https://www.microsoft.com/en-us/research/project/simple-encrypted-arithmetic-library/>
 
 The current status is that we can work with 64-bit ints and we have the beginnings of a Linq Expression analyzer to automate creating encrypted computations.
 
-https://github.com/lambdageek/sealsharp/tree
+<https://github.com/lambdageek/sealsharp/tree>
 
 Next steps would be to add more bindings (for example, support for floats and matrices), and to work on automating some of the entropy and relinearization key management by taking advantage of the analyzability of Linq expressions.
 

docs/about-mono/releases/5.16.0.md

@@ -5,10 +5,6 @@ version: 5.16.0
 releasedate: '2018-10-08'
 ---
 
-Release History
-===============
-
-
 Highlights
 ==========
 
@@ -44,8 +40,8 @@ Threads that are running managed code or code that is part of the managed runtim
 
 In 5.16, hybrid suspend is turned on by default on Linux (amd64 and i386) and macOS.  There are `configure` flags and environment variables available to control the suspend mechanism:
 
-- Pass `--enable-hybrid-suspend` to `configure` to turn on hybrid suspend by default.  Pass `--disable-hybrid-suspend --disable-cooperative-suspend` to use the old preemptive suspend as the default mechanism.
-- At runtime set the environment variable `MONO_THREADS_SUSPEND` to `preemptive` to use preemptive suspend or `hybrid` to use hybrid suspend.
+* Pass `--enable-hybrid-suspend` to `configure` to turn on hybrid suspend by default.  Pass `--disable-hybrid-suspend --disable-cooperative-suspend` to use the old preemptive suspend as the default mechanism.
+* At runtime set the environment variable `MONO_THREADS_SUSPEND` to `preemptive` to use preemptive suspend or `hybrid` to use hybrid suspend.
 
 ### 32-bit floating operations
 
@@ -88,14 +84,15 @@ The single-precision math operations are now available in a new `System.MathF` c
 ### Prettier exception stack-traces
 
 Ben Adams has contributed prettier exception printer, especially for generated code stack traces. For example, the async exceptions are now automatically de-mangled and instead of showing
-```
+
+```text
 System.ApplicationException: Error in the application.
   at X+<Foo>d__1.MoveNext () [0x0006c] in /path/foo.cs:14 <---
 ```
 
 the stack trace shows the C# code signature
 
-```
+```text
 System.ApplicationException: Error in the application.
   at X.Foo () [0x0006c] in /path/foo.cs:14 <---
 ```
@@ -104,9 +101,11 @@ System.ApplicationException: Error in the application.
 
 The arbitrary command nesting is now supported. The two new mechanisms were introduced to allow that. The command names may now contain spaces and `CommandSets` may be nested within `CommandSets`. This allows supporting syntax like:
 
-```
+```bash
 $ azure config mode arm
+...
 $ azure vm create
+...
 ```
 
 ### Automatic proxy configuration
@@ -176,7 +175,7 @@ The nuget tool has been updated to the latest 4.8 version (4.8.2).
 * [#7785](https://github.com/mono/mono/issues/7785) - Dead link (404) in a runtime execution engine exception
 * [#7828](https://github.com/mono/mono/issues/7828) - Invalid instruction generated by regex runtime when using dapper
 * [#7944](https://github.com/mono/mono/issues/7944) - CreateDelegate produces delegate wrapping incorrect method
-* [#7947](https://github.com/mono/mono/issues/7947) - Missing forwarders from System.Runtime.Extensions 
+* [#7947](https://github.com/mono/mono/issues/7947) - Missing forwarders from System.Runtime.Extensions
 * [#8036](https://github.com/mono/mono/issues/8036) - Update API diff to ignore more attributes
 * [#8074](https://github.com/mono/mono/issues/8074) - signing problems in preset fullaot build
 * [#8089](https://github.com/mono/mono/issues/8089) - Add System.Drawing.Common facade for Xamarin profiles

docs/about-mono/releases/5.18.0.md

@@ -5,10 +5,6 @@ version: 5.18.0
 releasedate: '2018-12-21'
 ---
 
-Release History
-===============
-
-
 Highlights
 ==========
 
@@ -25,7 +21,7 @@ Due to limitations in the TLS stack on 10.7 we are updating the minimum macOS de
 
 ### AOT
 
-Few hard to track race conditions in trampolines unboxing for AOT backend targetting amd64 were fixed. 
+Few hard to track race conditions in trampolines unboxing for AOT backend targetting amd64 were fixed.
 
 ### Interpreter
 
@@ -58,6 +54,7 @@ A new `CommandSet.GetCompletions()` method was introduced, which returns all pos
 It's now possible to use `RuntimeInformation` API to detect ARM and ARM64 platforms.
 
 ### System.Drawing
+
 Image loading routines have been hardened to have thorough checks for out of range inputs for various codecs.
 
 ## Tools
@@ -67,6 +64,7 @@ Image loading routines have been hardened to have thorough checks for out of ran
 Reference assemblies for .NET 4.7.2 are included to allow targeting .NET Framework 4.7.2 using MSBuild on Mono.
 
 ### nuget
+
 The nuget tool has been updated to the latest 4.8 version (4.8.2).
 
 # Resolved Issues

docs/about-mono/releases/5.20.0.md

@@ -5,9 +5,6 @@ version: 5.20.0
 releasedate: '2019-04-11'
 ---
 
-Release History
-===============
-
 Highlights
 ==========