Angel \”Java\” Lopez on Blog

October 20, 2014

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

Filed under: JavaScript, Links, NodeJs — ajlopez @ 5:43 pm

Previous Post

component – modular javascript framework

luismreis/node-openvg-canvas · GitHub

astalker/nblog · GitHub
A Simple CMS module for Node Js using Express, EJS and Mongo

Episode 101 – Real-World Windows Azure with Auth0 | Windows Azure Cloud Cover Show | Channel 9

Episode 93 – Real-World Windows Azure with | Windows Azure Cloud Cover Show | Channel 9

Modulus | Node.js Hosting Platform


MangoRaft/Raft · GitHub

Node.js Jobs

Projects, Applications, and Companies Using Node · joyent/node Wiki,-Applications,-and-Companies-Using-Node

substack/lexical-scope · GitHub

substack/scoper · GitHub

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

Pomelo home
Fast, scalable, distributed game server framework for node.js

express – How to send files with node.js – Stack Overflow

Serving Static Files with Node.js – SitePoint

Serving Static Files from Node.js

e14n/ · GitHub


How to create a private npm.js repository by Tom Gallacher




Nodejitsu Business Plans Are Here! —

How an Event Loop works « Matt’s Hacking Blog

Fully Loaded Node – A Node.JS Holiday Season, part 2 ✩ Mozilla Hacks – the Web developer blog

My Links

Stay tuned!

Angel “Java” Lopez

October 17, 2014

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

Filed under: Links, NodeJs — ajlopez @ 4:46 pm

Previous Post
Next Post

Projects, Applications, and Companies Using Node · joyent/node Wiki



StrongLoop | Node.js Support, Consulting and Training

Introducing StrongLoop | StrongLoop

Floby/node-parser · GitHub
a generic parser to parse whatever you want in node.js

Floby/node-tokenizer · GitHub

Floby/node-json-streams · GitHub

Node.js Parsing streams – Projects –

A Federated Message Network in Node.js

PinchProject/Node-StringsParser · GitHub

bigcompany/resource · GitHub

TooTallNate/node-stream-parser · GitHub

hij1nx/node-chrome · GitHub

skeggse/node-bzip · GitHub


nodejitsu/nssocket · GitHub

saary/ · GitHub

Node.js 101: Web based development


My Links

Stay tuned!

Angel “Java” Lopez

October 11, 2014

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

Filed under: Links, NodeJs — ajlopez @ 5:59 pm

Previous Post
Next Post

To the Node.js Community: Healthcare needs your help! « The EWD Files

NodeM: A Node.js binding to the GT.M language and database

ewdGateway2/lib/ewdGlobals.js at master · robtweed/ewdGateway2 · GitHub

Can a Phoenix arise from the ashes of Mumps? « The EWD Files

Can a Phoenix arise from the ashes of Mumps? (Part 2) « The EWD Files

A Phoenix Rises « The EWD Files

maxogden/voxel-engine · GitHub
3D HTML5 voxel game engine

mikedeboer/jsDAV · GitHub
jsDAV allows you to easily add WebDAV support to a NodeJS application. jsDAV is meant to cover the entire standard, and attempts to allow integration using an easy to understand API.

javascript – Node.js copy remote file to server – Stack Overflow

bitlyfied/vagrant-chef-nodejs-startup · GitHub
This is a simple, basic Vagrant set-up for a development box for Node JS, provisioned with chef-solo

GotEmB/BattleShip · GitHub
A simple BattleShip game using HTML5 Canvas and

multi-server continuous deployment with fleet

bpostlethwaite/colormap · GitHub
output rgb or hex colormaps

harthur/brain · GitHub
Neural networks in JavaScript

bpostlethwaite/pde-engine · GitHub
A nodejs module for server side or browser computation of heat and wave equation.

albertosantini/node-rio · GitHub
Integration with Rserve, a TCP/IP server for R framework

mdalpi/battleship-node · GitHub

tripsis/node-battleship · GitHub

Parser for Swiss-Chess Tournament (SWT) files

