feed.xml

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    
    <title></title>
    <description>blog for veblush, programmer</description>
    <link>http://veblush.github.io/</link>
    <atom:link href="http://veblush.github.io/feed.xml" rel="self" type="application/rss+xml"/>
    <pubDate>Fri, 15 Jul 2016 23:17:05 +0900</pubDate>
    <lastBuildDate>Fri, 15 Jul 2016 23:17:05 +0900</lastBuildDate>
    <generator>Jekyll v3.1.3</generator>
    
      <item>
        <title>Online game server works on Akka.NET for the last 2 months</title>
        <description>&lt;p&gt;I’ve been working on works related to &lt;a href=&quot;http://veblush.github.io/posts/online-game-server-on-akkanet/&quot;&gt;Online game server on Akka.NET&lt;/a&gt;
which I made a speech about at NDC 2016. Most of work is for polishing and paying down the technical debt.
This article explains what has been done and what will be (maybe) done later.&lt;/p&gt;

&lt;h3 id=&quot;works-done&quot;&gt;Works done&lt;/h3&gt;

&lt;h4 id=&quot;expressive-interface&quot;&gt;Expressive Interface&lt;/h4&gt;

&lt;p&gt;&lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced&quot;&gt;Akka.Interfaced&lt;/a&gt; uses C# &lt;code class=&quot;highlighter-rouge&quot;&gt;interface&lt;/code&gt; to define a contract
for communicating with an actor. It’s natural for C# programmer and makes easy to send and receive messages with actors.
However &lt;code class=&quot;highlighter-rouge&quot;&gt;interface&lt;/code&gt; is used and programmers seem to expect that major interface features are possible to use,
generic and inheritance are supported to satisfy this.&lt;/p&gt;

&lt;h6 id=&quot;generic&quot;&gt;Generic&lt;/h6&gt;

&lt;p&gt;Generic interface and method are supported and following interface can be defined.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c1&quot;&gt;// generic interface
&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IInterfacedActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Greet&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;U&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;U&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// generic method
&lt;/span&gt;    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetCount&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Actor can implement the previous interface like:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;GreetingActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;InterfacedActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Greet&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Greet&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;U&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;U&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Supporting generic interface was quite simple because generic parameters are determined at the time of creating an actor.
But for generic method, it was not because new generic handler should be instantiated
whenever new message containing different parameters arrives.&lt;/p&gt;

&lt;p&gt;Related issue: &lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/issues/30&quot;&gt;Generic interface #30&lt;/a&gt;&lt;/p&gt;

&lt;h6 id=&quot;inheritance&quot;&gt;Inheritance&lt;/h6&gt;

&lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;Interface&lt;/code&gt; inheritance can be used like following. Work to support it was simple.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IInterfacedActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Greet&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeterEx&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GreetEx&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Related issue: &lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/issues/27&quot;&gt;Support interface inheritance #27&lt;/a&gt;&lt;/p&gt;

&lt;h4 id=&quot;polishing-api&quot;&gt;Polishing API&lt;/h4&gt;

&lt;p&gt;At the previous Proof-Of-Concept stage, all works were for implementing and verifying the idea, not for polishing.
Because polishing itself costs many hours than expected and doesn’t always end up with good result.
But this time is good for this polishing.&lt;/p&gt;

&lt;h6 id=&quot;remove-crtp-curiously-recurring-template-pattern&quot;&gt;Remove CRTP (Curiously Recurring Template Pattern)&lt;/h6&gt;

&lt;p&gt;Base class, &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActor&lt;/code&gt; needs a dedicate place to store a message dispatch table for each class.
CRTP is convenient to handle this because generic class always allocate new static storage when being instantiated.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;GreeterActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;InterfacedActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GreeterActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;But this pattern causes programmer make a silly mistake like providing a wrong generic parameter.
For previous case, wrong base class such as &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActor&amp;lt;GuestActor&amp;gt;&lt;/code&gt; cannot prevent compiler to build it
but will throw runtime exception. It’s not good for safe programming environment so it’s improved like following.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;GreeterActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;InterfacedActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Related issue: &lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/issues/20&quot;&gt;Change InterfacedActor&amp;lt;T&amp;gt; to InterfacedActor #20&lt;/a&gt;&lt;/p&gt;

&lt;h6 id=&quot;unhandled-exception-policy&quot;&gt;Unhandled exception policy&lt;/h6&gt;

&lt;p&gt;Previous version of &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActor&lt;/code&gt; always returns an exception back to a requester
an unhandler exception is thrown while processing requests.
This decision was made because Requester-Responder is similar with Caller-Callee.
But Akka.NET doesn’t work like this and it becomes a problem.
Akka.NET actor always propagates unhandled exceptions to a supervisor (usually parent) not to a requester. (&lt;a href=&quot;http://getakka.net/docs/Fault%20tolerance&quot;&gt;Fault Tolerance&lt;/a&gt;)
If the interfaced actor works different from Akka.NET standard way, it could be a source of confusion.
Because of this, &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActor&lt;/code&gt; is updated to follow the standard way but the other option is provided.
If you want to propagate an unhandled exception to requester like before, &lt;code class=&quot;highlighter-rouge&quot;&gt;ResponsiveException&lt;/code&gt; can be used.
Following &lt;code class=&quot;highlighter-rouge&quot;&gt;Greet&lt;/code&gt; method will propagate only &lt;code class=&quot;highlighter-rouge&quot;&gt;ArgumentException&lt;/code&gt; to requester and others to supervisor.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;GreeterActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;InterfacedActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ResponsiveException&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ArgumentException&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))]&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IGreeter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Greet&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Related issue: &lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/issues/21&quot;&gt;Exception policy for handling request, notification and message. #21&lt;/a&gt;&lt;/p&gt;

