Angel \”Java\” Lopez on Blog

July 17, 2014

ScalaSharp Simple Scala In C# (1) The Idea

Filed under: .NET, C Sharp, Open Source Projects, Programming Languages, Scala, ScalaSharp — ajlopez @ 6:32 pm

I wrote something in this blog, but it’s time to introduce it to society. Last year a few months ago, I started the project:

A simple interpreter for a simplified Scala, C #. I do not intend to implement all Scala as a compiler for CLR. NET. My intention is to explore an alternative implementation of interpreter, adopting only some “light” features of Scala.

Without being a Scala programmer (or amateur or professional) my impression is that Scala as a language and library, is something like "too much", a bit overwhelming. People adopts Scala because it is more flexible, less need "boilerplate" etc.. But it seems like Scala went too far. Having programmed in Java and C#, I think the latter, adding a few things (delegates years, lambdas, extension methods, "generics" in the VM, and recently, in asynchronous input/output, async, await), has managed to stay healthy, without major complications. See how easy it has been to implement LINQ with evaluation "lazy" and others.

Instead, Scala seems to me like it’s too many things, all together. From what I saw, type inference is a feature that is not so necessary in the real projects. And yet I can not accept that the list of operators in Scala occupies more than one web page. But hey, that’s the current state of things. People Scala is working on a new implementation, called Dotty. But if you are just doing after years of language definition, I have to declare: "too little, too late."

