Update README

Author: trustmaster

.travis.yml

@@ -1,169 +1,157 @@
-# GoFlow - Dataflow and Flow-based programming library for Go (golang)
+# GoFlow
 
-[![Build Status](https://travis-ci.com/trustmaster/goflow.svg?branch=master)](https://travis-ci.com/trustmaster/goflow) [![codecov](https://codecov.io/gh/trustmaster/goflow/branch/master/graph/badge.svg)](https://codecov.io/gh/trustmaster/goflow)
+[![Go Reference](https://pkg.go.dev/badge/github.com/trustmaster/goflow.svg)](https://pkg.go.dev/github.com/trustmaster/goflow)
+[![Go Version](https://img.shields.io/github/go-mod/go-version/trustmaster/goflow)](https://golang.org)
+[![CI](https://github.com/trustmaster/goflow/actions/workflows/golangci-lint.yml/badge.svg)](https://github.com/trustmaster/goflow/actions/workflows/golangci-lint.yml)
+[![codecov](https://codecov.io/gh/trustmaster/goflow/branch/master/graph/badge.svg)](https://codecov.io/gh/trustmaster/goflow)
 
+Dataflow and Flow-based programming library for Go.
 
-### _Status of this branch (WIP)_
+GoFlow is a lean and opinionated implementation of [Flow-based programming (FBP)](http://en.wikipedia.org/wiki/Flow-based_programming) that lets you design applications as graphs of components reacting to data as it flows through the graph.
 
-_Warning: you are currently on v1 branch of GoFlow. v1 is a revisit and refactoring of the original GoFlow code which remained almost unchanged for 7 years. This branch is deep **in progress**, no stability guaranteed. API also may change._
+> **Flow-based programming** is a programming paradigm that defines applications as networks of black-box processes that exchange data across predefined connections by message passing, where the connections are specified externally to the processes.
 
-- _[More information on v1](https://github.com/trustmaster/goflow/issues/49)_
-- _[Take me back to v0](https://github.com/trustmaster/goflow/tree/v0)_
+## Features
 
-_If your code depends on the old implementation, you can build it using [release 0.1](https://github.com/trustmaster/goflow/releases/tag/0.1)._
+- **Concurrent** — graph nodes run in parallel via goroutines and channels.
+- **Structural** — applications are described as components, their ports, and the connections between them.
+- **Reactive** — system behavior is defined by how components react to events or manage their lifecycle.
+- **Asynchronous by default** — events have no predetermined order unless you enforce one.
+- **Isolated** — communication replaces shared state; components don't share memory.
 
---
+## Installation
 
-GoFlow is a lean and opinionated implementation of [Flow-based programming](http://en.wikipedia.org/wiki/Flow-based_programming) in Go that aims at designing applications as graphs of components which react to data that flows through the graph.
+GoFlow requires Go 1.23 or later.
 
-The main properties of the proposed model are:
-
-* Concurrent - graph nodes run in parallel.
-* Structural - applications are described as components, their ports and connections between them.
-* Reactive/active - system's behavior is how components react to events or how they handle their lifecycle.
-* Asynchronous/synchronous - there is no determined order in which events happen, unless you demand for such order.
-* Isolated - sharing is done by communication, state is not shared.
-
-## Getting started
-
-If you don't have the Go compiler installed, read the official [Go install guide](http://golang.org/doc/install).
-
-Use go tool to install the package in your packages tree:
-
-```
+```bash
 go get github.com/trustmaster/goflow
 ```
 
-Then you can use it in import section of your Go programs:
+Then import it in your code:
 
 ```go
 import "github.com/trustmaster/goflow"
 ```
 
-## Basic Example
+## Quick Start
 
-Below there is a listing of a simple program running a network of two processes.
+Below is a complete program that builds a simple two-component network: one greets names, the other prints the result.
 
 ![Greeter example diagram](http://flowbased.wdfiles.com/local--files/goflow/goflow-hello.png)
 
-This first one generates greetings for given names, the second one prints them on screen. It demonstrates how components and graphs are defined and how they are embedded into the main program.
-
 ```go
 package main
 
 import (
 	"fmt"
+
 	"github.com/trustmaster/goflow"
 )
 
-// Greeter sends greetings
+// Greeter sends greetings.
 type Greeter struct {
-	Name           <-chan string // input port
-	Res            chan<- string // output port
+	Name <-chan string // input port
+	Res  chan<- string // output port
 }
 
-// Process incoming data
+// Process reads incoming names and sends back greetings.
 func (c *Greeter) Process() {
-	// Keep reading incoming packets
 	for name := range c.Name {
-		greeting := fmt.Sprintf("Hello, %s!", name)
-		// Send the greeting to the output port
-		c.Res <- greeting
+		c.Res <- fmt.Sprintf("Hello, %s!", name)
 	}
 }
 
-// Printer prints its input on screen
+// Printer prints its input on screen.
 type Printer struct {
-	Line <-chan string // inport
+	Line <-chan string // input port
 }
 
-// Process prints a line when it gets it
+// Process reads lines and prints them.
 func (c *Printer) Process() {
 	for line := range c.Line {
 		fmt.Println(line)
 	}
 }
 
-// NewGreetingApp defines the app graph
+// NewGreetingApp defines the application graph.
 func NewGreetingApp() *goflow.Graph {
 	n := goflow.NewGraph()
-	// Add processes to the network
 	n.Add("greeter", new(Greeter))
 	n.Add("printer", new(Printer))
-	// Connect them with a channel
 	n.Connect("greeter", "Res", "printer", "Line")
-	// Our net has 1 inport mapped to greeter.Name
 	n.MapInPort("In", "greeter", "Name")
 	return n
 }
 
 func main() {
-	// Create the network
 	net := NewGreetingApp()
-	// We need a channel to talk to it
 	in := make(chan string)
 	net.SetInPort("In", in)
-	// Run the net
+
 	wait := goflow.Run(net)
-	// Now we can send some names and see what happens
+
 	in <- "John"
 	in <- "Boris"
 	in <- "Hanna"
-	// Send end of input
 	close(in)
-	// Wait until the net has completed its job
+
 	<-wait
 }
 ```
 
-Looks a bit heavy for such a simple task but FBP is aimed at a bit more complex things than just printing on screen. So in more complex an realistic examples the infractructure pays the price.
-
-You probably have one question left even after reading the comments in code: why do we need to wait for the finish signal? This is because flow-based world is asynchronous and while you expect things to happen in the same sequence as they are in main(), during runtime they don't necessarily follow the same order and the application might terminate before the network has done its job. To avoid this confusion we listen for a signal on network's `wait` channel which is sent when the network finishes its job.
+> **Why the `wait` channel?** The flow-based world is asynchronous — events don't necessarily happen in the order they were sent. The `wait` channel signals when the network has fully completed, preventing premature program termination.
 
 ## Terminology
 
-Here are some Flow-based programming terms used in GoFlow:
-
-* Component - the basic element that processes data. Its structure consists of input and output ports and state fields. Its behavior is the set of event handlers. In OOP terms Component is a Class.
-* Connection - a link between 2 ports in the graph. In Go it is a channel of specific type.
-* Graph - components and connections between them, forming a higher level entity. Graphs may represent composite components or entire applications. In OOP terms Graph is a Class.
-* Network - is a Graph instance running in memory. In OOP terms a Network is an object of Graph class.
-* Port - is a property of a Component or Graph through which it communicates with the outer world. There are input ports (Inports) and output ports (Outports). For GoFlow components it is a channel field.
-* Process - is a Component instance running in memory. In OOP terms a Process is an object of Component class.
+| Term      | Description |
+|-----------|-------------|
+| **Component** | The basic processing element. Its structure consists of input/output ports and state fields; its behavior is defined by event handlers. Analogous to a Class. |
+| **Connection** | A link between two ports in the graph. In GoFlow this is a typed channel. |
+| **Graph** | A higher-level entity composed of components and connections. Can represent composite components or entire applications. Analogous to a Class. |
+| **Network** | A running instance of a Graph. Analogous to an Object. |
+| **Port** | A property through which a Component or Graph communicates with the outside world (input/output). In GoFlow this is a channel field. |
+| **Process** | A running instance of a Component. Analogous to an Object. |
 
-More terms can be found in [Flow-based Wiki Terms](https://github.com/flowbased/flowbased.org/wiki/Terminology) and [FBP wiki](http://www.jpaulmorrison.com/cgi-bin/wiki.pl?action=index).
+More terms can be found in the [Flowbased.org Terminology](https://github.com/flowbased/flowbased.org/wiki/Terminology) and the [FBP wiki](http://www.jpaulmorrison.com/cgi-bin/wiki.pl?action=index).
 
 ## Documentation
 
-### Contents
-
-1. [Components](https://github.com/trustmaster/goflow/wiki/Components)
-    1. [Ports and Events](https://github.com/trustmaster/goflow/wiki/Components#ports-and-events)
-    2. [Process](https://github.com/trustmaster/goflow/wiki/Components#process)
-    3. [State](https://github.com/trustmaster/goflow/wiki/Components#state)
-2. [Graphs](https://github.com/trustmaster/goflow/wiki/Graphs)
-    1. [Structure definition](https://github.com/trustmaster/goflow/wiki/Graphs#structure-definition)
-    2. [Behavior](https://github.com/trustmaster/goflow/wiki/Graphs#behavior)
+### Wiki
 
-### Package docs
+- [Components](https://github.com/trustmaster/goflow/wiki/Components) — ports, events, process, and state.
+- [Graphs](https://github.com/trustmaster/goflow/wiki/Graphs) — structure definition and behavior.
 
-Documentation for the flow package can be accessed using standard godoc tool, e.g.
+### GoDoc
 
+```bash
+go doc github.com/trustmaster/goflow
 ```
-godoc github.com/trustmaster/goflow
-```
 
-## Links
+Or view the [online reference](https://pkg.go.dev/github.com/trustmaster/goflow).
+
+## Related Projects
+
+- [Flow-based.org](https://github.com/flowbased/flowbased.org/wiki) — specifications and recommendations for FBP systems.
+- [J. Paul Morrison's Flow-Based Programming](https://jpaulm.github.io/fbp/index.html) — the origin of FBP, including [JavaFBP](https://github.com/jpaulm/javafbp), [C#FBP](https://github.com/jpaulm/csharpfbp), and the [DrawFBP](https://github.com/jpaulm/drawfbp) diagramming tool.
+- [NoFlo](http://noflojs.org/) — FBP for JavaScript and Node.js.
 
-Here are related projects and resources:
+## Roadmap
 
-* [Flowbased.org](https://github.com/flowbased/flowbased.org/wiki), specifications and recommendations for FBP systems.
-* [J. Paul Morrison's Flow-Based Programming](https://jpaulm.github.io/fbp/index.html), the origin of FBP, [JavaFBP](https://github.com/jpaulm/javafbp), [C#FBP](https://github.com/jpaulm/csharpfbp) and [DrawFBP](https://github.com/jpaulm/drawfbp) diagramming tool.
-* [NoFlo](http://noflojs.org/), FBP for JavaScript and Node.js
-* [Go](http://golang.org/), the Go programming language
+- Integration with NoFlo-UI / Flowhub (in progress)
+- Distributed networks via TCP/IP and UDP
+- Reflection and monitoring of networks
+
+## Contributing
+
+Contributions are welcome! Please open an issue or pull request on [GitHub](https://github.com/trustmaster/goflow).
+
+Before submitting changes, make sure your code passes the linter and tests:
+
+```bash
+golangci-lint run ./...
+go test -v -race ./...
+```
 
-## TODO
+## License
 
-* Integration with NoFlo-UI/Flowhub (in progress)
-* Distributed networks via TCP/IP and UDP
-* Reflection and monitoring of networks
+[MIT](LICENSE)