1. Create an extension of Go Executor operator and add the desired input and output ports.
2. Add your Go code as an inline "script" parameter in the extension configuration or put the code into a separate file and use the prefix "file://" to specify the file name. The script must belong to package main.
3. There are two reserved functions for initialization and cleanup (runs during shutdown of operator). The signature for the initialization function is func Setup(); this function may implement some setup code, it is called only once, when the operator starts. And the shutdown function should have the following signature: func Cleanup(); it is called only once before operator shuts down.
4. All inputs are considered interface{} type, so for the one writing the script is important to deal with correct type assertions. In order to use message type, the value received through the input port should be converted to type map[string]interface{}, then the values can be accessed as "Attributes", "Encoding" and "Body" as in the following example:

   package main
   
   //here implement the function with the input port name, so data coming from this input will call this function
   func In(val interface{}){
   	message := val.(map[string]interface{})
   	body := message["Body"]
   	attr := message["Attributes"].(map[string]interface{})
   	encoding := message["Encoding"]
   
   	...
   }

5. In order to call a function based on an input incoming data, the function name should be the same as the port name, and data from that port will be sent through its parameter. And to output data, a function with the outport name should be defined and called with data as parameter. As in the following example:

   package main
   var Out func(interface{})
   //here implement the function with the input port name, so data coming from this input will call this function
   func In(val interface{}){
   	strValue := val.(string)
   	strValue += "test"
   
   	Out(strValue)
   	...
   }

package main
var Log func(string)
var Logf func(string, ...interface{})

func Setup() {
	Log("starting go operator")
}

func In(val interface{}){
	strValue := val.(string)
	strValue += "test"
	Logf("input:%s", strValue)
	...
}

package main

var GetString func(string) string
var GetInt func(string) int
var GetBool func(string) bool
var GetObject func(string) map[string]interface{}
var AsObject func(string) map[string]interface{}

func In(val interface{}){
	strValue := GetString("str")
	intValue := GetInt("int")
 	boolValue := GetBool("bool")
	objValue := GetObject("obj")
	entireConfig := AsObject()
	...
}

package main

var SendResponse func(map[string]interface{}, map[string]interface{}, error)

func Input(val interface{}){
	message := val.(map[string]interface{})
	body := message["Body"]
	attr := message["Attributes"].(map[string]interface{})
	encoding := message["Encoding"]

	SendResponse(message, message, nil)
	...
}

package main
var Timer int64 = 500

func Tick() {
	//function to be called every 500 ms
	//changes here
}