diff --git a/example/trainingmodel/README.md b/example/trainingmodel/README.md index 06eb1960e..2ad4ecf11 100644 --- a/example/trainingmodel/README.md +++ b/example/trainingmodel/README.md @@ -6,9 +6,9 @@ ## Our customer's asked: -Our client needs to complete a calculation when there are multiple data sources generating data at high frequencies: a calculation task is performed only when all the data from all the data sources have arrived, then send computed result to the next processing session, otherwise, keeps waiting data. +Our client needs to perform a calculation in an environment where high frequency data generation occurs from multiple data sources. A calculation is only performed when data from all the sources has arrived. After calculation, the computed result is sent to the next processing session, and the whole process repeats. -Usually, our business logic code intrudes on the collection of heterogeneous data from multiple sources, multi-threading, concurrency and computation caching, which prevents us from concentrating on abstracting and describing the abstraction: +Traditionally, in a scenario where heterogenous data from multiple data sources is collected, developers face several issues related to multi-threading, concurrency, race, locking, cache, among other things. As a result, instead of abstraction and implementation, developers spend time fixing issues. YoMo solves that below: ```go var convert = func(v []byte) (interface{}, error) { @@ -20,7 +20,7 @@ var zipper = func(_ context.Context, ia interface{}, ib interface{}) (interface{ return fmt.Sprintf("⚡️ Sum(%s: %f, %s: %f) => Result: %f", "data A", ia.(float32), "data B", ib.(float32), result), nil } -// Handler handle two event streams and calculate sum when data arrived +// Handler handles two event streams and calculates sum upon data's arrival func Handler(rxstream rx.RxStream) rx.RxStream { streamA := rxstream.Subscribe(0x11).OnObserve(convert) streamB := rxstream.Subscribe(0x12).OnObserve(convert) @@ -34,9 +34,9 @@ func Handler(rxstream rx.RxStream) rx.RxStream { ## Code structure -+ `source-data-a`: Analog data source A, sending random Float32 numbers. [yomo.run/source](https://yomo.run/source) -+ `source-data-b`: Analog data source B, sending random Float32 numbers. [yomo.run/source](https://yomo.run/source) -+ `flow`: Combine simulated data source A and simulated data source B for calculation[yomo.run/flow](https://yomo.run/flow) ++ `source-data-a`: Analog data source A, sending random Float32 numbers [yomo.run/source](https://yomo.run/source) ++ `source-data-b`: Analog data source B, sending random Float32 numbers [yomo.run/source](https://yomo.run/source) ++ `flow`: Combine simulated data sources A and B for calculation [yomo.run/flow](https://yomo.run/flow) + `zipper`: Setup a workflow that receives multiple sources and completes the merge calculation [yomo.run/zipper](https://yomo.run/zipper) ## Implementation @@ -51,7 +51,7 @@ func Handler(rxstream rx.RxStream) rx.RxStream { ``` -if `$GOPATH` is not set, check [Set $GOPATH and $GOBIN](#optional-set-gopath-and-gobin) first. +if `$GOPATH` is not set, immediately check [Set $GOPATH and $GOBIN](#optional-set-gopath-and-gobin). ```bash $ GO111MODULE=off go get github.com/yomorun/yomo @@ -61,9 +61,7 @@ $ cd $GOPATH/src/github.com/yomorun/yomo $ make install ``` -![YoMo Tutorial 1](https://yomo.run/tutorial-1.png) - -### 2. Start `flow` for streaming calculating +### 2. Start `flow` for streaming calculation ```bash $ cd $GOPATH/src/github.com/yomorun/yomo/example/trainingmodel/flow @@ -75,7 +73,7 @@ $ yomo run ``` -### 3. Start `zipper` to orgnize stream processing workflow +### 3. Start `zipper` to organize stream processing workflow ```bash $ cd $GOPATH/src/github.com/yomorun/yomo/example/trainingmodel/zipper @@ -110,7 +108,7 @@ $ cd $GOPATH/src/github.com/yomorun/yomo/example/trainingmodel/source-data-b $ go run main.go 2021/03/01 17:35:04 ✅ Connected to yomo-zipper localhost:9999 -2021/03/01 17:35:05 ✅ Emit 123.41881 to yomo-zipper +2021/03/01 17:35:05 ✅ Emit 36.92933 to yomo-zipper ```