adding SDK guides for readme.io (#261)

* adding SDK guides for readme.io

* Changes for github support.

Co-authored-by: Yasir Ali <yali@folio3.com>

Author: fscelliott

docs/010 - install-sdk-go.md

@@ -0,0 +1,23 @@
+---
+title: "Install SDK"
+excerpt: ""
+slug: "install-sdk-go"
+hidden: false
+createdAt: "2019-08-21T21:13:10.351Z"
+updatedAt: "2019-09-05T15:25:17.864Z"
+---
+The Go SDK is open source and available on [GitHub](https://github.com/optimizely/go-sdk).
+
+You can install using the following command:
+
+```go
+go get github.com/optimizely/go-sdk
+```
+
+### Install from CLI source
+​
+```go
+go get github.com/optimizely/go-sdk
+$GOPATH/src/github.com/optimizely/go-sdk
+go install
+```

docs/020 - initialize-sdk-go.md

@@ -0,0 +1,23 @@
+---
+title: "Initialize SDK"
+excerpt: ""
+slug: "initialize-sdk-go"
+hidden: false
+createdAt: "2019-08-21T21:13:33.317Z"
+updatedAt: "2019-08-21T21:13:45.319Z"
+---
+To initialize the **OptimizelyClient** you will need either the SDK key or hard-coded JSON datafile.
+```go
+import "github.com/optimizely/go-sdk/pkg/client"
+
+optimizelyFactory := &client.OptimizelyFactory{
+            SDKKey: "[SDK_KEY_HERE]",         
+            Datafile: []byte("DATAFILE_JSON_STRING_HERE")
+}
+
+// Instantiate a static client (no datafile polling)
+optlyClient, err := optimizelyFactory.StaticClient()
+
+// Instantiates a client that syncs the datafile in the background
+optlyClient, err := optimizelyFactory.Client()
+```

docs/030 - example-usage-go.md

@@ -0,0 +1,48 @@
+---
+title: "Example usage"
+excerpt: ""
+slug: "example-usage-go"
+hidden: true
+createdAt: "2019-09-11T22:26:55.008Z"
+updatedAt: "2019-12-13T01:40:10.425Z"
+---
+Once you've installed the Go SDK, import the Optimizely library into your code, get your Optimizely project's datafile, and instantiate a client. Then, you can use the client to evaluate feature flags, activate an A/B test, or feature test.
+
+This example demonstrates the basic usage of each of these concepts. Each concept is described in detail in this guide, and you can find each method's arguments and return values in the [API Reference](doc:activate). 
+
+This example shows how to: 
+1. Evaluate a feature with the key `price_filter` and check a configuration variable on it called `min_price`. The SDK evaluates your feature test and rollouts to determine whether the feature is enabled for a particular user, and which minimum price they should see if so.
+
+2. Run an A/B test called `app_redesign`. This experiment has two variations, `control` and `treatment`. It uses the `activate` method to assign the user to a variation, returning its key. As a side effect, the activate function also sends an impression event to Optimizely to record that the current user has been exposed to the experiment. 
+
+3. Use event tracking to track an event called `purchased`. This conversion event measures the impact of an experiment. Using the track method, the purchase is automatically attributed back to the running A/B and feature tests we've activated, and the SDK sends a network request to Optimizely via the customizable event dispatcher so we can count it in your results page.
+
+```go
+import (
+	optly "github.com/optimizely/go-sdk"
+)
+
+attributes := map[string]interface{}{
+  "DEVICE": "iPhone",
+  "hey":    2,
+}
+
+user := optly.UserContext("userId", attributes)
+
+// Instantiate an Optimizely client
+if client, err := optly.Client("SDK_KEY_HERE"); err == nil {
+  client.IsFeatureEnabled("price_filter", user)
+  minPrice, _ := client.GetFeatureVariableInteger("price_filter", "min_price", user)
+
+  // Activate an A/B test
+  variation, _ := client.Activate("app_redesign", user)
+  if variation == "control" {
+    // Execute code for variation A
+  } else if variation == "treatment" {
+    // Execute code for variation B
+  } else {
+    // Execute code for users who don't qualify for the experiment
+  }
+  client.Track("purchased", user, map[string]interface{}{})
+}
+```

docs/040 - optimizelyconfig-go.md

@@ -0,0 +1,154 @@
+---
+title: "OptimizelyConfig"
+excerpt: ""
+slug: "optimizelyconfig-go"
+hidden: true
+createdAt: "2020-01-17T19:10:55.970Z"
+updatedAt: "2020-01-28T21:53:26.607Z"
+---
+### Overview
+
+Full Stack SDKs open a well-defined set of public APIs, hiding all implementation details. However, some clients may need access to project configuration data within the "datafile". 
+
+In this document, we extend our public APIs to define data models and access methods, which clients can use to access project configuration data. 
+
+### OptimizelyConfig API
+
+A public configuration data model (OptimizelyConfig) is defined below as a structured format of static Optimizely Project data.
+
+OptimizelyConfig can be accessed from OptimizelyClient (top-level) with this public API call:
+```go
+client, e := optimizelyFactory.Client()
+var config = client.GetOptimizelyConfig()
+```
+`GetOptimizelyConfig` returns an `config.OptimizelyConfig` instance which include a datafile revision number, all experiments, and feature flags mapped by their key values.
+
+>ℹ️ Note
+>
+> When the SDK datafile is updated (the client can add a notification listener for `ProjectConfigUpdateNotification` to get notified), the client is expected to call the method to get the updated OptimizelyConfig data. See examples below.
+
+```go
+// OptimizelyConfig is an object describing the current project configuration data 
+type OptimizelyConfig struct {
+	Revision       string                          
+	ExperimentsMap map[string]OptimizelyExperiment 
+	FeaturesMap    map[string]OptimizelyFeature    
+}
+
+
+// OptimizelyFeature is an object describing a feature
+type OptimizelyFeature struct {
+	ID             string                          
+	Key            string                          
+	ExperimentsMap map[string]OptimizelyExperiment 
+	VariablesMap   map[string]OptimizelyVariable  
+}
+
+
+// OptimizelyExperiment is an object describing a feature test or an A/B test
+type OptimizelyExperiment struct {
+	ID            string                         
+	Key           string                        
+	VariationsMap map[string]OptimizelyVariation 
+}
+
+
+// OptimizelyVariation is an object describing a variation in a feature test or A/B //test
+type OptimizelyVariation struct {
+	ID             string                       
+	Key            string                      
+	FeatureEnabled bool                          
+	VariablesMap   map[string]OptimizelyVariable 
+}
+
+
+// OptimizelyVariable is an object describing a feature variable
+type OptimizelyVariable struct {
+	ID    string 
+	Key   string 
+	Type  string 
+	Value string 
+}
+```
+
+### Examples
+OptimizelyConfig can be accessed from OptimizelyClient (top-level) like this:
+
+```go
+client, e := optimizelyFactory.Client()
+// all experiments
+var experimentsMap = optimizelyConfig.ExperimentsMap
+var experiments = []config.OptimizelyExperiment{}
+var experimentKeys = []string{}
+
+for experimentKey, experiment := range experimentsMap {
+	experimentKeys = append(experimentKeys, experimentKey)
+	experiments = append(experiments, experiment)
+}
+
+for _, experimentKey := range experimentKeys {
+	var experiment = experimentsMap[experimentKey]
+
+	// all variations for an experiment
+	var variationsMap = experiment.VariationsMap
+	var variations = []config.OptimizelyVariation{}
+	var variationKeys = []string{}
+
+	for variationKey, variation := range variationsMap {
+		variations = append(variations, variation)
+		variationKeys = append(variationKeys, variationKey)
+	}
+
+	for _, variationKey := range variationKeys {
+		var variation = variationsMap[variationKey]
+
+		// all variables for a variation
+		var variablesMap = variation.VariablesMap
+		var variables = []config.OptimizelyVariable{}
+		var variableKeys = []string{}
+
+		for variableKey, variable := range variablesMap {
+			variables = append(variables, variable)
+			variableKeys = append(variableKeys, variableKey)
+		}
+
+		for _, variableKey := range variableKeys {
+			var variable = variablesMap[variableKey]
+			// use variable data here...
+		}
+	}
+}
+
+// all features
+var featuresMap = optimizelyConfig.FeaturesMap
+var features = []config.OptimizelyFeature{}
+var featureKeys = []string{}
+
+for featureKey, feature := range featuresMap {
+	features = append(features, feature)
+	featureKeys = append(featureKeys, featureKey)
+}
+
+for _, featureKey := range featureKeys {
+	var feature = featuresMap[featureKey]
+
+	// all experiments for a feature
+	var experimentsMap = feature.ExperimentsMap
+	var experiments = []config.OptimizelyExperiment{}
+	var experimentKeys = []string{}
+
+	for experimentKey, experiment := range experimentsMap {
+		experiments = append(experiments, experiment)
+		experimentKeys = append(experimentKeys, experimentKey)
+	}
+
+	// use experiments and other feature data here...
+}
+
+// listen to ProjectConfigUpdateNotification to get updated data
+callback := func(notification notification.ProjectConfigUpdateNotification) {
+	var newConfig = client.GetOptimizelyConfig()
+	// ...
+}
+client.ConfigManager.OnProjectConfigUpdate(callback)
+```

docs/050 - implement-a-user-profile-service-go.md

@@ -0,0 +1,74 @@
+---
+title: "Implement a user profile service"
+excerpt: ""
+slug: "implement-a-user-profile-service-go"
+hidden: true
+createdAt: "2019-09-12T13:56:27.183Z"
+updatedAt: "2019-12-03T20:10:31.031Z"
+---
+Use a **User Profile Service** to persist information about your users and ensure variation assignments are sticky. The User Profile Service implementation you provide will override Optimizely's default bucketing behavior in cases when an experiment assignment has been saved. 
+
+When implementing in a multi-server or stateless environment, we suggest using this interface with a backend like Cassandra or Redis. You can decide how long you want to keep your sticky bucketing around by configuring these services.
+
+Implementing a User Profile Service is optional and is only necessary if you want to keep variation assignments sticky even when experiment conditions are changed while it is running (for example, audiences, attributes, variation pausing, and traffic distribution). Otherwise, the Go SDK is stateless and relies on deterministic bucketing to return consistent assignments. See [How bucketing works](doc:how-bucketing-works) for more information.
+### Implement a user profile service
+Refer to the code samples below to provide your own User Profile Service. It should expose two functions with the following signatures:
+
+  * lookup: Takes a user ID string and returns a user profile matching the schema below.
+  * save: Takes a user profile and persists it.
+
+```go
+import ( "github.com/optimizely/go-sdk/pkg/decision" )
+
+// CustomUserProfileService is custom implementation of the UserProfileService interface
+type CustomUserProfileService struct {
+}
+
+// Lookup is used to retrieve past bucketing decisions for users
+func (s *CustomUserProfileService) Lookup(userID string) decision.UserProfile {
+   return decision.UserProfile{}
+}
+
+// Save is used to save bucketing decisions for users
+func (s *CustomUserProfileService) Save(userProfile decision.UserProfile) {
+}
+
+```
+**The UserProfile struct** 
+```go
+type UserProfile struct {
+   ID                  string
+   ExperimentBucketMap map[UserDecisionKey]string
+}
+
+// UserDecisionKey is used to access the saved decisions in a user profile
+type UserDecisionKey struct {
+   ExperimentID string
+   Field        string
+}
+
+// Sample user profile with a saved variation
+userProfile := decision.UserProfile{
+		ID: "optly_user_1",
+		ExperimentBucketMap: map[decision.UserDecisionKey]string{
+			decision.UserDecisionKey{ExperimentID: "experiment_1", Field: "variation_id" 
+    }: "variation_1234",
+	},
+}
+```
+
+Use `experiment_bucket_map` from the `UserProfile` struct to override the default bucketing behavior and define an alternate experiment variation for a given user. For each experiment that you want to override, add an object to the map. Use the experiment ID as the key and include a variation_id property that specifies the desired variation. If there isn't an entry for an experiment, then the default bucketing behavior persists.
+
+The Go SDK uses the field `variation_id` by default to create a decision key. Create a decision key manually with the method `decision.NewUserDecisionKey`: 
+
+```go
+decisionKey := decision.NewUserDecisionKey("experiment_id")
+```
+**Passing a User Profile Service Implementation to the OptimizelyClient:** 
+```go
+userProfileService := new(CustomUserProfileService)
+optimizelyClient, err := factory.Client(
+       client.WithUserProfileService(userProfileService),
+)
+
+```

docs/060 - configure-event-dispatcher-go.md

@@ -0,0 +1,57 @@
+---
+title: "Configure event dispatcher"
+excerpt: ""
+slug: "configure-event-dispatcher-go"
+hidden: true
+createdAt: "2019-09-12T13:58:15.596Z"
+updatedAt: "2019-12-10T00:19:39.940Z"
+---
+The Optimizely SDKs make HTTP requests for every impression or conversion that gets triggered. Each SDK has a built-in **event dispatcher** for handling these events, but we recommend overriding it based on the specifics of your environment.
+
+The Go SDK has an out-of-the-box asynchronous dispatcher. We recommend customizing the event dispatcher you use in production to ensure that you queue and send events in a manner that scales to the volumes handled by your application. Customizing the event dispatcher allows you to take advantage of features like batching, which makes it easier to handle large event volumes efficiently or to implement retry logic when a request fails. You can build your dispatcher from scratch or start with the provided dispatcher.
+
+The examples show that to customize the event dispatcher, initialize the Optimizely client (or manager) with an event dispatcher instance.
+```go
+import "github.com/optimizely/go-sdk/pkg/event"
+
+type CustomEventDispatcher struct {
+}
+
+// DispatchEvent dispatches event with callback
+func (d *CustomEventDispatcher) DispatchEvent(event event.LogEvent) (bool, error) {
+	dispatchedEvent := map[string]interface{}{
+		"url":       event.EndPoint,
+		"http_verb": "POST",
+		"headers":   map[string]string{"Content-Type": "application/json"},
+		"params":    event.Event,
+	}
+	return true, nil
+}
+
+```
+
+```go
+import (
+	"github.com/optimizely/go-sdk/pkg/client"
+	"github.com/optimizely/go-sdk/pkg/event"
+)
+
+optimizelyFactory := &client.OptimizelyFactory{
+  SDKKey: "SDK_KEY_HERE",
+	}
+
+customEventDispatcher := &CustomEventDispatcher{}
+
+// Create an Optimizely client with the custom event dispatcher
+optlyClient, e := optimizelyFactory.Client(client.WithEventDispatcher(customEventDispatcher))
+
+
+```
+
+The event dispatcher should implement a `DispatchEvent` function, which takes in one argument: `event.LogEvent`. In this function, you should send a `POST` request to the given `event.EndPoint` using the `event.EndPoint` as the body of the request (be sure to stringify it to JSON) and `{content-type: 'application/json'}` in the headers.
+
+>⚠️ Important
+>
+> If you are using a custom event dispatcher, do not modify the event payload returned from Optimizely. Modifying this payload will alter your results.
+
+By default, our Go SDK uses a [basic asynchronous event dispatcher](https://github.com/optimizely/go-sdk/blob/master/pkg/event/dispatcher.go).