&lt;h6 id=&quot;add-extensions-to-observer-and-message-handler-like-request-handler&quot;&gt;Add extensions to observer and message handler like request handler&lt;/h6&gt;

&lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActor&lt;/code&gt; can handle 3 different types of message.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Request: Request messages which are defined at &lt;code class=&quot;highlighter-rouge&quot;&gt;IInterfacedActor&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;Notification: Event notification messages which are defined at &lt;code class=&quot;highlighter-rouge&quot;&gt;IInterfacedObserver&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;Message: Message which have a handler annotated by &lt;code class=&quot;highlighter-rouge&quot;&gt;[MessageHandler]&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Among these kinds of message, only Request handler could make use of filter and the extended handler.
But programmers expect that these kinds of message are equally supported so same features are added to notification and message handler.&lt;/p&gt;

&lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;LogFilter&lt;/code&gt; can be used for message handler now.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;TestActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;InterfacedActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;MessageHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Log&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;OnMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;message&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Notification handler for observer can be implemented with an extended handler.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;TestActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;InterfacedActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IExtendedInterface&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ISubjectObserver&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ExtendedHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Event&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;eventName&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;...&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Related issue: &lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/issues/16&quot;&gt;Let observer handler work with ExtendedHandler and Filter like Interfaced handler. #16&lt;/a&gt;&lt;/p&gt;

&lt;h6 id=&quot;terse-slimclient-api&quot;&gt;Terse SlimClient API&lt;/h6&gt;

&lt;p&gt;SlimClient does not depend on Akka.NET to make actors accessible from clients outside of Akka.NET.
Because &lt;code class=&quot;highlighter-rouge&quot;&gt;ActorRef&lt;/code&gt; for SlimClient is implemented quite differently, interpretation is required to
send and receive &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActorRef&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedObserver&lt;/code&gt; across the boundary between SlimClient and Akka.NET.&lt;/p&gt;

&lt;p&gt;For example, following code shows IUserLogin.Login which gets an observer created at SlimClient and
returns User actorRef created at Akka.NET to SlimClient.
Previous version of library forced you to use ID and translate it manually to pass and construct UserRef.
It is not a transparent API and makes bloated code.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUserLogin&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IInterfacedActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Login&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;observerId&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;n&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userId&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userLogin&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Login&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(...);&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;user&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;UserRef&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SlimActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;userId&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SlimRequestWaiter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;_comm&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;this&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)));&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;It’s improved like following. &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedActorRef&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;InterfacedObserver&lt;/code&gt; can be used directly like Akka.NET.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUserLogin&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IInterfacedActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IUser&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Login&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IUserObserver&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;observer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;n&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;user&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userLogin&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Login&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(...);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Related issue: &lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/issues/23&quot;&gt;Concise way for retrieving InterfacedActorRef on slim-client. #23&lt;/a&gt;&lt;/p&gt;

&lt;h4 id=&quot;extend-slimclient-channel&quot;&gt;Extend SlimClient channel&lt;/h4&gt;

&lt;p&gt;Single TCP channel has been extended.&lt;/p&gt;

&lt;h5 id=&quot;udp-support&quot;&gt;UDP Support&lt;/h5&gt;

&lt;p&gt;UDP channel is introduced in addition to TCP. Rationale for adding UDP channnel is:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;HandOver: There is an issue on TCP for handling handover on mobile environment.
To make it happen, reliable data transfer layer should be implemented on top of TCP.
Instead of hard work on TCP, how about using reliable UDP?
It’s better for fast hand-over because it doesn’t establish the connection.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;Various QOS:
TCP allows only reliable and ordered transmission but UDP allows many options
such as reliable-unoredered and unreliable. For sending player movement notification message,
unreliable-sequenced is enough and more performant than TCP.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href=&quot;https://github.com/lidgren/lidgren-network-gen3&quot;&gt;Lidgren Network Library&lt;/a&gt; is chosen to be used
even it is not designed for server environment because writing robust communication library 
takes lots of effort. Just &lt;a href=&quot;https://github.com/SaladLab/LidgrenUdpNet&quot;&gt;forked&lt;/a&gt; it and updated it to meet my own requirements.
Following works are done.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;Support .NET 3.5 for nuget package: &lt;a href=&quot;https://www.nuget.org/packages/LidgrenUdpNet/&quot;&gt;LidgrenUdpNet&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;Support UnityPackage: &lt;a href=&quot;https://github.com/SaladLab/LidgrenUdpNet/releases&quot;&gt;LidgrenUdpNet for Unity3D&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;Add fast message handler.&lt;/li&gt;
  &lt;li&gt;Connection is defined not by EndPoint but by ConnectionID to allow hand-over between WiFi and 3G.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;And also Lidgren Network Library provides a P2P network feature which is a good tool for network game.&lt;/p&gt;

&lt;h5 id=&quot;remote-channel-binding&quot;&gt;Remote channel binding&lt;/h5&gt;

