Repository: Tochemey/goakt
Pull request #267 (2024-03-17 17:55:52)

chore: remove unnessary comments

codecov[bot]: ## [Codecov](https://app.codecov.io/gh/Tochemey/goakt/pull/267?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Arsene) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Project coverage is 76.00%. Comparing base [(`65f08ac`)](https://app.codecov.io/gh/Tochemey/goakt/commit/65f08ac65b4b73d26fe8b5ac549329e028fd9234?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Arsene) to head [(`f8f7993`)](https://app.codecov.io/gh/Tochemey/goakt/pull/267?dropdown=coverage&src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Arsene).


<details><summary>Additional details and impacted files</summary>


```diff
@@            Coverage Diff             @@
##             main     #267      +/-   ##
==========================================
- Coverage   76.01%   76.00%   -0.02%     
==========================================
  Files          34       34              
  Lines        3640     3638       -2     
==========================================
- Hits         2767     2765       -2     
  Misses        755      755              
  Partials      118      118              
```



</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/Tochemey/goakt/pull/267?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Arsene).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Arsene).


Patch:
diff --git a/actors/actor_system.go b/actors/actor_system.go
index 109df31..2938654 100644
--- a/actors/actor_system.go
+++ b/actors/actor_system.go
@@ -38,11 +38,11 @@ import (
 	"github.com/google/uuid"
 	"github.com/pkg/errors"
 	"github.com/tochemey/goakt/discovery"
-	addresspb "github.com/tochemey/goakt/goaktpb"
+	"github.com/tochemey/goakt/goaktpb"
 	"github.com/tochemey/goakt/hash"
 	"github.com/tochemey/goakt/internal/cluster"
 	"github.com/tochemey/goakt/internal/eventstream"
-	internalpb "github.com/tochemey/goakt/internal/internalpb"
+	"github.com/tochemey/goakt/internal/internalpb"
 	"github.com/tochemey/goakt/internal/internalpb/internalpbconnect"
 	"github.com/tochemey/goakt/internal/metric"
 	"github.com/tochemey/goakt/internal/types"
@@ -86,12 +86,12 @@ type ActorSystem interface {
 	// RemoteActor returns the address of a remote actor when cluster is enabled
 	// When the cluster mode is not enabled an actor not found error will be returned
 	// One can always check whether cluster is enabled before calling this method or just use the ActorOf method.
-	RemoteActor(ctx context.Context, actorName string) (addr *addresspb.Address, err error)
+	RemoteActor(ctx context.Context, actorName string) (addr *goaktpb.Address, err error)
 	// ActorOf returns an existing actor in the local system or in the cluster when clustering is enabled
 	// When cluster mode is activated, the PID will be nil.
 	// When remoting is enabled this method will return and error
 	// An actor not found error is return when the actor is not found.
-	ActorOf(ctx context.Context, actorName string) (addr *addresspb.Address, pid PID, err error)
+	ActorOf(ctx context.Context, actorName string) (addr *goaktpb.Address, pid PID, err error)
 	// InCluster states whether the actor system is running within a cluster of nodes
 	InCluster() bool
 	// GetPartition returns the partition where a given actor is located
@@ -108,11 +108,11 @@ type ActorSystem interface {
 	// This requires remoting to be enabled on the actor system.
 	// This will send the given message to the actor after the given interval specified
 	// The message will be sent once
-	RemoteScheduleOnce(ctx context.Context, message proto.Message, address *addresspb.Address, interval time.Duration) error
+	RemoteScheduleOnce(ctx context.Context, message proto.Message, address *goaktpb.Address, interval time.Duration) error
 	// ScheduleWithCron schedules a message to be sent to an actor in the future using a cron expression.
 	ScheduleWithCron(ctx context.Context, message proto.Message, pid PID, cronExpression string) error
 	// RemoteScheduleWithCron schedules a message to be sent to an actor in the future using a cron expression.
-	RemoteScheduleWithCron(ctx context.Context, message proto.Message, address *addresspb.Address, cronExpression string) error
+	RemoteScheduleWithCron(ctx context.Context, message proto.Message, address *goaktpb.Address, cronExpression string) error
 	// PeerAddress returns the actor system address known in the cluster. That address is used by other nodes to communicate with the actor system.
 	// This address is empty when cluster mode is not activated
 	PeerAddress() string
@@ -132,7 +132,7 @@ type actorSystem struct {
 	actors *pidMap
 
 	// states whether the actor system has started or not
-	hasStarted atomic.Bool
+	started atomic.Bool
 
 	// Specifies the actor system name
 	name string
@@ -179,13 +179,14 @@ type actorSystem struct {
 	partitionHasher hash.Hasher
 
 	// help protect some the fields to set
-	sem sync.Mutex
+	mutex sync.Mutex
 	// specifies actors mailbox size
 	mailboxSize uint64
 	// specifies the mailbox to use for the actors
 	mailbox Mailbox
-	// specifies the stash buffer
-	stashBuffer        uint64
+	// specifies the stash capacity
+	stashCapacity uint64
+
 	housekeeperStopSig chan types.Unit
 
 	// specifies the events stream
@@ -196,6 +197,7 @@ type actorSystem struct {
 	// specifies whether tracing is enabled
 	traceEnabled atomic.Bool
 	tracer       trace.Tracer
+
 	// specifies whether metric is enabled
 	metricEnabled atomic.Bool
 	eventsChan    <-chan *cluster.Event
@@ -210,16 +212,13 @@ var _ ActorSystem = (*actorSystem)(nil)
 
 // NewActorSystem creates an instance of ActorSystem
 func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
-	// check whether the name is set or not
 	if name == "" {
 		return nil, ErrNameRequired
 	}
-	// make sure the actor system name is valid
 	if match, _ := regexp.MatchString("^[a-zA-Z0-9][a-zA-Z0-9-_]*$", name); !match {
 		return nil, ErrInvalidActorSystemName
 	}
 
-	// create the instance of the actor system with the default settings
 	system := &actorSystem{
 		actors:              newPIDMap(10),
 		clusterChan:         make(chan *internalpb.WireActor, 10),
@@ -230,7 +229,7 @@ func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
 		actorInitMaxRetries: DefaultInitMaxRetries,
 		supervisorStrategy:  DefaultSupervisoryStrategy,
 		telemetry:           telemetry.New(),
-		sem:                 sync.Mutex{},
+		mutex:               sync.Mutex{},
 		shutdownTimeout:     DefaultShutdownTimeout,
 		mailboxSize:         defaultMailboxSize,
 		housekeeperStopSig:  make(chan types.Unit, 1),
@@ -241,14 +240,13 @@ func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
 		eventsChan:          make(chan *cluster.Event, 1),
 		typesRegistry:       NewRegistry(),
 	}
-	// set the atomic settings
-	system.hasStarted.Store(false)
+
+	system.started.Store(false)
 	system.remotingEnabled.Store(false)
 	system.clusterEnabled.Store(false)
 	system.traceEnabled.Store(false)
 	system.metricEnabled.Store(false)
 
-	// set the reflection
 	system.reflection = NewReflection(system.typesRegistry)
 
 	// apply the various options
@@ -256,18 +254,13 @@ func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
 		opt.Apply(system)
 	}
 
-	// set the tracer when tracing is enabled
 	if system.traceEnabled.Load() {
 		system.tracer = system.telemetry.Tracer
 	}
 
-	// set the message scheduler
 	system.scheduler = newScheduler(system.logger, system.shutdownTimeout, withSchedulerCluster(system.cluster))
 
-	// set metric and return the registration error in case there is one
-	// re-register metric when metric is enabled
 	if system.metricEnabled.Load() {
-		// log the error but don't panic
 		if err := system.registerMetrics(); err != nil {
 			return nil, err
 		}
@@ -280,11 +273,8 @@ func NewActorSystem(name string, opts ...Option) (ActorSystem, error) {
 // This will send the given message to the actor after the given interval specified.
 // The message will be sent once
 func (x *actorSystem) ScheduleOnce(ctx context.Context, message proto.Message, pid PID, interval time.Duration) error {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "ScheduleOnce")
-	// defer the closing of the span
 	defer span.End()
-	// schedule message
 	return x.scheduler.ScheduleOnce(spanCtx, message, pid, interval)
 }
 
@@ -292,70 +282,52 @@ func (x *actorSystem) ScheduleOnce(ctx context.Context, message proto.Message, p
 // This requires remoting to be enabled on the actor system.
 // This will send the given message to the actor after the given interval specified
 // The message will be sent once
-func (x *actorSystem) RemoteScheduleOnce(ctx context.Context, message proto.Message, address *addresspb.Address, interval time.Duration) error {
-	// start a tracing span
+func (x *actorSystem) RemoteScheduleOnce(ctx context.Context, message proto.Message, address *goaktpb.Address, interval time.Duration) error {
 	spanCtx, span := x.tracer.Start(ctx, "RemoteScheduleOnce")
-	// defer the closing of the span
 	defer span.End()
-	// schedule the message
 	return x.scheduler.RemoteScheduleOnce(spanCtx, message, address, interval)
 }
 
 // ScheduleWithCron schedules a message to be sent to an actor in the future using a cron expression.
 func (x *actorSystem) ScheduleWithCron(ctx context.Context, message proto.Message, pid PID, cronExpression string) error {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "ScheduleWithCron")
-	// defer the closing of the span
 	defer span.End()
-	// schedule message
 	return x.scheduler.ScheduleWithCron(spanCtx, message, pid, cronExpression)
 }
 
 // RemoteScheduleWithCron schedules a message to be sent to an actor in the future using a cron expression.
-func (x *actorSystem) RemoteScheduleWithCron(ctx context.Context, message proto.Message, address *addresspb.Address, cronExpression string) error {
-	// start a tracing span
+func (x *actorSystem) RemoteScheduleWithCron(ctx context.Context, message proto.Message, address *goaktpb.Address, cronExpression string) error {
 	spanCtx, span := x.tracer.Start(ctx, "RemoteScheduleWithCron")
-	// defer the closing of the span
 	defer span.End()
-	// schedule message
 	return x.scheduler.RemoteScheduleWithCron(spanCtx, message, address, cronExpression)
 }
 
 // Subscribe help receive dead letters whenever there are available
 func (x *actorSystem) Subscribe() (eventstream.Subscriber, error) {
-	// first check whether the actor system has started
-	if !x.hasStarted.Load() {
+	if !x.started.Load() {
 		return nil, ErrActorSystemNotStarted
 	}
-	// create the consumer
 	subscriber := x.eventsStream.AddSubscriber()
-	// subscribe the consumer to the deadletter topic
 	x.eventsStream.Subscribe(subscriber, eventsTopic)
 	return subscriber, nil
 }
 
 // Unsubscribe unsubscribes a subscriber.
 func (x *actorSystem) Unsubscribe(subscriber eventstream.Subscriber) error {
-	// first check whether the actor system has started
-	if !x.hasStarted.Load() {
+	if !x.started.Load() {
 		return ErrActorSystemNotStarted
 	}
-	// subscribe the consumer to the deadletter topic
 	x.eventsStream.Unsubscribe(subscriber, eventsTopic)
-	// remove the subscriber from the events stream
 	x.eventsStream.RemoveSubscriber(subscriber)
 	return nil
 }
 
 // GetPartition returns the partition where a given actor is located
 func (x *actorSystem) GetPartition(actorName string) uint64 {
-	// return zero when the actor system is not in cluster mode
 	if !x.InCluster() {
 		// TODO: maybe add a partitioner function
 		return 0
 	}
-
-	// fetch the actor name partition from the cluster
 	return uint64(x.cluster.GetPartition(actorName))
 }
 
@@ -371,31 +343,23 @@ func (x *actorSystem) NumActors() uint64 {
 
 // Spawn creates or returns the instance of a given actor in the system
 func (x *actorSystem) Spawn(ctx context.Context, name string, actor Actor) (PID, error) {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "Spawn")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether the actor system has started
-	if !x.hasStarted.Load() {
-		// let us record the error in the span
+	if !x.started.Load() {
 		span.SetStatus(codes.Error, "Spawn")
 		span.RecordError(ErrDead)
-		// return the error
 		return nil, ErrActorSystemNotStarted
 	}
+
 	// set the default actor path assuming we are running locally
 	actorPath := NewPath(name, NewAddress(x.name, "", -1))
-	// set the actor path when the remoting is enabled
 	if x.remotingEnabled.Load() {
-		// get the path of the given actor
 		actorPath = NewPath(name, NewAddress(x.name, x.remotingHost, int(x.remotingPort)))
 	}
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
-	// actor already exist no need recreate it.
 	if exist {
-		// check whether the given actor heart beat
 		if pid.IsRunning() {
 			// return the existing instance
 			return pid, nil
@@ -413,43 +377,34 @@ func (x *actorSystem) Spawn(ctx context.Context, name string, actor Actor) (PID,
 		withSupervisorStrategy(x.supervisorStrategy),
 		withMailboxSize(x.mailboxSize),
 		withMailbox(x.mailbox),
-		withStash(x.stashBuffer),
+		withStash(x.stashCapacity),
 		withEventsStream(x.eventsStream),
 		withInitTimeout(x.actorInitTimeout),
 		withTelemetry(x.telemetry),
 	}
 
-	// set the pid tracing option
 	if x.traceEnabled.Load() {
 		opts = append(opts, withTracing())
 	}
 
-	// set the pid metric option
 	if x.metricEnabled.Load() {
 		opts = append(opts, withMetric())
 	}
 
-	// create an instance of the actor ref
 	pid, err := newPID(spanCtx,
 		actorPath,
 		actor,
 		opts...)
 
-	// handle the error
 	if err != nil {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Spawn")
 		span.RecordError(err)
-		// return the error
 		return nil, err
 	}
 
-	// add the given actor to the actor map
 	x.actors.Set(pid)
 
-	// when cluster is enabled replicate the actor metadata across the cluster
 	if x.clusterEnabled.Load() {
-		// send it to the cluster channel a wire actor
 		x.clusterChan <- &internalpb.WireActor{
 			ActorName:    name,
 			ActorAddress: actorPath.RemoteAddress(),
@@ -457,37 +412,26 @@ func (x *actorSystem) Spawn(ctx context.Context, name string, actor Actor) (PID,
 		}
 	}
 
-	// return the actor ref
 	return pid, nil
 }
 
 // SpawnFromFunc creates an actor with the given receive function.
 func (x *actorSystem) SpawnFromFunc(ctx context.Context, receiveFunc ReceiveFunc, opts ...FuncOption) (PID, error) {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "SpawnFromFunc")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether the actor system has started
-	if !x.hasStarted.Load() {
-		// let us record the error in the span
+	if !x.started.Load() {
 		span.SetStatus(codes.Error, "SpawnFromFunc")
 		span.RecordError(ErrDead)
-		// return the error
 		return nil, ErrActorSystemNotStarted
 	}
 
-	// create the name of the actor
 	actorID := uuid.NewString()
-
-	// create an instance of the receiveActor
 	actor := newFnActor(actorID, receiveFunc, opts...)
 
-	// set the default actor path assuming we are running locally
 	actorPath := NewPath(actorID, NewAddress(x.name, "", -1))
-	// set the actor path when the remoting is enabled
+
 	if x.remotingEnabled.Load() {
-		// get the path of the given actor
 		actorPath = NewPath(actorID, NewAddress(x.name, x.remotingHost, int(x.remotingPort)))
 	}
 
@@ -502,43 +446,34 @@ func (x *actorSystem) SpawnFromFunc(ctx context.Context, receiveFunc ReceiveFunc
 		withSupervisorStrategy(x.supervisorStrategy),
 		withMailboxSize(x.mailboxSize),
 		withMailbox(x.mailbox),
-		withStash(x.stashBuffer),
+		withStash(x.stashCapacity),
 		withEventsStream(x.eventsStream),
 		withInitTimeout(x.actorInitTimeout),
 		withTelemetry(x.telemetry),
 	}
 
-	// set the pid tracing option
 	if x.traceEnabled.Load() {
 		pidOpts = append(pidOpts, withTracing())
 	}
 
-	// set the pid metric option
 	if x.metricEnabled.Load() {
 		pidOpts = append(pidOpts, withMetric())
 	}
 
-	// create an instance of the actor ref
 	pid, err := newPID(spanCtx,
 		actorPath,
 		actor,
 		pidOpts...)
 
-	// handle the error
 	if err != nil {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Spawn")
 		span.RecordError(err)
-		// return the error
 		return nil, err
 	}
 
-	// add the given actor to the actor map
 	x.actors.Set(pid)
 
-	// when cluster is enabled replicate the actor metadata across the cluster
 	if x.clusterEnabled.Load() {
-		// send it to the cluster channel a wire actor
 		x.clusterChan <- &internalpb.WireActor{
 			ActorName:    actorID,
 			ActorAddress: actorPath.RemoteAddress(),
@@ -546,43 +481,35 @@ func (x *actorSystem) SpawnFromFunc(ctx context.Context, receiveFunc ReceiveFunc
 		}
 	}
 
-	// return the actor ref
 	return pid, nil
 }
 
 // Kill stops a given actor in the system
 func (x *actorSystem) Kill(ctx context.Context, name string) error {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "Kill")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether the actor system has started
-	if !x.hasStarted.Load() {
-		// let us record the error in the span
+	if !x.started.Load() {
 		span.SetStatus(codes.Error, "Kill")
 		span.RecordError(ErrActorSystemNotStarted)
-		// return the error
 		return ErrActorSystemNotStarted
 	}
+
 	// set the default actor path assuming we are running locally
 	actorPath := NewPath(name, NewAddress(x.name, "", -1))
-	// set the actor path with the remoting is enabled
 	if x.remotingEnabled.Load() {
-		// get the path of the given actor
 		actorPath = NewPath(name, NewAddress(x.name, x.remotingHost, int(x.remotingPort)))
 	}
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
-	// actor is found.
+
 	if exist {
 		// stop the given actor. No need to record error in the span context
 		// because the shutdown method is taking care of that
 		return pid.Shutdown(spanCtx)
 	}
-	// create the error
+
 	err := ErrActorNotFound(actorPath.String())
-	// let us record the error in the span
 	span.SetStatus(codes.Error, "Kill")
 	span.RecordError(err)
 	return err
@@ -590,44 +517,32 @@ func (x *actorSystem) Kill(ctx context.Context, name string) error {
 
 // ReSpawn recreates a given actor in the system
 func (x *actorSystem) ReSpawn(ctx context.Context, name string) (PID, error) {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "ReSpawn")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether the actor system has started
-	if !x.hasStarted.Load() {
-		// let us record the error in the span
+	if !x.started.Load() {
 		span.SetStatus(codes.Error, "ReSpawn")
 		span.RecordError(ErrActorSystemNotStarted)
-		// return the error
 		return nil, ErrActorSystemNotStarted
 	}
 	// set the default actor path assuming we are running locally
 	actorPath := NewPath(name, NewAddress(x.name, "", -1))
-	// set the actor path with the remoting is enabled
+
 	if x.remotingEnabled.Load() {
-		// get the path of the given actor
 		actorPath = NewPath(name, NewAddress(x.name, x.remotingHost, int(x.remotingPort)))
 	}
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
-	// actor is found.
 	if exist {
-		// restart the given actor
-		// pid.Restart handle error propagation in span
 		if err := pid.Restart(spanCtx); err != nil {
-			// return the error in case the restart failed
 			return nil, errors.Wrapf(err, "failed to restart actor=%s", actorPath.String())
 		}
-		// let us re-add the actor to the actor system list when it has successfully restarted
-		// add the given actor to the actor map
+
 		x.actors.Set(pid)
 		return pid, nil
 	}
-	// create the error
+
 	err := ErrActorNotFound(actorPath.String())
-	// let us record the error in the span
 	span.SetStatus(codes.Error, "ReSpawn")
 	span.RecordError(err)
 	return nil, err
@@ -635,32 +550,23 @@ func (x *actorSystem) ReSpawn(ctx context.Context, name string) (PID, error) {
 
 // Name returns the actor system name
 func (x *actorSystem) Name() string {
-	// acquire the lock
-	x.sem.Lock()
-	// release the lock
-	defer x.sem.Unlock()
+	x.mutex.Lock()
+	defer x.mutex.Unlock()
 	return x.name
 }
 
 // Actors returns the list of Actors that are alive in the actor system
 func (x *actorSystem) Actors() []PID {
-	// acquire the lock
-	x.sem.Lock()
-	// release the lock
-	defer x.sem.Unlock()
-
-	// get the actors from the actor map
+	x.mutex.Lock()
+	defer x.mutex.Unlock()
 	return x.actors.List()
 }
 
 // PeerAddress returns the actor system address known in the cluster. That address is used by other nodes to communicate with the actor system.
 // This address is empty when cluster mode is not activated
 func (x *actorSystem) PeerAddress() string {
-	// acquire the lock
-	x.sem.Lock()
-	// release the lock
-	defer x.sem.Unlock()
-	// check whether cluster mode is enabled
+	x.mutex.Lock()
+	defer x.mutex.Unlock()
 	if x.clusterEnabled.Load() {
 		// return the cluster node advertised address
 		return x.cluster.AdvertisedAddress()
@@ -672,77 +578,56 @@ func (x *actorSystem) PeerAddress() string {
 // When cluster mode is activated, the PID will be nil.
 // When remoting is enabled this method will return and error
 // An actor not found error is return when the actor is not found.
-func (x *actorSystem) ActorOf(ctx context.Context, actorName string) (addr *addresspb.Address, pid PID, err error) {
-	// start a tracing span
+func (x *actorSystem) ActorOf(ctx context.Context, actorName string) (addr *goaktpb.Address, pid PID, err error) {
 	spanCtx, span := x.tracer.Start(ctx, "ActorOf")
-	// defer the closing of the span
 	defer span.End()
 
-	// acquire the lock
-	x.sem.Lock()
-	// release the lock
-	defer x.sem.Unlock()
+	x.mutex.Lock()
+	defer x.mutex.Unlock()
 
-	// make sure the actor system has started
-	if !x.hasStarted.Load() {
-		// let us record the error in the span
+	if !x.started.Load() {
 		span.SetStatus(codes.Error, "ActorOf")
 		span.RecordError(ErrActorSystemNotStarted)
-		// return the error
 		return nil, nil, ErrActorSystemNotStarted
 	}
 
 	// try to locate the actor in the cluster when cluster is enabled
 	if x.cluster != nil || x.clusterEnabled.Load() {
-		// let us locate the actor in the cluster
 		wireActor, err := x.cluster.GetActor(spanCtx, actorName)
-		// handle the eventual error
 		if err != nil {
 			if errors.Is(err, cluster.ErrActorNotFound) {
 				x.logger.Infof("actor=%s not found", actorName)
-				// create the error
 				e := ErrActorNotFound(actorName)
-				// let us record the error in the span
 				span.SetStatus(codes.Error, "ActorOf")
 				span.RecordError(e)
-				// return the error
 				return nil, nil, e
 			}
-			// create the error
+
 			e := errors.Wrapf(err, "failed to fetch remote actor=%s", actorName)
-			// let us record the error in the span
 			span.SetStatus(codes.Error, "ActorOf")
 			span.RecordError(e)
 			return nil, nil, e
 		}
 
-		// return the address of the remote actor
 		return wireActor.GetActorAddress(), nil, nil
 	}
 
-	// method call is not allowed
 	if x.remotingEnabled.Load() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "ActorOf")
 		span.RecordError(ErrMethodCallNotAllowed)
-		// return the error
 		return nil, nil, ErrMethodCallNotAllowed
 	}
 
-	// try to locate the actor when cluster is not enabled
-	// first let us do a local lookup
 	items := x.actors.List()
-	// iterate the local actors storage
 	for _, actorRef := range items {
 		if actorRef.ActorPath().Name() == actorName {
 			return actorRef.ActorPath().RemoteAddress(), actorRef, nil
 		}
 	}
-	// add a logger
+
 	x.logger.Infof("actor=%s not found", actorName)
-	// create the error
+
 	e := ErrActorNotFound(actorName)
-	// let us record the error in the span
 	span.SetStatus(codes.Error, "ActorOf")
 	span.RecordError(e)
 	return nil, nil, e
@@ -751,25 +636,20 @@ func (x *actorSystem) ActorOf(ctx context.Context, actorName string) (addr *addr
 // LocalActor returns the reference of a local actor.
 // A local actor is an actor that reside on the same node where the given actor system is running
 func (x *actorSystem) LocalActor(actorName string) (PID, error) {
-	// acquire the lock
-	x.sem.Lock()
-	// release the lock
-	defer x.sem.Unlock()
+	x.mutex.Lock()
+	defer x.mutex.Unlock()
 
-	// make sure the actor system has started
-	if !x.hasStarted.Load() {
+	if !x.started.Load() {
 		return nil, ErrActorSystemNotStarted
 	}
 
-	// first let us do a local lookup
 	items := x.actors.List()
-	// iterate the local actors storage
 	for _, actorRef := range items {
 		if actorRef.ActorPath().Name() == actorName {
 			return actorRef, nil
 		}
 	}
-	// add a logger
+
 	x.logger.Infof("actor=%s not found", actorName)
 	return nil, ErrActorNotFound(actorName)
 }
@@ -777,89 +657,63 @@ func (x *actorSystem) LocalActor(actorName string) (PID, error) {
 // RemoteActor returns the address of a remote actor when cluster is enabled
 // When the cluster mode is not enabled an actor not found error will be returned
 // One can always check whether cluster is enabled before calling this method or just use the ActorOf method.
-func (x *actorSystem) RemoteActor(ctx context.Context, actorName string) (addr *addresspb.Address, err error) {
-	// start a tracing span
+func (x *actorSystem) RemoteActor(ctx context.Context, actorName string) (addr *goaktpb.Address, err error) {
 	spanCtx, span := x.tracer.Start(ctx, "RemoteActor")
-	// defer the closing of the span
 	defer span.End()
 
-	// acquire the lock
-	x.sem.Lock()
-	// release the lock
-	defer x.sem.Unlock()
+	x.mutex.Lock()
+	defer x.mutex.Unlock()
 
-	// make sure the actor system has started
-	if !x.hasStarted.Load() {
-		// set the error
+	if !x.started.Load() {
 		e := ErrActorSystemNotStarted
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "RemoteActor")
 		span.RecordError(e)
-		// return the error
 		return nil, e
 	}
 
-	// check whether cluster is enabled or not
 	if x.cluster == nil {
-		// set the error
 		e := ErrClusterDisabled
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "RemoteActor")
 		span.RecordError(e)
-		// return the error
 		return nil, e
 	}
 
-	// let us locate the actor in the cluster
 	wireActor, err := x.cluster.GetActor(spanCtx, actorName)
-	// handle the eventual error
 	if err != nil {
 		if errors.Is(err, cluster.ErrActorNotFound) {
 			x.logger.Infof("actor=%s not found", actorName)
-			// set the error
 			e := ErrActorNotFound(actorName)
-			// let us record the error in the span
 			span.SetStatus(codes.Error, "RemoteActor")
 			span.RecordError(e)
-			// return the error
 			return nil, e
 		}
-		// set the error
+
 		e := errors.Wrapf(err, "failed to fetch remote actor=%s", actorName)
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "RemoteActor")
 		span.RecordError(e)
 		return nil, e
 	}
 
-	// return the address of the remote actor
 	return wireActor.GetActorAddress(), nil
 }
 
 // Start starts the actor system
 func (x *actorSystem) Start(ctx context.Context) error {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "Start")
-	// defer the closing of the span
 	defer span.End()
 
-	// set the has started to true
-	x.hasStarted.Store(true)
+	x.started.Store(true)
 
-	// enable clustering when it is enabled
 	if x.clusterEnabled.Load() {
 		x.enableClustering(spanCtx)
 	}
 
-	// start remoting when remoting is enabled
 	if x.remotingEnabled.Load() {
 		x.enableRemoting(spanCtx)
 	}
 
-	// start the message scheduler
 	x.scheduler.Start(spanCtx)
 
-	// start the housekeeper
 	go x.housekeeper()
 
 	x.logger.Infof("%s started..:)", x.name)
@@ -868,32 +722,23 @@ func (x *actorSystem) Start(ctx context.Context) error {
 
 // Stop stops the actor system
 func (x *actorSystem) Stop(ctx context.Context) error {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "Stop")
-	// defer the closing of the span
 	defer span.End()
 
 	// make sure the actor system has started
-	if !x.hasStarted.Load() {
-		// set the error
+	if !x.started.Load() {
 		e := ErrActorSystemNotStarted
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Stop")
 		span.RecordError(e)
 		return e
 	}
 
-	// stop the housekeeper
 	x.housekeeperStopSig <- types.Unit{}
 	x.logger.Infof("%s is shutting down..:)", x.name)
 
-	// set started to false
-	x.hasStarted.Store(false)
-
-	// stop the messages scheduler
+	x.started.Store(false)
 	x.scheduler.Stop(spanCtx)
 
-	// shutdown the events stream
 	if x.eventsStream != nil {
 		x.eventsStream.Shutdown()
 	}
@@ -902,91 +747,63 @@ func (x *actorSystem) Stop(ctx context.Context) error {
 	ctx, cancel := context.WithTimeout(spanCtx, x.shutdownTimeout)
 	defer cancel()
 
-	// stop the remoting server
 	if x.remotingEnabled.Load() {
-		// stop the server
 		if err := x.remotingServer.Shutdown(spanCtx); err != nil {
-			// let us record the error in the span
 			span.SetStatus(codes.Error, "Stop")
 			span.RecordError(err)
-			// return the error
 			return err
 		}
 
-		// unset the remoting settings
 		x.remotingEnabled.Store(false)
 		x.remotingServer = nil
 	}
 
-	// stop the cluster service
 	if x.clusterEnabled.Load() {
-		// stop the cluster service
 		if err := x.cluster.Stop(spanCtx); err != nil {
-			// let us record the error in the span
 			span.SetStatus(codes.Error, "Stop")
 			span.RecordError(err)
-			// return the error
 			return err
 		}
-		// stop broadcasting cluster messages
+
 		close(x.clusterChan)
-		// unset the remoting settings
 		x.clusterEnabled.Store(false)
 	}
 
-	// short-circuit the shutdown process when there are no online actors
 	if len(x.Actors()) == 0 {
 		x.logger.Info("No online actors to shutdown. Shutting down successfully done")
 		return nil
 	}
 
-	// stop all the actors
 	for _, actor := range x.Actors() {
-		// remove the actor the map and shut it down
 		x.actors.Delete(actor.ActorPath())
-		// only shutdown live actors
-		// no need to record span error
 		if err := actor.Shutdown(ctx); err != nil {
-			// reset the actor system
 			x.reset()
-			// return the error
 			return err
 		}
 	}
 
-	// reset the actor system
 	x.reset()
-
 	return nil
 }
 
 // RemoteLookup for an actor on a remote host.
 func (x *actorSystem) RemoteLookup(_ context.Context, request *connect.Request[internalpb.RemoteLookupRequest]) (*connect.Response[internalpb.RemoteLookupResponse], error) {
-	// get a context log
 	logger := x.logger
 
-	// first let us make a copy of the incoming request
 	reqCopy := request.Msg
-
-	// set the actor path with the remoting is enabled
 	if !x.remotingEnabled.Load() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition, ErrRemotingDisabled)
 	}
 
-	// construct the actor address
 	name := reqCopy.GetName()
 	actorPath := NewPath(name, NewAddress(x.Name(), reqCopy.GetHost(), int(reqCopy.GetPort())))
-	// start or get the PID of the actor
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
-	// return an error when the remote address is not found
 	if !exist {
-		// log the error
 		logger.Error(ErrAddressNotFound(actorPath.String()).Error())
 		return nil, ErrAddressNotFound(actorPath.String())
 	}
 
-	// let us construct the address
 	addr := pid.ActorPath().RemoteAddress()
 
 	return connect.NewResponse(&internalpb.RemoteLookupResponse{Address: addr}), nil
@@ -996,74 +813,56 @@ func (x *actorSystem) RemoteLookup(_ context.Context, request *connect.Request[i
 // immediately. With this type of message the receiver cannot communicate back to Sender
 // except reply the message with a response. This one-way communication
 func (x *actorSystem) RemoteAsk(ctx context.Context, request *connect.Request[internalpb.RemoteAskRequest]) (*connect.Response[internalpb.RemoteAskResponse], error) {
-	// get a context log
 	logger := x.logger
-	// first let us make a copy of the incoming request
 	reqCopy := request.Msg
 
-	// set the actor path with the remoting is enabled
 	if !x.remotingEnabled.Load() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition, ErrRemotingDisabled)
 	}
 
-	// construct the actor address
 	name := reqCopy.GetRemoteMessage().GetReceiver().GetName()
 	actorPath := NewPath(name, NewAddress(x.name, x.remotingHost, int(x.remotingPort)))
 
-	// start or get the PID of the actor
-	// check whether the given actor already exist in the system or not
 	pid, exist := x.actors.Get(actorPath)
-	// return an error when the remote address is not found
 	if !exist {
-		// log the error
 		logger.Error(ErrAddressNotFound(actorPath.String()).Error())
 		return nil, ErrAddressNotFound(actorPath.String())
 	}
 
-	// send the message to actor
 	reply, err := x.handleRemoteAsk(ctx, pid, reqCopy.GetRemoteMessage())
-	// handle the error
 	if err != nil {
 		logger.Error(ErrRemoteSendFailure(err).Error())
 		return nil, ErrRemoteSendFailure(err)
 	}
-	// let us marshal the reply
+
 	marshaled, _ := anypb.New(reply)
 	return connect.NewResponse(&internalpb.RemoteAskResponse{Message: marshaled}), nil
 }
 
 // RemoteTell is used to send a message to an actor remotely by another actor
 func (x *actorSystem) RemoteTell(ctx context.Context, request *connect.Request[internalpb.RemoteTellRequest]) (*connect.Response[internalpb.RemoteTellResponse], error) {
-	// get a context log
 	logger := x.logger
-	// first let us make a copy of the incoming request
 	reqCopy := request.Msg
 
 	receiver := reqCopy.GetRemoteMessage().GetReceiver()
 
-	// set the actor path with the remoting is enabled
 	if !x.remotingEnabled.Load() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition, ErrRemotingDisabled)
 	}
 
-	// construct the actor address
 	actorPath := NewPath(
 		receiver.GetName(),
 		NewAddress(
 			x.Name(),
 			receiver.GetHost(),
 			int(receiver.GetPort())))
-	// start or get the PID of the actor
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
-	// return an error when the remote address is not found
 	if !exist {
-		// log the error
 		logger.Error(ErrAddressNotFound(actorPath.String()).Error())
 		return nil, ErrAddressNotFound(actorPath.String())
 	}
 
-	// send the message to actor
 	if err := x.handleRemoteTell(ctx, pid, reqCopy.GetRemoteMessage()); err != nil {
 		logger.Error(ErrRemoteSendFailure(err))
 		return nil, ErrRemoteSendFailure(err)
@@ -1073,186 +872,133 @@ func (x *actorSystem) RemoteTell(ctx context.Context, request *connect.Request[i
 
 // RemoteBatchTell is used to send a bulk of messages to an actor remotely by another actor.
 func (x *actorSystem) RemoteBatchTell(ctx context.Context, request *connect.Request[internalpb.RemoteBatchTellRequest]) (*connect.Response[internalpb.RemoteBatchTellResponse], error) {
-	// get a context log
 	logger := x.logger
-	// first let us make a copy of the incoming request
 	reqCopy := request.Msg
 
-	// get the receiver
 	receiver := reqCopy.GetReceiver()
 
-	// set the actor path with the remoting is enabled
 	if !x.remotingEnabled.Load() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition, ErrRemotingDisabled)
 	}
 
-	// construct the actor address
 	actorPath := NewPath(
 		receiver.GetName(),
 		NewAddress(
 			x.Name(),
 			receiver.GetHost(),
 			int(receiver.GetPort())))
-	// start or get the PID of the actor
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
-	// return an error when the remote address is not found
 	if !exist {
-		// log the error
 		logger.Error(ErrAddressNotFound(actorPath.String()).Error())
 		return nil, ErrAddressNotFound(actorPath.String())
 	}
 
-	// send the messages to the receiver mailbox
 	var messages []proto.Message
-	// let us unpack each message
 	for _, message := range reqCopy.GetMessages() {
-		// unmarshal the message
 		actual, err := message.UnmarshalNew()
-		// handle the error
 		if err != nil {
 			logger.Error(err)
 			return nil, connect.NewError(connect.CodeFailedPrecondition, err)
 		}
-		// add to the list of messages
 		messages = append(messages, actual)
 	}
 
-	// push the messages to the actor mailbox
 	if err := BatchTell(ctx, pid, messages...); err != nil {
-		// log the error
 		logger.Error(ErrRemoteSendFailure(err))
 		return nil, ErrRemoteSendFailure(err)
 	}
 
-	// return the rpc response
 	return connect.NewResponse(new(internalpb.RemoteBatchTellResponse)), nil
 }
 
 // RemoteBatchAsk is used to send a bulk messages to a remote actor with replies.
 // The replies are sent in the same order as the messages
 func (x *actorSystem) RemoteBatchAsk(ctx context.Context, request *connect.Request[internalpb.RemoteBatchAskRequest]) (*connect.Response[internalpb.RemoteBatchAskResponse], error) {
-	// get a context log
 	logger := x.logger
-	// first let us make a copy of the incoming request
 	reqCopy := request.Msg
 
-	// set the actor path with the remoting is enabled
 	if !x.remotingEnabled.Load() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition, ErrRemotingDisabled)
 	}
 
-	// construct the actor address
 	name := reqCopy.GetReceiver().GetName()
 	actorPath := NewPath(name, NewAddress(x.name, x.remotingHost, int(x.remotingPort)))
 
-	// start or get the PID of the actor
-	// check whether the given actor already exist in the system or not
 	pid, exist := x.actors.Get(actorPath)
-	// return an error when the remote address is not found
 	if !exist {
-		// log the error
 		logger.Error(ErrAddressNotFound(actorPath.String()).Error())
 		return nil, ErrAddressNotFound(actorPath.String())
 	}
 
-	// send the messages to the receiver mailbox
 	var messages []proto.Message
-	// let us unpack each message
 	for _, message := range reqCopy.GetMessages() {
-		// unmarshal the message
 		actual, err := message.UnmarshalNew()
-		// handle the error
 		if err != nil {
 			logger.Error(err)
 			return nil, connect.NewError(connect.CodeFailedPrecondition, err)
 		}
-		// add to the list of messages
 		messages = append(messages, actual)
 	}
 
-	// push the messages to the actor mailbox and await replies
 	replies, err := BatchAsk(ctx, pid, x.replyTimeout, messages...)
-	// handle the error
 	if err != nil {
-		// log the error
 		logger.Error(ErrRemoteSendFailure(err))
 		return nil, ErrRemoteSendFailure(err)
 	}
 
-	// define a variable to hold responses as they trickle in
 	var responses []*anypb.Any
 	for reply := range replies {
-		// let us unpack the responses
 		actual, err := anypb.New(reply)
-		// handle the error
 		if err != nil {
-			// log the error
 			logger.Error(err)
 			return nil, connect.NewError(connect.CodeFailedPrecondition, err)
 		}
 		responses = append(responses, actual)
 	}
 
-	// return the rpc response
 	return connect.NewResponse(&internalpb.RemoteBatchAskResponse{Messages: responses}), nil
 }
 
 // RemoteReSpawn is used the handle the re-creation of an actor from a remote host or from an api call
 func (x *actorSystem) RemoteReSpawn(ctx context.Context, request *connect.Request[internalpb.RemoteReSpawnRequest]) (*connect.Response[internalpb.RemoteReSpawnResponse], error) {
-	// get a context log
 	logger := x.logger
 
-	// first let us make a copy of the incoming request
 	reqCopy := request.Msg
 
-	// set the actor path with the remoting is enabled
 	if !x.remotingEnabled.Load() {
 		return nil, connect.NewError(connect.CodeFailedPrecondition, ErrRemotingDisabled)
 	}
 
-	// construct the actor address
 	actorPath := NewPath(reqCopy.GetName(), NewAddress(x.Name(), reqCopy.GetHost(), int(reqCopy.GetPort())))
-	// start or get the PID of the actor
-	// check whether the given actor already exist in the system or not
+
 	pid, exist := x.actors.Get(actorPath)
 
-	// return an error when the remote address is not found
 	if !exist {
-		// log the error
 		logger.Error(ErrAddressNotFound(actorPath.String()).Error())
 		return nil, ErrAddressNotFound(actorPath.String())
 	}
 
-	// restart the given actor
 	if err := pid.Restart(ctx); err != nil {
-		// return the error in case the restart failed
 		return nil, errors.Wrapf(err, "failed to restart actor=%s", actorPath.String())
 	}
 
-	// let us re-add the actor to the actor system list when it has successfully restarted
-	// add the given actor to the actor map
 	x.actors.Set(pid)
 
-	// return the response
 	return connect.NewResponse(new(internalpb.RemoteReSpawnResponse)), nil
 }
 
 // handleRemoteAsk handles a synchronous message to another actor and expect a response.
 // This block until a response is received or timed out.
 func (x *actorSystem) handleRemoteAsk(ctx context.Context, to PID, message proto.Message) (response proto.Message, err error) {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "HandleRemoteAsk")
-	// defer the closing of the span
 	defer span.End()
 	return Ask(spanCtx, to, message, x.replyTimeout)
 }
 
 // handleRemoteTell handles an asynchronous message to an actor
 func (x *actorSystem) handleRemoteTell(ctx context.Context, to PID, message proto.Message) error {
-	// start a tracing span
 	spanCtx, span := x.tracer.Start(ctx, "HandleRemoteTell")
-	// defer the closing of the span
 	defer span.End()
 	return Tell(spanCtx, to, message)
 }
@@ -1260,92 +1006,69 @@ func (x *actorSystem) handleRemoteTell(ctx context.Context, to PID, message prot
 // enableClustering enables clustering. When clustering is enabled remoting is also enabled to facilitate remote
 // communication
 func (x *actorSystem) enableClustering(ctx context.Context) {
-	// add some logging information
 	x.logger.Info("enabling clustering...")
 
-	// create an instance of the cluster service and start it
 	cluster, err := cluster.NewNode(x.Name(),
 		x.serviceDiscovery,
 		cluster.WithLogger(x.logger),
 		cluster.WithPartitionsCount(x.partitionsCount),
 		cluster.WithHasher(x.partitionHasher),
 	)
-	// handle the error
 	if err != nil {
 		x.logger.Panic(errors.Wrap(err, "failed to initialize cluster engine"))
 	}
 
-	// add some logging information
 	x.logger.Info("starting cluster engine...")
-	// start the cluster service
 	if err := cluster.Start(ctx); err != nil {
 		x.logger.Panic(errors.Wrap(err, "failed to start cluster engine"))
 	}
 
-	// create the bootstrap channel
 	bootstrapChan := make(chan struct{}, 1)
-	// let us wait for some time for the cluster to be properly started
 	timer := time.AfterFunc(time.Second, func() {
 		bootstrapChan <- struct{}{}
 	})
 	<-bootstrapChan
 	timer.Stop()
 
-	// add some logging information
 	x.logger.Info("cluster engine successfully started...")
-	// acquire the lock
-	x.sem.Lock()
-	// set the cluster field
+
+	x.mutex.Lock()
 	x.cluster = cluster
-	// set the cluster events channel
 	x.eventsChan = cluster.Events()
-	// set the remoting host and port
 	x.remotingHost = cluster.NodeHost()
 	x.remotingPort = int32(cluster.NodeRemotingPort())
-	// release the lock
-	x.sem.Unlock()
-	// start listening to cluster events
+	x.mutex.Unlock()
+
 	go x.broadcastClusterEvents()
-	// start broadcasting cluster message
 	go x.broadcast(ctx)
-	// add some logging
+
 	x.logger.Info("clustering enabled...:)")
 }
 
 // enableRemoting enables the remoting service to handle remote messaging
 func (x *actorSystem) enableRemoting(ctx context.Context) {
-	// add some logging information
 	x.logger.Info("enabling remoting...")
 
-	// define a variable to hold the interceptor
 	var interceptor *otelconnect.Interceptor
 	var err error
-	// only set the observability when metric or trace is enabled
 	if x.metricEnabled.Load() || x.traceEnabled.Load() {
-		// create an interceptor and panic
 		interceptor, err = otelconnect.NewInterceptor(
 			otelconnect.WithTracerProvider(x.telemetry.TracerProvider),
 			otelconnect.WithMeterProvider(x.telemetry.MeterProvider),
 		)
-		// panic when there is an error
 		if err != nil {
 			x.logger.Panic(errors.Wrap(err, "failed to initialize observability feature"))
 		}
 	}
 
-	// create the handler option
 	var opts []connect.HandlerOption
-	// set handler options when interceptor is defined
 	if interceptor != nil {
 		opts = append(opts, connect.WithInterceptors(interceptor))
 	}
 
-	// create a http service mux
 	mux := http.NewServeMux()
-	// create the resource and handler
 	path, handler := internalpbconnect.NewRemotingServiceHandler(x, opts...)
 	mux.Handle(path, handler)
-	// create the address
 	serverAddr := fmt.Sprintf("%s:%d", x.remotingHost, x.remotingPort)
 
 	// create a http service instance
@@ -1371,30 +1094,23 @@ func (x *actorSystem) enableRemoting(ctx context.Context) {
 		Handler: h2c.NewHandler(mux, &http2.Server{
 			IdleTimeout: 1200 * time.Second,
 		}),
-		// Set the base context to incoming context of the system
 		BaseContext: func(listener net.Listener) context.Context {
 			return ctx
 		},
 	}
 
-	// listen and service requests
 	go func() {
 		if err := server.ListenAndServe(); err != nil {
-			// check the error type
 			if !errors.Is(err, http.ErrServerClosed) {
 				x.logger.Panic(errors.Wrap(err, "failed to start remoting service"))
 			}
 		}
 	}()
 
-	// acquire the lock
-	x.sem.Lock()
-	// set the server
+	x.mutex.Lock()
 	x.remotingServer = server
-	// release the lock
-	x.sem.Unlock()
+	x.mutex.Unlock()
 
-	// add some logging information
 	x.logger.Info("remoting enabled...:)")
 }
 
@@ -1408,11 +1124,8 @@ func (x *actorSystem) reset() {
 
 // broadcast publishes newly created actor into the cluster when cluster is enabled
 func (x *actorSystem) broadcast(ctx context.Context) {
-	// iterate over the channel
 	for wireActor := range x.clusterChan {
-		// making sure the cluster is still enabled
 		if x.cluster != nil {
-			// broadcast the message on the cluster
 			if err := x.cluster.PutActor(ctx, wireActor); err != nil {
 				x.logger.Error(err.Error())
 				// TODO: stop or continue
@@ -1425,27 +1138,19 @@ func (x *actorSystem) broadcast(ctx context.Context) {
 // housekeeper time to time removes dead actors from the system
 // that helps free non-utilized resources
 func (x *actorSystem) housekeeper() {
-	// add some logging
 	x.logger.Info("Housekeeping has started...")
-	// create the ticker
 	ticker := time.NewTicker(30 * time.Millisecond)
-	// create the stop ticker signal
 	tickerStopSig := make(chan types.Unit, 1)
 	go func() {
 		for {
 			select {
 			case <-ticker.C:
-				// loop over the actors in the system and remove the dead one
 				for _, actor := range x.Actors() {
 					if !actor.IsRunning() {
 						x.logger.Infof("Removing actor=%s from system", actor.ActorPath().Name())
-						// delete the actor from the map
 						x.actors.Delete(actor.ActorPath())
-						// when cluster is enabled
 						if x.InCluster() {
-							// remove the actor
 							if err := x.cluster.RemoveActor(context.Background(), actor.ActorPath().Name()); err != nil {
-								// log the error
 								x.logger.Error(err.Error())
 								// TODO: stop or continue
 							}
@@ -1453,32 +1158,25 @@ func (x *actorSystem) housekeeper() {
 					}
 				}
 			case <-x.housekeeperStopSig:
-				// set the done channel to stop the ticker
 				tickerStopSig <- types.Unit{}
 				return
 			}
 		}
 	}()
-	// wait for the stop signal to stop the ticker
+
 	<-tickerStopSig
-	// stop the ticker
 	ticker.Stop()
-	// add some logging
 	x.logger.Info("Housekeeping has stopped...")
 }
 
 // registerMetrics register the PID metrics with OTel instrumentation.
 func (x *actorSystem) registerMetrics() error {
-	// grab the OTel meter
 	meter := x.telemetry.Meter
-	// create an instance of the ActorMetrics
 	metrics, err := metric.NewActorSystemMetric(meter)
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// register the metrics
 	_, err = meter.RegisterCallback(func(ctx context.Context, observer otelmetric.Observer) error {
 		observer.ObserveInt64(metrics.ActorsCount(), int64(x.NumActors()))
 		return nil
@@ -1489,21 +1187,13 @@ func (x *actorSystem) registerMetrics() error {
 
 // broadcastClusterEvents listens to cluster events
 func (x *actorSystem) broadcastClusterEvents() {
-	// read from the channel
 	for event := range x.eventsChan {
-		// when cluster is enabled
 		if x.clusterEnabled.Load() {
-			// only push cluster event when defined
 			if event != nil && event.Type != nil {
-				// unpack the event
 				message, _ := event.Type.UnmarshalNew()
-				// push the cluster event when event stream is set
 				if x.eventsStream != nil {
-					// add some debug log
 					x.logger.Debugf("node=(%s) publishing cluster event=(%s)....", x.name, event.Type.GetTypeUrl())
-					// send the event to the event streams
 					x.eventsStream.Publish(eventsTopic, message)
-					// add some debug log
 					x.logger.Debugf("cluster event=(%s) successfully published by node=(%s)", event.Type.GetTypeUrl(), x.name)
 				}
 			}
diff --git a/actors/address.go b/actors/address.go
index 3f15f07..75649bb 100644
--- a/actors/address.go
+++ b/actors/address.go
@@ -55,7 +55,6 @@ func NewAddress(system string, host string, port int) *Address {
 
 // WithHost sets the hosts of a given Address and returns a new instance of the address
 func (a *Address) WithHost(host string) (*Address, error) {
-	// only allow this operation if the given address is a remote one
 	if a.IsLocal() {
 		return nil, ErrLocalAddress
 	}
@@ -64,7 +63,6 @@ func (a *Address) WithHost(host string) (*Address, error) {
 
 // WithPort sets the port of a given Address and returns a new instance of the address
 func (a *Address) WithPort(port int) (*Address, error) {
-	// only allow this operation if the given address is a remote one
 	if a.IsLocal() {
 		return nil, ErrLocalAddress
 	}
@@ -115,9 +113,7 @@ func (a *Address) HostPort() string {
 // String returns the canonical String representation of this Address formatted as:
 // `protocol://system@host:port`
 func (a *Address) String() string {
-	// create a bytes buffer instance
 	buf := bytes.NewBuffer(nil)
-	// write the protocol field to bytes buffer
 	buf.WriteString(a.protocol)
 	buf.WriteString("://")
 	buf.WriteString(a.system)
diff --git a/actors/api.go b/actors/api.go
index 414b913..27f5de8 100644
--- a/actors/api.go
+++ b/actors/api.go
@@ -41,31 +41,23 @@ import (
 // Ask sends a synchronous message to another actor and expect a response.
 // This block until a response is received or timed out.
 func Ask(ctx context.Context, to PID, message proto.Message, timeout time.Duration) (response proto.Message, err error) {
-	// make sure the actor is live
 	if !to.IsRunning() {
 		return nil, ErrDead
 	}
 
-	// create a message context
 	var messageContext *receiveContext
 
-	// set the actual message
 	switch msg := message.(type) {
 	case *internalpb.RemoteMessage:
-		// define the actual message variable
 		var actual proto.Message
-		// unmarshal the message and handle the error
 		if actual, err = msg.GetMessage().UnmarshalNew(); err != nil {
 			return nil, ErrInvalidRemoteMessage(err)
 		}
-		// set the context message and the sender
 		messageContext = newReceiveContext(ctx, NoSender, to, actual, false).WithRemoteSender(msg.GetSender())
 	default:
-		// set the context message and the sender
 		messageContext = newReceiveContext(ctx, NoSender, to, message, false).WithRemoteSender(RemoteNoSender)
 	}
 
-	// put the message context in the mailbox of the recipient actor
 	to.doReceive(messageContext)
 
 	// await patiently to receive the response from the actor
@@ -75,9 +67,7 @@ func Ask(ctx context.Context, to PID, message proto.Message, timeout time.Durati
 			return
 		case <-await:
 			err = ErrRequestTimeout
-			// push the message as a deadletter
 			to.handleError(messageContext, err)
-			// stop the whole processing
 			return
 		}
 	}
@@ -85,35 +75,27 @@ func Ask(ctx context.Context, to PID, message proto.Message, timeout time.Durati
 
 // Tell sends an asynchronous message to an actor
 func Tell(ctx context.Context, to PID, message proto.Message) error {
-	// make sure the recipient actor is live
 	if !to.IsRunning() {
 		return ErrDead
 	}
 
-	// create a message context
 	var messageContext *receiveContext
 
-	// set the actual message
 	switch msg := message.(type) {
 	case *internalpb.RemoteMessage:
 		var (
-			// define the actual message variable
 			actual proto.Message
-			// define the error variable
-			err error
+			err    error
 		)
-		// unmarshal the message and handle the error
+
 		if actual, err = msg.GetMessage().UnmarshalNew(); err != nil {
 			return ErrInvalidRemoteMessage(err)
 		}
-		// set the context message and the sender
 		messageContext = newReceiveContext(ctx, NoSender, to, actual, true).WithRemoteSender(msg.GetSender())
 	default:
-		// set the context message and the sender
 		messageContext = newReceiveContext(ctx, NoSender, to, message, true).WithRemoteSender(RemoteNoSender)
 	}
 
-	// put the message context in the mailbox of the recipient actor
 	to.doReceive(messageContext)
 
 	return nil
@@ -121,18 +103,13 @@ func Tell(ctx context.Context, to PID, message proto.Message) error {
 
 // BatchTell sends bulk asynchronous messages to an actor
 func BatchTell(ctx context.Context, to PID, messages ...proto.Message) error {
-	// make sure the recipient actor is live
 	if !to.IsRunning() {
 		return ErrDead
 	}
 
-	// iterate the list messages
 	for i := 0; i < len(messages); i++ {
-		// get the message
 		message := messages[i]
-		// create a message context
 		messageContext := newReceiveContext(ctx, NoSender, to, message, true).WithRemoteSender(RemoteNoSender)
-		// put the message context in the mailbox of the recipient actor
 		to.doReceive(messageContext)
 	}
 	return nil
@@ -142,24 +119,16 @@ func BatchTell(ctx context.Context, to PID, messages ...proto.Message) error {
 // The messages will be processed one after the other in the order they are sent
 // This is a design choice to follow the simple principle of one message at a time processing by actors.
 func BatchAsk(ctx context.Context, to PID, timeout time.Duration, messages ...proto.Message) (responses chan proto.Message, err error) {
-	// make sure the actor is live
 	if !to.IsRunning() {
 		return nil, ErrDead
 	}
 
-	// create a buffered channel to hold the responses
 	responses = make(chan proto.Message, len(messages))
-
-	// close the responses channel when done
 	defer close(responses)
 
-	// let us process the messages one after the other
 	for i := 0; i < len(messages); i++ {
-		// grab the message at index i
 		message := messages[i]
-		// create a message context
 		messageContext := newReceiveContext(ctx, NoSender, to, message, false)
-		// push the message to the actor mailbox
 		to.doReceive(messageContext)
 
 		// await patiently to receive the response from the actor
@@ -167,15 +136,11 @@ func BatchAsk(ctx context.Context, to PID, timeout time.Duration, messages ...pr
 		for await := time.After(timeout); ; {
 			select {
 			case resp := <-messageContext.response:
-				// send the response to the responses channel
 				responses <- resp
 				break timerLoop
 			case <-await:
-				// set the request timeout error
 				err = ErrRequestTimeout
-				// push the message as a deadletter
 				to.handleError(messageContext, err)
-				// stop the whole processing
 				return
 			}
 		}
@@ -185,27 +150,23 @@ func BatchAsk(ctx context.Context, to PID, timeout time.Duration, messages ...pr
 
 // RemoteTell sends a message to an actor remotely without expecting any reply
 func RemoteTell(ctx context.Context, to *goaktpb.Address, message proto.Message) error {
-	// marshal the message
 	marshaled, err := anypb.New(message)
 	if err != nil {
 		return ErrInvalidRemoteMessage(err)
 	}
 
-	// create an interceptor
 	interceptor, err := otelconnect.NewInterceptor()
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(to.GetHost(), int(to.GetPort())),
 		connect.WithInterceptors(interceptor),
 		connect.WithGRPC(),
 	)
-	// prepare the rpcRequest to send
+
 	request := connect.NewRequest(&internalpb.RemoteTellRequest{
 		RemoteMessage: &internalpb.RemoteMessage{
 			Sender:   RemoteNoSender,
@@ -213,7 +174,7 @@ func RemoteTell(ctx context.Context, to *goaktpb.Address, message proto.Message)
 			Message:  marshaled,
 		},
 	})
-	// send the message and handle the error in case there is any
+
 	if _, err := remoteClient.RemoteTell(ctx, request); err != nil {
 		return err
 	}
@@ -222,27 +183,23 @@ func RemoteTell(ctx context.Context, to *goaktpb.Address, message proto.Message)
 
 // RemoteAsk sends a synchronous message to another actor remotely and expect a response.
 func RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.Message) (response *anypb.Any, err error) {
-	// marshal the message
 	marshaled, err := anypb.New(message)
 	if err != nil {
 		return nil, ErrInvalidRemoteMessage(err)
 	}
 
-	// create an interceptor
 	interceptor, err := otelconnect.NewInterceptor()
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(to.GetHost(), int(to.GetPort())),
 		connect.WithInterceptors(interceptor),
 		connect.WithGRPC(),
 	)
-	// prepare the rpcRequest to send
+
 	rpcRequest := connect.NewRequest(&internalpb.RemoteAskRequest{
 		RemoteMessage: &internalpb.RemoteMessage{
 			Sender:   RemoteNoSender,
@@ -250,9 +207,8 @@ func RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.Message)
 			Message:  marshaled,
 		},
 	})
-	// send the request
+
 	rpcResponse, rpcErr := remoteClient.RemoteAsk(ctx, rpcRequest)
-	// handle the error
 	if rpcErr != nil {
 		return nil, rpcErr
 	}
@@ -262,14 +218,11 @@ func RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.Message)
 
 // RemoteLookup look for an actor address on a remote node.
 func RemoteLookup(ctx context.Context, host string, port int, name string) (addr *goaktpb.Address, err error) {
-	// create an interceptor
 	interceptor, err := otelconnect.NewInterceptor()
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(host, port),
@@ -283,9 +236,8 @@ func RemoteLookup(ctx context.Context, host string, port int, name string) (addr
 		Port: int32(port),
 		Name: name,
 	})
-	// send the message and handle the error in case there is any
+
 	response, err := remoteClient.RemoteLookup(ctx, request)
-	// we know the error will always be a grpc error
 	if err != nil {
 		code := connect.CodeOf(err)
 		if code == connect.CodeNotFound {
@@ -294,34 +246,25 @@ func RemoteLookup(ctx context.Context, host string, port int, name string) (addr
 		return nil, err
 	}
 
-	// return the response
 	return response.Msg.GetAddress(), nil
 }
 
 // RemoteBatchTell sends bulk asynchronous messages to an actor
 func RemoteBatchTell(ctx context.Context, to *goaktpb.Address, messages ...proto.Message) error {
-	// create an interceptor
 	interceptor, err := otelconnect.NewInterceptor()
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// define a variable holding the remote messages
 	var remoteMessages []*anypb.Any
-	// iterate the list of messages and pack them
 	for _, message := range messages {
-		// let us pack it
 		packed, err := anypb.New(message)
-		// handle the error
 		if err != nil {
 			return ErrInvalidRemoteMessage(err)
 		}
-		// add it to the list of remote messages
 		remoteMessages = append(remoteMessages, packed)
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(to.GetHost(), int(to.GetPort())),
@@ -329,13 +272,12 @@ func RemoteBatchTell(ctx context.Context, to *goaktpb.Address, messages ...proto
 		connect.WithGRPC(),
 	)
 
-	// prepare the remote batch tell request
 	request := connect.NewRequest(&internalpb.RemoteBatchTellRequest{
 		Messages: remoteMessages,
 		Sender:   RemoteNoSender,
 		Receiver: to,
 	})
-	// send the message and handle the error in case there is any
+
 	if _, err := remoteClient.RemoteBatchTell(ctx, request); err != nil {
 		return err
 	}
@@ -344,28 +286,20 @@ func RemoteBatchTell(ctx context.Context, to *goaktpb.Address, messages ...proto
 
 // RemoteBatchAsk sends bulk messages to an actor with responses expected
 func RemoteBatchAsk(ctx context.Context, to *goaktpb.Address, messages ...proto.Message) (responses []*anypb.Any, err error) {
-	// create an interceptor
 	interceptor, err := otelconnect.NewInterceptor()
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// define a variable holding the remote messages
 	var remoteMessages []*anypb.Any
-	// iterate the list of messages and pack them
 	for _, message := range messages {
-		// let us pack it
 		packed, err := anypb.New(message)
-		// handle the error
 		if err != nil {
 			return nil, ErrInvalidRemoteMessage(err)
 		}
-		// add it to the list of remote messages
 		remoteMessages = append(remoteMessages, packed)
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(to.GetHost(), int(to.GetPort())),
@@ -373,32 +307,26 @@ func RemoteBatchAsk(ctx context.Context, to *goaktpb.Address, messages ...proto.
 		connect.WithGRPC(),
 	)
 
-	// prepare the remote batch tell request
 	request := connect.NewRequest(&internalpb.RemoteBatchAskRequest{
 		Messages: remoteMessages,
 		Sender:   RemoteNoSender,
 		Receiver: to,
 	})
-	// send the message and handle the error in case there is any
+
 	response, err := remoteClient.RemoteBatchAsk(ctx, request)
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
-	// return the responses
 	return response.Msg.GetMessages(), nil
 }
 
 // RemoteReSpawn restarts actor address on a remote node.
 func RemoteReSpawn(ctx context.Context, host string, port int, name string) error {
-	// create an interceptor
 	interceptor, err := otelconnect.NewInterceptor()
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(host, port),
@@ -406,13 +334,12 @@ func RemoteReSpawn(ctx context.Context, host string, port int, name string) erro
 		connect.WithGRPC(),
 	)
 
-	// prepare the request to send
 	request := connect.NewRequest(&internalpb.RemoteReSpawnRequest{
 		Host: host,
 		Port: int32(port),
 		Name: name,
 	})
-	// send the message and handle the error in case there is any
+
 	if _, err = remoteClient.RemoteReSpawn(ctx, request); err != nil {
 		code := connect.CodeOf(err)
 		if code == connect.CodeNotFound {
@@ -421,6 +348,5 @@ func RemoteReSpawn(ctx context.Context, host string, port int, name string) erro
 		return err
 	}
 
-	// return the response
 	return nil
 }
diff --git a/actors/context.go b/actors/context.go
index 3dc8efd..9ad9ca2 100644
--- a/actors/context.go
+++ b/actors/context.go
@@ -297,9 +297,7 @@ func (c *receiveContext) Tell(to PID, message proto.Message) {
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	if err := recipient.Tell(ctx, to, message); err != nil {
 		panic(err)
 	}
@@ -313,9 +311,7 @@ func (c *receiveContext) BatchTell(to PID, messages ...proto.Message) {
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	if err := recipient.BatchTell(ctx, to, messages...); err != nil {
 		c.Err(err)
 	}
@@ -328,9 +324,7 @@ func (c *receiveContext) Ask(to PID, message proto.Message) (response proto.Mess
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	reply, err := recipient.Ask(ctx, to, message)
 	if err != nil {
 		c.Err(err)
@@ -345,9 +339,7 @@ func (c *receiveContext) BatchAsk(to PID, messages ...proto.Message) (responses
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	reply, err := recipient.BatchAsk(ctx, to, messages...)
 	if err != nil {
 		c.Err(err)
@@ -360,9 +352,7 @@ func (c *receiveContext) RemoteTell(to *goaktpb.Address, message proto.Message)
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	if err := recipient.RemoteTell(ctx, to, message); err != nil {
 		c.Err(err)
 	}
@@ -374,9 +364,7 @@ func (c *receiveContext) RemoteAsk(to *goaktpb.Address, message proto.Message) (
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	reply, err := recipient.RemoteAsk(ctx, to, message)
 	if err != nil {
 		c.Err(err)
@@ -390,9 +378,7 @@ func (c *receiveContext) RemoteBatchTell(to *goaktpb.Address, messages ...proto.
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient and let it crash
 	if err := recipient.RemoteBatchTell(ctx, to, messages...); err != nil {
 		c.Err(err)
 	}
@@ -405,9 +391,7 @@ func (c *receiveContext) RemoteBatchAsk(to *goaktpb.Address, messages ...proto.M
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// send the message to the recipient or let it crash
 	replies, err := recipient.RemoteBatchAsk(ctx, to, messages...)
 	if err != nil {
 		c.Err(err)
@@ -421,9 +405,7 @@ func (c *receiveContext) RemoteLookup(host string, port int, name string) (addr
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// perform the lookup or let it crash
 	remoteAddr, err := recipient.RemoteLookup(ctx, host, port, name)
 	if err != nil {
 		c.Err(err)
@@ -438,7 +420,6 @@ func (c *receiveContext) Shutdown() {
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
 	if err := recipient.Shutdown(ctx); err != nil {
 		c.Err(err)
@@ -450,9 +431,7 @@ func (c *receiveContext) Spawn(name string, actor Actor) PID {
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
-	// create the child actor or let it crash
 	pid, err := recipient.SpawnChild(ctx, name, actor)
 	if err != nil {
 		c.Err(err)
@@ -485,7 +464,7 @@ func (c *receiveContext) Stop(child PID) {
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
+
 	ctx := context.WithoutCancel(c.ctx)
 	err := recipient.Stop(ctx, child)
 	if err != nil {
@@ -498,18 +477,13 @@ func (c *receiveContext) Stop(child PID) {
 // The message that is forwarded is the current message received by the received context.
 // This operation does nothing when the receiving actor is not running
 func (c *receiveContext) Forward(to PID) {
-	// grab the actual message
 	message := c.Message()
-	// grab the sender of the message
 	sender := c.Sender()
-	// forward the actual message
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	// only forward when the receiving actor is running
+
 	if to.IsRunning() {
-		// create a new context from the parent context
 		ctx := context.WithoutCancel(c.ctx)
-		// create a receiveContext
 		receiveContext := &receiveContext{
 			ctx:            ctx,
 			message:        message,
@@ -518,19 +492,15 @@ func (c *receiveContext) Forward(to PID) {
 			mu:             sync.Mutex{},
 			isAsyncMessage: false,
 		}
-		// forward the actual message
 		to.doReceive(receiveContext)
 	}
 }
 
 // Unhandled is used to handle unhandled messages instead of throwing error
 func (c *receiveContext) Unhandled() {
-	// acquire the lock
 	c.mu.Lock()
 	me := c.recipient
-	// release the lock
 	c.mu.Unlock()
-	// send the current message to deadletters
 	me.handleError(c, ErrUnhandled)
 }
 
@@ -539,7 +509,6 @@ func (c *receiveContext) RemoteReSpawn(host string, port int, name string) {
 	c.mu.Lock()
 	recipient := c.recipient
 	defer c.mu.Unlock()
-	// create a new context from the parent context
 	ctx := context.WithoutCancel(c.ctx)
 	err := recipient.RemoteReSpawn(ctx, host, port, name)
 	if err != nil {
diff --git a/actors/option.go b/actors/option.go
index ec3fe0c..91a91d5 100644
--- a/actors/option.go
+++ b/actors/option.go
@@ -148,7 +148,7 @@ func WithMailbox(mailbox Mailbox) Option {
 // WithStash sets the stash buffer size
 func WithStash(capacity uint64) Option {
 	return OptionFunc(func(a *actorSystem) {
-		a.stashBuffer = capacity
+		a.stashCapacity = capacity
 	})
 }
 
diff --git a/actors/pid.go b/actors/pid.go
index d02e845..27c2616 100644
--- a/actors/pid.go
+++ b/actors/pid.go
@@ -252,7 +252,6 @@ var _ PID = (*pid)(nil)
 
 // newPID creates a new pid
 func newPID(ctx context.Context, actorPath *Path, actor Actor, opts ...pidOption) (*pid, error) {
-	// create the actor PID
 	p := &pid{
 		Actor:              actor,
 		lastProcessingTime: atomic.Time{},
@@ -277,7 +276,6 @@ func newPID(ctx context.Context, actorPath *Path, actor Actor, opts ...pidOption
 		childrenCount:      atomic.NewInt64(0),
 	}
 
-	// set some of the defaults values
 	p.initMaxRetries.Store(DefaultInitMaxRetries)
 	p.shutdownTimeout.Store(DefaultShutdownTimeout)
 	p.lastProcessingDuration.Store(0)
@@ -289,56 +287,44 @@ func newPID(ctx context.Context, actorPath *Path, actor Actor, opts ...pidOption
 	p.traceEnabled.Store(false)
 	p.metricEnabled.Store(false)
 
-	// set the custom options to override the default values
 	for _, opt := range opts {
 		opt(p)
 	}
 
-	// set the default mailbox if mailbox is not set
 	if p.mailbox == nil {
 		p.mailbox = newReceiveContextBuffer(p.mailboxSize)
 	}
 
-	// set the stash buffer when capacity is set
 	if p.stashCapacity.Load() > 0 {
 		p.stashBuffer = newReceiveContextBuffer(p.stashCapacity.Load())
 	}
 
-	// set the actor behavior stack
 	behaviorStack := newBehaviorStack()
 	behaviorStack.Push(p.Receive)
 	p.behaviorStack = behaviorStack
 
-	// set the tracer when tracing is enabled
 	if p.traceEnabled.Load() {
 		p.tracer = p.telemetry.Tracer
 	}
 
-	// initialize the actor and init processing public
 	if err := p.init(ctx); err != nil {
 		return nil, err
 	}
 
-	// init processing messages
 	go p.receive()
 
-	// init the passivation listener loop iff passivation is set
 	if p.passivateAfter.Load() > 0 {
 		go p.passivationListener()
 	}
 
-	// register metrics. However, we don't panic when we fail to register
 	if p.metricEnabled.Load() {
 		if err := p.registerMetrics(); err != nil {
-			// return the error
 			return nil, errors.Wrapf(err, "failed to register actor=%s metrics", p.ActorPath().String())
 		}
 	}
 
-	// put the message context in the mailbox of the recipient actor that the actor has started
 	p.doReceive(newReceiveContext(ctx, NoSender, p, new(goaktpb.PostStart), true))
 
-	// return the actor reference
 	return p, nil
 }
 
@@ -349,19 +335,12 @@ func (p *pid) ActorHandle() Actor {
 
 // Child returns the named child actor if it is alive
 func (p *pid) Child(name string) (PID, error) {
-	// first check whether the actor is ready to stop another actor
 	if !p.IsRunning() {
 		return nil, ErrDead
 	}
-
-	// create the child actor path
 	childActorPath := NewPath(name, p.ActorPath().Address()).WithParent(p.ActorPath())
-
-	// check whether the child actor already exist and just return the PID
 	if cid, ok := p.children.Get(childActorPath); ok {
-		// increment the children count
 		p.childrenCount.Inc()
-		// return the child PID
 		return cid, nil
 	}
 	return nil, ErrActorNotFound(childActorPath.String())
@@ -373,7 +352,6 @@ func (p *pid) Children() []PID {
 	children := p.children.List()
 	p.rwMutex.RUnlock()
 
-	// create the list of alive children
 	cids := make([]PID, 0, len(children))
 	for _, child := range children {
 		if child.IsRunning() {
@@ -387,53 +365,38 @@ func (p *pid) Children() []PID {
 // Stop forces the child Actor under the given name to terminate after it finishes processing its current message.
 // Nothing happens if child is already stopped.
 func (p *pid) Stop(ctx context.Context, cid PID) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "Stop")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether the actor is ready to stop another actor
 	if !p.IsRunning() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Stop")
 		span.RecordError(ErrDead)
-		// return the error
 		return ErrDead
 	}
 
-	// check the pid is not nil
 	if cid == nil || cid == NoSender {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Stop")
 		span.RecordError(ErrUndefinedActor)
-		// return the error
 		return ErrUndefinedActor
 	}
 
-	// grab the children thread-safely
 	p.rwMutex.RLock()
 	children := p.children
 	p.rwMutex.RUnlock()
 
-	// lookup the child actor and shut it down
 	if cid, ok := children.Get(cid.ActorPath()); ok {
-		// define the error description
 		desc := fmt.Sprintf("child.[%s] Shutdown", cid.ActorPath())
-		// stop the actor and record the error in the span
 		if err := cid.Shutdown(spanCtx); err != nil {
-			// let us record the error in the span
 			span.SetStatus(codes.Error, desc)
 			span.RecordError(err)
-			// return the error
 			return err
 		}
-		// set the status to ok
+
 		span.SetStatus(codes.Ok, desc)
 		return nil
 	}
-	// create an instance of error
+
 	err := ErrActorNotFound(cid.ActorPath().String())
-	// let us record the error in the span
 	span.SetStatus(codes.Error, "Stop")
 	span.RecordError(err)
 	return err
@@ -464,37 +427,25 @@ func (p *pid) ActorPath() *Path {
 // Restart restarts the actor.
 // During restart all messages that are in the mailbox and not yet processed will be ignored
 func (p *pid) Restart(ctx context.Context) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "Restart")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether we have an empty PID
 	if p == nil || p.ActorPath() == nil {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Restart")
 		span.RecordError(ErrUndefinedActor)
-		// return the error
 		return ErrUndefinedActor
 	}
 
-	// add some debug logging
 	p.logger.Debugf("restarting actor=(%s)", p.actorPath.String())
 
-	// only restart the actor when the actor is running
 	if p.IsRunning() {
-		// shutdown the actor. no need to record the error
-		// because it is already recorded in the Shutdown
 		if err := p.Shutdown(spanCtx); err != nil {
 			return err
 		}
-		// wait a while for the shutdown process to complete
 		ticker := time.NewTicker(10 * time.Millisecond)
-		// create the ticker stop signal
 		tickerStopSig := make(chan types.Unit, 1)
 		go func() {
 			for range ticker.C {
-				// stop ticking once the actor is offline
 				if !p.IsRunning() {
 					tickerStopSig <- types.Unit{}
 					return
@@ -505,71 +456,52 @@ func (p *pid) Restart(ctx context.Context) error {
 		ticker.Stop()
 	}
 
-	// set the default mailbox if mailbox is not set
 	p.mailbox.Reset()
-	// reset the behavior
 	p.resetBehavior()
-	// initialize the actor
 	if err := p.init(spanCtx); err != nil {
 		return err
 	}
-	// init processing public
 	go p.receive()
-	// init the passivation listener loop iff passivation is set
 	if p.passivateAfter.Load() > 0 {
 		go p.passivationListener()
 	}
 
-	// successful restart
 	span.SetStatus(codes.Ok, "Restart")
-	// increment the restart count
 	p.restartCount.Inc()
-	// emit actor started event
+
 	if p.eventsStream != nil {
-		// send the event to the event streams
 		p.eventsStream.Publish(eventsTopic, &goaktpb.ActorRestarted{
 			Address:     p.ActorPath().RemoteAddress(),
 			RestartedAt: timestamppb.Now(),
 		})
 	}
-	// return
+
 	return nil
 }
 
 // SpawnChild creates a child actor and start watching it for error
 // When the given child actor already exists its PID will only be returned
 func (p *pid) SpawnChild(ctx context.Context, name string, actor Actor) (PID, error) {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "SpawnChild")
-	// defer the closing of the span
 	defer span.End()
 
-	// first check whether the actor is ready to start another actor
 	if !p.IsRunning() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "SpawnChild")
 		span.RecordError(ErrDead)
-		// return the error
 		return nil, ErrDead
 	}
 
-	// create the child actor path
 	childActorPath := NewPath(name, p.ActorPath().Address()).WithParent(p.ActorPath())
 
-	// grab the children thread-safely
 	p.rwMutex.RLock()
 	children := p.children
 	p.rwMutex.RUnlock()
 
-	// check whether the child actor already exist and just return the PID
-	// whenever a child actor exists it means it is live
 	if cid, ok := children.Get(childActorPath); ok {
 		return cid, nil
 	}
 
-	// acquire the lock
 	p.rwMutex.Lock()
-	// release the lock
 	defer p.rwMutex.Unlock()
 
 	// create the child actor options child inherit parent's options
@@ -588,97 +520,74 @@ func (p *pid) SpawnChild(ctx context.Context, name string, actor Actor) (PID, er
 		withShutdownTimeout(p.shutdownTimeout.Load()),
 	}
 
-	// set the tracing option
 	if p.traceEnabled.Load() {
 		opts = append(opts, withTracing())
 	}
 
-	// set the pid metric option
 	if p.metricEnabled.Load() {
 		opts = append(opts, withMetric())
 	}
 
-	// create the child pid
 	cid, err := newPID(spanCtx,
 		childActorPath,
 		actor,
 		opts...,
 	)
 
-	// handle the error
 	if err != nil {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "SpawnChild")
 		span.RecordError(err)
-		// return the error
 		return nil, err
 	}
 
-	// add the pid to the map
 	p.children.Set(cid)
-
-	// let us start watching it
 	p.Watch(cid)
 
-	// set the span status and return
 	span.SetStatus(codes.Ok, "SpawnChild")
 
-	// emit actor started event
 	if p.eventsStream != nil {
-		// send the event to the event streams
 		p.eventsStream.Publish(eventsTopic, &goaktpb.ActorChildCreated{
 			Address:   cid.ActorPath().RemoteAddress(),
 			CreatedAt: timestamppb.Now(),
 			Parent:    p.ActorPath().RemoteAddress(),
 		})
 	}
+
 	return cid, nil
 }
 
 // StashSize returns the stash buffer size
 func (p *pid) StashSize() uint64 {
-	// avoid panic in case stash is not enabled
 	if p.stashBuffer == nil {
 		return 0
 	}
-	// return the stash buffer size
 	return p.stashBuffer.Size()
 }
 
 // Ask sends a synchronous message to another actor and expect a response.
 // This block until a response is received or timed out.
 func (p *pid) Ask(ctx context.Context, to PID, message proto.Message) (response proto.Message, err error) {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "Ask")
-	// defer the closing of the span
 	defer span.End()
 
-	// make sure the actor is live
 	if !to.IsRunning() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Ask")
 		span.RecordError(ErrDead)
-		// return the error
 		return nil, ErrDead
 	}
 
-	// create a message context
 	messageContext := newReceiveContext(spanCtx, p, to, message, false)
-	// put the message context in the mailbox of the recipient actor
 	to.doReceive(messageContext)
-	// await patiently to receive the response from the actor
+
 	for await := time.After(p.replyTimeout.Load()); ; {
 		select {
 		case response = <-messageContext.response:
-			// set the span status to Ok
 			span.SetStatus(codes.Ok, "Ask")
 			return
 		case <-await:
 			err = ErrRequestTimeout
-			// let us record the error in the span
 			span.SetStatus(codes.Error, "Ask")
 			span.RecordError(err)
-			// push the message as a deadletter
 			p.handleError(messageContext, err)
 			return nil, err
 		}
@@ -687,25 +596,18 @@ func (p *pid) Ask(ctx context.Context, to PID, message proto.Message) (response
 
 // Tell sends an asynchronous message to another PID
 func (p *pid) Tell(ctx context.Context, to PID, message proto.Message) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "Tell")
-	// defer the closing of the span
 	defer span.End()
 
-	// make sure the recipient actor is live
 	if !to.IsRunning() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Tell")
 		span.RecordError(ErrDead)
-		// return the error
 		return ErrDead
 	}
-	// create a message context
+
 	messageContext := newReceiveContext(spanCtx, p, to, message, true)
-	// put the message context in the mailbox of the recipient actor
 	to.doReceive(messageContext)
 
-	// set the status to OK and return
 	span.SetStatus(codes.Ok, "Tell")
 	return nil
 }
@@ -715,37 +617,26 @@ func (p *pid) Tell(ctx context.Context, to PID, message proto.Message) error {
 // This is a design choice to follow the simple principle of one message at a time processing by actors.
 // When BatchTell encounter a single message it will fall back to a Tell call.
 func (p *pid) BatchTell(ctx context.Context, to PID, messages ...proto.Message) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "BatchTell")
-	// defer the closing of the span
 	defer span.End()
 
-	// make sure the recipient actor is live
 	if !to.IsRunning() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "BatchTell")
 		span.RecordError(ErrDead)
-		// return the error
 		return ErrDead
 	}
 
-	// first check whether we need to fall back to a Tell
 	if len(messages) == 1 {
 		// no need to record span error here because Tell handles it
 		return p.Tell(spanCtx, to, messages[0])
 	}
 
-	// let us process the messages one after the other
 	for i := 0; i < len(messages); i++ {
-		// grab the message at index i
 		message := messages[i]
-		// create a message context
 		messageContext := newReceiveContext(ctx, p, to, message, true)
-		// push the message to the actor mailbox
 		to.doReceive(messageContext)
 	}
 
-	// set the span status and return
 	span.SetStatus(codes.Ok, "BatchTell")
 	return nil
 }
@@ -754,33 +645,21 @@ func (p *pid) BatchTell(ctx context.Context, to PID, messages ...proto.Message)
 // The messages will be processed one after the other in the order they are sent.
 // This is a design choice to follow the simple principle of one message at a time processing by actors.
 func (p *pid) BatchAsk(ctx context.Context, to PID, messages ...proto.Message) (responses chan proto.Message, err error) {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "BatchAsk")
-	// defer the closing of the span
 	defer span.End()
 
-	// make sure the actor is live
 	if !to.IsRunning() {
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "BatchAsk")
 		span.RecordError(ErrDead)
-		// return the error
 		return nil, ErrDead
 	}
 
-	// create a buffered channel to hold the responses
 	responses = make(chan proto.Message, len(messages))
-
-	// close the responses channel when done
 	defer close(responses)
 
-	// let us process the messages one after the other
 	for i := 0; i < len(messages); i++ {
-		// grab the message at index i
 		message := messages[i]
-		// create a message context
 		messageContext := newReceiveContext(spanCtx, p, to, message, false)
-		// push the message to the actor mailbox
 		to.doReceive(messageContext)
 
 		// await patiently to receive the response from the actor
@@ -788,19 +667,14 @@ func (p *pid) BatchAsk(ctx context.Context, to PID, messages ...proto.Message) (
 		for await := time.After(p.replyTimeout.Load()); ; {
 			select {
 			case resp := <-messageContext.response:
-				// send the response to the responses channel
 				responses <- resp
 				span.SetStatus(codes.Ok, "BatchAsk")
 				break timerLoop
 			case <-await:
-				// set the request timeout error
 				err = ErrRequestTimeout
-				// let us record the error in the span
 				span.SetStatus(codes.Error, "BatchAsk")
 				span.RecordError(err)
-				// push the message as a deadletter
 				p.handleError(messageContext, err)
-				// stop the whole processing
 				return nil, err
 			}
 		}
@@ -810,29 +684,24 @@ func (p *pid) BatchAsk(ctx context.Context, to PID, messages ...proto.Message) (
 
 // RemoteLookup look for an actor address on a remote node.
 func (p *pid) RemoteLookup(ctx context.Context, host string, port int, name string) (addr *goaktpb.Address, err error) {
-	// get the gRPC client connection options
 	clientConnectionOptions, err := p.getConnectionOptions()
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		p.httpClient,
 		http.URL(host, port),
 		clientConnectionOptions...,
 	)
 
-	// prepare the request to send
 	request := connect.NewRequest(&internalpb.RemoteLookupRequest{
 		Host: host,
 		Port: int32(port),
 		Name: name,
 	})
-	// send the message and handle the error in case there is any
+
 	response, err := remoteClient.RemoteLookup(ctx, request)
-	// we know the error will always be a grpc error
 	if err != nil {
 		code := connect.CodeOf(err)
 		if code == connect.CodeNotFound {
@@ -840,33 +709,28 @@ func (p *pid) RemoteLookup(ctx context.Context, host string, port int, name stri
 		}
 		return nil, err
 	}
-	// return the response
+
 	return response.Msg.GetAddress(), nil
 }
 
 // RemoteTell sends a message to an actor remotely without expecting any reply
 func (p *pid) RemoteTell(ctx context.Context, to *goaktpb.Address, message proto.Message) error {
-	// marshal the message
 	marshaled, err := anypb.New(message)
 	if err != nil {
 		return err
 	}
 
-	// get the gRPC client connection options
 	clientConnectionOptions, err := p.getConnectionOptions()
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		p.httpClient,
 		http.URL(to.GetHost(), int(to.GetPort())),
 		clientConnectionOptions...,
 	)
 
-	// construct the from address
 	sender := &goaktpb.Address{
 		Host: p.ActorPath().Address().Host(),
 		Port: int32(p.ActorPath().Address().Port()),
@@ -874,7 +738,6 @@ func (p *pid) RemoteTell(ctx context.Context, to *goaktpb.Address, message proto
 		Id:   p.ActorPath().ID().String(),
 	}
 
-	// prepare the rpcRequest to send
 	request := connect.NewRequest(&internalpb.RemoteTellRequest{
 		RemoteMessage: &internalpb.RemoteMessage{
 			Sender:   sender,
@@ -883,47 +746,38 @@ func (p *pid) RemoteTell(ctx context.Context, to *goaktpb.Address, message proto
 		},
 	})
 
-	// add some debug logging
 	p.logger.Debugf("sending a message to remote=(%s:%d)", to.GetHost(), to.GetPort())
 
-	// send the message and handle the error in case there is any
 	if _, err := remoteClient.RemoteTell(ctx, request); err != nil {
 		p.logger.Error(errors.Wrapf(err, "failed to send message to remote=(%s:%d)", to.GetHost(), to.GetPort()))
 		return err
 	}
 
-	// add some debug logging
 	p.logger.Debugf("message successfully sent to remote=(%s:%d)", to.GetHost(), to.GetPort())
 	return nil
 }
 
 // RemoteAsk sends a synchronous message to another actor remotely and expect a response.
 func (p *pid) RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.Message) (response *anypb.Any, err error) {
-	// marshal the message
 	marshaled, err := anypb.New(message)
 	if err != nil {
 		return nil, err
 	}
 
-	// get the gRPC client connection options
 	clientConnectionOptions, err := p.getConnectionOptions()
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		p.httpClient,
 		http.URL(to.GetHost(), int(to.GetPort())),
 		clientConnectionOptions...,
 	)
 
-	// create the sender path
 	senderPath := p.ActorPath()
 	senderAddress := senderPath.Address()
 
-	// construct the from address
 	sender := &goaktpb.Address{
 		Host: senderAddress.Host(),
 		Port: int32(senderAddress.Port()),
@@ -931,7 +785,6 @@ func (p *pid) RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.
 		Id:   senderPath.ID().String(),
 	}
 
-	// prepare the rpcRequest to send
 	rpcRequest := connect.NewRequest(
 		&internalpb.RemoteAskRequest{
 			RemoteMessage: &internalpb.RemoteMessage{
@@ -940,9 +793,8 @@ func (p *pid) RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.
 				Message:  marshaled,
 			},
 		})
-	// send the request
+
 	rpcResponse, rpcErr := remoteClient.RemoteAsk(ctx, rpcRequest)
-	// handle the error
 	if rpcErr != nil {
 		return nil, rpcErr
 	}
@@ -953,30 +805,22 @@ func (p *pid) RemoteAsk(ctx context.Context, to *goaktpb.Address, message proto.
 // RemoteBatchTell sends a batch of messages to a remote actor in a way fire-and-forget manner
 // Messages are processed one after the other in the order they are sent.
 func (p *pid) RemoteBatchTell(ctx context.Context, to *goaktpb.Address, messages ...proto.Message) error {
-	// first check whether we need to fall back to a Tell
 	if len(messages) == 1 {
 		return p.RemoteTell(ctx, to, messages[0])
 	}
 
-	// define a variable holding the remote messages
 	var remoteMessages []*anypb.Any
-	// iterate the list of messages and pack them
 	for _, message := range messages {
-		// let us pack it
 		packed, err := anypb.New(message)
-		// handle the error
 		if err != nil {
 			return ErrInvalidRemoteMessage(err)
 		}
-		// add it to the list of remote messages
 		remoteMessages = append(remoteMessages, packed)
 	}
 
-	// create the sender path
 	senderPath := p.ActorPath()
 	senderAddress := senderPath.Address()
 
-	// construct the from address
 	sender := &goaktpb.Address{
 		Host: senderAddress.Host(),
 		Port: int32(senderAddress.Port()),
@@ -984,28 +828,23 @@ func (p *pid) RemoteBatchTell(ctx context.Context, to *goaktpb.Address, messages
 		Id:   senderPath.ID().String(),
 	}
 
-	// get the gRPC client connection options
 	clientConnectionOptions, err := p.getConnectionOptions()
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(to.GetHost(), int(to.GetPort())),
 		clientConnectionOptions...,
 	)
 
-	// prepare the remote batch tell request
 	request := connect.NewRequest(&internalpb.RemoteBatchTellRequest{
 		Messages: remoteMessages,
 		Sender:   sender,
 		Receiver: to,
 	})
 
-	// send the message and handle the error in case there is any
 	if _, err := remoteClient.RemoteBatchTell(ctx, request); err != nil {
 		return err
 	}
@@ -1016,25 +855,18 @@ func (p *pid) RemoteBatchTell(ctx context.Context, to *goaktpb.Address, messages
 // Messages are processed one after the other in the order they are sent.
 // This can hinder performance if it is not properly used.
 func (p *pid) RemoteBatchAsk(ctx context.Context, to *goaktpb.Address, messages ...proto.Message) (responses []*anypb.Any, err error) {
-	// define a variable holding the remote messages
 	var remoteMessages []*anypb.Any
-	// iterate the list of messages and pack them
 	for _, message := range messages {
-		// let us pack it
 		packed, err := anypb.New(message)
-		// handle the error
 		if err != nil {
 			return nil, ErrInvalidRemoteMessage(err)
 		}
-		// add it to the list of remote messages
 		remoteMessages = append(remoteMessages, packed)
 	}
 
-	// create the sender path
 	senderPath := p.ActorPath()
 	senderAddress := senderPath.Address()
 
-	// construct the from address
 	sender := &goaktpb.Address{
 		Host: senderAddress.Host(),
 		Port: int32(senderAddress.Port()),
@@ -1042,70 +874,57 @@ func (p *pid) RemoteBatchAsk(ctx context.Context, to *goaktpb.Address, messages
 		Id:   senderPath.ID().String(),
 	}
 
-	// get the gRPC client connection options
 	clientConnectionOptions, err := p.getConnectionOptions()
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		http.NewClient(),
 		http.URL(to.GetHost(), int(to.GetPort())),
 		clientConnectionOptions...,
 	)
 
-	// prepare the remote batch tell request
 	request := connect.NewRequest(&internalpb.RemoteBatchAskRequest{
 		Messages: remoteMessages,
 		Sender:   sender,
 		Receiver: to,
 	})
-	// send the message and handle the error in case there is any
+
 	response, err := remoteClient.RemoteBatchAsk(ctx, request)
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
-	// return the responses
 	return response.Msg.GetMessages(), nil
 }
 
 // RemoteReSpawn restarts an actor on a remote node.
 func (p *pid) RemoteReSpawn(ctx context.Context, host string, port int, name string) error {
-	// get the gRPC client connection options
 	clientConnectionOptions, err := p.getConnectionOptions()
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// create an instance of remote client service
 	remoteClient := internalpbconnect.NewRemotingServiceClient(
 		p.httpClient,
 		http.URL(host, port),
 		clientConnectionOptions...,
 	)
 
-	// prepare the request to send
 	request := connect.NewRequest(&internalpb.RemoteReSpawnRequest{
 		Host: host,
 		Port: int32(port),
 		Name: name,
 	})
 
-	// send the message and handle the error in case there is any
-	_, err = remoteClient.RemoteReSpawn(ctx, request)
-	// we know the error will always be a grpc error
-	if err != nil {
+	if _, err = remoteClient.RemoteReSpawn(ctx, request); err != nil {
 		code := connect.CodeOf(err)
 		if code == connect.CodeNotFound {
 			return nil
 		}
 		return err
 	}
-	// return the response
+
 	return nil
 }
 
@@ -1113,43 +932,31 @@ func (p *pid) RemoteReSpawn(ctx context.Context, host string, port int, name str
 // All current messages in the mailbox will be processed before the actor shutdown after a period of time
 // that can be configured. All child actors will be gracefully shutdown.
 func (p *pid) Shutdown(ctx context.Context) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "Shutdown")
-	// defer the closing of the span
 	defer span.End()
 
-	// acquire the shutdown lock
 	p.stopMutex.Lock()
-	// release the lock
 	defer p.stopMutex.Unlock()
 
 	p.logger.Info("Shutdown process has started...")
 
-	// check whether the actor is still alive. Maybe it has been passivated already
 	if !p.isRunning.Load() {
 		p.logger.Infof("Actor=%s is offline. Maybe it has been passivated or stopped already", p.ActorPath().String())
-		// set the span status to Ok
 		span.SetStatus(codes.Ok, "Shutdown")
-		// return
 		return nil
 	}
 
-	// stop the passivation listener
 	if p.passivateAfter.Load() > 0 {
-		// add some debug logging
 		p.logger.Debug("sending a signal to stop passivation listener....")
 		p.haltPassivationLnr <- types.Unit{}
 	}
 
-	// stop the actor. No need to record span error here
 	if err := p.doStop(spanCtx); err != nil {
 		p.logger.Errorf("failed to stop actor=(%s)", p.ActorPath().String())
 		return err
 	}
 
-	// emit actor stopped event
 	if p.eventsStream != nil {
-		// send the event to the event streams
 		p.eventsStream.Publish(eventsTopic, &goaktpb.ActorStopped{
 			Address:   p.ActorPath().RemoteAddress(),
 			StoppedAt: timestamppb.Now(),
@@ -1163,29 +970,21 @@ func (p *pid) Shutdown(ctx context.Context) error {
 
 // Watch a pid for errors, and send on the returned channel if an error occurred
 func (p *pid) Watch(cid PID) {
-	// create a watcher
 	w := &watcher{
 		WatcherID: p,
 		ErrChan:   make(chan error, 1),
 		Done:      make(chan types.Unit, 1),
 	}
-	// add the watcher to the list of watchMen
 	cid.watchers().Append(w)
-	// supervise the PID
 	go p.supervise(cid, w)
 }
 
 // UnWatch stops watching a given actor
 func (p *pid) UnWatch(pid PID) {
-	// iterate the watchMen list
 	for item := range pid.watchers().Iter() {
-		// grab the item value
 		w := item.Value
-		// locate the given watcher
 		if w.WatcherID.ActorPath().Equal(p.ActorPath()) {
-			// stop the watching go routine
 			w.Done <- types.Unit{}
-			// remove the watcher from the list
 			pid.watchers().Delete(item.Index)
 			break
 		}
@@ -1199,25 +998,19 @@ func (p *pid) watchers() *slices.ConcurrentSlice[*watcher] {
 
 // doReceive pushes a given message to the actor receiveContextBuffer
 func (p *pid) doReceive(ctx ReceiveContext) {
-	// acquire the lock and release it once done
 	p.rwMutex.Lock()
 	defer p.rwMutex.Unlock()
 
-	// set the last processing time
 	p.lastProcessingTime.Store(time.Now())
 
-	// set the start processing time
 	startTime := time.Now()
 	defer func() {
 		duration := time.Since(startTime)
 		p.lastProcessingDuration.Store(duration)
 	}()
 
-	// push the message to the actor mailbox
 	if err := p.mailbox.Push(ctx); err != nil {
-		// add a warning log because the mailbox is full and do nothing
 		p.logger.Warn(err)
-		// push the message as a deadletter
 		p.handleError(ctx, err)
 		return
 	}
@@ -1226,54 +1019,43 @@ func (p *pid) doReceive(ctx ReceiveContext) {
 // init initializes the given actor and init processing messages
 // when the initialization failed the actor will not be started
 func (p *pid) init(ctx context.Context) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "Init")
-	// defer the closing of the span
 	defer span.End()
 
-	// add some logging info
 	p.logger.Info("Initialization process has started...")
-	// create a context to handle the start timeout
+
 	cancelCtx, cancel := context.WithTimeout(spanCtx, p.initTimeout.Load())
-	// cancel the context when done
 	defer cancel()
+
 	// create a new retrier that will try a maximum of `initMaxRetries` times, with
 	// an initial delay of 100 ms and a maximum delay of 1 second
 	retrier := retry.NewRetrier(int(p.initMaxRetries.Load()), 100*time.Millisecond, time.Second)
-	// init the actor initialization receive
-	err := retrier.RunContext(cancelCtx, p.Actor.PreStart)
-	// handle backoff error
-	if err != nil {
-		// create the error
+	if err := retrier.RunContext(cancelCtx, p.Actor.PreStart); err != nil {
 		e := ErrInitFailure(err)
-		// let us record the error in the span
 		span.SetStatus(codes.Error, "Init")
 		span.RecordError(e)
-		// return the error
 		return e
 	}
-	// set the actor is ready
+
 	p.rwMutex.Lock()
 	p.isRunning.Store(true)
 	p.rwMutex.Unlock()
-	// add some logging info
+
 	p.logger.Info("Initialization process successfully completed.")
 	span.SetStatus(codes.Ok, "Init")
-	// emit actor started event
+
 	if p.eventsStream != nil {
-		// send the event to the event streams
 		p.eventsStream.Publish(eventsTopic, &goaktpb.ActorStarted{
 			Address:   p.ActorPath().RemoteAddress(),
 			StartedAt: timestamppb.Now(),
 		})
 	}
-	// return safely
+
 	return nil
 }
 
 // reset re-initializes the actor PID
 func (p *pid) reset() {
-	// reset the various settings of the PID
 	p.lastProcessingTime = atomic.Time{}
 	p.passivateAfter.Store(DefaultPassivationTimeout)
 	p.replyTimeout.Store(DefaultReplyTimeout)
@@ -1284,13 +1066,9 @@ func (p *pid) reset() {
 	p.children = newPIDMap(10)
 	p.watchersList = slices.NewConcurrentSlice[*watcher]()
 	p.telemetry = telemetry.New()
-	// reset the mailbox
 	p.mailbox.Reset()
-	// reset the behavior stack
 	p.resetBehavior()
-	// re-register metric when metric is enabled
 	if p.metricEnabled.Load() {
-		// log the error but don't panic
 		if err := p.registerMetrics(); err != nil {
 			p.logger.Error(errors.Wrapf(err, "failed to register actor=%s metrics", p.ActorPath().String()))
 		}
@@ -1300,23 +1078,15 @@ func (p *pid) reset() {
 func (p *pid) freeWatchers(ctx context.Context) {
 	p.logger.Debug("freeing all watcher actors...")
 
-	// grab the actor watchers
 	watchers := p.watchers()
 	if watchers.Len() > 0 {
-		// iterate the list of watchers
 		for item := range watchers.Iter() {
-			// grab the item value
 			watcher := item.Value
-			// notified the watcher with the Terminated message
 			terminated := &goaktpb.Terminated{}
-			// only send the parent actor when it is running
 			if watcher.WatcherID.IsRunning() {
-				// send the notification the watcher
 				// TODO: handle error and push to some system dead-letters queue
 				_ = p.Tell(ctx, watcher.WatcherID, terminated)
-				// unwatch the child actor
 				watcher.WatcherID.UnWatch(p)
-				// remove the actor from the list of watcher's children
 				watcher.WatcherID.removeChild(p)
 			}
 		}
@@ -1326,13 +1096,9 @@ func (p *pid) freeWatchers(ctx context.Context) {
 func (p *pid) freeChildren(ctx context.Context) {
 	p.logger.Debug("freeing all child actors...")
 
-	// iterate the child actors and shut them down
 	for _, child := range p.Children() {
-		// unwatch the child
 		p.UnWatch(child)
-		// remove the child from the list
 		p.children.Delete(child.ActorPath())
-		// stop the child actor
 		if err := child.Shutdown(ctx); err != nil {
 			p.logger.Panic(err)
 		}
@@ -1341,7 +1107,6 @@ func (p *pid) freeChildren(ctx context.Context) {
 
 // receive handles every mail in the actor receiveContextBuffer
 func (p *pid) receive() {
-	// run the processing loop
 	for {
 		select {
 		case <-p.shutdownSignal:
@@ -1351,7 +1116,7 @@ func (p *pid) receive() {
 			if !ok {
 				return
 			}
-			// switch on the type of message
+
 			switch received.Message().(type) {
 			case *goaktpb.PoisonPill:
 				// stop the actor
@@ -1364,12 +1129,9 @@ func (p *pid) receive() {
 }
 
 func (p *pid) handleReceived(received ReceiveContext) {
-	// recover from a panic attack
 	defer func() {
 		if r := recover(); r != nil {
-			// construct the error to return
 			err := fmt.Errorf("%s", r)
-			// send the error to the watchMen
 			for item := range p.watchersList.Iter() {
 				item.Value.ErrChan <- err
 			}
@@ -1392,11 +1154,8 @@ func (p *pid) supervise(cid PID, watcher *watcher) {
 			p.logger.Errorf("child actor=(%s) is failing: Err=%v", cid.ActorPath().String(), err)
 			switch p.supervisorStrategy {
 			case StopDirective:
-				// unwatch the given actor
 				p.UnWatch(cid)
-				// remove the actor from the children map
 				p.children.Delete(cid.ActorPath())
-				// shutdown the actor and panic in case of error
 				if err := cid.Shutdown(context.Background()); err != nil {
 					// this can enter into some infinite loop if we panic
 					// since we are just shutting down the actor we can just log the error
@@ -1404,20 +1163,14 @@ func (p *pid) supervise(cid PID, watcher *watcher) {
 					p.logger.Error(err)
 				}
 			case RestartDirective:
-				// unwatch the given actor
 				p.UnWatch(cid)
-				// restart the actor
 				if err := cid.Restart(context.Background()); err != nil {
 					p.logger.Panic(err)
 				}
-				// re-watch the actor
 				p.Watch(cid)
 			default:
-				// unwatch the given actor
 				p.UnWatch(cid)
-				// remove the actor from the children map
 				p.children.Delete(cid.ActorPath())
-				// shutdown the actor and panic in case of error
 				if err := cid.Shutdown(context.Background()); err != nil {
 					// this can enter into some infinite loop if we panic
 					// since we are just shutting down the actor we can just log the error
@@ -1433,10 +1186,8 @@ func (p *pid) supervise(cid PID, watcher *watcher) {
 // when the actor is idle, it automatically shuts down to free resources
 func (p *pid) passivationListener() {
 	p.logger.Info("start the passivation listener...")
-	// create the ticker
 	p.logger.Infof("passivation timeout is (%s)", p.passivateAfter.Load().String())
 	ticker := time.NewTicker(p.passivateAfter.Load())
-	// create the stop ticker signal
 	tickerStopSig := make(chan types.Unit, 1)
 
 	// start ticking
@@ -1444,59 +1195,44 @@ func (p *pid) passivationListener() {
 		for {
 			select {
 			case <-ticker.C:
-				// check whether the actor is idle or not
 				idleTime := time.Since(p.lastProcessingTime.Load())
-				// check whether the actor is idle
 				if idleTime >= p.passivateAfter.Load() {
-					// set the done channel to stop the ticker
 					tickerStopSig <- types.Unit{}
 					return
 				}
 			case <-p.haltPassivationLnr:
-				// set the done channel to stop the ticker
 				tickerStopSig <- types.Unit{}
 				return
 			}
 		}
 	}()
-	// wait for the stop signal to stop the ticker
-	<-tickerStopSig
 
-	// stop the ticker
+	<-tickerStopSig
 	ticker.Stop()
 
-	// only passivate when actor is alive
 	if !p.IsRunning() {
-		// add some logging info
 		p.logger.Infof("Actor=%s is offline. No need to passivate", p.ActorPath().String())
 		return
 	}
 
-	// acquire the shutdown lock
 	p.stopMutex.Lock()
-	// release the lock
 	defer p.stopMutex.Unlock()
 
-	// add some logging info
 	p.logger.Infof("Passivation mode has been triggered for actor=%s...", p.ActorPath().String())
 
-	// create a context
 	ctx := context.Background()
 
-	// stop the actor
 	if err := p.doStop(ctx); err != nil {
 		// TODO: rethink properly about PostStop error handling
 		p.logger.Errorf("failed to passivate actor=(%s): reason=(%v)", p.ActorPath().String(), err)
 		return
 	}
 
-	// emit actor passivated event
 	if p.eventsStream != nil {
 		event := &goaktpb.ActorPassivated{
 			Address:      p.ActorPath().RemoteAddress(),
 			PassivatedAt: timestamppb.Now(),
 		}
-		// send the event to the event streams
 		p.eventsStream.Publish(eventsTopic, event)
 	}
 
@@ -1536,22 +1272,16 @@ func (p *pid) unsetBehaviorStacked() {
 
 // doStop stops the actor
 func (p *pid) doStop(ctx context.Context) error {
-	// start a tracing span
 	spanCtx, span := p.tracer.Start(ctx, "doStop")
-	// defer the closing of the span
 	defer span.End()
 
-	// stop receiving and sending messages
 	p.isRunning.Store(false)
 
-	// let us unstash all messages in case there are some
 	// TODO: just signal stash processing done and ignore the messages or process them
 	for p.stashBuffer != nil && !p.stashBuffer.IsEmpty() {
 		if err := p.unstashAll(); err != nil {
-			// let us record the error in the span
 			span.SetStatus(codes.Error, "doStop")
 			span.RecordError(err)
-			// return the error
 			return err
 		}
 	}
@@ -1561,63 +1291,44 @@ func (p *pid) doStop(ctx context.Context) error {
 	// mailbox.
 	ticker := time.NewTicker(10 * time.Millisecond)
 	timer := time.After(p.shutdownTimeout.Load())
-	// create the ticker stop signal
 	tickerStopSig := make(chan types.Unit)
 	// start ticking
 	go func() {
 		for {
 			select {
 			case <-ticker.C:
-				// no more message to process
 				if p.mailbox.IsEmpty() {
-					// tell the ticker to stop
 					close(tickerStopSig)
 					return
 				}
 			case <-timer:
-				// tell the ticker to stop when timer is up
 				close(tickerStopSig)
 				return
 			}
 		}
 	}()
-	// listen to ticker stop signal
-	<-tickerStopSig
 
-	// signal we are shutting down to stop processing messages
+	<-tickerStopSig
 	p.shutdownSignal <- types.Unit{}
-
-	// close lingering http connections
 	p.httpClient.CloseIdleConnections()
-
-	// stop all the child actors
 	p.freeChildren(spanCtx)
-	// free the watchers
 	p.freeWatchers(spanCtx)
 
-	// add some logging
 	p.logger.Infof("Shutdown process is on going for actor=%s...", p.ActorPath().String())
-
-	// reset the actor
 	p.reset()
-
-	// perform some cleanup with the actor
 	return p.Actor.PostStop(spanCtx)
 }
 
 // removeChild helps remove child actor
 func (p *pid) removeChild(pid PID) {
-	// first check whether the actor is ready to stop another actor
 	if !p.IsRunning() {
 		return
 	}
 
-	// check the pid is not nil
 	if pid == nil || pid == NoSender {
 		return
 	}
 
-	// grab the actor path
 	path := pid.ActorPath()
 	if cid, ok := p.children.Get(path); ok {
 		if cid.IsRunning() {
@@ -1629,21 +1340,16 @@ func (p *pid) removeChild(pid PID) {
 
 // handleError handles the error during a message handling
 func (p *pid) handleError(receiveCtx ReceiveContext, err error) {
-	// only send to the stream when defined
 	if p.eventsStream == nil {
 		return
 	}
-	// marshal the message
 	msg, _ := anypb.New(receiveCtx.Message())
-	// grab the sender
 	var senderAddr *goaktpb.Address
 	if receiveCtx.Sender() != nil || receiveCtx.Sender() != NoSender {
 		senderAddr = receiveCtx.Sender().ActorPath().RemoteAddress()
 	}
 
-	// define the receiver
 	receiver := p.actorPath.RemoteAddress()
-	// create the deadletter
 	deadletter := &goaktpb.Deadletter{
 		Sender:   senderAddr,
 		Receiver: receiver,
@@ -1651,22 +1357,18 @@ func (p *pid) handleError(receiveCtx ReceiveContext, err error) {
 		SendTime: timestamppb.Now(),
 		Reason:   err.Error(),
 	}
-	// add to the events stream
+
 	p.eventsStream.Publish(eventsTopic, deadletter)
 }
 
 // registerMetrics register the PID metrics with OTel instrumentation.
 func (p *pid) registerMetrics() error {
-	// grab the OTel meter
 	meter := p.telemetry.Meter
-	// create an instance of the ActorMetrics
 	metrics, err := metric.NewActorMetric(meter)
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// register the metrics
 	_, err = meter.RegisterCallback(func(ctx context.Context, observer otelmetric.Observer) error {
 		observer.ObserveInt64(metrics.ChildrenCount(), p.childrenCount.Load())
 		observer.ObserveInt64(metrics.StashCount(), int64(p.StashSize()))
@@ -1681,27 +1383,21 @@ func (p *pid) registerMetrics() error {
 
 // getConnectionOptions returns the gRPC client connections options
 func (p *pid) getConnectionOptions() ([]connect.ClientOption, error) {
-	// define a variable to hold the interceptor
 	var interceptor *otelconnect.Interceptor
 	var err error
-	// only set the observability when metric or trace is enabled
 	if p.metricEnabled.Load() || p.traceEnabled.Load() {
-		// create an interceptor and panic
 		interceptor, err = otelconnect.NewInterceptor(
 			otelconnect.WithTracerProvider(p.telemetry.TracerProvider),
 			otelconnect.WithMeterProvider(p.telemetry.MeterProvider))
-		// panic when there is an error
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to initialize observability feature")
 		}
 	}
 
-	// create the handler option
 	clientConnectionOptions := []connect.ClientOption{
 		connect.WithGRPC(),
 	}
-	// add the grpc connection
-	// set handler options when interceptor is defined
+
 	if interceptor != nil {
 		clientConnectionOptions = append(clientConnectionOptions, connect.WithInterceptors(interceptor))
 	}
diff --git a/actors/reflection.go b/actors/reflection.go
index 9df483e..abc5792 100644
--- a/actors/reflection.go
+++ b/actors/reflection.go
@@ -49,17 +49,14 @@ func NewReflection(registry Registry) Reflection {
 
 // ActorOf creates a new instance of an Actor
 func (r *reflection) ActorOf(rtype reflect.Type) (actor Actor, err error) {
-	// grab the Actor interface type
 	iface := reflect.TypeOf((*Actor)(nil)).Elem()
-	// make sure the type implements Actor interface
 	isActor := rtype.Implements(iface) || reflect.PointerTo(rtype).Implements(iface)
-	// reject the creation of the instance
+
 	if !isActor {
 		return nil, ErrInstanceNotAnActor
 	}
-	// get the type value of the object type
 	typVal := reflect.New(rtype)
-	// validate the typVal
+
 	if !typVal.IsValid() {
 		return nil, ErrInvalidInstance
 	}
@@ -68,7 +65,6 @@ func (r *reflection) ActorOf(rtype reflect.Type) (actor Actor, err error) {
 
 // ActorFrom creates a new instance of Actor from its FQN
 func (r *reflection) ActorFrom(name string) (actor Actor, err error) {
-	// grab the type from the typesLoader
 	rtype, ok := r.registry.GetNamedType(name)
 	if !ok {
 		return nil, ErrTypeNotFound(name)
diff --git a/actors/registry.go b/actors/registry.go
index aae0e59..5523d17 100644
--- a/actors/registry.go
+++ b/actors/registry.go
@@ -95,18 +95,12 @@ func (r *registry) Register(name string, v any) {
 
 // GetType returns the type of object
 func (r *registry) GetType(v any) (reflect.Type, bool) {
-	// acquire the lock
 	r.mu.Lock()
-	// release the lock
 	defer r.mu.Unlock()
 
-	// grab the object type
 	elem := reflect.TypeOf(v).Elem()
-	// construct the qualified name
 	path := fmt.Sprintf("%s.%s", elem.PkgPath(), elem.Name())
-	// lookup the type in the typesLoader registry
 	t, ok := r.types[path]
-	// if ok return it
 	return t, ok
 }
 
diff --git a/actors/scheduler.go b/actors/scheduler.go
index 4049f4e..db814fd 100644
--- a/actors/scheduler.go
+++ b/actors/scheduler.go
@@ -96,40 +96,27 @@ func newScheduler(logger log.Logger, stopTimeout time.Duration, opts ...schedule
 
 // Start starts the scheduler
 func (x *scheduler) Start(ctx context.Context) {
-	// acquire the lock
 	x.mu.Lock()
-	// release the lock once done
 	defer x.mu.Unlock()
-	// add logging information
 	x.logger.Info("starting messages scheduler...")
-	// start the scheduler
 	x.quartzScheduler.Start(ctx)
-	// set the started
 	x.started.Store(x.quartzScheduler.IsStarted())
-	// add logging information
 	x.logger.Info("messages scheduler started.:)")
 }
 
 // Stop stops the scheduler
 func (x *scheduler) Stop(ctx context.Context) {
-	// add logging information
 	x.logger.Info("stopping messages scheduler...")
-	// acquire the lock
 	x.mu.Lock()
-	// release the lock once done
 	defer x.mu.Unlock()
-	// clear all scheduled jobs
 	_ = x.quartzScheduler.Clear()
-	// stop the scheduler
 	x.quartzScheduler.Stop()
-	// set the started
 	x.started.Store(x.quartzScheduler.IsStarted())
-	// create a cancellation context
+
 	ctx, cancel := context.WithTimeout(ctx, x.stopTimeout)
 	defer cancel()
-	// wait for all workers to exit
 	x.quartzScheduler.Wait(ctx)
-	// add logging information
+
 	x.logger.Info("messages scheduler stopped...:)")
 }
 
@@ -137,38 +124,29 @@ func (x *scheduler) Stop(ctx context.Context) {
 // This will send the given message to the actor after the given interval specified.
 // The message will be sent once
 func (x *scheduler) ScheduleOnce(ctx context.Context, message proto.Message, pid PID, interval time.Duration) error {
-	// acquire the lock
 	x.mu.Lock()
-	// release the lock once done
 	defer x.mu.Unlock()
-	// check whether the scheduler has started or not
+
 	if !x.started.Load() {
 		// TODO: add a custom error
 		return errors.New("messages scheduler is not started")
 	}
-	// create the job
+
 	job := job.NewFunctionJob[bool](func(ctx context.Context) (bool, error) {
-		// when the job run send the message to actor
 		if err := Tell(ctx, pid, message); err != nil {
 			return false, err
 		}
-		// return true when successful
 		return true, nil
 	})
 
-	// create the job details
 	jobDetails := quartz.NewJobDetail(job, quartz.NewJobKey(pid.ActorPath().String()))
-
-	// check whether the job is already scheduled
 	if err := x.distributeJobKeyOrNot(ctx, jobDetails); err != nil {
-		// skip the job scheduling when the key is already distributed
 		if errors.Is(err, errSkipJobScheduling) {
 			return nil
 		}
 		return err
 	}
 
-	// schedule the job
 	return x.quartzScheduler.ScheduleJob(jobDetails, quartz.NewRunOnceTrigger(interval))
 }
 
@@ -177,32 +155,23 @@ func (x *scheduler) ScheduleOnce(ctx context.Context, message proto.Message, pid
 // This will send the given message to the actor after the given interval specified
 // The message will be sent once
 func (x *scheduler) RemoteScheduleOnce(ctx context.Context, message proto.Message, address *goaktpb.Address, interval time.Duration) error {
-	// acquire the lock
 	x.mu.Lock()
-	// release the lock once done
 	defer x.mu.Unlock()
 
-	// check whether the scheduler has started or not
 	if !x.started.Load() {
 		// TODO: add a custom error
 		return errors.New("messages scheduler is not started")
 	}
-	// create the job
 	job := job.NewFunctionJob[bool](func(ctx context.Context) (bool, error) {
-		// when the job run send the message to actor
 		if err := RemoteTell(ctx, address, message); err != nil {
 			return false, err
 		}
-		// return true when successful
 		return true, nil
 	})
-	// create the job key name
+
 	key := fmt.Sprintf("%s@%s", address.GetName(), net.JoinHostPort(address.GetHost(), strconv.Itoa(int(address.GetPort()))))
-	// create the job details
 	jobDetails := quartz.NewJobDetail(job, quartz.NewJobKey(key))
-	// check whether the job is already scheduled
 	if err := x.distributeJobKeyOrNot(ctx, jobDetails); err != nil {
-		// skip the job scheduling when the key is already distributed
 		if errors.Is(err, errSkipJobScheduling) {
 			return nil
 		}
@@ -214,110 +183,84 @@ func (x *scheduler) RemoteScheduleOnce(ctx context.Context, message proto.Messag
 
 // ScheduleWithCron schedules a message to be sent to an actor in the future using a cron expression.
 func (x *scheduler) ScheduleWithCron(ctx context.Context, message proto.Message, pid PID, cronExpression string) error {
-	// acquire the lock
 	x.mu.Lock()
-	// release the lock once done
 	defer x.mu.Unlock()
-	// check whether the scheduler has started or not
 	if !x.started.Load() {
 		return errors.New("messages scheduler is not started")
 	}
-	// create the job
+
 	job := job.NewFunctionJob[bool](func(ctx context.Context) (bool, error) {
-		// when the job run send the message to actor
 		if err := Tell(ctx, pid, message); err != nil {
 			return false, err
 		}
-		// return true when successful
 		return true, nil
 	})
-	// create the job details
+
 	jobDetails := quartz.NewJobDetail(job, quartz.NewJobKey(pid.ActorPath().String()))
-	// check whether the job is already scheduled
 	if err := x.distributeJobKeyOrNot(ctx, jobDetails); err != nil {
-		// skip the job scheduling when the key is already distributed
 		if errors.Is(err, errSkipJobScheduling) {
 			return nil
 		}
 		return err
 	}
 
-	// get the system time location
 	location := time.Now().Location()
-	// create the cron trigger
 	trigger, err := quartz.NewCronTriggerWithLoc(cronExpression, location)
-	// handle the error
 	if err != nil {
 		x.logger.Error(errors.Wrap(err, "failed to schedule message"))
 		return err
 	}
-	// schedule the job
+
 	return x.quartzScheduler.ScheduleJob(jobDetails, trigger)
 }
 
 // RemoteScheduleWithCron schedules a message to be sent to an actor in the future using a cron expression.
 func (x *scheduler) RemoteScheduleWithCron(ctx context.Context, message proto.Message, address *goaktpb.Address, cronExpression string) error {
-	// acquire the lock
 	x.mu.Lock()
-	// release the lock once done
 	defer x.mu.Unlock()
-	// check whether the scheduler has started or not
+
 	if !x.started.Load() {
 		return errors.New("messages scheduler is not started")
 	}
-	// create the job
+
 	job := job.NewFunctionJob[bool](func(ctx context.Context) (bool, error) {
-		// when the job run send the message to actor
 		if err := RemoteTell(ctx, address, message); err != nil {
 			return false, err
 		}
-		// return true when successful
 		return true, nil
 	})
-	// create the job key name
+
 	key := fmt.Sprintf("%s@%s", address.GetName(), net.JoinHostPort(address.GetHost(), strconv.Itoa(int(address.GetPort()))))
-	// create the job details
 	jobDetails := quartz.NewJobDetail(job, quartz.NewJobKey(key))
 
-	// check whether the job is already scheduled
 	if err := x.distributeJobKeyOrNot(ctx, jobDetails); err != nil {
-		// skip the job scheduling when the key is already distributed
 		if errors.Is(err, errSkipJobScheduling) {
 			return nil
 		}
 		return err
 	}
 
-	// get the system time location
 	location := time.Now().Location()
-	// create the cron trigger
 	trigger, err := quartz.NewCronTriggerWithLoc(cronExpression, location)
-	// handle the error
 	if err != nil {
 		x.logger.Error(errors.Wrap(err, "failed to schedule message"))
 		return err
 	}
-	// schedule the job
+
 	return x.quartzScheduler.ScheduleJob(jobDetails, trigger)
 }
 
 // distributeJobKeyOrNot distribute the job key when it does not exist or skip it
 func (x *scheduler) distributeJobKeyOrNot(ctx context.Context, job *quartz.JobDetail) error {
-	// get the job key
 	jobKey := job.JobKey().String()
-	// check whether the cluster mode is enabled
 	if x.cluster != nil {
-		// check the job existence
 		ok, err := x.cluster.KeyExists(ctx, jobKey)
-		// handle the error
 		if err != nil {
 			return err
 		}
-		// job is already scheduled or running skip it
 		if ok {
 			return errSkipJobScheduling
 		}
-		// set the job key
 		if err := x.cluster.SetKey(ctx, jobKey); err != nil {
 			return err
 		}
diff --git a/actors/stash.go b/actors/stash.go
index 2950e03..19873ae 100644
--- a/actors/stash.go
+++ b/actors/stash.go
@@ -26,7 +26,6 @@ package actors
 
 // stash adds the current message to the stash buffer
 func (p *pid) stash(ctx ReceiveContext) error {
-	// return an error when the stash buffer is not set
 	if p.stashBuffer == nil {
 		return ErrStashBufferNotSet
 	}
@@ -34,13 +33,11 @@ func (p *pid) stash(ctx ReceiveContext) error {
 	p.stashMutex.Lock()
 	defer p.stashMutex.Unlock()
 
-	// add the message to stash buffer
 	return p.stashBuffer.Push(ctx)
 }
 
 // unstash unstashes the oldest message in the stash and prepends to the mailbox
 func (p *pid) unstash() error {
-	// return an error when the stash buffer is not set
 	if p.stashBuffer == nil {
 		return ErrStashBufferNotSet
 	}
@@ -49,9 +46,7 @@ func (p *pid) unstash() error {
 	defer p.stashMutex.Unlock()
 
 	if !p.stashBuffer.IsEmpty() {
-		// grab the message from the stash buffer. Ignore the error when the mailbox is empty
 		received, _ := p.stashBuffer.Pop()
-		// send it to the mailbox processing
 		p.doReceive(received)
 	}
 	return nil
@@ -60,7 +55,6 @@ func (p *pid) unstash() error {
 // unstashAll unstashes all messages from the stash buffer and prepends in the mailbox
 // (it keeps the messages in the same order as received, unstashing older messages before newer).
 func (p *pid) unstashAll() error {
-	// return an error when the stash buffer is not set
 	if p.stashBuffer == nil {
 		return ErrStashBufferNotSet
 	}
@@ -68,11 +62,8 @@ func (p *pid) unstashAll() error {
 	p.stashMutex.Lock()
 	defer p.stashMutex.Unlock()
 
-	// send all the messages in the stash buffer to the mailbox
 	for !p.stashBuffer.IsEmpty() {
-		// grab the message from the stash buffer. Ignore the error when the mailbox is empty
 		received, _ := p.stashBuffer.Pop()
-		// send it to the mailbox for processing
 		p.doReceive(received)
 	}
 
diff --git a/discovery/config.go b/discovery/config.go
index 26aa35c..d422693 100644
--- a/discovery/config.go
+++ b/discovery/config.go
@@ -41,12 +41,11 @@ func NewConfig() Config {
 // GetString returns the string value of a given key which value is a string
 // If the key value is not a string then an error is return
 func (m Config) GetString(key string) (string, error) {
-	// let us check whether the given key is in the map
 	val, ok := m[key]
 	if !ok {
 		return "", fmt.Errorf("key=%s not found", key)
 	}
-	// let us check the type of val
+
 	switch x := val.(type) {
 	case string:
 		return x, nil
@@ -58,12 +57,11 @@ func (m Config) GetString(key string) (string, error) {
 // GetInt returns the int value of a given key which value is an integer
 // If the key value is not an integer then an error is return
 func (m Config) GetInt(key string) (int, error) {
-	// let us check whether the given key is in the map
 	val, ok := m[key]
 	if !ok {
 		return 0, fmt.Errorf("key=%s not found", key)
 	}
-	// let us check the type of val
+
 	switch x := val.(type) {
 	case int:
 		return x, nil
@@ -76,19 +74,16 @@ func (m Config) GetInt(key string) (int, error) {
 // GetBool returns the int value of a given key which value is a boolean
 // If the key value is not a boolean then an error is return
 func (m Config) GetBool(key string) (*bool, error) {
-	// let us check whether the given key is in the map
 	val, ok := m[key]
 	if !ok {
 		return nil, fmt.Errorf("key=%s not found", key)
 	}
-	// let us check the type of val
+
 	switch x := val.(type) {
 	case bool:
 		return &x, nil
 	default:
-		// parse the string value
 		res, err := strconv.ParseBool(val.(string))
-		// return the possible error
 		if err != nil {
 			return nil, err
 		}
@@ -99,12 +94,11 @@ func (m Config) GetBool(key string) (*bool, error) {
 // GetMapString returns the map of string value of a given key which value is a map of string
 // Map of string means that the map key value pair are both string
 func (m Config) GetMapString(key string) (map[string]string, error) {
-	// let us check whether the given key is in the map
 	val, ok := m[key]
 	if !ok {
 		return nil, fmt.Errorf("key=%s not found", key)
 	}
-	// assert the type of val
+
 	switch x := val.(type) {
 	case map[string]string:
 		return x, nil
diff --git a/discovery/dnssd/discovery.go b/discovery/dnssd/discovery.go
index e91fdb6..c6f68c0 100644
--- a/discovery/dnssd/discovery.go
+++ b/discovery/dnssd/discovery.go
@@ -65,7 +65,6 @@ var _ discovery.Provider = &Discovery{}
 
 // NewDiscovery returns an instance of the DNS discovery provider
 func NewDiscovery() *Discovery {
-	// create an instance of Discovery and return it
 	return &Discovery{
 		mu:          sync.Mutex{},
 		config:      &discoConfig{},
@@ -80,11 +79,8 @@ func (d *Discovery) ID() string {
 
 // Initialize initializes the plugin: registers some internal data structures, clients etc.
 func (d *Discovery) Initialize() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
-	// first check whether the discovery provider is running
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
@@ -94,89 +90,66 @@ func (d *Discovery) Initialize() error {
 
 // Register registers this node to a service discovery directory.
 func (d *Discovery) Register() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
-	// avoid to re-register the discovery
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyRegistered
 	}
 
-	// set initialized
 	d.initialized = atomic.NewBool(true)
 	return nil
 }
 
 // Deregister removes this node from a service discovery directory.
 func (d *Discovery) Deregister() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
 	if !d.initialized.Load() {
 		return discovery.ErrNotInitialized
 	}
-	// set the initialized to false
 	d.initialized = atomic.NewBool(false)
-	// return
 	return nil
 }
 
 // SetConfig registers the underlying discovery configuration
 func (d *Discovery) SetConfig(config discovery.Config) error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
 
-	// create an instance of option
 	discoConfig := new(discoConfig)
 	var err error
-	// extract the dns name
 	discoConfig.Domain, err = config.GetString(DomainName)
-	// handle the error
 	if err != nil {
 		return err
 	}
-	// make sure it is not empty
 	if discoConfig.Domain == "" {
 		return errors.New("dns name not set")
 	}
 
-	// extract the ipv6 option
 	discoConfig.IPv6, err = config.GetBool(IPv6)
-	// handle the error
 	if err != nil {
 		return err
 	}
-	// set the config
+
 	d.config = discoConfig
 	return nil
 }
 
 // DiscoverPeers returns a list of known nodes.
 func (d *Discovery) DiscoverPeers() ([]string, error) {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if !d.initialized.Load() {
 		return nil, discovery.ErrNotInitialized
 	}
 
-	// create a context
 	ctx := context.Background()
 
 	// set ipv6 filter
@@ -190,35 +163,28 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 
 	// only extract ipv6
 	if v6 {
-		// lookup the addresses based upon the dns name
 		ips, err := net.DefaultResolver.LookupIP(ctx, "ip6", d.config.Domain)
-		// handle the error
 		if err != nil {
 			return nil, err
 		}
-		// iterate the list of ips and add them to the list
+
 		for _, ip := range ips {
-			// add the ip string the peers
 			if !peers.Add(ip.String()) {
 				// return an error when fail to add to the list
 				return nil, errors.New("failed to retrieve addresses")
 			}
 		}
 
-		// return the list of peers
 		return peers.ToSlice(), nil
 	}
 
 	// lookup the addresses based upon the dns name
 	addrs, err := net.DefaultResolver.LookupIPAddr(ctx, d.config.Domain)
-	// handle the error
 	if err != nil {
 		return nil, err
 	}
 
-	// iterate the list of addresses
 	for _, addr := range addrs {
-		// add the ip string the peers
 		if !peers.Add(addr.IP.String()) {
 			// return an error when fail to add to the list
 			return nil, errors.New("failed to retrieve addresses")
diff --git a/discovery/kubernetes/discovery.go b/discovery/kubernetes/discovery.go
index 1bb69c9..5e21f23 100644
--- a/discovery/kubernetes/discovery.go
+++ b/discovery/kubernetes/discovery.go
@@ -97,16 +97,13 @@ func (d *Discovery) ID() string {
 
 // Initialize initializes the plugin: registers some internal data structures, clients etc.
 func (d *Discovery) Initialize() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
-	// first check whether the discovery provider is running
+
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
 
-	// check the options
 	if d.option.Provider == "" {
 		d.option.Provider = d.ID()
 	}
@@ -116,12 +113,9 @@ func (d *Discovery) Initialize() error {
 
 // SetConfig registers the underlying discovery configuration
 func (d *Discovery) SetConfig(meta discovery.Config) error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
@@ -131,58 +125,43 @@ func (d *Discovery) SetConfig(meta discovery.Config) error {
 
 // Register registers this node to a service discovery directory.
 func (d *Discovery) Register() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
-	// avoid to re-register the discovery
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyRegistered
 	}
 
-	// create the k8 config
 	config, err := rest.InClusterConfig()
-	// handle the error
 	if err != nil {
 		return errors.Wrap(err, "failed to get the in-cluster config of the kubernetes provider")
 	}
-	// create an instance of the k8 client set
+
 	client, err := kubernetes.NewForConfig(config)
-	// handle the error
 	if err != nil {
 		return errors.Wrap(err, "failed to create the kubernetes client api")
 	}
-	// set the k8 client
+
 	d.client = client
-	// set initialized
 	d.initialized = atomic.NewBool(true)
 	return nil
 }
 
 // Deregister removes this node from a service discovery directory.
 func (d *Discovery) Deregister() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
 	if !d.initialized.Load() {
 		return discovery.ErrNotInitialized
 	}
-	// set the initialized to false
 	d.initialized = atomic.NewBool(false)
-	// stop the watchers
 	close(d.stopChan)
-	// return
 	return nil
 }
 
 // DiscoverPeers returns a list of known nodes.
 func (d *Discovery) DiscoverPeers() ([]string, error) {
-	// first check whether the discovery provider is running
 	if !d.initialized.Load() {
 		return nil, discovery.ErrNotInitialized
 	}
@@ -195,36 +174,31 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 		"app.kubernetes.io/name":      d.option.ApplicationName,
 	}
 
-	// create a context
 	ctx := context.Background()
 
-	// List all the pods based on the filters we requested
 	pods, err := d.client.CoreV1().Pods(d.option.NameSpace).List(ctx, metav1.ListOptions{
 		LabelSelector: labels.SelectorFromSet(podLabels).String(),
 	})
-	// panic when we cannot poll the pods
+
 	if err != nil {
 		return nil, err
 	}
 
-	// define valid port names
 	validPortNames := []string{ClusterPortName, GossipPortName, RemotingPortName}
 
 	// define the addresses list
 	addresses := goset.NewSet[string]()
-	// iterate the pods list and only the one that are running
+
 MainLoop:
 	for _, pod := range pods.Items {
-		// create a variable copy of pod
 		pod := pod
-		// only consider running pods
+
 		if pod.Status.Phase != corev1.PodRunning {
 			continue MainLoop
 		}
 		// If there is a Ready condition available, we need that to be true.
 		// If no ready condition is set, then we accept this pod regardless.
 		for _, condition := range pod.Status.Conditions {
-			// ignore pod that is not in ready state
 			if condition.Type == corev1.PodReady && condition.Status != corev1.ConditionTrue {
 				continue MainLoop
 			}
@@ -232,11 +206,8 @@ MainLoop:
 
 		// iterate the pod containers and find the named port
 		for _, container := range pod.Spec.Containers {
-			// iterate the container ports to set the join port
 			for _, port := range container.Ports {
-				// make sure we have the gossip and cluster port defined
 				if !slices.Contains(validPortNames, port.Name) {
-					// skip that port
 					continue
 				}
 
@@ -256,27 +227,24 @@ func (d *Discovery) Close() error {
 
 // setConfig sets the kubernetes discoConfig
 func (d *Discovery) setConfig(config discovery.Config) (err error) {
-	// create an instance of option
 	option := new(discoConfig)
-	// extract the namespace
+
 	option.NameSpace, err = config.GetString(Namespace)
-	// handle the error in case the namespace value is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the actor system name
+
 	option.ActorSystemName, err = config.GetString(ActorSystemName)
-	// handle the error in case the actor system name value is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the application name
+
 	option.ApplicationName, err = config.GetString(ApplicationName)
-	// handle the error in case the application name value is not properly set
+
 	if err != nil {
 		return err
 	}
-	// in case none of the above extraction fails then set the option
+
 	d.option = option
 	return nil
 }
diff --git a/discovery/mdns/discovery.go b/discovery/mdns/discovery.go
index 1fc9173..3a1abb7 100644
--- a/discovery/mdns/discovery.go
+++ b/discovery/mdns/discovery.go
@@ -82,7 +82,6 @@ var _ discovery.Provider = &Discovery{}
 
 // NewDiscovery returns an instance of the mDNS discovery provider
 func NewDiscovery() *Discovery {
-	// create an instance of
 	d := &Discovery{
 		mu:          sync.Mutex{},
 		stopChan:    make(chan struct{}, 1),
@@ -100,11 +99,9 @@ func (d *Discovery) ID() string {
 
 // Initialize the discovery provider
 func (d *Discovery) Initialize() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
-	// first check whether the discovery provider is running
+
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
@@ -119,64 +116,47 @@ func (d *Discovery) Initialize() error {
 
 // Register registers this node to a service discovery directory.
 func (d *Discovery) Register() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
-	// avoid to re-register the discovery
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyRegistered
 	}
 
-	// initialize the resolver
 	res, err := zeroconf.NewResolver(nil)
-	// handle the error
 	if err != nil {
 		return errors.Wrap(err, "failed to instantiate the mDNS discovery provider")
 	}
-	// set the resolver
+
 	d.resolver = res
 
-	// register the service
 	srv, err := zeroconf.Register(d.option.ServiceName, d.option.Service, d.option.Domain, d.option.Port, []string{"txtv=0", "lo=1", "la=2"}, nil)
-	// handle the error
 	if err != nil {
 		return err
 	}
 
-	// set the server
 	d.server = srv
 
-	// set initialized
 	d.initialized = atomic.NewBool(true)
 	return nil
 }
 
 // Deregister removes this node from a service discovery directory.
 func (d *Discovery) Deregister() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
 	if !d.initialized.Load() {
 		return discovery.ErrNotInitialized
 	}
 
-	// set the initialized to false
 	d.initialized = atomic.NewBool(false)
 
-	// shutdown the registered service
 	if d.server != nil {
 		d.server.Shutdown()
 	}
 
-	// stop the watchers
 	close(d.stopChan)
-	// return
 	return nil
 }
 
@@ -187,46 +167,34 @@ func (d *Discovery) Close() error {
 
 // SetConfig registers the underlying discovery configuration
 func (d *Discovery) SetConfig(config discovery.Config) error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
 
 	var err error
-	// validate the meta
-	// let us make sure we have the required options set
-
-	// assert the presence of service instance
 	if _, ok := config[ServiceName]; !ok {
 		return errors.New("mDNS service name is not provided")
 	}
 
-	// assert the presence of the service type
 	if _, ok := config[Service]; !ok {
 		return errors.New("mDNS service type is not provided")
 	}
 
-	// assert the presence of the listening port
 	if _, ok := config[Port]; !ok {
 		return errors.New("mDNS listening port is not provided")
 	}
 
-	// assert the service domain
 	if _, ok := config[Domain]; !ok {
 		return errors.New("mDNS domain is not provided")
 	}
 
-	// assert the ipv6 domain
 	if _, ok := config[IPv6]; !ok {
 		return errors.New("mDNS ipv6 option is not provided")
 	}
 
-	// set the options
 	if err = d.setOptions(config); err != nil {
 		return errors.Wrap(err, "failed to instantiate the mDNS discovery provider")
 	}
@@ -235,11 +203,9 @@ func (d *Discovery) SetConfig(config discovery.Config) error {
 
 // DiscoverPeers returns a list of known nodes.
 func (d *Discovery) DiscoverPeers() ([]string, error) {
-	// first check whether the discovery provider is running
 	if !d.initialized.Load() {
 		return nil, discovery.ErrNotInitialized
 	}
-	// init entries channel
 	entries := make(chan *zeroconf.ServiceEntry, 100)
 
 	// create a context to browse the services for 5 seconds
@@ -247,34 +213,28 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
-	// let us browse the services
 	if err := d.resolver.Browse(ctx, d.option.Service, d.option.Domain, entries); err != nil {
 		return nil, err
 	}
 	<-ctx.Done()
 
-	// set ipv6 filter
 	v6 := false
 	if d.option.IPv6 != nil {
 		v6 = *d.option.IPv6
 	}
 
-	// define the addresses list
 	addresses := goset.NewSet[string]()
 	for entry := range entries {
-		// validate the entry
 		if !d.validateEntry(entry) {
 			continue
 		}
-		// lookup for v6 address
+
 		if v6 {
-			// iterate the list of ports
 			for _, addr := range entry.AddrIPv6 {
 				addresses.Add(net.JoinHostPort(addr.String(), strconv.Itoa(entry.Port)))
 			}
 		}
 
-		// iterate the list of ports
 		for _, addr := range entry.AddrIPv4 {
 			addresses.Add(net.JoinHostPort(addr.String(), strconv.Itoa(entry.Port)))
 		}
@@ -284,36 +244,30 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 
 // setOptions sets the kubernetes discoConfig
 func (d *Discovery) setOptions(config discovery.Config) (err error) {
-	// create an instance of Option
 	option := new(discoConfig)
-	// extract the service name
+
 	option.ServiceName, err = config.GetString(ServiceName)
-	// handle the error in case the service instance value is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the service name
+
 	option.Service, err = config.GetString(Service)
-	// handle the error in case the service type value is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the service domain
+
 	option.Domain, err = config.GetString(Domain)
-	// handle the error when the domain is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the port the service is listening to
+
 	option.Port, err = config.GetInt(Port)
-	// handle the error when the port is not properly set
 	if err != nil {
 		return err
 	}
 
 	// extract the type of ip address to lookup
 	option.IPv6, err = config.GetBool(IPv6)
-	// handle the error
 	if err != nil {
 		return err
 	}
diff --git a/discovery/nats/discovery.go b/discovery/nats/discovery.go
index 7a3f66a..7fa2d71 100644
--- a/discovery/nats/discovery.go
+++ b/discovery/nats/discovery.go
@@ -111,24 +111,18 @@ func (d *Discovery) ID() string {
 
 // Initialize initializes the plugin: registers some internal data structures, clients etc.
 func (d *Discovery) Initialize() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
 
-	// set the default discovery timeout
 	if d.config.Timeout <= 0 {
 		d.config.Timeout = time.Second
 	}
 
-	// grab the host node
 	hostNode, err := discovery.HostNode()
-	// handle the error
 	if err != nil {
 		return err
 	}
@@ -153,41 +147,30 @@ func (d *Discovery) Initialize() error {
 	// create a new instance of retrier that will try a maximum of five times, with
 	// an initial delay of 100 ms and a maximum delay of opts.ReconnectWait
 	retrier := retry.NewRetrier(maxRetries, 100*time.Millisecond, opts.ReconnectWait)
-	// handle the retry error
 	err = retrier.Run(func() error {
-		// connect to the NATs server
 		connection, err = opts.Connect()
 		if err != nil {
 			return err
 		}
-		// successful connection
 		return nil
 	})
 
 	// create the NATs connection encoder
 	encodedConn, err := nats.NewEncodedConn(connection, protobuf.PROTOBUF_ENCODER)
-	// handle the error
 	if err != nil {
 		return err
 	}
-	// set the connection
 	d.natsConnection = encodedConn
-	// set initialized
 	d.initialized = atomic.NewBool(true)
-	// set the host node
 	d.hostNode = hostNode
 	return nil
 }
 
 // Register registers this node to a service discovery directory.
 func (d *Discovery) Register() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider has started
-	// avoid to re-register the discovery
 	if d.registered.Load() {
 		return discovery.ErrAlreadyRegistered
 	}
@@ -196,18 +179,15 @@ func (d *Discovery) Register() error {
 	subscriptionHandler := func(subj, reply string, msg *internalpb.NatsMessage) {
 		switch msg.GetMessageType() {
 		case internalpb.NatsMessageType_NATS_MESSAGE_TYPE_DEREGISTER:
-			// add logging information
 			d.logger.Infof("received an de-registration request from peer[name=%s, host=%s, port=%d]",
 				msg.GetName(), msg.GetHost(), msg.GetPort())
 		case internalpb.NatsMessageType_NATS_MESSAGE_TYPE_REGISTER:
-			// add logging information
 			d.logger.Infof("received an registration request from peer[name=%s, host=%s, port=%d]",
 				msg.GetName(), msg.GetHost(), msg.GetPort())
 		case internalpb.NatsMessageType_NATS_MESSAGE_TYPE_REQUEST:
-			// add logging information
 			d.logger.Infof("received an identification request from peer[name=%s, host=%s, port=%d]",
 				msg.GetName(), msg.GetHost(), msg.GetPort())
-			// send the reply
+
 			replyMessage := &internalpb.NatsMessage{
 				Host:        d.hostNode.Host,
 				Port:        int32(d.hostNode.GossipPort),
@@ -215,23 +195,19 @@ func (d *Discovery) Register() error {
 				MessageType: internalpb.NatsMessageType_NATS_MESSAGE_TYPE_RESPONSE,
 			}
 
-			// send the reply and handle the error
 			if err := d.natsConnection.Publish(reply, replyMessage); err != nil {
 				d.logger.Errorf("failed to reply for identification request from peer[name=%s, host=%s, port=%d]",
 					msg.GetName(), msg.GetHost(), msg.GetPort())
 			}
 		}
 	}
-	// start listening to incoming messages
+
 	subscription, err := d.natsConnection.Subscribe(d.config.NatsSubject, subscriptionHandler)
-	// return any eventual error
 	if err != nil {
 		return err
 	}
 
-	// add the subscription to the list of subscriptions
 	d.subscriptions = append(d.subscriptions, subscription)
-	// set the registration flag to true
 	d.registered = atomic.NewBool(true)
 	return nil
 }
@@ -272,19 +248,16 @@ func (d *Discovery) Deregister() error {
 			MessageType: internalpb.NatsMessageType_NATS_MESSAGE_TYPE_DEREGISTER,
 		})
 	}
-	// set registered to false
+
 	d.registered.Store(false)
 	return nil
 }
 
 // SetConfig registers the underlying discovery configuration
 func (d *Discovery) SetConfig(config discovery.Config) error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if d.initialized.Load() {
 		return discovery.ErrAlreadyInitialized
 	}
@@ -294,17 +267,13 @@ func (d *Discovery) SetConfig(config discovery.Config) error {
 
 // DiscoverPeers returns a list of known nodes.
 func (d *Discovery) DiscoverPeers() ([]string, error) {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// first check whether the discovery provider is running
 	if !d.initialized.Load() {
 		return nil, discovery.ErrNotInitialized
 	}
 
-	// later check the provider is registered
 	if !d.registered.Load() {
 		return nil, discovery.ErrNotRegistered
 	}
@@ -321,7 +290,6 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 		return nil, err
 	}
 
-	// send registration request and return in case of error
 	if err = d.natsConnection.PublishRequest(d.config.NatsSubject, inbox, &internalpb.NatsMessage{
 		Host:        d.hostNode.Host,
 		Port:        int32(d.hostNode.GossipPort),
@@ -331,14 +299,10 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 		return nil, err
 	}
 
-	// define the list of peers to lookup
 	var peers []string
-	// define the timeout
 	timeout := time.After(d.config.Timeout)
-	// get the host node gossip address
 	me := d.hostNode.GossipAddress()
 
-	// loop till we have enough nodes
 	for {
 		select {
 		case m, ok := <-recv:
@@ -349,17 +313,13 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 
 			// get the found peer address
 			addr := net.JoinHostPort(m.GetHost(), strconv.Itoa(int(m.GetPort())))
-			// ignore this node
 			if addr == me {
-				// Ignore a reply from self
 				continue
 			}
 
-			// add the peer to the list of discovered peers
 			peers = append(peers, addr)
 
 		case <-timeout:
-			// close the receiving channel
 			_ = sub.Unsubscribe()
 			close(recv)
 		}
@@ -368,28 +328,20 @@ func (d *Discovery) DiscoverPeers() ([]string, error) {
 
 // Close closes the provider
 func (d *Discovery) Close() error {
-	// acquire the lock
 	d.mu.Lock()
-	// release the lock
 	defer d.mu.Unlock()
 
-	// set the initialized to false
 	d.initialized.Store(false)
 
 	if d.natsConnection != nil {
 		defer func() {
-			// close the underlying connection
 			d.natsConnection.Close()
 			d.natsConnection = nil
 		}()
 
-		// close all the subscriptions
 		for _, subscription := range d.subscriptions {
-			// when subscription is defined
 			if subscription != nil {
-				// check whether the subscription is active or not
 				if subscription.IsValid() {
-					// unsubscribe and return when there is an error
 					if err := subscription.Unsubscribe(); err != nil {
 						return err
 					}
@@ -397,7 +349,6 @@ func (d *Discovery) Close() error {
 			}
 		}
 
-		// flush all messages
 		return d.natsConnection.Flush()
 	}
 	return nil
@@ -405,34 +356,29 @@ func (d *Discovery) Close() error {
 
 // setConfig sets the kubernetes discoConfig
 func (d *Discovery) setConfig(config discovery.Config) (err error) {
-	// create an instance of option
 	option := new(discoConfig)
-	// extract the nats server address
+
 	option.NatsServer, err = config.GetString(NatsServer)
-	// handle the error in case the nats server value is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the nats subject address
+
 	option.NatsSubject, err = config.GetString(NatsSubject)
-	// handle the error in case the nats subject value is not properly set
 	if err != nil {
 		return err
 	}
 
 	// extract the actor system name
 	option.ActorSystemName, err = config.GetString(ActorSystemName)
-	// handle the error in case the actor system name value is not properly set
 	if err != nil {
 		return err
 	}
-	// extract the application name
+
 	option.ApplicationName, err = config.GetString(ApplicationName)
-	// handle the error in case the application name value is not properly set
 	if err != nil {
 		return err
 	}
-	// in case none of the above extraction fails then set the option
+
 	d.config = option
 	return nil
 }
diff --git a/internal/cluster/discovery.go b/internal/cluster/discovery.go
index bdd6e27..51d0020 100644
--- a/internal/cluster/discovery.go
+++ b/internal/cluster/discovery.go
@@ -45,11 +45,10 @@ var _ service_discovery.ServiceDiscovery = &discoveryProvider{}
 
 // Initialize implementation
 func (d *discoveryProvider) Initialize() error {
-	// check whether the provider is set or not
 	if d.provider == nil {
 		return errors.New("discovery provider is not set")
 	}
-	// call the initialize method of the provider
+
 	if err := d.provider.Initialize(); err != nil {
 		if !errors.Is(err, discovery.ErrAlreadyInitialized) {
 			return err
@@ -61,24 +60,22 @@ func (d *discoveryProvider) Initialize() error {
 
 // SetConfig implementation
 func (d *discoveryProvider) SetConfig(c map[string]any) error {
-	// check whether the id is provided or not
 	id, ok := c["id"]
 	if !ok {
 		return errors.New("discovery provider id is not set")
 	}
-	// validate the id
+
 	idVal := id.(string)
 	if !strings.EqualFold(idVal, d.provider.ID()) {
 		return errors.New("invalid discovery provider id")
 	}
-	// let us extract the options
+
 	options, ok := c["options"]
 	if !ok {
 		return errors.New("discovery provider options is not set")
 	}
-	// let us cast the options to disco Meta
+
 	meta := options.(discovery.Config)
-	// call the underlying provider
 	if err := d.provider.SetConfig(meta); err != nil {
 		if !errors.Is(err, discovery.ErrAlreadyInitialized) {
 			return err
@@ -94,11 +91,9 @@ func (d *discoveryProvider) SetLogger(l *golog.Logger) {
 
 // Register implementation
 func (d *discoveryProvider) Register() error {
-	// check whether the provider is set or not
 	if d.provider == nil {
 		return errors.New("discovery provider is not set")
 	}
-	// call the provider register
 	if err := d.provider.Register(); err != nil {
 		if !errors.Is(err, discovery.ErrAlreadyRegistered) {
 			return err
@@ -110,22 +105,18 @@ func (d *discoveryProvider) Register() error {
 
 // Deregister implementation
 func (d *discoveryProvider) Deregister() error {
-	// check whether the provider is set or not
 	if d.provider == nil {
 		return errors.New("discovery provider is not set")
 	}
-	// call the provider de-register
 	return d.provider.Deregister()
 }
 
 // DiscoverPeers implementation
 func (d *discoveryProvider) DiscoverPeers() ([]string, error) {
-	// check whether the provider is set or not
 	if d.provider == nil {
 		return nil, errors.New("discovery provider is not set")
 	}
 
-	// call the provider discover peers
 	return d.provider.DiscoverPeers()
 }
 
diff --git a/internal/cluster/node.go b/internal/cluster/node.go
index 0013637..798565c 100644
--- a/internal/cluster/node.go
+++ b/internal/cluster/node.go
@@ -165,20 +165,14 @@ func NewNode(name string, serviceDiscovery *discovery.ServiceDiscovery, opts ...
 
 // Start starts the Node.
 func (n *Node) Start(ctx context.Context) error {
-	// set the logger
 	logger := n.logger
 
-	// add some logging information
 	logger.Infof("Starting GoAkt cluster Node service on (%s)....🤔", n.host.ClusterAddress())
 
-	// build the Node engine config
 	conf := n.buildConfig()
-	// set the hasher to the custom hasher
 	conf.Hasher = &hasherWrapper{n.hasher}
 
-	// create the member list config
 	m, err := olriconfig.NewMemberlistConfig("lan")
-	// panic when there is an error
 	if err != nil {
 		logger.Error(errors.Wrap(err, "failed to configure the cluster Node memberlist.💥"))
 		return err
@@ -195,7 +189,7 @@ func (n *Node) Start(ctx context.Context) error {
 		provider: n.discoveryProvider,
 		log:      n.logger.StdLogger(),
 	}
-	// set the discovery service
+
 	conf.ServiceDiscovery = map[string]any{
 		"plugin":  discoveryWrapper,
 		"id":      n.discoveryProvider.ID(),
@@ -206,15 +200,12 @@ func (n *Node) Start(ctx context.Context) error {
 	startCtx, cancel := context.WithCancel(ctx)
 	// cancel the context the server has started
 	conf.Started = func() {
-		// cancel the start context
 		defer cancel()
-		// add some logging information
 		logger.Infof("GoAkt cluster Node=(%s) successfully started. 🎉", n.name)
 	}
 
 	// let us create an instance of the Node engine
 	eng, err := olric.New(conf)
-	// handle the error
 	if err != nil {
 		logger.Error(errors.Wrapf(err, "failed to start the cluster Node=(%s).💥", n.name))
 		return err
@@ -223,50 +214,37 @@ func (n *Node) Start(ctx context.Context) error {
 	// set the server
 	n.server = eng
 	go func() {
-		// start the Node engine
-		err = n.server.Start()
-		// handle the error in case there is an early error
-		if err != nil {
+		if err = n.server.Start(); err != nil {
 			logger.Error(errors.Wrapf(err, "failed to start the cluster Node=(%s).💥", n.name))
-			// let us stop the started engine
 			if e := n.server.Shutdown(ctx); e != nil {
 				logger.Panic(e)
 			}
 		}
 	}()
 
-	// wait for start
 	<-startCtx.Done()
 
 	// set the client
 	n.client = n.server.NewEmbeddedClient()
-	// create the instance of the distributed map
 	dmp, err := n.client.NewDMap(n.name)
-	// handle the error
 	if err != nil {
 		logger.Error(errors.Wrapf(err, "failed to start the cluster Node=(%s).💥", n.name))
-		// let us stop the started engine
 		return n.server.Shutdown(ctx)
 	}
-	// set the distributed map
+
 	n.kvStore = dmp
 
 	// create a subscriber to consume to cluster events
 	ps, err := n.client.NewPubSub()
-	// handle the error
 	if err != nil {
 		logger.Error(errors.Wrapf(err, "failed to start the cluster Node=(%s).💥", n.name))
-		// let us stop the started engine
 		return n.server.Shutdown(ctx)
 	}
 
-	// subscribe to the cluster events channel
 	n.pubSub = ps.Subscribe(ctx, events.ClusterEventsChannel)
-	// set the events channel
 	n.messagesChan = n.pubSub.Channel()
-	// start consuming to cluster events
 	go n.consume()
-	// return successfully
+
 	return nil
 }
 
@@ -350,138 +328,101 @@ func (n *Node) PutActor(ctx context.Context, actor *internalpb.WireActor) error
 
 	// send the record into the Node
 	err = n.kvStore.Put(ctx, actor.GetActorName(), data)
-	// handle the error
 	if err != nil {
-		// log the error
 		logger.Error(errors.Wrapf(err, "failed to replicate actor=%s record.💥", actor.GetActorName()))
 		return err
 	}
 
-	// Ahoy we are successful
 	logger.Infof("actor (%s) successfully replicated.🎉", actor.GetActorName())
 	return nil
 }
 
 // GetActor fetches an actor from the Node
 func (n *Node) GetActor(ctx context.Context, actorName string) (*internalpb.WireActor, error) {
-	// create a cancellation context of 1 second timeout
 	ctx, cancelFn := context.WithTimeout(ctx, n.readTimeout)
 	defer cancelFn()
 
-	// set the logger
 	logger := n.logger
 
-	// add some logging information
 	logger.Infof("retrieving actor (%s) from the Node.🤔", actorName)
 
-	// grab the record from the distributed store
 	resp, err := n.kvStore.Get(ctx, actorName)
-	// handle the error
 	if err != nil {
-		// we could not find the given actor
 		if errors.Is(err, olric.ErrKeyNotFound) {
 			logger.Warnf("actor=%s is not found in the Node", actorName)
 			return nil, ErrActorNotFound
 		}
-		// log the error
 		logger.Error(errors.Wrapf(err, "failed to get actor=%s record.💥", actorName))
 		return nil, err
 	}
 
-	// grab the base64 representation of the wire actor
 	base64ActorStr, err := resp.String()
-	// handle the error
 	if err != nil {
 		logger.Error(errors.Wrapf(err, "failed to read the record at:{%s}.💥", actorName))
 		return nil, err
 	}
 
-	// decode it
 	actor, err := decode(base64ActorStr)
-	// let us unpack the byte array
 	if err != nil {
-		// log the error and return
 		logger.Error(errors.Wrapf(err, "failed to decode actor=%s record.💥", actorName))
 		return nil, err
 	}
 
-	// Ahoy we are successful
 	logger.Infof("actor (%s) successfully retrieved from the cluster.🎉", actor.GetActorName())
-	// return the response
 	return actor, nil
 }
 
 // RemoveActor removes a given actor from the cluster.
 // An actor is removed from the cluster when this actor has been passivated.
 func (n *Node) RemoveActor(ctx context.Context, actorName string) error {
-	// set the logger
 	logger := n.logger
 
-	// add some logging information
 	logger.Infof("removing actor (%s).🤔", actorName)
 
-	// remove the actor from the cluster
 	_, err := n.kvStore.Delete(ctx, actorName)
-	// handle the error
 	if err != nil {
-		// log the error
 		logger.Error(errors.Wrapf(err, "failed to remove actor=%s record.💥", actorName))
 		return err
 	}
 
-	// add a logging information
 	logger.Infof("actor (%s) successfully removed from the cluster.🎉", actorName)
 	return nil
 }
 
 // SetKey sets a given key to the cluster
 func (n *Node) SetKey(ctx context.Context, key string) error {
-	// create a cancellation context of 1 second timeout
 	ctx, cancelFn := context.WithTimeout(ctx, n.writeTimeout)
 	defer cancelFn()
 
-	// set the logger
 	logger := n.logger
 
-	// add some logging information
 	logger.Infof("replicating key (%s).🤔", key)
 
-	// send the record into the Node
-	err := n.kvStore.Put(ctx, key, true)
-	// handle the error
-	if err != nil {
-		// log the error
+	if err := n.kvStore.Put(ctx, key, true); err != nil {
 		logger.Error(errors.Wrapf(err, "failed to replicate key=%s record.💥", key))
 		return err
 	}
 
-	// Ahoy we are successful
 	logger.Infof("key (%s) successfully replicated.🎉", key)
 	return nil
 }
 
 // KeyExists checks the existence of a given key
 func (n *Node) KeyExists(ctx context.Context, key string) (bool, error) {
-	// create a cancellation context of 1 second timeout
 	ctx, cancelFn := context.WithTimeout(ctx, n.readTimeout)
 	defer cancelFn()
 
-	// set the logger
 	logger := n.logger
 
-	// add some logging information
 	logger.Infof("checking key (%s) existence in the cluster.🤔", key)
 
-	// grab the record from the distributed store
 	resp, err := n.kvStore.Get(ctx, key)
-	// handle the error
 	if err != nil {
-		// we could not find the given actor
 		if errors.Is(err, olric.ErrKeyNotFound) {
 			logger.Warnf("key=%s is not found in the Node", key)
 			return false, nil
 		}
-		// log the error
+
 		logger.Error(errors.Wrapf(err, "failed to check key=%s existence.💥", key))
 		return false, err
 	}
@@ -490,13 +431,9 @@ func (n *Node) KeyExists(ctx context.Context, key string) (bool, error) {
 
 // GetPartition returns the partition where a given actor is stored
 func (n *Node) GetPartition(actorName string) int {
-	// create the byte array of the actor name
 	key := []byte(actorName)
-	// compute the hash key
 	hkey := n.hasher.HashCode(key)
-	// compute the partition and return it
 	partition := int(hkey % n.partitionsCount)
-	// add some debug log
 	n.logger.Debugf("partition of actor (%s) is (%d)", actorName, partition)
 	return partition
 }
@@ -514,61 +451,46 @@ func (n *Node) consume() {
 		case <-n.messagesReaderChan:
 			return
 		case message, ok := <-n.messagesChan:
-			// break out of the loop when the channel is closed
 			if !ok {
 				return
 			}
-			// grab the message payload
 			payload := message.Payload
-			// get the message payload
 			var event map[string]any
-			// let us unmarshal the event
 			if err := json.Unmarshal([]byte(payload), &event); err != nil {
 				n.logger.Error(errors.Wrap(err, "failed to decode cluster event"))
 				// TODO: should we continue or not
 				continue
 			}
 
-			// grab the kind
 			kind := event["kind"]
-			// add some debug log
 			n.logger.Debugf("%s received (%s) cluster event", n.name, kind)
 
 			switch kind {
 			case events.KindNodeJoinEvent:
-				// create the node joined to unmarshal the event
 				nodeJoined := new(events.NodeJoinEvent)
-				// let us unmarshal the event
 				if err := json.Unmarshal([]byte(payload), &nodeJoined); err != nil {
 					n.logger.Error(errors.Wrap(err, "failed to decode NodeJoined cluster event"))
 					// TODO: should we continue or not
 					continue
 				}
 
-				// make sure to skip self
 				if n.AdvertisedAddress() == nodeJoined.NodeJoin {
-					// add some debug log
 					n.logger.Debug("skipping self")
 					continue
 				}
 
 				// TODO: need to cross check this calculation
-				// convert the timestamp to milliseconds
 				timeMilli := nodeJoined.Timestamp / int64(1e6)
-				// create the startNode joined event
 				event := &goaktpb.NodeJoined{
 					Address:   nodeJoined.NodeJoin,
 					Timestamp: timestamppb.New(time.UnixMilli(timeMilli)),
 				}
-				// serialize as any pb
+
 				eventType, _ := anypb.New(event)
-				// send the event to queue
 				n.events <- &Event{eventType}
 
 			case events.KindNodeLeftEvent:
-				// create the node left to unmarshal the event
 				nodeLeft := new(events.NodeLeftEvent)
-				// let us unmarshal the event
 				if err := json.Unmarshal([]byte(payload), &nodeLeft); err != nil {
 					n.logger.Error(errors.Wrap(err, "failed to decode NodeLeft cluster event"))
 					// TODO: should we continue or not
@@ -576,16 +498,14 @@ func (n *Node) consume() {
 				}
 
 				// TODO: need to cross check this calculation
-				// convert the timestamp to milliseconds
 				timeMilli := nodeLeft.Timestamp / int64(1e6)
-				// create the startNode joined event
+
 				event := &goaktpb.NodeLeft{
 					Address:   nodeLeft.NodeLeft,
 					Timestamp: timestamppb.New(time.UnixMilli(timeMilli)),
 				}
-				// serialize as any pb
+
 				eventType, _ := anypb.New(event)
-				// send the event to queue
 				n.events <- &Event{eventType}
 			default:
 				// skip


Test patch:
diff --git a/actors/option_test.go b/actors/option_test.go
index d1ce20e..c28c8d5 100644
--- a/actors/option_test.go
+++ b/actors/option_test.go
@@ -104,7 +104,7 @@ func TestOption(t *testing.T) {
 		{
 			name:     "WithStash",
 			option:   WithStash(10),
-			expected: actorSystem{stashBuffer: 10},
+			expected: actorSystem{stashCapacity: 10},
 		},
 		{
 			name:     "WithPartitionHasher",