Add packages concept text, use in party-robot exercise.

Fixes #1586

Author: bobtfish

concepts/functions/introduction.md

@@ -8,12 +8,6 @@ TODO: the content below is copied from the exercise introduction and probably ne
 
 ## variables
 
-In Go an application is organized in packages. A package is a collection of source files located in the same folder. All source files in a folder must have the same package name at the top of the file. The package name is preferred to be the same as the folder it is located in.
-
-```go
-package greeting
-```
-
 Go is a statically-typed language, which means that everything has a type at compile-time. Assigning a value to a name is referred to as defining a variable. A variable can be defined either by explicitly specifying its type, or by assigning a value to have the Go compiler infer its type based on the assigned value.
 
 ```go

concepts/packages/.meta/config.json

@@ -1,5 +1,5 @@
 {
-  "blurb": "TODO: add blurb",
-  "authors": ["ErikSchierboom"],
+  "blurb": "Packages are the unit of code reuse in Go",
+  "authors": ["bobtfish"],
   "contributors": []
 }

concepts/packages/about.md

@@ -1,12 +1,37 @@
 # About
 
-In Go an application is organized in packages. A package is a collection of source files located in the same folder. All source files in a folder must have the same package name at the top of the file. The package is preferred to be the same as the folder it is located in.
+In Go an application is organized in packages.
+A package is a collection of source files located in the same folder.
+All source files in a folder must have the same package name at the top of the file.
+The package is preferred to be the same as the folder it is located in.
 
 ```go
 package greeting
 ```
 
-Standard library packages are imported using their name. Other packages are imported using the url of the package's location. A package can be given an alias when importing. This can be used to avoid package name conflicts:
+Go provides an extensive standard library of packages which you can use in your program using the `import` keyword.
+Standard library packages are imported using their name.
+
+```go
+package greeting
+
+import "fmt"
+```
+
+Multiple packages can be imported at once by encoding them in brackets.
+
+```go
+package greeting
+
+import (
+    "errors"
+    "fmt"
+)
+```
+
+Third party packages are imported using the url of the package's location.
+A package can be given an alias when importing.
+This can be used to avoid package name conflicts:
 
 ```go
 package greeting

concepts/packages/introduction.md

@@ -1,52 +1,20 @@
 # Introduction
 
-TODO: the content below is copied from the exercise introduction and probably needs rewriting to a proper concept introduction
-
-## packages
-
-## functions
-
-## variables
-
-In Go an application is organized in packages. A package is a collection of source files located in the same folder. All source files in a folder must have the same package name at the top of the file. The package name is preferred to be the same as the folder it is located in.
+In Go an application is organized in packages.
+A package is a collection of source files located in the same folder.
+All source files in a folder must have the same package name at the top of the file.
+The package is preferred to be the same as the folder it is located in.
 
 ```go
 package greeting
 ```
 
-Go is a statically-typed language, which means that everything has a type at compile-time. Assigning a value to a name is referred to as defining a variable. A variable can be defined either by explicitly specifying its type, or by assigning a value to have the Go compiler infer its type based on the assigned value.
-
-```go
-var explicit int // Explicitly typed
-implicit := 10   // Implicitly typed
-```
-
-The value of a variable can be assigned using the `:=` and updated using the `=`. Once defined, a variable's type can never change.
-
-```go
-count := 1 // Assign initial value
-count = 2  // Update to new value
-
-// Compiler error when assigning different type
-// count = false
-```
-
-A function can have zero or more parameters. All parameters must be explicitly typed, there is no type inference for parameters. A function can also have multiple return values which must also be explicitly typed. Values are returned from functions using the `return` keyword. To allow a function to be called by code in other packages, the name of the function must start with a capital letter.
+Go provides an extensive standard library of packages which you can use in your program using the `import` keyword.
+Standard library packages are imported using their name.
 
 ```go
 package greeting
 
-// Hello is a public function
-func Hello(name string) string {
-    return hello(name)
-}
-
-// hello is a private function
-func hello(name string) string {
-    return "Hello " + name
-}
+import "fmt"
 ```
 