&lt;p&gt;Remote channel binding allow clients to connect another servers owning specfic actors directly.
Previous one allowed clients to access remote actor only via a channel establised at first connection. 
(Forwarding Channel in the following figure)
This method is quite simple to use but it causes unncessary traffic for forwarding channel.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;   * Forwarding Channel                          * Direct Channel
   Client -&amp;gt; Channel1 -&amp;gt; UserActor               Client -&amp;gt; Channel1 -&amp;gt; UserActor        
                |                                   | 
             ~~~|~~~~                               |      ~~~~~~~~
                |                                   |
                +---- -&amp;gt; GameActor                  +----&amp;gt; Channel2 -&amp;gt; GameActor
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;To deal with this problem, client can establish a channel on remote server to access remote actors.
(Direct Channel in the previous figure)&lt;/p&gt;

&lt;p&gt;Following code shows how server open a remote channel to allow client to access GameActor directly.
It opens a remote channel and returns connection information to a client.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;n&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IGamePlayer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUser&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;JoinGame&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;long&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;game&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetGame&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;game&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Join&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;_id&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;...);&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;boundTarget&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_channel&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;BindActorOrOpenChannel&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;game&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;CastToIActorRef&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(),&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;TaggedType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IGamePlayer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_id&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;},&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;ActorBindingFlags&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;OpenThenNotification&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;|&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ActorBindingFlags&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CloseThenNotification&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
        &lt;span class=&quot;s&quot;&gt;&quot;GameGateway&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_id&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;boundTarget&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Cast&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GamePlayerRef&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;After client receives connection information from server, it establishes new connection to reach GameActor
and commuicate with it as a regular actor.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;n&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;gamePlayer&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;User&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;JoinGame&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;gameId&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;...);&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;gamePlayer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;IsChannelConnected&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;false&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;gamePlayer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ConnectChannelAsync&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;gamePlayer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;CallSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;h5 id=&quot;bind-multiple-interfaces-to-a-bound-actor&quot;&gt;Bind multiple interfaces to a bound actor&lt;/h5&gt;

&lt;p&gt;Bound actor to channel could be accessed via one bound interface. (Not means that actor can implement only one interface.)
It changed to bind multiple interfaces to an actor and the following use case can be implemented with this feature.&lt;/p&gt;

&lt;p&gt;For example, &lt;code class=&quot;highlighter-rouge&quot;&gt;UserActor&lt;/code&gt; has two kinds of permission to access. Normal access and administrative access.
Normal access is only permitted before client is confirmed to have an administrative priviledge.
At first, write &lt;code class=&quot;highlighter-rouge&quot;&gt;UserActor&lt;/code&gt; implementing &lt;code class=&quot;highlighter-rouge&quot;&gt;IUser&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;IUserForAdmin&lt;/code&gt; as separate methods by permission and
bind only &lt;code class=&quot;highlighter-rouge&quot;&gt;IUser&lt;/code&gt; to bound user actor.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UserActor&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IInterfacedActor&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUser&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUserForAdmin&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUser&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;NormalMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IUserForAdmin&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;PowerMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;After verifying client is an administrator, tell channel to allow a client to access &lt;code class=&quot;highlighter-rouge&quot;&gt;IUserForAdmin&lt;/code&gt; methods
by binding &lt;code class=&quot;highlighter-rouge&quot;&gt;IUserForAdmin&lt;/code&gt; to bound actor. After binding, client can access methods of &lt;code class=&quot;highlighter-rouge&quot;&gt;IUserForAdmin&lt;/code&gt;.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Authorize&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(...)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_channel&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;BindType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Self&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;TaggedType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[]&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IUserForAdmin&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;});&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;h4 id=&quot;example-works&quot;&gt;Example works&lt;/h4&gt;

&lt;p&gt;Writing examples has been an important part through the whole development process.
In developing libraries, it could be the first way to make sure it works well and
show how easy programmer can write features that libraries want to help with.
And it let me know what is missing and what is bad quickly. 
Also it is really helpful to let newcomer understand how the library works and learn best practices.
Because of this several advantages, I have been updating examples even it costs tons of efforts.&lt;/p&gt;

&lt;h5 id=&quot;keep-reference-applications-up-to-date&quot;&gt;Keep reference applications up-to-date&lt;/h5&gt;

&lt;p&gt;There are three reference applications: &lt;a href=&quot;https://github.com/SaladLab/Chatty&quot;&gt;Chatty&lt;/a&gt;,
&lt;a href=&quot;https://github.com/SaladLab/TicTacToe&quot;&gt;TicTacToe&lt;/a&gt;, &lt;a href=&quot;https://github.com/SaladLab/Snake&quot;&gt;Snake&lt;/a&gt;.
These have been updated by the changes of library. (More hours were spent than expected)&lt;/p&gt;

&lt;p&gt;These three diffrent applications share common parts and help for extracting common reusable parts.
In this period, &lt;a href=&quot;https://github.com/SaladLab/Aim.ClusterNode&quot;&gt;Aim.ClusterNode&lt;/a&gt; are written for covering
common cluster node behaviours.&lt;/p&gt;

&lt;p&gt;Also all servers in application can run as a service now.&lt;/p&gt;

&lt;h5 id=&quot;project-scaffolding&quot;&gt;Project scaffolding&lt;/h5&gt;

