Continuous Learning

Remove Submodule from GIT Repo

yc — Mon, 05 Mar 2012 01:31:50 +0000

There is no git submodule rm command, so it takes a bit of manual work to remove a submodule reference in your git repo

From (https://git.wiki.kernel.org/articles/g/i/t/GitSubmoduleTutorial_c489.html)

Delete the relevant line from the .gitmodules file.
Delete the relevant section from .git/config.
Run git rm --cached path_to_submodule (no trailing slash).
Commit the superproject.
Delete the now untracked submodule files.

Using Git Submodules

yc — Fri, 02 Mar 2012 04:30:37 +0000

If you want to reference code from external repositories within your own repository in GIT – you’ll have to use GIT submodules.

Let’s say that we have a repo called sandbox, and inside sandbox, we have a lib sub directory that refers to multiple libraries from other repos, looking like the following

/sandbox # your repo
 |
 +-> /lib
      |
      +-> /subA # submodule A
      +-> /subB # submodule B
      ...

To add the submodules, you need to use the git submodule add command at the root of your repo as follows

$ cd ~/sandbox
$ git submodule add  lib/subA
$ git submodule add  lib/subB
$ ...

Each git submodule add will create a clone of the external git repo into your existing repo and manage them as a submodule.

Because each submodule is also a git repo clone, you can modify/change source code inside submodule and then push it back to the origin.

$ cd ~/sandbox/lib/subA

$ git commit -a -m "reason of change..."
$ git push
$ cd ~/sandbox
$ git add lib/subA
$ git commit -m "updated submodule"

Submodule changes has to be pushed back out to the origin before the rest of the code, otherwise it will break the dependency.

Also submodules are “fixed” to a particular version of the original repo – so if you want to keep up the latest version, remember to issue the following

# at the root of the repo
$ git submodule update

You can put the above into a cronjob to refresh it automatically, or use git config alias as described in this link.

That’s it – enjoy git submodules.

HTTPS with GITHUB

yc — Tue, 28 Feb 2012 18:35:09 +0000

SSH port is blocked at many company firewalls – for no good technical reasons of course, but probably driven by security policies, and that means one cannot use github without either a weird proxy hack or via HTTPS, which github now supports.

For cloning an existing repro – just use the https path.

# public repro
git clone https://github.com/username/repro.git
# private repro - will prompt for password
git clone https://username@github.com/username/repro.git

If you are creating a new repro, then you want to add the http path as the origin server.

# will prompt password upon push
git remote add origin https://username@github.com/username/repro.git

Working with HTML Canvas

yc — Mon, 27 Feb 2012 22:07:38 +0000

Canvas is central to HTML5 for 2D graphics. It is supported to various degree by the modern browsers, which of course means IE lags behind until version 9.

The following creates a canvas element in an HTML page

To make the above work in IE – you will need to use the ExploreCanvas project (there are others but won’t look at them in this post), which provides a javascript implementation of the canvas element.

Although ExploreCanvas provides quite a bit of coverage, it currently does not implement all canvas capabilities, one of which is the text capability, which fortunately can be decently patched with the canvas-text project.

Between the two of them we now have 90% of canvas capability, enough for us to play with canvas in a cross-browser fashion.

To use canvas-text, add the following line to as well.

You’ll also need to pick a particular font, which is also implemented in javascript as part of the canvas-text project. I have only tried …

Time to start drawing on the canvas…

Rectangle

The following draws a rectangle.

var example = document.getElementById('example');
var context = example.getContext('2d');
context.fillStyle = 'red';
context.fillRect(30, 30, 50, 50);

The first two line basically returns a drawing context from the particular canvas, so you can use it for drawing. It’s best to put that into an initiation routine, since you’ll likely to reuse the context over and over again. We won’t see these line repeated going forward.

The 3rd line (fillStyle) sets the color of the fill function. Besides colors it can also be a gradient object, and there are two types of gradients (linear and radial), but with IE only linear works at this moment (IE for now also cannot handle every common color names; for example – magenta).

The last line creates a rectangle filled with the color specified in the 3rd line. The parameters are top, left, width, and height.

Circle

Drawing a circle looks like the following

context.beginPath();
context.arc(x, y, radius, 0 , Math.PI * 2, true);
context.closePath();
context.fill();

Basically, draw an arc of a circle with the arc() function, with beginPath()/closePath() pair perform the drawing, and fill() to color the circle.

Polygon

Both circles and polygons are drawn with a path, so they both make use of the beginPath(), closePath() and fill(). The difference is that circle uses arc, whereas polygon uses straight lines via moveTo()/lineTo() as follows:

context.beginPath();
context.moveTo(x, y);
for (i = 0; i < points.length; ++i) {
    context.lineTo(points[i][0], points[i][1]);
}
context.closePath();
context.fill();

Text

Finally – text is done as follows

context.font = '20pt Arial';
context.fillText('hello world', 20, 50);

Keep in mind that not every font is available for IE – so trial and error is inevitable.

Gradient

Gradient is created by setting context.fillStyle to a gradient object, which is created via one of the following methods

var linearG = context.createLinearGradient(startX, startY, endX, endY);
var radialG = context.createRadialGradient(startX, startY, startRadius, endX, endY, endRadius);

Currently radial gradient does not work in IE.

To create additional “stops” (additional points between the start and end points), use addColorStop().

gradient.addColorStop(color, offset); // offset is between 0 and 1

The above is a quick tour of the canvas API. It’s fairly low level as you are working with a context object. It would be much nicer to work at the shapes level, or even above. Libraries such as Processing is supposed to offer such capability. We’ll revisit canvas in the future.

NodeJS Serving Static Files

yc — Sat, 25 Feb 2012 08:29:57 +0000

We have previously generated dynamic hello world in NodeJS – let’s now try to do so via serving a static file instead.

The hello.html contains the following

hello world

Hello world

To serve this file we can quickly hack our handler to just load this file whenever we are pointing to root.

The fs module provides file I/O for NodeJS. The simplest approach is probably to read the whole file into memory and write it out at once, via readFile:

var fs = require('fs');
...
fs.readFile('hello.html', function (err, data) {
    if (err) {
	res.writeHead(500, {'Content-Type':'text/plain'});
	res.end('internal error: ' + err);
    } else {
	res.writeHead(200, {'Content-Type':'text/html'});
	res.end(data, 'utf-8');
    }
});

fs.readFile isn’t the most efficient method, especially for large files, but for now it suffices, and we’ll revisit how to handle large files in the future.

The above will serve hello.html with every request, since it’s embedded into the code. What we want is to be able to serve any file based on the incoming path.

For that – we’ll need the following

A mapping between the virtual path to physical path on disk
A content type map between the file extension to the content type

To map the physical path, we’ll need to start with a root path, say /tmp/node, and we’ll at this moment simply append the path to the root path.

function virtualToPhysical(path) {
    return '/tmp/node' + path;
}
...
fs.readFile(virtualToPhysical(req.url), function (err, data) {

Since req.url always starts with /, the virtualToPhysical function will not have issue with missing / if used within the context of NodeJS.

The above change allows you to serve file from anywhere (assuming NodeJS has the proper permission) on the filesystem. However, we still need to deal with the mime types of different types of file.

Traditionally web servers such as Apache uses a mime.types file that holds the mapping between extensions and the content type. Although parsing mime.types isn’t all that difficult (just split on lines and split again on spaces, and then remove comments), it’s simpler to just use a pre-written module here, specifically node-mime.

Installing node-mime is simple, just issue the following command

$ npm install mime

Then add the following code

var mime = require('mime');
...
// on fileRead success
res.writeHead(200, {'Content-Type': mime.lookup(req.url) });

With the above – we can now serve arbitrary static files!

NodeJS Hello World

yc — Sat, 25 Feb 2012 06:21:48 +0000

NodeJS hello world is pretty straight forward

Download NodeJS & install it

Verify via running node on command line

Type up the following hello.js in your favorite editor

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/plain'});
  response.end('Hello World\n');
}).listen(8080);

console.log('Server running at http://127.0.0.1:8080/');

Run
```
node hello.js
```
You’ll see Hello World printed when you visit http://localhost:8080

Counting Hello World

A counting hello world is also pretty straight forward, as Javascript has closure, so we just need to setup a variable to store the counter.

Change hello.jsand add a count variable as follows

var http = require('http');
var count = 0;
http.createServer(function (req, res) {
            res.writeHead(200, {'Content-Type': 'text/plain'});
            count += 1;
            res.end('Hello World ' + count + '\n');
    }).listen(8080, "127.0.0.1");
console.log('Server running at http://127.0.0.1:8080/');

Refresh the page and you’ll see the counter being updated.

You might find the counter being updated in increments of 2 – this is due to your browser issue an “invisible request” (because we are not logging it) for the non-existent /favicon.ico file as well as for the root. To see it in action, we’ll add a logging line to see the request url via req.url, as follows

var http = require('http');
var count = 0;
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    count += 1;
    console.log('count: ' + count + ': ' + req.url); 
    res.end('Hello World ' + count + '\n');
    }).listen(8080, "127.0.0.1");
