Monthly Archives: July 2014

Node.Js: Links, News And Resources (26)

Previous Post 
Next Post

Links from my collection. Recent links at

Managing Node.js Dependencies with Shrinkwrap

Yammer Engineering – Managing Node.js Dependencies and Deployments at Yammer

reid/node-jslint · GitHub
The JavaScript Code Quality Tool — for Node.js

Getting Started with Node.js on Heroku | Heroku Dev Center

felixge/node-mysql · GitHub
A pure node.js JavaScript Client implementing the MySql protocol

How to “Ping” from a Node.js app? – Stack Overflow

javascript – In Node.js, how do I “include” functions from my other files? – Stack Overflow

Script.runInNewContext and global objects – nodejs | Google Groups

Simple Chat – Node.js + WebSockets | Switch on the Code

Introduction to Node.js – Online Training Course for .NET Developers

chriso/ · GitHub
A data scraping and processing framework

Experimenting with Node.js – Jeff Kreeftmeijer


Official NodeJS Binaries on Heroku – Arunoda Susiripala – Web Geek

You work for me, Computer: The Node.js REPL is Broken

1602/compound · GitHub
MVC framework. Built on Node.JS. Works on server and browser

A New Streaming API for Node v0.10

coopernurse/node-pool · GitHub

Object Modeling in Node.js with Mongoose | Heroku Dev Center

Raynos/levelidb · GitHub

shtylman/balabolka · GitHub
Dead simple hosted chat for your website

NetEase/chatofpomelo · GitHub
Chat application of pomelo

My Links

Stay tuned!

Angel “Java” Lopez

Node.Js: Links, News And Resources (25)

Previous Post
Next Post

Links from my collection. Recent links at

qooxdoo » Home
A universal JavaScript framework

Developing a complete client-server application with qooxdoo on Cloud9IDE. Part 1: Application architecture « Panyasan’s Random Musings

Create JSON APIs

Why we need a NodeJS application server or: writing boilerplate code considered harmful « Panyasan’s Random Musings

On “Reserving” Package Names – nodejs | Google Groups

Felix’s Node.js Guide

Felix’s Node.js Style Guide

substack/stream-handbook · GitHub
How to write node programs with streams

Chris Granger – Anatomy of a knockout

NetEase/lordofpomelo · GitHub
A browser-based MMORPG

instructure/canvas-lms · GitHub
Learning management systems

mem-memov/blackboard · GitHub
Online blackboard


javascript – How to decide when to use NodeJS? – Stack Overflow

Introducing – scaling node.js applications one callback at a time.


Express.js by Dan Zajdband – Comunidad Nodejs Argentina – YouTube

Roll your own PubSub with DNode :: The Universe of Discord

Tracking Down Memory Leaks in Node.js – A Node.JS Holiday Season ✩ Mozilla Hacks – the Web developer blog

<The client side of the moon />: Chat Evolution — Node.js and Socket.IO

My Links

Stay tuned!

Angel “Java” Lopez

SharpStorm Implementing Storm in C# (1) Initial Project