&lt;p&gt;New tool, &lt;a href=&quot;https://github.com/SaladLab/Akka.ProjectScaffolding&quot;&gt;Akka.ProjectScaffolding&lt;/a&gt; is introduced
to help for initiating new project with akka.net and unity.
For building online game, at least 3 projects should be created and many libraries have to be installed and configurated,
which are boring and time-consuming. At first, Visual Studio &lt;a href=&quot;https://msdn.microsoft.com/en-us/library/ms185301.aspx&quot;&gt;Project Template&lt;/a&gt; 
was being considered but it is not easy to support other IDEs such as Visual Sutio Code and to maintain template project without burden
so standalone scaffolding tool was chosen.&lt;/p&gt;

&lt;p&gt;Run a program from &lt;a href=&quot;https://github.com/SaladLab/Akka.ProjectScaffolding/releases&quot;&gt;Release&lt;/a&gt; and
it will create new project configured to work on right now. Following command generates new project using cluster.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;akka-unity-cluster NewProjectName
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;h4 id=&quot;writing-test-and-documentation&quot;&gt;Writing test and documentation&lt;/h4&gt;

&lt;p&gt;Some tests and documentationwere skipped because of a rapid development. Missing parts have been written.
For tests, writing test itself is a little bit easy, whereas building testing environment is sometimes really hard.
And writing documentation is always difficult. :)&lt;/p&gt;

&lt;p&gt;New tests&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/tree/master/core/CodeGenerator.Tests&quot;&gt;Akka.Interfaced CodeGenerator&lt;/a&gt; :
Make simple test code for verifying result code not by comparing generated code source but by analyzing generated semantic trees.&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced.SlimSocket/tree/master/core/Akka.Interfaced.SlimSocket.Tests&quot;&gt;Akka.Interfaced.SlimSocket&lt;/a&gt; :
It was impossible to write test code because SlimClient and Akka.Interfaced were mutual exclusive but it became possible to write after removing SlimClient project.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;New documentation&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;a href=&quot;https://github.com/SaladLab/Akka.Interfaced/blob/master/docs/Manual.md&quot;&gt;Akka.Interfaced Manual&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;futher-work&quot;&gt;Futher work&lt;/h3&gt;

&lt;p&gt;These are short summary that want to be implemented. But when and how are not determined.&lt;/p&gt;

&lt;h4 id=&quot;encrypting-udp-communication&quot;&gt;Encrypting UDP communication&lt;/h4&gt;

&lt;p&gt;Add encryption to UDP communication. UDP channel identifies each connection by connection ID (not endpoint)
so someone can insert a malicious packet into other’s connection if he can guess connection ID and sequence number.
To prevent this, encryption have to be adopted.
For the same reason, &lt;a href=&quot;https://en.wikipedia.org/wiki/QUIC&quot;&gt;QUIC&lt;/a&gt; specifies that TLS/SSL is mandatory for keeping connection safe.&lt;/p&gt;

&lt;h4 id=&quot;wire-instead-of-protobufnet&quot;&gt;Wire instead of Protobuf.NET&lt;/h4&gt;

&lt;p&gt;SlimSocket uses &lt;a href=&quot;https://github.com/mgravell/protobuf-net&quot;&gt;protobuf-net&lt;/a&gt; for a message serializer. 
Because of limits of protobuf, it is practically impossible to use inheritance and generic for serializing a message.
Also protobuf-net always make a empty container variable null, which surprises a programmer. (maybe me alone?)
To alleviate this problem, alternative serializer can be used such as &lt;a href=&quot;https://github.com/akkadotnet/Wire&quot;&gt;wire&lt;/a&gt;.&lt;/p&gt;

&lt;h4 id=&quot;distributed-actortable&quot;&gt;Distributed ActorTable&lt;/h4&gt;

&lt;p&gt;Current implementation &lt;a href=&quot;https://github.com/SaladLab/Akka.Cluster.Utility/blob/master/docs/DistributedActorTable.md&quot;&gt;DistributedActorTable&lt;/a&gt;
at &lt;a href=&quot;https://github.com/SaladLab/Akka.Cluster.Utility&quot;&gt;Akka.Cluster.Utility&lt;/a&gt; provides a distribued actor table across cluster nodes.
But table should be placed at one node, which make this SPOF/B.
To make fault tolerant distributed system, this table should be improved.&lt;/p&gt;

&lt;h4 id=&quot;net-core-support&quot;&gt;.NET Core Support&lt;/h4&gt;

&lt;p&gt;Let’s support .NET Core which is the future of .NET. It provides a lot of benefits such as
hosting services on Linux or Windows nano server. But we need to wait for all dependent libraries to
support .NET core first.&lt;/p&gt;

&lt;h3 id=&quot;closing&quot;&gt;Closing&lt;/h3&gt;

&lt;p&gt;All these works were estimated for my 1 month work but turned out 2 months. :cry:
But I finished all planned works and I’m happy about it.&lt;/p&gt;
</description>
        <pubDate>Fri, 15 Jul 2016 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/akkanet-online-game-works-for-the-last-2-months/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/akkanet-online-game-works-for-the-last-2-months/</guid>
        
        
        <category>akkanet</category>
        
      </item>
    
      <item>
        <title>Online game server on Akka.NET</title>
        <description>&lt;p&gt;I made a speech about “Online game server on Akka.NET” at &lt;a href=&quot;https://ndc.nexon.com&quot;&gt;NDC&lt;/a&gt; 2016.
Following are slides and Q&amp;amp;As in the session.&lt;/p&gt;

