http://getakka.net/docs/Building%20and%20Distributing%20Akka - need to mention here that the F# tools must be installed.

http://fsharp.org/use/windows/

�Running "compass:dist" (compass) task�
�Warning: Couldn't find the compass binary. Make sure it's installed and in your $PATH� Use --force to continue.�

cc @skotzko

Where can I find copass binaries?

The Deployments Scenarios page is growing and it could still be improved upon in terms of details per scenario.

Should we split the different scenarios into sub pages so that we can better describe each individual case?

This "Edit on GitHub" link on this page is broken and returns 404.

http://getakka.net/docs/deployment-scenarios/ASP%20NET

As a trackpad user, I find sites that use smoothscroll (a Javascript library) to be very awkward to navigate. Smoothscroll appears to animate every page scroll. I think this is supposed to provide a better user experience, but it creates these problems.

1. It adds a delay when scrolling with the trackpad. My trackpad and browser already support both fine scrolling and inertial scroll. Smoothscroll works to undermine both of these mechanisms. On most sites, when I stop moving my fingers, scrolling also stops. And when I've flung the page, placing my fingers back on the trackpad stops the scroll. Neither of these behaviors are true on pages with smoothscroll. Instead, I'm constantly overshooting my scrolling.
2. It's even worse with a scroll wheel mouse. Smoothscroll seems to buffer the actual wheel events, and "plays them back" over time. So I might be moving the wheel up, but I instead see the page scroll down.

Smoothscroll is bad for both trackpad and mouse users. It makes everything delayed and laggy and terrible. Personally, it makes me feel drunk. Please remove it.

It looks like this can be done by simply removing the smoothscroll class from src/layouts/master.hbs

As I'm working on the docs and the community site, I think we can pretty easily simplify the setup to use what's already built into Github pages / Jekyll, without much effort.

If we change, we get to keep all our content and layouts, but:

• we don't need a separate build server (drone.io)
• dont need to use assemble.io / grunt / nodeJS (they're wonderful tools, but IMHO they are overkill here)
• more devs can update docs / contribute to community site since many more people know Jekyll
• don't have to write custom Gruntfile additions to get basic things like "rebuild pages when I make changes to them in development"
• deploying community site changes is just a simple PR merge

@rogeralsing I'm proposing a switchover, and am happy to lead the effort. You okay with this? Is there a particular reason we need with the current setup? I would like to simplify this process and setup so more people can easily contribute / make updates without.

Roles are such a fundamental concept to using Akka.Cluster properly, and we cover them in scant detail in the documentation right now. Without them it's impossible to build heterogeneous clusters.

The grunt script now comes with a separate prod task that only regenerates the content, the build server then publishes the result to the site.

Handling messages is pretty important topic for beginners, however it looks like it's still a blank page in our case.

Should be interesting to have some docs on how this would work with OWIN. Should not be to different from hosting inside normal ASP.NET applications.

If you want I can make a short write-up for this and do a PR.

Add an index page that links to the following:

• Unstable latest API docs
• Stable latest API docs
• API docs for previous versions (list)

Moved from akkadotnet/akka.net#794 to here.

Took me forever to put this together, but here it is - my proposed rework for the Akka.NET docs for v1.0.

Documentation Guidelines

Here are some rules and guidelines to follow when working on the updated docs.

• Use the v1.0 APIs everywhere, since they will be supported long-term. We just published a pre-release V1 nuget package to make this easier for writing compilable samples.
• Replace any Java / Scala code from existing documents with relevant C# and F# samples.
• Use .NET Fiddle for any runnable samples in the docs.
• Include BOTH F# and C# samples - if you need help with the F#, let @akkadotnet/fsharpteam know.
• Draw diagrams where appropriate. Most programmers are visual learners. They will love you for this.

All of the docs are written in Markdown format and are saved to the /wiki directory in this repo.

This will take a lot of effort, so we need all the help we can get. Calling all @akkadotnet/contributors - pick some areas where you can help and send us some PRs for the documents there.

Akka.NET v1.0 Documentation

This is what the table of contents will look like - all left-most items are individual pages. Anything that's indented further in can either be a section on that page or its own sub-page depending on whether or not the content is something that should be immediately visible to developers scanning the TOC.

Introduction

• What is Akka.NET?
  • Akka & Typesafe
• Why Akka.NET?
• Akka.NET Quickstart
  • C# Quickstart
  • F# Quickstart
• What are some real-world use cases for Akka.NET?
• FAQ
  • Mono Support
  • Remoting & Clustering
  • Contributing
  • Commercial Support
• Learning Resources
  • Akka.NET Bootcamp
  • OSS Akka.NET Examples
  • Videos
  • Blogs & Articles
  • Podcasts & Interviews
  • Talks and Presentations

Akka.NET Concepts and Terminology

• Terminology, Concepts
• Actor Systems
• What is an Actor?
• What is a Message?
  • Immutability
• Supervision and Monitoring
• Actor References, Paths, and Addresses
• Location Transparency
• Message Delivery Reliability
• Configuration

Working with Actors

• Creating your first Actor
  • C#
  • F#
• Defining an Actor class
  • ReceiveActor
  • UntypedActor
• What's in an actor?
  • State
  • Behavior(s)
  • Mailbox
  • Children
  • Supervisor Strategy
  • Context
• ActorRefs and ActorSelections
  • Location Transparency
  • Explan how actors can be restarted independently of actorrefs, and this is why they're cool
• Creating actors with Props
  • Props
    • What's the point?
    • Serializability
    • Role in restarts
  • System.ActorOf
  • Creating Children with Context.ActorOf
• Handling Messages
  • ReceiveActor
  • UntypedActor
    • if, else if, else - type interference
    • PatternMatch
• Sending Messages
  • Immutability
  • Tell
  • Ask
  • Forward
  • Replying to messages
• Looking up Actors
  • ActorSelection
• Stopping Actors
  • PoisonPill
  • Graceful Stop
• What happens when an actor dies?
  • Unplanned Termination ("Crashes")
    • Supervision strategies in action
    • Restarts
    • What happens to messages during restarts?
      • Unprocessed messages
      • Message that caused the restart
    • What happens to children during restarts?
  • Planned Termination
    • How to stop an actor
    • DeathWatch
      • What happens to messages during termination?
        • Unprocessed messages
        • Message that caused the restart
    • What happens to children after termination?
• The Actor Lifecycle
  • PreStart
  • PreRestart
  • PostStop
  • PostRestart
  • DeathWatch
• Dispatchers
  • What Dispatchers Do
  • Types of Dispatchers
    • ThreadPoolDispatcher (default)
    • ForkJoinDispatcher
    • SynchronizedDispatcher
    • SingleThreadDispatcher
    • TaskDispatcher
  • Custom Dispatchers
• Mailboxes
  • What Mailboxes Do
  • Types of Mailboxes
    • UnboundedMailbox (default)
    • PriorityMailbox
  • Custom Mailboxes
• Switchable Behaviors
  • Become
  • BecomeStacked
  • UnbecomeStacked
• Stashing Messages
  • Bounded Stash
  • Unbounded Stash
• Detecting Failures with ReceiveTimeout
• Dependency Injection and Actors
  • Ninject
  • Autofac
  • Castle Windsor
• Routers
  • Pool vs. Group
    • Supervision
  • RoundRobin
  • Broadcast
  • Random
  • ConsistentHash
  • TailChopping
  • SmallestMailbox

Configuration

• Using Akka.NET Config (HOCON) in Production
  • Fallbacks
  • App.config & Web.config
  • Parsing Configuration from Strings
• Configuring Akka.NET Modules
  • Akka.Remote
  • Akka.Cluster
  • Akka.Persistence
• Configuring Loggers
  • Logging Options
  • Serilog
  • NLog
  • Custom Loggers

ActorSystems & Utilities

• Finite State Machines (FSM)
• EventBus
• Scheduler
  • Scheduling Recurring Messages
  • Canceling a Recurring Message
  • Scheduling a One-time Message
• Inbox
• ActorSystem Extensions
  • Using ActorSystem Extensions
  • Creating ActorSystem Extensions
• Extending the Actor Construction Pipeline
  • What does the Actor Construction Pipeline do?
  • Use Cases
  • Examples

Unit Testing Your Actors

• Using Akka.TestKit
  • With XUnit
  • With MSTest
• Writing Testable Actors
• TestKit Tools
  • TestActor
  • Expecting Messages
  • TestProbe
  • EventFilter

Akka.Remote (Networked ActorSystems)

• Remoting Overview
  • Remote Addressing
  • How Remote Connections Form
  • Transports
  • Location Transparency
• Serialization
• Transports
  • Helios
    • TCP
    • UDP (in the future)
  • Custom Transports
• Sending Messages to Remote Actors
  • What happens when a connection dies?
• Deploying Actors onto Remote Systems
  • What happens to remotely deployed actors when a connection dies?
  • Remote DeathWatch
• Remoting Configuration

Akka.Cluster (Clustered ActorSystems)

• Clustering Overview
  • How is Clustering different from Remoting?
  • How a Cluster Forms
    • Seed Nodes
    • Gossip
    • Leader Election
    • Reachability
  • Location Transparency
• Cluster Routing
  • Deploying Clustered Routees
  • Configured Cluster Routers
• Cluster ActorSystem Extension
  • Getting Cluster State
  • Subscribing to Cluster Events
  • Cluster Event Types
    • Reachability
    • MemberUp / MemberDown
• Cluster Configuration

Akka.Persistence (Guaranteed Message Delivery, Persistent Actors)

• Persistence Overview
  • Goals of Persistence
  • Snapshots
  • Journals
  • Persistence Plugins
    • SQL Server
    • File System
• Guaranteed Delivery of Messages
• Creating your own Persistent Actors
• Creating your own Persistence Target
• Persistence Configuration

Information for Akka Developers

• Building and Distributing Akka.NET
• Contributor guidelines
• Documentation Guidelines
• Team

Project Information

• Licenses
• Sponsors
• Project

Additional Information

• FAQ
• Online resources
• Books
• Commercial Support & Training

When running the site generator locally, we now support live reload when source files changes under the src folder.

Porting this from akkadotnet/akka.net#655 as it's more germane here.

Initial issue text below.

On the Deployment Scenarios page, I noticed there is an empty section for ASP.NET.

Adding it here in case someone wants to take it on (may do so myself).

@jpierson commented on Wed Jul 27 2016

I wanted to contribute some documentation fixes for the page on Remoting but found that the edit on GitHub link yields a 404 error and when searching the repository for Remoting.md nothing could be found. I'm assuming that the documentation has been migrated out of some original GitHub Markdown files and placed somewhere else. Is the current documentation somewhere contributors can help with? Can the links be fixed to give a better impression of the project to newcomers and to direct contributors to where they can modify the documents?

By the way, the original change I wanted to make was to update some stale comments about "Akka I/O(Not yet ported to Akka.NET)".

@jpierson commented on Wed Jul 27 2016

Ok, I believe I've answered my own question on where to contribute documentation changes on remoting but it looks like the documentation in question has already been corrected. This leads me to followup question though, why isn't the documentation updated on the site?

Porting from akkadotnet/akka.net#656 since this lives in its own repo now:

On the Deployment Scenarios page, I noticed there is an empty section for Windows Service.

Adding it here in case someone wants to take it on (may do so myself).

We should improve the syntaxhighlighting story.

1. When using indented codeblocks, we are currently not applying all the css classes to the pre/code tags, thus, those code blocks looks strange.
2. Create a HLJS theme for HOCON. should be possible to re-use and adapt JS/JSON for this.

Since the last update of the Epona Theme the code blocks now have an ugly dropshadow.
This should be removed

In PR #60 some bits where removed from the Dependency Injection.md file. I am wondering if it was intentional or not. Because I think that the part in question is still relevant information. And if not on that page, it should at least be described somewhere else.

Its about this part:

Creating child Actors from inside an Actor can be done using the DI() extension method.

//In for example the PreStart...
protected override void PreStart()
{
    myWorker = Context.DI().ActorOf<TypedWorker>("childWorker");
}

The main index that serves as a starting point / guideline.
http://doc.akka.io/docs/akka/2.4.4/scala/stream/index.html

Ill be working on this. Ill create a PR for the some of the hooks in the main index page. Once thats done. Anyone is welcome to pick a subject to port and contribute to the overall process.

Post in here if you want to take a chunk of the work. And let us know which part your taking.

• Akka
• Akka.Remote
• Akka.Cluster
• Akka.Persistence.*
• Akka.TestKit

This is an area where we're currently missing documentation, and it'd be a helpful thing to include for folks who want to use NLog or any other custom logging framework.

I think this is a leftover from when the docs were moved out of the main akka.net tree. It's not hurting anything at the moment since wiki/ isn't a direct link on the page, but if a user types wiki/ or another website points there...

I suggest either remove wiki/ or revamp it to something other than a mirror of docs/

We decided to add some page where we could listen contributor's plugins, which doesn't necessarily reside in akkadotnet organization. This way we could make them more discoverable to potential people interested in using them.

Don't think I ever noticed this before. Currently using FF 41.0.2 and the "Open Source" panel on the front page is not aligned properly. See screenshot below.

I feel we should better describe how you can use the FromConfig to configure individual actors props.
The current configuration page: http://getakka.net/docs/concepts/configuration explains hocon pretty well. But could use more examples that show how you can call specific config sections to configure individual actor props etc.
Also to give more expose to things like this:

FromConfig.Instance.WithSupervisorStrategy(new OneForOneStrategy(ex => Directive.Restart)).Props()

[ ] Please update https://twitter.com/AkkaDotNET profile's URL to getakka.net
[ ] Finish the DotNetFiddle email acceptance / confirmation

This documentation page seems like something I need, but it seems the only place this code exists is here, which hasn't been merged into the akkadotnet repo. Is there a projected date on when this will become available?

Inspired by akkadotnet/akka.net#165 (comment)

Update all examples to no longer include the following:

FluentConfig
TypedActor

and what else?

The current paralax Akka mountains doesn't do much good.
Imo, we should replace the header with something more useful similar to the header in https://www.python.org/

Investigate how well https://www.npmjs.com/package/node-sass works as a replacement for compass.

It's JS + pure C, removes the dependency on Ruby.
And its faster..

We should add some doc page that describes where and under what conditions we can run Akka.NET.
Listing each module and where it works.

Sort of:

• Winows 10
• Visual Studio 2015 Enterprise
• Akka 1.1.0

While running the https://github.com/petabridge/akka-bootcamp, lessons 2 and 3 (.NET 4.6 - WinForms applications that want to use Akka.net SynchronizedDispatcher so as to access UI controls in the UI thread), I get this error when using the SynchronizedDispatcher through the following configuration):

Configuration

akka {
    actor{
        serializers {
            wire = "Akka.Serialization.WireSerializer, Akka.Serialization.Wire"
        }
        serialization-bindins {
            "System.Object" = 
        }
        deployment{
            /mainform{
                dispatcher = akka.actor.synchronized-dispatcher
            }
            /authenticator{
                dispatcher = akka.actor.synchronized-dispatcher 
            }
        }
    }
}

Error

[ERROR][15-Jul-16 08:40:37][Thread 0012][LocalActorRefProvider(akka://GithubActors)] Guardian failed. Shutting down system
Cause: System.InvalidOperationException: The current SynchronizationContext may not be used as a TaskScheduler.
   at System.Threading.Tasks.SynchronizationContextTaskScheduler..ctor()
   at System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext()
   at Akka.Dispatch.CurrentSynchronizationContextExecutorServiceFactory.Produce(String id)
   at Akka.Dispatch.Dispatcher.LazyExecutorServiceDelegate.<>c__DisplayClass3_0.<.ctor>b__0()
   at Akka.Util.FastLazy`1.get_Value()
   at Akka.Dispatch.Dispatcher.LazyExecutorServiceDelegate.get_Executor()
   at Akka.Dispatch.Dispatcher.get_Executor()
   at Akka.Dispatch.Dispatcher.ExecuteTask(IRunnable run)
   at Akka.Dispatch.MessageDispatcher.RegisterForExecution(Mailbox mbox, Boolean hasMessageHint, Boolean hasSystemMessageHint)
   at Akka.Dispatch.MessageDispatcher.Attach(ActorCell cell)
   at Akka.Actor.ActorCell.Start()
   at Akka.Actor.RepointableActorRef.Point()
   at Akka.Actor.ActorCell.HandleSupervise(IActorRef child, Boolean async)
   at Akka.Actor.ActorCell.Supervise(IActorRef child, Boolean async)
   at Akka.Actor.ActorCell.SysMsgInvokeAll(EarliestFirstSystemMessageList messages, Int32 currentState)
[ERROR][15-Jul-16 08:40:37][Thread 0012][akka://GithubActors/user] The current SynchronizationContext may not be used as a TaskScheduler.
Cause: System.InvalidOperationException: The current SynchronizationContext may not be used as a TaskScheduler.
   at System.Threading.Tasks.SynchronizationContextTaskScheduler..ctor()
   at System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext()
   at Akka.Dispatch.CurrentSynchronizationContextExecutorServiceFactory.Produce(String id)
   at Akka.Dispatch.Dispatcher.LazyExecutorServiceDelegate.<>c__DisplayClass3_0.<.ctor>b__0()
   at Akka.Util.FastLazy`1.get_Value()
   at Akka.Dispatch.Dispatcher.LazyExecutorServiceDelegate.get_Executor()
   at Akka.Dispatch.Dispatcher.get_Executor()
   at Akka.Dispatch.Dispatcher.ExecuteTask(IRunnable run)
   at Akka.Dispatch.MessageDispatcher.RegisterForExecution(Mailbox mbox, Boolean hasMessageHint, Boolean hasSystemMessageHint)
   at Akka.Dispatch.MessageDispatcher.Attach(ActorCell cell)
   at Akka.Actor.ActorCell.Start()
   at Akka.Actor.RepointableActorRef.Point()
   at Akka.Actor.ActorCell.HandleSupervise(IActorRef child, Boolean async)
   at Akka.Actor.ActorCell.Supervise(IActorRef child, Boolean async)
   at Akka.Actor.ActorCell.SysMsgInvokeAll(EarliestFirstSystemMessageList messages, Int32 currentState)

We should create some documentation on this subject. In other words, provide some sort of introduction to the pattern. Why its useful, how it works and how you can use it.

I read somewhere that the Fault Tolerance page is a good place to put this. So lets add a section there.

Im already integrating this pattern into my own application. So I might as take this issue on myself.

Mostly a follow-up for myself but anyone can take it.

If I get this wrong, feel free to note it here.

• UntypedActor: handles messages using Handle(object message)
• TypedActor: implements various IHandle<TMessage> interfaces which then render to Handle(TMessage message) methods
• ReceiveActor: Uses Receive<TMessage>( message => DoSomething(message)) in the constructor of the actor to do things.

We should describe how and when to make your own plugins

The current support page is empty.
We should add one with involved parties.

There are quite a few production users of Akka.NET now, anyone want to be listed on the site?

On the following page:
http://getakka.net/docs/CircuitBreaker

Code samples are displayed as:
F# Api
.. includecode:: code/docs/circuitbreaker/CircuitBreakerDocSpec.cs :include: imports1,circuit-breaker-initialization

C# Api
.. includecode:: code/docs/circuitbreaker/DangerousJavaActor.fs :include: imports1,circuit-breaker-initialization

In some of the next documentation I'm working on I use inline hyperlinks to cross-reference other related articles in the documentation.

But I'm having a hard time seeing them.

Here's an example - there's one hyperlink here. Can you find it?

We've recently updated the Akka.NET Users and Use Cases page to include links to some of the public stories and testimonials of companies who are using Akka.NET in production - and we would like you to add yours!

This issue explains how.

Why is this important?

We have tons of active users of Akka.NET and many more who are trying to sell their management on Akka.NET in production - and an important metric for gauging that is social capital: who else is using it?

The more people using Akka.NET, the more bug fixes / features / design feedback: everyone wins. So it's important to start getting more data points out into public.

How to add your company

Two ways:

1. Just add your name, a rough description ("we use Akka.NET for our analytics system") and a link to your website as a comment here - if you have a blog post or a video talking about you how actually use Akka.NET then link that instead.
2. Fork this repository, add the same data above to this markdown, and then submit a pull request to this repository.

Good hunting!

This question have come up a few times.
We need to describe the difference and when to use what.

pages that are located in the Concepts folder can currently not be edited via the Edit on Github link.
The link does not include the sub path \concepts\.

Link to documentation - https://github.com/akkadotnet/getakka.net/blob/master/src/docs/testing/multinode-testkit.md

Other details

https://files.gitter.im/akkadotnet/akka.net/fr2E/blob
https://files.gitter.im/akkadotnet/akka.net/K8m9/blob

http://getakka.net/docs/Serialization

See

protocol using new Address(protocol, "", "", 0) (assuming that the actual transport used is as lenient as Akka’s RemoteActorRefProvider).

There is also a default remote address which is the one used by cluster support (and typical systems have just this one); you can get it like this:

.. includecode:: code/docs/serialization/DefaultAddress.cs

There's a few other instances of this on this page too.

Need to make links look much more obvious when they're included inline in a regular document. They blend right in at the moment.

Currently these pages contain the same thing. Im guessing this is a leftover from some rename action. Can I safely assume the EventStream page can be removed?
(since the eventbus one contains a specific link back to the JVM docs)

It's currently kinda "hard" to use DI with Akka.net.

You need need to either drag around an IDependencyResolver (as shown in the documentation) to create the Props for Actors or use actorSystem.GetExtension<DIExt>() (not documented) to get access to a Props Props(Type actorType) method that lets you create Props through the DI container.

There is an extension DI() for IActorContext shown in the documentation that gives you access to a ActorOf<TActor>(string name) method that lets you create Child Actors. But that method doesn't let you configure the created actor in code because it returns an IActorRef.

My suggestion would be to add an extension DI(this ActorSystem system) to the ActorSystem to make it similar to that of the IActorContext class.

In addition to that a way should be added to just have the Props be created through the DI container so that one can configure an Actor in code as well. I would suggest adding Props<TActor>() methods in each Adapter class.

Add the index page referenced in #5 to the top-level navigation of the site.

https://github.com/akkadotnet/akka.net/tree/dev/src/contrib/persistence/Akka.Persistence.SqlServer - migrate the README to its own page and link it directly from the index