console.log('Server running at http://127.0.0.1:8080/');

You can then verify the log at the console

$ node http.js
Server running at http://127.0.0.1:8080/
count: 1: /
count: 2: /favicon.ico
count: 3: /
count: 4: /favicon.ico
count: 5: /
count: 6: /favicon.ico

To not count the favicon request – we can add a conditional test to the http handler function against the req.urland return 404 for favicon.

var http = require('http');
var count = 0;
http.createServer(function (req, res) {
    if (req.url == '/favicon.ico') {
	res.writeHead(404, {'Content-type' : 'text/plain'});
	res.end('not found'); 
    } else {
	res.writeHead(200, {'Content-Type': 'text/plain'});
	count += 1;
	console.log('count: ' + count + ': ' + req.url);
	res.end('Hello World ' + count + '\n');
    }
    }).listen(8080, "127.0.0.1");
console.log('Server running at http://127.0.0.1:8080/');

That’s it – your counting NodeJS hello world program.

Ignore That RFP When…

yc — Fri, 11 Mar 2011 04:07:10 +0000

It is often difficult to ignore the RFP that just lands on your desk. There lies the untold riches and glory that awaits you.

But just like the gold rush, most people come home empty handed with RFPs. In each RFP, there is exactly one winner (there are RFPs with zero winner – yes, these are just market surveys in disguise), and everyone else go home for the next time.