&lt;h2 id=&quot;slides&quot;&gt;Slides&lt;/h2&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;a href=&quot;http://www.slideshare.net/veblush/online-game-server-on-akkanet-ndc2016&quot;&gt;Slideshare&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;/assets/posts/2016-05-16-online-game-server-on-akkanet/NDC2016_OnlineGameServer_With_AkkaNet_English.pptx&quot;&gt;PPT&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;qa&quot;&gt;Q&amp;amp;A&lt;/h2&gt;

&lt;h4 id=&quot;basic&quot;&gt;Basic&lt;/h4&gt;

&lt;h6 id=&quot;should-i-concern-about-multi-thread-synchronization-and-thread-blocking-on-akkanet&quot;&gt;# Should I concern about multi-thread synchronization and thread-blocking on Akka.NET?&lt;/h6&gt;

&lt;p&gt;Basically, No.
Actor model which akka provides is the another way to write concurrent code
without complex issues such as multi-threading and thread-blocking.&lt;/p&gt;

&lt;h6 id=&quot;is-message-passing-only-method-for-accessing-the-state-of-actor-any-latency-or-io-overhead-related-with&quot;&gt;# Is message passing only method for accessing the state of actor? Any latency or IO overhead related with?&lt;/h6&gt;

&lt;p&gt;Yes. Message passing only and it adds more latency and IO overhead but it’s well-optimized and good to go.&lt;/p&gt;

&lt;h6 id=&quot;what-does-happen-to-child-actors-when-their-parent-actor-stops-is-it-could-be-spof&quot;&gt;# What does happen to child actors when their parent actor stops? Is it could be SPOF?&lt;/h6&gt;

&lt;p&gt;Child actors will stop when their parent actor stops.
SPOF could be handled with high level tools such as akka.cluster not with actor itself.&lt;/p&gt;

&lt;h6 id=&quot;any-performance-problem-when-there-are-lots-of-messages-in-one-actor-mailbox&quot;&gt;# Any performance problem when there are lots of messages in one actor mailbox.&lt;/h6&gt;

&lt;p&gt;One actor processes one message at a time. So that actor will be busy in processing all messages
and takes more time to respond requests. But it doesn’t affect other actors because they are isolated from each others.&lt;/p&gt;

&lt;h6 id=&quot;how-can-i-synchronize-data-when-one-actor-is-shared-from-several-nodes-in-a-cluster-any-lock-is-required&quot;&gt;# How can I synchronize data when one actor is shared from several nodes in a cluster. Any lock is required?&lt;/h6&gt;

&lt;p&gt;Actor is only accessable via ActorRef so nodes cannot access data of actor just can send a message to it.
When several messages received from nodes, the actor will process a message at a time so no lock is required to synchronize requests.&lt;/p&gt;

&lt;h6 id=&quot;is-there-a-way-to-broadcast-a-message-to-many-actors-on-akkanet&quot;&gt;# Is there a way to broadcast a message to many actors on Akka.NET?&lt;/h6&gt;

&lt;p&gt;Yes. There are two ways for that. First one is using wildcard included 
&lt;a href=&quot;http://getakka.net/docs/Working%20with%20actors#identifying-actors-via-actor-selection&quot;&gt;ActorSelection&lt;/a&gt; and 
second one is using 
&lt;a href=&quot;http://getakka.net/docs/working-with-actors/Routers#broadcast&quot;&gt;Broadcast Router&lt;/a&gt;.&lt;/p&gt;

&lt;h4 id=&quot;programming-pattern&quot;&gt;Programming Pattern&lt;/h4&gt;

&lt;h6 id=&quot;deadlock-may-occur-when-two-actors-send-a-message-to-each-other-and-await-how-can-we-handle-it&quot;&gt;# Deadlock may occur when two actors send a message to each other and await. How can we handle it?&lt;/h6&gt;

&lt;p&gt;Yes it can cause deadlock. Because of this problem, send and await pattern is &lt;a href=&quot;http://bartoszsypytkowski.com/dont-ask-tell-2/&quot;&gt;not recommended&lt;/a&gt;.
But if you want, there are three workarounds.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;Like a lock-use scenario, you can set await hierarchies for actors.
For more info about lock hierarchy, read &lt;a href=&quot;http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163&quot;&gt;Use Lock Hierarchies to Avoid Deadlock&lt;/a&gt;.&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;ReentrantAttribute in Akka.Interfaced allows an actor to handle other messages while waiting await response.
This can makes you avoid deadlock but you need to take care of reentrancy in await state.&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h6 id=&quot;mmorpg-can-be-implemented-with-the-actor-model-there-could-be-many-interactions-between-actors-in-mmorpg-and-it-seems-hard-to-build-it&quot;&gt;# MMORPG can be implemented with the actor model? There could be many interactions between actors in MMORPG and it seems hard to build it.&lt;/h6&gt;

&lt;p&gt;If actors depend on each others’ state and need lots of synchronized interactions, it will be hard to build a system with actors. 
Therefore we need a system to make this easy. In case of TicTacToe, there is a GameActor for handling this problem.
This GameActor receives all game commands from users in a game and processes it easily. (It’s like a single-threaded programming.)
If a MMORPG whose world is separate into several isolated zones, you can use same approch for each zones.
But for a MMORPG whose world is not separate such as a seemless world, it will be a challenging work.&lt;/p&gt;

&lt;h6 id=&quot;transaction-for-multiple-actors-for-examples-trade-between-two-users-requires-transaction-to-implement-it&quot;&gt;# Transaction for multiple actors? For examples, trade between two users requires transaction to implement it.&lt;/h6&gt;