-Invoking a function is done by specifying the function name and passing arguments for each of the function's parameters.
-
-Go supports two types of comments. Single line comments are preceded by `//` and multiline comments are inserted between `/*` and `*/`.

concepts/packages/links.json

@@ -1,35 +1,18 @@
 [
   {
-    "url": "https://golang.org/ref/spec#Assignments",
-    "description": "assignment"
+    "url": "https://tour.golang.org/basics/1",
+    "description": "Tour of Go: Packages"
   },
   {
-    "url": "https://golang.org/ref/spec#Assignments",
-    "description": "assignment"
+    "url": "https://tour.golang.org/basics/2",
+    "description": "Tour of Go: Imports"
   },
   {
-    "url": "https://golang.org/ref/spec#Operators",
-    "description": "operators"
+    "url": "https://golang.org/ref/spec#Import_declarations",
+    "description": "import-declaration-spec"
   },
   {
-    "url": "https://golang.org/ref/spec#Exported_identifiers",
-    "description": "public-vs-private"
-  },
-  {
-    "url": "https://golang.org/ref/spec#Method_declarations",
-    "description": "methods"
-  },
-  {
-    "url": "https://golang.org/ref/spec#Exported_identifiers",
-    "description": "public-vs-private"
-  },
-  {
-    "url": "https://golang.org/ref/spec#Return_statements",
-    "description": "return"
-  },
-  {
-    "url": "https://golang.org/ref/spec#Exported_identifiers",
-    "description": "public-vs-private"
-  },
-  { "url": "https://golang.org/ref/spec#Comments", "description": "comments" }
+    "url": "https://golang.org/ref/spec#Package_clause",
+    "description": "package-spec"
+  }
 ]

concepts/variables/introduction.md

@@ -1,11 +1,5 @@
 # Introduction
 
-In Go an application is organized in packages. A package is a collection of source files located in the same folder. All source files in a folder must have the same package name at the top of the file. The package name is preferred to be the same as the folder it is located in.
-
-```go
-package greeting
-```
-
 Go is a statically-typed language, which means that everything has a type at compile-time. Assigning a value to a name is referred to as defining a variable. A variable can be defined either by explicitly specifying its type, or by assigning a value to have the Go compiler infer its type based on the assigned value.
 
 ```go

config.json

@@ -61,7 +61,8 @@
         "name": "Party Robot",
         "uuid": "b3594c44-1a68-489d-a446-16369247c84c",
         "concepts": [
-          "string-formatting"
+          "string-formatting",
+          "packages"
         ],
         "prerequisites": [
           "basics"
@@ -1821,6 +1822,11 @@
       "slug": "numbers",
       "uuid": "82cff17e-88cd-4707-a6d7-b5143251f029"
     },
+    {
+      "name": "Packages",
+      "slug": "packages",
+      "uuid": "2062bff8-33ed-4081-8ad6-774b3410c450"
+    },
     {
       "name": "Range Iteration",
       "slug": "range-iteration",

exercises/concept/party-robot/.docs/introduction.md

@@ -4,6 +4,8 @@ Go provides an in-built package called `fmt` (format package) which offers a var
 The most commonly used function is `Sprinf`, which uses verbs like `%s` to interpolate values into a string and returns that string.
 
 ```go
+import "fmt"
+
 food := "taco"
 fmt.Sprintf("Bring me a %s", food)
 // Returns: Bring me a taco
@@ -13,6 +15,8 @@ In Go floating point values are conveniently formatted with Sprintf's verbs: `%g
 All three verbs allow the field's width and numeric position to be controlled.
 
 ```go
+import "fmt"
+
 f := 4.3242
 fmt.Sprintf("%.2f", f)
 // Returns: 4.32

exercises/concept/party-robot/.meta/config.json

@@ -4,7 +4,8 @@
     "tehsphinx"
   ],
   "contributors": [
-    "oanaOM"
+    "oanaOM",
+    "bobtfish"
   ],
   "files": {
     "solution": [