Mocha – the fun, simple, flexible JavaScript test framework

eldargab/node-fake-fs · GitHub
Fake node.js file system for testing

Contextify caller attack

My Links

Stay tuned!

Angel “Java” Lopez

October 9, 2014

Akka: Links, News And Resources (10)

Filed under: Akka, Distributed Computing, Java, Links, Scala — ajlopez @ 4:36 pm

Previous Post


Distributed Publish Subscribe in Cluster — Akka Documentation

Kamon | Core | Documentation – Resilient Applications with Akka Persistence by Björn Antonsson, Konrad Malawski, Patrik Nordwall

AKKA 5 Year Anniversary

How One Developer Set Out To Make The Internet Of Things Manageable – ReadWrite






My Links

Stay tuned!

Angel “Java” Lopez

October 7, 2014

New Month’s Resolutions: October 2014

Filed under: .NET, C Sharp, JavaScript, NodeJs, Open Source Projects — ajlopez @ 5:50 pm

Time to write my technical new month’s resolutions. But first, review of past month’s ones:

- Distributed Aktores [complete] see repo
- Distributed AjErl [pending]
- Web support and example for RuScript [partial] see repo
- Complete Mochy [partial] see repo
- Improve RSharp [complete] see repo
- Work with NodeJs on Deep Learning, Internet of Things, Artificial Intelligence [pending]
- Work on Code Generation using AjGenesis for Node [complete] see main repo see Express repo see Sinatra repo see Laravel repo
- Work on Liqueed Project [complete] see repo

Additional, I worked on

- Improve AjScript [complete] see repo
- Refactor BasicScript tests to use SimpleUnit [complete] see repo
- Create SimpleColls, simple collection functions in JavaScript, alone or a la Linq [complete] see repo
- Refactor SimpleStore tests to use SimpleUnit [complete] see repo
- Improve AjTalkJs, Smalltalk in JavaScript, support for super, Express 4 first sample [complete] see repo
- Refactor MProc tests to use SimpleUnit [complete] see repo
- Refactor AjLogoJs tests to use SimpleUnit [complete] see repo
- Refactor SimpleKeeper tests to use SimpleUnit [complete] see repo
- Refactor SimpleTags tests to use SimpleUnit [complete] see repo
- Improve SimpleUnit, publish new version [complete] see repo
- Refactor SimplePipes tests to use SimpleUnit, and publish new version [complete] see repo

My new month’s resolutions:

- Give a talk Aktores intro
- Distributed AjErl
- More Express samples in AjTalkJs
- Explore neural networks in JavaScript
- Explore genetic algorithms in JavaScript
- Explore other artificial intelligence topics in JavaScript
- More Distributed Aktores
- Start Distributed Smalltalk in AjTalkJs

Stay tuned!

Angel “Java” Lopez

October 6, 2014

Akka: Links, News And Resources (9)

Filed under: Akka, Distributed Computing, Java, Links, Scala — ajlopez @ 4:13 pm

Previous Post
Next Post

Building Reactive Applications with Akka

Typed Actors — Akka Documentation

Reactive DDD with Akka | Write less, do more!

Publish/Subscribe using Scala and Akka EventStream

Vaadin in Akka – Blog –

Endre Sándor Varga – Without Present or Past: How to Think Distributed – The Hard Way, With the rise of distributed databases, cluster management tools, co…

Reactive Programming with Akka and Scala | comSysto Blog

Let it crash



Jonas Bonér – Going Reactive: Event-Driven, Scalable, Resilient & Responsive Systems, The demands and expectations for applications have changed dramat…

Get started quicker with our docker image

Java is the new C: Comparision of different concurrency models: Actors, CSP, Disruptor and Threads


April 17, 2014 | Typesafe announces Akka Streams, a part of the Reactive Streams Initiative | Typesafe

akka/akka-stream/src/main/scala/akka/stream at release-2.3 · akka/akka

A very simple Ping Pong example using Akka’s local actors.

Orleans Actors Analysis – Tech stuff that interests me