&lt;p&gt;If we can sqeeze multiple entities into one actor like zone actor, it will be solve easily.
But an user inventory doesn’t seem to work like this. In this case, regular distributed transation will be an answer.
&lt;a href=&quot;https://en.wikipedia.org/wiki/Two-phase_commit_protocol&quot;&gt;Two-Phase commit protocol&lt;/a&gt; is a common solution and
you can check 
&lt;a href=&quot;http://www.slideshare.net/petabridge/distributed-transactions-in-akkanet&quot;&gt;How do I do transactions across a distributed system?&lt;/a&gt;.&lt;/p&gt;

&lt;h6 id=&quot;any-race-condition-for-trackabledata-set&quot;&gt;# Any race condition for TrackableData Set?&lt;/h6&gt;

&lt;p&gt;No. TrackableData is not for concurrent data modification.
It just tracks the changes of data and propages changes to other systems such as DB and client.
There is no race condition because an actor owns trackabledata instances and processes a message at a time.&lt;/p&gt;

&lt;h4 id=&quot;integration&quot;&gt;Integration&lt;/h4&gt;

&lt;h6 id=&quot;languages-other-than-c-can-interoperate-with-akkanet&quot;&gt;# Languages other than C# can interoperate with Akka.NET?&lt;/h6&gt;

&lt;p&gt;Yes. Any languages supporting .NET such as C#, F# and VB.NET can interoperate with Akka.NET.
However, it’s not easy now for the environment beyond .NET.&lt;/p&gt;

&lt;h6 id=&quot;it-it-easy-or-hard-to-write-test-code-on-akkanet&quot;&gt;# It it easy or hard to write test code on Akka.NET?&lt;/h6&gt;

&lt;p&gt;Fundamentally it is harder than writing test code consisting of calling synchronized methods
because the environment with multiple actors sending messages to each others is not deterministic.
But Akka.NET provides handy tools helping for writing unit tests.
Check out &lt;a href=&quot;https://petabridge.com/blog/how-to-unit-test-akkadotnet-actors-akka-testkit/&quot;&gt;How to Unit Test Akka.NET Actors with Akka.TestKit&lt;/a&gt;.&lt;/p&gt;

&lt;h6 id=&quot;can-akkanet-interop-with-akka-on-jvm&quot;&gt;# Can Akka.NET interop with Akka on JVM?&lt;/h6&gt;

&lt;p&gt;Unfortunately, No. Check this &lt;a href=&quot;https://github.com/akkadotnet/akka.net/issues/1629&quot;&gt;Issue&lt;/a&gt;.&lt;/p&gt;

&lt;h4 id=&quot;performance&quot;&gt;Performance&lt;/h4&gt;

&lt;h6 id=&quot;it-seems-to-have-performance-issues-do-you-have-stress-tests&quot;&gt;# It seems to have performance issues. Do you have stress tests?&lt;/h6&gt;

&lt;p&gt;Still I don’t have any benchmark on whole system but I did tests on components and results looked good.
From the Akka.NET manual, 50 million msg/sec on a single machine and ~2.5 million actors per GB of heap.&lt;/p&gt;

&lt;h6 id=&quot;latency-could-be-problematic-when-hundreds-of-servers-send-messages-on-network&quot;&gt;# Latency could be problematic when hundreds of servers send messages on network?&lt;/h6&gt;

&lt;p&gt;When an actor send a message to other actor in same machine,
it doens’t use network just put a message in a recipient’s mailbox.
So you need to put actors interacting with each others alot in same machine to avoid network stress.&lt;/p&gt;

&lt;h4 id=&quot;etc&quot;&gt;Etc&lt;/h4&gt;

&lt;h6 id=&quot;you-said-that-monstersweeperz-uses-c-iocp-but-there-is-no-iocp-api-on-net-how-did-you-do&quot;&gt;# You said that MonsterSweeperz uses C# IOCP but there is no IOCP API on .NET how did you do?&lt;/h6&gt;

&lt;p&gt;Yes, there is no IOCP API on .NET and I didn’t make a lib for that.
MonsterSweeperz uses .NET socket which is implemented on IOCP so I said like that.&lt;/p&gt;

&lt;h6 id=&quot;any-problem-with-full-gc-latency-if-not-could-you-tell-me-the-maximum-size-of-heap&quot;&gt;# Any problem with full GC latency? If not, could you tell me the maximum size of heap?&lt;/h6&gt;

&lt;p&gt;MonsterSweeperz has not suffered any GC problems because basic memory optimization already has been done
and quick responsiveness was not a requirement of system. The maximum size of heap was about 1-2 GB.&lt;/p&gt;
</description>
        <pubDate>Mon, 16 May 2016 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/online-game-server-on-akkanet/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/online-game-server-on-akkanet/</guid>
        
        
        <category>akkanet</category>
        
      </item>
    
      <item>
        <title>How I build my blog using Jekyll</title>
        <description>&lt;p&gt;Recently I has been building blog. It was expected to take
at most 2 days but more time spent because of some traps.
But anyway it’s done!&lt;/p&gt;

&lt;h2 id=&quot;requirements&quot;&gt;Requirements&lt;/h2&gt;

&lt;ul&gt;
  &lt;li&gt;Simple UI&lt;/li&gt;
  &lt;li&gt;Easy to insert code blocks and math expressions&lt;/li&gt;
  &lt;li&gt;Supports both english and korean&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;works&quot;&gt;Works&lt;/h2&gt;