In the last two years I was exploring the ideas of Storm (see, implementing a local topology Node.js. It’s time to practice more C # and TDD (Test-Driven Development), with:

Current status of the project:

The idea is to implement Bolt, Spout and a TopologyBilder. See

There are just three abstractions in Storm: spouts, bolts, and topologies. A spout is a source of streams in a computation. Typically a spout reads from a queueing broker such as Kestrel, RabbitMQ, or Kafka, but a spout can also generate its own stream or read from somewhere like the Twitter streaming API. Spout implementations already exist for most queueing systems.

A bolt processes any number of input streams and produces any number of new output streams. Most of the logic of a computation goes into bolts, such as functions, filters, streaming joins, streaming aggregations, talking to databases, and so on.

A topology is a network of spouts and bolts, with each edge in the network representing a bolt subscribing to the output stream of some other spout or bolt. A topology is an arbitrarily complex multi-stage stream computation. Topologies run indefinitely when deployed.

In the project are now defined interfaces, to have bolts and spouts, and topology builder to build a topology. For now, I want a local implementation (without distributed processing). Then, I hope to implement ACK algorithm that has original Storm, which lets you know when an incoming message was completely processed (including processes messages that occurred in the middle of the process).

Upcoming topics: discuss ISpout, iBOLT, and topology implementation.

Stay tuned

Angel “Java” Lopez

SharpDoop Implementing Map Reduce in C# (1) The Project

I was experimenting with map-reduce in Node.js / JavaScript. But it is also something interesting to implement the algorithm in C #, to practice TDD (Test-Driven Development) and to learn more about what it takes to implement the algorithm. The project that I started is:

The current status:

It has a class library project and the test project. I came to think of something not yet distributed. All I want for now is to specify the map/reduce algorithm map, and run it in the same process.

See that there is then a MapReduceJob. The base class that is responsible for running a map (lambda function) and reduce (takes a key,  a list of values for that key, and output the result). With C #, these two operations can be expressed as lambdas or delegate methods inside a more complex object. For now, I pose the simple cases in the tests, and all them are running.

I also put together a MapProcessJob, which is a variant of map / reduce to discuss. Instead of processing all keys first, then roll them into the reduce phase, try to do everything together. In some use cases it may be more efficient, but is an issue to discuss in more detail.

Upcoming topics: more in-depth review and implementation ideas, such as map / process.

Stay tuned!

Angel “Java” Lopez

AjTalk Implementing Smalltalk In C# (4) The Project

Previous Post

Year and a half since I didn’t write about this project in C #, but I was working on it, and the parallel implementation I have in JavaScript (in fact, I introduced some concepts of both the Smalltalks 2013 conference, Rosario, Argentina).

The project is at:

Current structure:

The projects are:

AjTalk: class library, with a compiler to bytecodes implementation. There is a compiler to JavaScript too. There is an interpreter of those bytecodes.

AjTalk.Compiler: a console project that uses the compiler to JavaScript.

AjTalk.Console: a simple REPL (Read Eval Print Loop)

AjTalk.Gui: a work-in-progress example using windows

AjTalk.Tests: the test I wrote, followin TDD (Test-Driven Development) flow.

I guess now I don’t need the compiler to JavaScript, because I have a native JavaScript implementation at:

It can compile to bytecodes or to JavaScript. The project is written in JavaScript.

The window implementation is very primitive. I plan to replace it for direct AjTalk program using .NET types and object.

One point that I find very interesting (in both projects, C # and JavaScript) is to have a modular implementation: instead of loading an image yet defined, my plan is to define modules to load, as happens in the Node.js environment . The modules would be published in the NPM (Node Package Manager’s), and each could indicate which modules need in your program instead of lifting all Smalltalk.

Another topic in this C # project I have implemented that can run more than one AjTalk machine at the same time. And I can even make a machine “help” to the other. For example, if the machine does not have to compile methods to new methods, machine B can go to his aid. Thus, A machine (and his image, I’m already recording binary image) can be kept small.

Another feature that I have implemented: the ability to send a message to an object, without waiting for a response, a “fire and forget”. And that the target object can attend ONE OF those messages as models of actors.

I have to review the implementation of remote objects (now based on the old Remoting. NET). But I think it is an important feature to maintain and explore.

Well, you see, many issues remain for other posts, such as implementation details Smalltalk concepts such as Object, Class, ClassDescription, Behavior, MetaClass, etc..

Nos leemos!

Angel “Java” Lopez

AjKeyvs Implementing Key-Value Store in C# (1) The Project

I want to implement a key-value store (as Redis) in C#, play with data structures, and practice TDD (Test-Driven Development). I started:

The current structure:

There is a class library project, AjKeyvs, that contains the collections in an in-memory repository. The interesting part of this projects is to implement arrays and sets that can be sparse, having different keys. Example, having a key 1 (one) and a key 1000000 (one million) does not imply to have an array with one million positions. At the same, I want to have a good access and update time. In other use cases, I will have string keys, like “user”, “user:1”, “user:1:email”, etc. There are use cases that need the use of sets, with union, intersection, difference, etc… For integer keys, I jave a set where a could turn a bit on or off, for the presence or absense of an element. More implementation details in upcoming post.

The library can be used in-process, but I added a server and a client program. The server listen commands sent by the clientes. All collections reside in memory. Persistence is something orthogonal to the implemented use cases. I should decide if add the persistence into the command processing, or is something to be implemented outside the project.

As usual, I followed TDD workflow.

Next topics: data structures, collections, commands, concurrency, etc.

Stay tuned!

Angel “Java” Lopez

DylanSharp Implementing Dylan in C# (1) The Project

A few months ago I started to implement an interpreter of Dylan language, to practice TDD in C #, and learn some functional programming. I read:

Dylan is a multi-paradigm functional and object-oriented programming language. It is dynamic while providing a programming model designed to support efficient machine code generation, including fine-grained control over dynamic and static behaviors.

The interesting thing about Dylan is that it incorporates types and objects. For now I do not intend to generate machine code, but, following "baby steps" to implement the main concepts of language as an interpreter. I would like to add access to the libraries. NET, which I find interesting to extend the reach of language. You can learn more of the language in:

The project I am writing in C # is:

Its current structure:

It consists of a class library, and a draft tests. So far there are some simple expressions implemented a Parser a Lexer and implemented as a concept of class C # language: List, which lists as implemented in Lisp. As in other projects, I Context to maintain the values ​​of variables, and recall by name. Notably, in Dylan variables have type, but I’m not controlling the types, just evaluating any expressions. I’ll have to decide at some point to control the types at the time of compiling / processing program. According:

Type mismatch errors should be caught at compile time.

But the time will come. Advancing TDD, I am confident that if necessary I can make a “surgical” refactor / redesign, without a lot of pain. I could do this in the next iteration or later. I did something similar during the coding of ScalaSharp.

Next steps: continue implemented expressions, definitions of classes, modules, commands, anonymous functions. And control the types.

Stay tuned!

Angel “Java” Lopez