Abstractivate: ForkJoinPool: the Other ExecutorService

Running an Akka Cluster with Docker Containers | Adventures in HttpContext

Getting Started with Actor Based Programming Using Scala and Akka – Reactive.TIPS – The Official Blog of Reactive.IO

My Links

Stay tuned!

Angel “Java” Lopez

October 2, 2014

Express: Links, News And Resources (9)

Filed under: Express, Links, NodeJs, Web Development — ajlopez @ 5:37 pm

Previous Post

Node.js boilerplate with Express, MongoDB, Moongose, Backbone

StrongLoop | Express 3.x to 4.x Migration Guide

Pixelhandler’s Blog

Express.js 4, Node.js and MongoDB REST API Tutorial

Locomotive – Powerful MVC web framework for Node.js.

javascript – Difference between res.send and res.json in Express.js – Stack Overflow

joemalski / Out .js 4.0- installation-guide

MongoDB, Express, AngularJs, NodeJs

MEAN.JS Generator

codexar / Turn
Packet-Oriented Framework for ES6 and Express

An express.js Template language that uses dom manipulation instead of a markup language – A Fullstack Javascript Framework!/

Collection of middleware to implement various security headers for Express / Connect

Passwordless – A node.js/express module for token-based logins

#3 Beginning routing in Node.js – Learn All The Nodes

My Links

Stay tuned!

Angel “Java” Lopez

September 29, 2014

Express: Links, News And Resources (8)

Filed under: Express, Links, NodeJs, Web Development — ajlopez @ 5:08 pm

Previous Post
Next Post




Stand-up: Developing a node.js application using Monaco (Part 1) – Visual Studio Online “Monaco” – Site Home – MSDN Blogs

Catnap helps you REST

typescript compile server for [connect/express]-middleware

RhapsodyJS docs – Get started
RhapsodyJS is a HMVC framework that runs on top of Express 4, it also auto-generate, in build time, a RESTful API with your database-agnostic Models

Just a blogging platform

Ghost – Just a blogging platform

Ghost: Just a Blogging Platform by John O’Nolan — Kickstarter

StrongLoop | Comparing Express, Restify, hapi and LoopBack for building RESTful APIs

MEAN Stack – A Quick Start Guide | Flippin’ Awesome

An Introduction to the MEAN Stack

StrongLoop | Beyond Node.js Express: An Intro to Koa.js and a Preview of Zones

Express – api reference

Build a RESTful API Using Node and Express 4 ♥ Scotch


Express 4 — Javascript and the server — Medium

Using Webix with NodeJS

DailyJS: Node Tutorial Part 22: Backbone (Again)

KrakenJS Suite

12 Web Application Frameworks for Node.js | CodeCondo

My Links

Stay tuned!

Angel “Java” Lopez

September 18, 2014

TDD: Links, News And Resources (23)

Previous Post

Lo que los gurús nunca te cuentan sobre Kanban y SCRUM

Moving from Practice to Production with Test-Driven Development

TDD is TDD (And Far From Dead) – Software People Inspiring

A TDD Journey: 1-Trials and Tribulations

A TDD Journey: 2- Naming Tests; Mocking Frameworks; Dependency Injection–naming-tests-mocking-frameworks-dependency-injection/

When TDD Doesn’t Matter

Test-Driven Development… by Grzegorz Gałęzowski [PDF/iPad/Kindle]

Creating and testing Meteor applications with BDD using Velocity and Jasmine | Dr. Llama’s Blog

One Mock Per Test Considered Not Awesome at

Everyday Tales: We Call It Unit For A Reason

Programming Without Fear | The Journeyman Programmer

Applying TDD to Scalding Development |

My Links

Stay tuned!

Angel “Java” Lopez

September 16, 2014

RuScript, Ruby Interpreter in JavaScript (1) The Project

Filed under: JavaScript, NodeJs, Open Source Projects, Ruby, RuScript — ajlopez @ 5:08 pm

When I have free time, I’m working on:

I’m writing the code following the TDD (Test-Driven Development) workflow (see commit history)