Furthermore, RFPs generally favors the participants differently. It’s similar to a playoff seeding, where there usually is a already clear favorite, and they get to play the lower seed first before facing tougher competitions.

Nevertheless, vendors who want to get into the buyer’s door will keep playing the game. So it’s prudent to know how to play this game well.

To win any RFP, you will have to put a lot of effort into it, in order to convince the buyer that your solution is the best choice.

To do that – you’ll have to invest a lot of resources. If you are a big company that can throw armies of people on all the RFPs that comes across your desk, great. You can stop reading now.

If not – you will need to be selective about the RFPs you answer. Yes that means you need to concentrate on the likely winners, and ignore the rest.

It’s always scary to limit the opportunities. But focus will give you greater penetration power, which is exactly what you need to win an RFP.

1 out of 10 is much better than 0 out of 100.

So what RFP you should go for? And what to ignore?

The surest RFPs to go for are the ones that buyers told you “this is yours to lose.”

Okay – no buyer will say that, so this needs to be implied, whether it’s because you have strong relationship with the buyers, or that you are the incumbent vendor. The point is – you already know you are likely to win before you bid (not that you know you can win).

Conversely – if you do not know whether you are likely to win, then you are not likely to win. And broadly speaking – all such RFPs should be ignored.

But what if your job is to get new buyers to bite? In that case you cannot just ignore all of the RFPs from new buyers.

In that case, you’ll need to know which ones you actually have a chance, and which ones you really don’t:

When the existing incumbent is getting kicked out of the door – there is a vacuum, so someone new gets to fill it
When you get to directly work with the buying manager and not the procurement – there is a chance that you can build working relationship
When you only have a very short amount of time to turn around RFP – either you are late to the party, or the buyer doesn’t have its act together; in either case, the chance is not there
When you have to follow a very rigid RFP structure – this means buyer is not looking for people to “innovate” on RFP, and chance is that buyer is not looking for innovation period – this is not likely to be a good fit either
The RFP is likely stretching your company’s resource if you win – the size discrepancy will likely disqualify you – don’t waste the time

The truth is that RFP is often not the best way to get into a new buyer’s door except under drastic situations. Look for the compelling reason(s) for the buyer to search for a new vendor, if you can’t find that reason, it’s best to look elsewhere for now, and wait for the compelling opportunity to present itself to you (this likely will occur on a “side door”) down the road.

Increase Upload Quota in WordPress

yc — Fri, 04 Mar 2011 18:10:36 +0000

In WordPress Network, there is a upload size quota limitation, defaulted to 10MB. Which works for ISP selling their spaces at premium, but not if you already buy the space:

Administration -> Super Admin -> Sites
Choose the site that you want to update the quota, click Edit
Update the field that says Site Upload Space Quota, or Blog Upload Space in 3.1

Flapjax – Functional Reactive Programming in Javascript

yc — Thu, 03 Mar 2011 19:40:05 +0000

What if programming can be as simple as writing spreadsheet formulas?

Now – there are some complex spreadsheets out there for sure, but the power of spreadsheet comes from that the values are self-updating, i.e. changing value in one cell will automatically cause all its dependent cells to reflect the change. If spreadsheets cannot do the auto-propagation, even the simplest spredsheet will be much more complex.

