content: rename articles to reinforce convention of short URLs

The Go blog started out on Blogger
(http://web.archive.org/web/20100325005843/http://blog.golang.org/).
Later, we moved to the current self-hosted blog server
with extra Go-specific functionality like playground snippets.

The old Blogger posts have very long URLs that Blogger chose
for us, such as "go-programming-language-turns-two" or
"two-go-talks-lexical-scanning-in-go-and", predating
the convention of giving posts shorter, more share-friendly,
typeable names.

The conversion of the old Blogger posts also predated
the convention of putting supporting files in a subdirectory.

The result is that although we've established new conventions,
you wouldn't know by listing the directory - the old Blogger
content presents a conflicting picture.

This commit renames the posts with very long names
to have shorter, more share-friendly names, and it moves
all supporting files to subdirectories. It also adds a README
documenting the conventions.

For example, blog.golang.org/go-programming-language-turns-two
is now blog.golang.org/2years, matching our more recent birthday
post URLs, and its supporting files are moved to the new 2years/ directory.

The old URLs redirect to the new ones.

Change-Id: I9f46a790c2c8fab8459aeda73d4e3d2efc86d88f
Reviewed-on: https://go-review.googlesource.com/c/blog/+/223599
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Andrew Bonventre <andybons@golang.org>

1 files changed, 33 insertions, 0 deletions

diff --git a/content/waza-talk.article b/content/waza-talk.article
new file mode 100644
index 0000000..5bf1895
--- /dev/null
+++ b/content/waza-talk.article
@@ -0,0 +1,33 @@
+# Concurrency is not parallelism
+16 Jan 2013
+Tags: concurrency, talk, video
+Summary: Watch Rob Pike's talk, _Concurrency is not parallelism._
+OldURL: /concurrency-is-not-parallelism
+
+Andrew Gerrand
+
+##
+
+If there's one thing most people know about Go,
+is that it is designed for concurrency.
+No introduction to Go is complete without a demonstration of its goroutines and channels.
+
+But when people hear the word _concurrency_ they often think of _parallelism_,
+a related but quite distinct concept.
+In programming, concurrency is the _composition_ of independently executing processes,
+while parallelism is the simultaneous _execution_ of (possibly related) computations.
+Concurrency is about _dealing with_ lots of things at once.
+Parallelism is about _doing_ lots of things at once.
+
+To clear up this conflation, Rob Pike gave a talk at [Heroku](http://heroku.com/)'s
+[Waza](http://waza.heroku.com/) conference entitled _Concurrency is not parallelism_,
+and a video recording of the talk was released a few months ago.
+
+.iframe //player.vimeo.com/video/49718712?badge=0 281 500
+
+The slides are available at [talks.golang.org](https://talks.golang.org/2012/waza.slide)
+(use the left and right arrow keys to navigate).
+
+To learn about Go's concurrency primitives,
+watch [Go concurrency patterns](http://www.youtube.com/watch?v=f6kdp27TYZs)
+([slides](https://talks.golang.org/2012/concurrency.slide)).