The idea is to have a Ruby interpreter written in JavaScript, so it can run at the browser, or at the server with Node.js. I’m not implementing a compiler yet, because I want to do “baby steps”, and because Ruby semantic could be different to JavaScript one. Ie, the resolution of methods, or check if a variable is local to a function or not, are examples of divergences between the languages. So, I decided to write an interpreter.

I’m applying “dog fooding”: the parser is written using:

I’m applying SimpleGrammar in other projects, like RustScript. There is an implementation in C#, too, named GrammGen). A fragment of the defined rules for RuScript parser:

// Expression Level 1
get('Expression1', 'Plus', 'Expression0')
    .generate('Expression1', function (values) { return new AddExpression(values[0], values[2]); }),
get('Expression1', 'Minus', 'Expression0')
    .generate('Expression1', function (values) { return new SubtractExpression(values[0], values[2]); }),

// Expression Level 0
get('Expression0', 'Multiply', 'Term')
    .generate('Expression0', function (values) { return new MultiplyExpression(values[0], values[2]); }),
get('Expression0', 'Divide', 'Term')
    .generate('Expression0', function (values) { return new DivideExpression(values[0], values[2]); }),

// Term
get('Term', 'LeftBracket', 'ExpressionList', 'RightBracket')
    .generate('Term', function (values) { return new IndexedExpression(values[0], values[2]); }),
get('@@', 'Name').generate('ClassVariable', 
    function (values) { return new ClassVariableExpression(values[1].getName()); }),
get('@', 'Name').generate('InstanceVariable', 
    function (values) { return new InstanceVariableExpression(values[1].getName()); }),
get('LeftParenthesis', 'Expression', 'RightParenthesis')
    .generate('Expression0', function (values) { return values[1]; }),
get('LeftBracket', 'RightBracket')
    .generate('Array', function (values) { return new ArrayExpression([]); }),
get('LeftBracket', 'ExpressionList', 'RightBracket')
    .generate('Array', function (values) { return new ArrayExpression(values[1]); }),

For each discovered element, the grammar is building an expression, that can be evaluate using a context. A context has the values of the visible variables. Example:

function NameExpression(name) {
    this.evaluate = function (context) {
        var value = context.getValue(name);
        if (typeof value == 'function')
            return value();
        return value;
    this.getName = function () { return name; };
    this.setValue = function (context, value) {
        context.setLocalValue(name, value);

function InstanceVariableExpression(name) {
    this.evaluate = function (context) {
        if (!context.$self.$vars)
            return null;
        return context.$self.$vars[name];
    this.getName = function () { return name; };
    this.setValue = function (context, value) {
        if (!context.$self.$vars)
            context.$self.$vars = { };
        context.$self.$vars[name] = value;

function ClassVariableExpression(name) {
    this.evaluate = function (context) {
        if (!context.$self.$class.$vars)
            return null;
        return context.$self.$class.$vars[name];
    this.getName = function () { return name; };
    this.setValue = function (context, value) {
        if (!context.$self.$class.$vars)
            context.$self.$class.$vars = { };
        context.$self.$class.$vars[name] = value;

function ConstantExpression(value) {
    this.evaluate = function () {
        return value;

I have access to JavaScript features from Ruby, example, a test:

exports['Evaluate JavaScript global name'] = function (test) {
    global.myglobal = 42;
    var context = contexts.createContext();
    var parser = parsers.createParser("js.myglobal");
    //parser.options({ log: true });
    var expr = parser.parse("Expression");
    var result = expr.value.evaluate(context);
    test.equal(result, 42);

The js namespaces allowed the access to JavaScript defined variables, and all its ecosystem, at the browser or at the server.

I want to share my advances at RubyConf 2014 Argentina.

Next steps: access to Node.js require, web site examples using Node.js/Express, console examples, browser examples, etc.

Stay tuned!

Angel “Java” Lopez

Older Posts »

Theme: Shocking Blue Green. Get a free blog at


Get every new post delivered to your Inbox.

Join 67 other followers