Most programming languages do not have the auto-propagating capability, but the ones that do are called reactive programming languages. And if the language is also functional, then it’s called a functional reactive programming language.

Since most of the mainstream languages did not have reactive features built-in, the feature need to be “bolted on”, as a library or a transformer. The one for Javascript is called Flapjax.

Let’s do a quick example to demonstrate the power of functional reactive programming. We’ll use timer as an example, where the timer should refresh its value (in total milliseconds) every tenth of a second.

If we were to write this in conventional Javascript, it will be something like this:

var d = new Date();
setTimeout(function () { node.innerHTML = d.getMilliseconds(); } , 100);

But if Flapjax it’s as follows (you can see the demo here):

 {! timerB(100); !}

Cool huh? The timerB “function” automatically handles the refresh that we have to manually handle with setTimeout in conventional Javascript.

What if we want to have two timers, the first gets updated every tenth of a second, and the second gets updated whenever the first is updated ten times?

In conventional Javascript we will write:

var d = new Date();
var i = 0;
setTimeout(function () { node.innerHTML = d.getMilliseconds();
   i++;
   if (i == 10) {
      node2.innerHTML = Math.floor(d.getMilliseconds());
   } else {
      i = 0;
   }
} , 100);

In Flapjax we can write (see a more extensive demo that includes the last digit of the timer):

var tenthB = timerB(100);
var secondB = Math.floor(tenthB / 1000);
{! tenthB !} {! secondB !}

It now looks like we have created two variables, and as the value of the first variable changes, the second variable changes along with it. In comparison, the conventional event-driven approach of Javascript has too much code, and also obscures the relationship between the two timers.

This is only the tip of the iceberg of what functional reactive programming can do – for more details, see the Flapjax tutorial.

Should You Have Faith in Lean Startups (or In Your Startup)?

yc — Thu, 03 Mar 2011 07:51:22 +0000

Ash Maurya is asking a very good question:

Do you have faith in lean startups?

He goes on to digest the “faith” in lean startups and cautions the practitioners to have a healthy dose of skeptism:

Observe the Stockdale Paradox at play – faith of ultimate result must be compartmentalized from the brutal confrontation of the current reality
The lean startup movement itself need to cross the chasm
Do not confuse the tactical techniques with the methodology
Focus on learning, validating, and iterating, instead of just believing

What Ash said are all valid – he then further made a point that he believes fundamentally that the lean startup methodology is fundamentally different from other well-intentioned agile methodology that has gone astray.

This is where I beg to differ.

While I cannot predict how the lean startup movement will end up, the matter of fact is that when a methodology/ideology movement gone astray, it is not the methodology/ideology itself, but the people who participate in the movements.

The famed Technology Adoption Lifecycle has captured the people’s behaviors in a nutshell:

Technology Adoption Lifecycle

Whether you factor into the Chasm or not, the following categories of people are defined:

Innovators – people who are constantly seeking to push the boundary
Early adopters – people who quickly sees the vision for the new ideas and can relate to how it will help them
Early majority – people are conservative, but will still open to new ideas, but will wait for early adopters to adopt the ideas
Late majority – people who are conservative, and will not adopt new ideas until others have adopted the ideas
Laggards – people who will never adopt the ideas

Just based on the above information alone, we immediately know that not all potential adoptees are equally invested in trying out new ideas. We can count on the innovators and the early adopters to try out the ideas and potentially help shape it, but late majority and laggards are not going to be invested in the ideas until it becomes inevitable (maybe not even then), and certainly they are not going to waste energies to figure out how to “make the idea work”.

In other words, lean startups will encounter more of people who will try to make the ideas work for them during the innovator and early adopter phase, but will encounter more of people who want the ideas to work for them during the later phases of adoption cycle.

Unfortunately, startups will require people who will make the ideas work, instead of the other way around.

So – if lean startup movement is ever successful enough to cross that chasm, it will encounter such the late majority and laggards, and will be met with the same market force that have subjected other technology/ideas/methodologies.

But that’s okay – because that does not impact your startup.

For your startup – you are looking for the best ideas to help it to become successful, but you know that it is prudent to prove that

the idea can help you, and
you can make the idea work

prior you go all-in, because you know your startup is a venture, not a speculation.

That “best idea” might be lean startup today, but it might be something different tomorrow. You might want to stick with an idea long enough to realize its value, but you are certainly not going to be married to an idea just for “faith”. But if it works, it will stay in your toolkit for further applications. Why not?

All these ideas are means to an end – for your startup and your success. Use your tools wisely.