&lt;h5 id=&quot;create-github-repository&quot;&gt;# Create Github repository&lt;/h5&gt;

&lt;p&gt;Personal github repository 
&lt;a href=&quot;https://github.com/veblush/veblush.github.io&quot;&gt;veblush.github.io&lt;/a&gt; is created
for hosting blog by &lt;a href=&quot;https://pages.github.com/&quot;&gt;Github Pages&lt;/a&gt; service.
Github provides the neat way to build sites from Jekyll source pages automatically
but it cannot be used because using plugins is not allowed by github.
So manual build process have to be prepared.&lt;/p&gt;

&lt;h5 id=&quot;install-jekyll-3&quot;&gt;# Install Jekyll 3&lt;/h5&gt;

&lt;p&gt;&lt;a href=&quot;https://jekyllrb.com/&quot;&gt;Jekyll&lt;/a&gt; 3.1.3 is installed.
With ruby gem utility, it is quite easy.&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&amp;gt; gem install jekyll
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;h5 id=&quot;theme&quot;&gt;# Theme&lt;/h5&gt;

&lt;p&gt;I don’t have the ability to design web sites and don’t have time to do it, either.
So I decided to use theme but choosing right theme among tons of themes is really
time-consuming and hard-to-pick work.
But accidently tidy blog &lt;a href=&quot;http://nithinbekal.com&quot;&gt;nithinbekal&lt;/a&gt; was found and
the theme of that was chosen to use. It looks simple and best fit to my requirement.
Based on this theme, layout and css has been modified slightly.&lt;/p&gt;

&lt;h5 id=&quot;setup-polyglot-plugin&quot;&gt;# Setup Polyglot plugin&lt;/h5&gt;

&lt;p&gt;Official i18n support is not provided by Jekyll. There are a few ways for supporting it.
&lt;a href=&quot;http://untra.github.io/polyglot/&quot;&gt;Polyglot&lt;/a&gt; was chosen for this blog
because it seemed simple to use and neat. 
However it took many hours to setup it because I was not familar with
the detail of Jekyll and there was a weird bug of polyglot active on windows.
Finally this bug is &lt;a href=&quot;https://github.com/untra/polyglot/commit/3280a2d84da1a36929fb5615426349dc6cccf4c3&quot;&gt;fixed&lt;/a&gt;
and it works well now.&lt;/p&gt;

&lt;h5 id=&quot;setup-asset-path-plugin&quot;&gt;# Setup Asset Path plugin&lt;/h5&gt;

&lt;p&gt;It seems better to allocate local storage for each post because some of post have
lots of images or diagrams generated with graphviz which are not shared by other posts.
&lt;a href=&quot;https://github.com/samrayner/jekyll-asset-path-plugin&quot;&gt;Jekyll Asset Path&lt;/a&gt; is installed for this.
It works well and is slightly modified to support Polyglot and my own directory naming rule.&lt;/p&gt;

&lt;h5 id=&quot;import-old-blogs&quot;&gt;# Import old blogs&lt;/h5&gt;

&lt;p&gt;All posts from previous blog can be imported as HTML format. These HTML articles are tranformed
to markdown with &lt;a href=&quot;https://www.pandadoc.com/&quot;&gt;Pandadoc&lt;/a&gt;. Most of them are good but there are some
incorrect markdowns that should be corrected by hand.
Image links are changed to fit asset directory and math expressions are converted to
kramdown &lt;a href=&quot;http://kramdown.gettalong.org/math_engine/mathjax.html&quot;&gt;form&lt;/a&gt;.
Fortunately it doens’t take long because there are not many articles to be imported.&lt;/p&gt;

&lt;h5 id=&quot;write-publish-script&quot;&gt;# Write publish script&lt;/h5&gt;

&lt;p&gt;Two branches are created on Github repository.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;site branch: Working branch for storing original source of blog.&lt;/li&gt;
  &lt;li&gt;master branch: Output branch for storing the result of Jekyll from site branch.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href=&quot;https://github.com/veblush/veblush.github.io/blob/site/publish.cmd&quot;&gt;Publish script&lt;/a&gt;
will run Jekyll at site branch and copy output to master branch to update blog.&lt;/p&gt;

</description>
        <pubDate>Sat, 14 May 2016 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/how-build-blog-using-jekyll/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/how-build-blog-using-jekyll/</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>Why I move to Jekyll for my blog</title>
        <description>&lt;p&gt;I used common blog service in creating my blog at 2012.
Blog service was good to write blog right after a few clicks even
it had some drawbacks.
Theseday I have some spare time for this and decide to change it.&lt;/p&gt;

&lt;h2 id=&quot;drawbacks-of-blog-service&quot;&gt;Drawbacks of blog service&lt;/h2&gt;

&lt;h5 id=&quot;not-easy-to-embed-code-and-math-expression&quot;&gt;# Not easy to embed code and math expression&lt;/h5&gt;

&lt;p&gt;Embeding code is not easy. My blog has lots of code blocks to be embeded.
Whenever code need to be inserted, I switch blog to HTML mode and insert
a few HTML code for that and switch it back to writing mode,
which is quite bothersome.&lt;/p&gt;

&lt;p&gt;Embeding math expression is not easy, too. There is a nice web service to
provide the way to convert LaTeX math expression to an image dynamically.
I used it happily but it requires some manual steps. Also my blog depends on
external service that could be down for maintenance or disappear forever.&lt;/p&gt;