That does not preclude recognizing that Scala has great triumphs, non-trivial applications like Play Framework and Akka. Akka is a very interesting project. I think we don’t need so many new language features (just the ones I mentioned for C #). We need more libraries that solve some issues (such as the implementation of an asynchronous HTTP message distribution server or distributed processing among actors).

To experiment with a simplified Scala, and to deliberately practice TDD (Test-Driven Development) in C #, I started the project ScalaSharp.

It is a challenge for me, because it is not a simple interpreter. I want to implement an AST (Abstract Syntax Tree) that detects inconsistencies between types. In my previous experiences, as RubySharp, PythonSharp, and Mass language, it was only necessary to assemble a tree expressions / commands and evaluate it. Now I’ll have to check that the types are correct. For example, one variable that is typed, and that their assignments, the expression to be evaluated and assigned for the type of the variable. You can see some of the work in progress:

where there is a node tree with types, versus commands and expressions to be executed and evalauted:

Upcoming topics: implementation details, control types in the AST transformation commands / expressions. The good thing to do with TDD is that it allows me to go implemented the solution as I define use cases.

Stay tuned!

Angel “Java” Lopez

July 16, 2014

RubySharp, implementing Ruby in C# (3)

Filed under: .NET, C Sharp, Open Source Projects, Programming Languages, Ruby, RubySharp — ajlopez @ 4:43 pm

Previous Post

In RubySharp, we can define new functions (methods of the current object), and invoke them. There are some built-in functions in C#:

Every function should implement the interface:

public interface IFunction
    object Apply(DynamicObject self, Context context, IList<object> values);

On apply, each function receives the object (self), the context for variables (locals, arguments, closure….), and a list of already evaluated arguments.

An example, the implemention of puts:

public class PutsFunction : IFunction
    private TextWriter writer;

    public PutsFunction(TextWriter writer)
        this.writer = writer;

    public object Apply(DynamicObject self, Context context, IList<object> values)
        foreach (var value in values)

        return null;

It receives the object to which it is a method, the context, and a list of arguments. Each of the arguments was evaluated. The implementation simply sends the arguments to a TextWriter, one argument per line. The TextWriter is provided when the function object is created (in the Machine object, that represents the current running environment). This injected facilites the test of the function, example:

public void PutsTwoIntegers()
    StringWriter writer = new StringWriter();
    PutsFunction function = new PutsFunction(writer);

    Assert.IsNull(function.Apply(null, null, new object[] { 123, 456 }));

    Assert.AreEqual("123\r\n456\r\n", writer.ToString());

The above code was born using the TDD workflow.

Let’s see another built-in function, require:

public class RequireFunction : IFunction
    private Machine machine;

    public RequireFunction(Machine machine)
        this.machine = machine;

    public object Apply(DynamicObject self, Context context, IList<object> values)
        string filename = (string)values[0];
        return this.machine.RequireFile(filename);

This time, the job of loading a file is delegated to the Machin object, injected in the constructor.

And finally, let’s review the code of a defined function (defined in RubySharp):

public class DefinedFunction : IFunction
    private IExpression body;
    private IList<string> parameters;
    private Context context;

    public DefinedFunction(IExpression body, IList<string> parameters, Context context)
        this.body = body;
        this.context = context;
        this.parameters = parameters;

    public object Apply(DynamicObject self, Context context, IList<object> values)
        Context newcontext = new Context(self, this.context);

        int k = 0;
        int cv = values.Count;

        foreach (var parameter in this.parameters) 
            newcontext.SetLocalValue(parameter, values[k]);

        return this.body.Evaluate(newcontext);

In this case, a new contexts is built, containing the new arguments to the defined function, but with the original closure, injected in the constructor. The context provided in the Apply is not used.

Next topics: some command implementations, the Machine object, the REPL, etc…

Stay tuned!

Angel “Java” Lopez

July 13, 2014

SharpBus in C# (1) First Steps

Filed under: .NET, C Sharp, Open Source Projects, SharpBus, Test-Driven Development — ajlopez @ 11:54 am

Last month I started to write SharpBus, a simple message processor inspired by ideas from Mule Java project. See:

As usual, I’m using TDD (Test-Driven Development), implementing small use cases and API consumption, in the simplest possible way. In fact, the project is a personal exercise of TDD. I hope that some may be useful beyond that. For now, it is an example that I want to share my workflow.

You can see the progress in:

The main ideas to implement are:

- There are Messages containing Payloads and Properties (dictionary of name / value)

- There Flows that process messages

- A Flow is composed of several elements

The elements can be chained in the flow, and can be:

- A Transformer, taking a payload or complete message, and returns a transformed version

- A Processor, taking a payload or complete message, operate on them, maybe accessing the business domain, but without transformation

- Input, a payload/message producer

- Output, a payload/message consumer, at the end od the Flow process

- A Rourter, given a payload/message, it decides with Branch to follow in the Flow. Each Branch is identified by a name.

There will also be items that can issue new posts than the current, and can issue them to different flows in the system. The message producers should be able to run threads (Threads) in principle. And there will be a set of threads (Pool of Threads) attending the incoming messages and deriving them to the respective flows.

A flow can take a message and return a response (Request / Response), or it can take a message, process it without returning an answer.

Some items need complete Message and other items operate over the Payload.

The elements in the world of Mule / Java are objects. Notably, in C #, the simplest way to implement is using lambdas. So, following TDD, the early testing and deployment has come out that way. You can see in some simple tests:

As an example of send a Payload and receive an answer, using an empty Flow:

var flow = Flow.Create();

Assert.AreEqual(1, flow.Send(1));

To send a payload and transform it:

var flow = Flow.Create()
    .Transform(x => ((int)x) + 1);

Assert.AreEqual(2, flow.Send(1));

The .Transform Transform expects a Func<object, object> which may be provided at the time with a lambda. In a classic Java 7 Mule, we should provide an object that implements an interface having a method to transform the Payload. I have to think whether it is worth having a typed Transform <T> (receiving T and returns T), or Transform <T, S> (receiving and returns T S).

I decided to build the flow by code. In the Mule environment Spring is used to set up the flow using XML. I think it is time to explore this other way, build the flow by code, and put it as the "first way", ie, as the way on which everything else could be mounted. If anyone ever needed a DSL (Domain-Specific Language) for creating flows could be implemented this way by having well designed code.

Following TDD, I still have not a case of using a Message (a complete message with content (Payload) and properties (Properties, a name / value) dictionary. All of the above is to process Payload directly.

Upcoming topics: add Message Payload with the output of messages, routing, assembling branches, etc. ..

Stay tuned!

Angel “Java” Lopez

July 12, 2014

Mass Programming Language (5) Variables Scope

Filed under: .NET, C Sharp, Mass, Open Source Projects, Programming Languages — ajlopez @ 6:18 pm

Previos Post

I finally started a new implementation of variables and their scope in programming language Mass. My idea is:

- Have local variables

- No need to explicitly declare

- Access available "outside" if necessary

The basic idea is:

- Any variable assignment involves the local level

That is, if I assign

a = 3

in a function, this refers to a local variable in the function. No matter if there is a variable external to the function

See for example

# file variable
a = 1

define foo()
    a = 2 # local variable


The first variable a is a variable of the file in process (the module). The variable assigned in the foo function is local to that function, and it is different from the outside variable.

But if we do not assign the variable, and only consulted it, its value is returned. example:

# file variable
a = 1

define foo()
   a # access file variable


In this case, the function foo returns the value to "outside", since this variable has not been assigned in the function when evaluating the return value.

How to edit an "external” variable, that is, a non-local variablel? Well, this is a topic for an upcoming post. The idea: to access the value of a non-local variable, it must be implied, without declaring anything extra. BUT modifying its value must should be explicit: we put something to explicitly declare "we are changing the value of a non-local variable".

Stay tuned!

Angel “Java” Lopez

GrammGen In C# (2) First Rules

Filed under: .NET, C Sharp, GrammGen, Open Source Projects — ajlopez @ 10:30 am

Previous Post

Let’s see today how a parser is built with GrammGen using code. The idea is to define using GrammGen how to build a tree with expressions detected in the text under process. The text is written in the programming language that we want to implement. The expression tree is created using the GrammGen definition, given by code.

I presented in the previous post for an example of a console program, which employs GrammGen. A parser is defined using rules. The rules indicate:

- How to process text characters
- How then form text elements, such as numbers, names, operators
- How to go from putting together such elements, expressions, commands that define our language to implement.

In the sample of calculator

the rules are defined by the parser:

The first rules:

private static Rule[] rules = new Rule[]
   Rule.Or(' ', '\t', '\r', '\n').Skip(),
   Rule.Or('+', '-').Generate("Oper0"),
   Rule.Or('*', '/').Generate("Oper1"),
// ...

The idea is to get an Expression. The first rule defines that anyone (Rule.Or) of space, tab, carriage return, new line items are ignored (. Skip ()). You can put more than one rule of this type, for example, to set comments to be ignored from the input text.

The second rule defines both + (the plus sign) and – (minus sign) produce a called terminal Oper0. They differ from * (the token) and / (divide sign) because we want to take precedence among operators.

There is a rule to construct integers:


Rule.Get("0-9").OneOrMore().Generate("Integer", MakeIntegerConstantExpression), 

The Rule.Get allows you to specify a range of characters, and then, with the fluent interface defined, you can attach the .OneOrMore () method, which specifies that the rule can be applied once or several times. When you can not apply more, it ends generating a node called "Integer". But in GrammGen a node, in addition to a name, may have an associated object. Al. A second parameter can be passed to Generate method, with a function that creates the associated object.

MakeIntegerConstantExpression job is:

- Get the object that was formed with the rule, in this case, a concatenated string with all digits were found.

- Transform it to integer

- Create a ConstantExpression with the intever as constant value.

The class ConstantExpression is not from GrammGen. It is defined by us. We have the freedom to define the objects we want to attach to each node of the GrammGen generated tree.

The code of MakeIntegerConstantExpression is:

   private static object MakeIntegerConstantExpression(object obj)
       int value = int.Parse((string)obj);

       return new ConstantExpression(value);

In the next posts we will see how the nodes of binary operations are formed, how operator precedence is implemented, how to manage left recursion, and evaluation of the generated expressions.

Stay tuned!

Angel “Java” Lopez

July 10, 2014

End Of Iteration 2014w27

Filed under: .NET, AjGenesis, C Sharp, Code Generation, Iteration, JavaScript, NodeJs — ajlopez @ 2:33 pm

Previous Post

Code Generation with AjGenesisNode

I updated and published new versions of my projects:

Now, there are new functions to manage the model directory in AjGenesis. That directory contains the JSON files that represent the model, ie entities, project settings, db settings, etc. It resides in “./ajgenesis/models”.

The code generation for Sinatra and Express was improved. Instead of create a project and then, generate a “build” subdirectory in project directory, now the code generation acts over the current project directory. This way is more straighforward, and more aligned with other projects that generates code: there is no “build” subdirectory.

I added the preserve of code regions by name. If a generated file has a code region delimited with special text, that region is preserved even when the file is regenerated.


My Dylan language interpreted in C#

I added more binary operations. I should add type support, but in the current use cases, the untyped evaluation is OK.


My Mule-like simple service bus in C#

I added message transformers, message processors, instead of play payload transformers and processors. And I added a Router object. So, the implementation has/will have:

- Lambdas that operates on payload (processors, transformers, outputs, routers)
- Lambdas that operatos on message (processors, transformers, outputs, routers)
- Objects that operates on payload (processors, transformers, outputs, routers)
- Objects that operates on messages (processors, transformers, outputs, routers)

A payload is an untyped object. A message has a payload and additional properties (by name/value).

JavaScript Samples

I wrote my first AngularJS samples

Dynamic Site in Express 4

Based on JSON definitions

I added the support of to load JSON files that have references to other JSON files. The site is a prototype based on pages defined in JSON files. So you can easy change the JSON data to alter the prototyped site. Next steps: add lists based on MongoDB collections, with views. Then, code generation for differents targets (Express 4? Laravel?)


I changed with minor improvements. I also worked on three non-public projects. More fun is coming.

Stay tuned!

Angel “Java” Lopez

June 27, 2014

End Of Iteration 2014w25

Previous Post
Next Post

Code Generation with AjGenesis

I published a new version of

My code generation tool, based on Node.js. Now, it can preserve files in generate tasks (if you want one of your files doesn’t overwritten). But the key change was to put models under current project directory, ajgenesis/models folder. In this way, I can put all the AjGenesis-related stuff in only one directory related to current project. So, I refactored and republished the modules and examples of:

Next steps: refactor to use the new directory, and refactor/complete the generation process in Express, Sinatra, Laravel, Django projects.


I worked on

implemented a simplified Mule-like message flow in C#, using TDD (Test-Driven Development). Now I have: input, output, transform, processors, routers, branches in flow. It was nice to see all in place, using “baby steps”, and the powerful lambdas of C#. I implemented transformer objects too. Next steps: instead of simply process a payload, start to process a complete message.


After attending a JavaScript meetup at Buenos Aires, I wrote a simple JavaScript curryfing function library:

Since then, I started to add some additional pieces, like partial application, and composition of functions.


Thanks to @fabiomaulo, I met state machine implementations in C#. So, I wrote my own version in JavaScript:

It has a fluent interface to define states, with triggers and actions. Next steps: add global triggers, and hierarchical states.


I added some functions to core and REPL. I worked on four private projects, too. More fun is comming.

Stay tuned!

Angel “Java” Lopez

June 20, 2014

End Of Iteration 2014w24

Filed under: .NET, C Sharp, Iteration, Mass, Open Source Projects, SharpBus, SharpGo, SharpMongo — ajlopez @ 6:27 pm

Previous Post
Next Post


My Go Programming Language interpreter in C#

I added typed nodes to Abstract Syntax Tree, and nodes that generate expressions instead of commands. The types will help me to determine if an expression is valid or not, according to Go type specifications.


The Mass programming language interpreter

I reimplemented binary arithmetic operations (and string concatenation) without using ObOps, but directly using compiled lambda expressions. Next steps: removing ObOps dependency from compare operations. I think that a compiled lambda is a better outcome for such expression.


My in-process, in-memory implementation in C# of a document database with a MongoDB-like interface:

I fixed source analysis issuses, and added .count method to collections and to collection objects in REPL.


I started

A simple message bus implemented in C#, inspired by Mule. Notably, the flow of message can be defined using lambdas (something missing in Mule Java up to version 7). Using TDD, using fluent interface, consuming lamdbas, is the simplest way I found to implement a message bus.


I worked fixing scripts in My parser “generator” was  converted to VisualStudio 2010I worked on four non-public projects. More fun is coming.

Stay tuned!

Angel “Java” Lopez

February 21, 2014

Owin: Links And Resources (2)

Filed under: .NET, C Sharp, Links, Owin — ajlopez @ 7:24 pm

Previous Post

Byte Rot: OWIN and Katana challenges: blues of a library developer

damianh (Damian Hickey)

owin Archives – StrathWeb

Getting Started With OWIN and the Katana Stack – Tugberk Ugurlu’s Blog

Owin.Dependencies: An IoC Container Adapter Into OWIN Pipeline – Tugberk Ugurlu’s Blog–an-ioc-container-adapter-into-owin-pipeline

Introducing SaasKit – Multi-tenancy made easy – Ben Foster

Are we gOWINg in the right direction? | Roysvork

The Liara Framework by Prasanna V. Loganathar



OWIN Middleware in the IIS Integrated Pipeline : The Official Microsoft ASP.NET Site

OWIN and Katana : The Official Microsoft ASP.NET Site

Fix and OWIN and Simple.Web – codeface


ASP.NET MVC 5 Fundamentals – Online Training Course for Developers

Writing OWIN middleware

ASP.NET – Getting Started with the Katana Project

Understanding OWIN Forms authentication in MVC 5 – .NET Web Development and Tools Blog – Site Home – MSDN Blogs

My Links

Keep tuned!

Angel “Java” Lopez

February 20, 2014

Owin: Links and Resources (1)

Filed under: .NET, C Sharp, Links, Owin — ajlopez @ 7:37 pm

Next Post

OWIN — Open Web Interface for .NET

Getting up to speed with Katana – Jon Galloway

Tomek on Software: Access MS SQL from a node.js application using OWIN, in-process CLR hosting, .NET, and ADO.NET

Tomek on Software: CPU bound workers for node.js applications using in-process .NET and OWIN

tjanczuk/owin · GitHub

Tomek on Software: Hosting .NET code in node.js applications using OWIN

gsscoder/owinhttplistener · GitHub

Herding Code 123: Andreas Håkansson and Steven Robbins on NancyFx

Kayak, a C# HTTP server.

OWIN — Open Web Server Interface for .NET, v1.0 Draft 5

Hanselminutes Podcast 264 – This is not your father’s WCF – All about the WebAPI with Glenn Block – Scott Hanselman

Getting fancy with Nancy – Introduction – TheCodeJunkie

CodePaste.NET – Processor for supporting uri extensions which map to variant representations

My Links

« Newer PostsOlder Posts »

The Shocking Blue Green Theme. Create a free website or blog at


Get every new post delivered to your Inbox.

Join 68 other followers