&lt;h5 id=&quot;need-to-store-original-data-of-diagram-separately&quot;&gt;# Need to store original data of diagram separately&lt;/h5&gt;

&lt;p&gt;GraphViz and Excel are used for authoring graph and chart which are converted
to images and inserted to blog. For futhur updates, source files
should be stored but because blog service does not provide storage, I backup
these files to the separate place, which is tiresome and easy to forget.&lt;/p&gt;

&lt;h2 id=&quot;why-i-choose-jekyll&quot;&gt;Why I choose Jekyll&lt;/h2&gt;

&lt;h5 id=&quot;easy-to-embed-code-and-math-expression&quot;&gt;# Easy to embed code and math expression&lt;/h5&gt;

&lt;p&gt;If you are accustomed to using markdown, it is really hard to imagine a better
way than using markdown to insert a code block.
Jekyll uses &lt;a href=&quot;http://kramdown.gettalong.org/&quot;&gt;kramdown&lt;/a&gt; as a default
markdown engine which is goot at dealing with code and math expression.&lt;/p&gt;

&lt;p&gt;Code block with syntax highlighting is rendered like:&lt;/p&gt;

&lt;div class=&quot;language-javascript highlighter-rouge&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kd&quot;&gt;function&lt;/span&gt; &lt;span class=&quot;nx&quot;&gt;fancyAlert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;arg&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
  &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;arg&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;nx&quot;&gt;$&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nx&quot;&gt;facebox&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;({&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;div&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt;&lt;span class=&quot;s1&quot;&gt;&#39;#foo&#39;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;})&lt;/span&gt;
  &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;

&lt;p&gt;Math expression by LaTeX format is rendered like:&lt;/p&gt;

&lt;script type=&quot;math/tex; mode=display&quot;&gt;\frac{n!}{k!(n-k)!} = {n \choose k}&lt;/script&gt;

&lt;h5 id=&quot;hosting-on-github&quot;&gt;# Hosting on Github&lt;/h5&gt;

&lt;p&gt;Github provides pages service for hosting a static web site.
It’s free and good to keep original source files of diagram and chart along with web site.&lt;/p&gt;

&lt;h5 id=&quot;simple-architecture-and-highly-customizable&quot;&gt;# Simple architecture and highly customizable&lt;/h5&gt;

&lt;p&gt;Jekyll is a simple tool to transform plain texts to htmls.
It’s easy to understand and can be customized as you want.
With greate customization comes great labor.
In my case, multi langauge plugin &lt;a href=&quot;https://untra.github.io/polyglot/&quot;&gt;polyglot&lt;/a&gt; is used to support
english and korean at the same time.&lt;/p&gt;

</description>
        <pubDate>Fri, 13 May 2016 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/why-move-to-jekyll/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/why-move-to-jekyll/</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>Python n-grouper</title>
        <description>&lt;p&gt;&lt;em&gt;Oops sorry! English post is not available.&lt;/em&gt;&lt;/p&gt;
</description>
        <pubDate>Thu, 28 Feb 2013 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/python-n-grouper/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/python-n-grouper/</guid>
        
        
        <category>python</category>
        
      </item>
    
      <item>
        <title>Parsing with GOLD Parser</title>
        <description>&lt;p&gt;&lt;em&gt;Oops sorry! English post is not available.&lt;/em&gt;&lt;/p&gt;
</description>
        <pubDate>Sun, 09 Dec 2012 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/parsing-with-gold-parser/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/parsing-with-gold-parser/</guid>
        
        
        <category>parser</category>
        
      </item>
    
      <item>
        <title>Filename case sensitivity</title>
        <description>&lt;p&gt;&lt;em&gt;Oops sorry! English post is not available.&lt;/em&gt;&lt;/p&gt;

</description>
        <pubDate>Sun, 09 Dec 2012 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/filename-case-sensitivity/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/filename-case-sensitivity/</guid>
        
        
        <category>windows</category>
        
      </item>
    
      <item>
        <title>C++11 variadic trio</title>
        <description>&lt;p&gt;&lt;em&gt;Oops sorry! English post is not available.&lt;/em&gt;&lt;/p&gt;
</description>
        <pubDate>Sat, 10 Nov 2012 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/cpp11-variadic-trio/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/cpp11-variadic-trio/</guid>
        
        
        <category>cpp</category>
        
      </item>
    
      <item>
        <title>C++11 rvalue references and move constructors</title>
        <description>&lt;p&gt;&lt;em&gt;Oops sorry! English post is not available.&lt;/em&gt;&lt;/p&gt;
</description>
        <pubDate>Thu, 08 Nov 2012 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/cpp11-rvalue-references-and-move-constructors/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/cpp11-rvalue-references-and-move-constructors/</guid>
        
        
        <category>cpp</category>
        
      </item>
    
      <item>
        <title>How windows installer works and free space of SSD</title>
        <description>&lt;p&gt;&lt;em&gt;Oops sorry! English post is not available.&lt;/em&gt;&lt;/p&gt;
</description>
        <pubDate>Sat, 03 Nov 2012 00:00:00 +0900</pubDate>
        <link>http://veblush.github.io/posts/how-windows-installer-works-and-ssd/</link>
        <guid isPermaLink="true">http://veblush.github.io/posts/how-windows-installer-works-and-ssd/</guid>
        
        
        <category>windows</category>
        
      </item>
    
  </channel>
</rss>