go tool.There are many other books on go, but these are the ones I have read.
https if your tools know about it. The solution is to tell git to always use https instead of git by running the following command:
git config --global url."https://".insteadOf git://This adds the following to your ~/.gitconfig:
[url "https://"]
insteadOf = git://
All git commands will perform a substitution of git:// to https://. Thanks StackOverflow!
The complete setup is available at https://github.com/jgoodall/vagrant-node.
First, download VirtualBox and install.
Download a Vagrant installer for Mac OS, Windows, and Linux and install it.
To create an initial Vagrant file, run the command:
vagrant init
The init command creates a sample Vagrantfile, which is the main configuration.
The first thing we need to do is add a box. Vagrant has a couple of preconfigured Ubuntu boxes (referred to in the Vagrant Docs), but there is a large list of available boxes. We are just going to use one of the available Ubuntu boxes, precise64 (Ubuntu 12.04). Edit the Vagrantfile, near the top:
# Every Vagrant virtual environment requires a box to build off of.
config.vm.box = "precise64"
# The url from where the 'config.vm.box' box will be fetched if it
# doesn't already exist on the user's system.
config.vm.box_url = "http://files.vagrantup.com/precise64.box"
To access the guest VM from the host OS, set up port forwarding. To set forwarding to access port 8000 on the guest VM from http://localhost:8000 on the host OS:
config.vm.network :forwarded_port, guest: 8000, host: 8000
For the VirtualBox provider, we can customize the provider settings by modifying this section, for example to set the VM memory to 2GB:
config.vm.provider :virtualbox do |vb|
vb.customize ["modifyvm", :id, "--memory", "2048"]
end
Here is a full list of the settings for VirtualBox.
We will use Chef for provisioning, but Puppet works too. Ops people undoubtedly have a preference, but for our purposes either works. One of the main differences is that Chef configuration is written in Ruby, while Puppet uses its own domain specific language.
While either Puppet or Chef will work, but we are going to use Chef Solo with our Vagrant setup. The Vagrant documentation on Chef Solo has more information.
First, let's update the packages already installed:
# Update the list of packages
config.vm.provision :shell, :inline => "sudo apt-get update -y"
This will not actually do the upgrades, for that you will need to run sudo apt-get upgrade -y, but grub seemed to be giving me errors when trying doing that automatically from the Vagrantfile.
You can download cookbooks into your Vagrant repository and configure in the Vagrantfile, or you can use one of the cookbook management tools, such as berkshelf:
gem install berkshelf
Create the file Berksfile and add the following:
cookbook "git"
cookbook "nodejs"
cookbook "redisio"
Add the following line to your Vagrantfile:
# Use [berkshelf](http://berkshelf.com/)
config.berkshelf.enabled = true
Install nodejs, setting the version to the latest stable or what version you need, redis, and yeoman, node-supervisor, and http-server:
config.vm.provision :chef_solo do |chef|
chef.json = {
"nodejs" => {
"version" => "0.10.7"
}
}
chef.add_recipe "git"
chef.add_recipe "nodejs"
chef.add_recipe "redisio::install"
chef.add_recipe "redisio::enable"
end
# install global node modules
config.vm.provision :shell, :inline => "npm install -g yo grunt-cli bower supervisor http-server"
Note, there are several cookbooks for node.js and redis; this uses the redisio and the nodejs cookbooks.
At this point, you probably want to install your own software. You can do this from your Vagrantfile using git, but then you will have to do a git pull after all your changes. Another approach is to clone everything inside your vagrant directory and it will then be mounted within the guest VM automatically. Anything that is in the same directory as the Vagrantfile will be mounted within the VM in /vagrant.
If you have multiple sub-projects, another approach is to put all of your sub-projects under one project-root directory. One way to configure things if you have multiple projects and a separate repo for your vagrant configuration is to set up your directory structure like this:
- project-root
- vagrant-config
- sub-project1
- sub-project2
And then symlink your Vagrantfile to the project-root (ln -s vagrant-config/Vagrantfile .). Using this approach, you can edit your code in your host OS using Sublime Text, or whatever editor you like, and it is automatically changed in the /vagrant directory. Alternately, everything will be under your vagrant configuration repo.
To create the VM, run: vagrant up. This will take a few minutes as it downloads the box, configures the VM, updates install packages, and installs the packages listed in the Vagrantfile.
Redis should be running already (that is what the redisio::enable does). Because port forwarding for the redis port is configured, you can use redis-cli from the host OS to connect to the guest (assuming you don't also have redis running on the host).
If you have a nodejs process server set up and running on port 8000 (or if you have it set to start on a different port, change the mapping in the Vagrantfile), you can open a browser or use curl to access the server from the host OS by going to http://localhost:8000/
To log into the VM, from the directory that has your Vagrantfile, do: vagrant ssh. Here is a list of all Vagrant commands.
Here are the presentation frameworks I found and took a look at, in order of github stars:
impress.js (github / demo) is essentially a clone of prezi, allowing for really crazy presentations that use all sorts of transformations on an infinite canvas. This isnt the kind of thing I was looking for, but it does live up to its name (in the same way that the first time you see a 3D globe does). Documentation seems to be lacking, but it seems very popular (~13,000 stars).
reveal.js (github / demo) includes nested slides, markdown contents, PDF export (using Chrome via a special style sheet), and speaker notes. Content can be created in html or markdown (yay), and there is even an online editor, rvl.io. Navigation by keyboard or touch events (swipe) or an overview hotkey that zooms you out (press ESC). There are lots of different transitions and default themes. Code highlighting is included by way of highlight.js.
deck.js (github / demo) seems mature and has a whole ecosystem around it. Content is created in HTML. Navigation by keyboard or touch events (swipe) or an overview hotkey (or touch double tap). Deck.js supports extensions, and beyond the default ones, there appears to be a whole bunch of contributed ones on the project wiki, including lots of options for writing content in Jade or markdown.
flowtime.js (github / demo) is a relative newcomer, but seems pretty nice. Content is created in HTML. Navigation by keyboard or touch events or clicking on the overview. The one thing that sets flowtime apart is the overview, which displays all slides in a grid. The flowtime.js demo crashed both Chrome and Safari on my iPad, so not sure if mobile is really an option.
fathom.js (github / demo) is a jquery plugin that is limited in terms of features, but looks easy to get started with. Content is created in HTML. Navigation by keyboard or mouse. The demo is a bit awkward on an iPad, you can scroll but it is more like scrolling a web page than flipping through slides. You can sync the video of your presentation, although that wasnt important for me.
The ability of reveal.js to export to PDF and write slides in markdown are two features that set it apart. The export to PDF feature seems to only be available in reveal.js; I would like to see more support for that as there are times when I can only bring a pdf or ppt file to a presentation. Deck.js also seems solid, especially when all of the contributed plugins are considered.
]]>Anyway, Commonplace got me thinking of serving markdown files, and more generally in wikis. I have hated almost every wiki that I have ever tried: MediaWiki, DokuWiki, and the rest that I have played with. (Ward Cunningham has a list of popular wiki engines that is a good starting point for finding wikis).
This brings me to gollum, a wiki built on top of Git from github. It is the same engine that powers github project wiki pages. It supports lots of different formats for source files, including markdown, mediawiki, org mode, and textile. It is easily customizable with simple files for a sidebar, header and footer. Syntax highlighting is included via Pygments; mathematical equations via Mathjax. Installation is surprisingly easy, via RubyGems:
gem install gollumThere is a built in web editor, but we prefer to use git for all our edits. This provides a history of who is editing the files, and at one point we had a git corruption issue when editing from the web server itself (although I suspect this has been fixed). Since our team uses git regularly for all our source code, everyone is already familiar with the workflow, and I much prefer to edit markdown files in TextMate, while other members of our team use org mode with Emacs. Having a wiki where all editing is done locally, rather than through a web interface, while using any format you want is actually pretty awesome. We have taken care to keep things organized in a structured hierarchy, so navigating the wiki from the terminal is easy, and there is a built-in search in the web interface. Although not perfect, it is the best wiki I have used. Thanks github, for making me not hate wikis any more.
]]>master branch of a project, build static html from that, and keep those changes in sync with the gh-pages branch to automatically deploy to github pages on each commit.
Here are the steps to set this up. This assumes you dont have a gh-pages branch already (if you do, delete it). I was using the deploy directory in master branch as the source for the gh-pages branch, so modify that directory as needed. Here are the steps (you should be in the root of your project when you start this sequence):
git checkout -b gh-pages
ls | grep -v deploy | xargs rm -rf
git mv deploy/* .
rmdir deploy
git add .
git ls-files --deleted | while read FILE; do git rm "$FILE"; done
git commit -a -m "Initial commit in pages branch"
git push origin master gh-pages
git checkout masterUpdate: you may have to do git mv -k deploy/* . if you have empty directories in your deploy directory
First, this creates and checks out the new gh-pages branch. Then remove all of the directories and files except the directory containing the web site (i.e. deploy). Move those files into the root directory and commit. Push the changes and go back to master.
Now, when you edit the files in master, you can merge them into the gh-pages branch by doing this (you should be in the root of your project when you start this sequence):
git checkout gh-pages
git merge -s subtree master
git push origin master gh-pagesThis will checkout the gh-pages branch, merge using the subtree strategy, then push both back to the origin remote repository.
Since we dont want to do all that every time, we can automate the process using git hooks in the master branch, so that the workflow is:
mastergit push --allA simple git pre-commit hook that uses grunt builds the static web site:
#!/bin/sh
./node_modules/.bin/grunt
git add deployThe git post-commit hook will merge the changes with the gh-pages branch for deployment on github pages:
#!/bin/sh
git checkout gh-pages
git merge -s subtree master
git checkout masterTo use the hooks, create them in your project root and then create the symlinks:
ln -s ../../pre-commit.sh .git/hooks/pre-commit
ln -s ../../post-commit.sh .git/hooks/post-commitNow, every time you do a git push --all in the master branch, the hooks will first build the static site and add the deploy directory to the commit, then will merge the changes to the gh-pages branch.
npm search connect- and npm search express-). It has been around for a while, is probably the most heavily used, and is under current development. It is flexible in terms of the template engines that you use, but using jade, which makes writing html not suck nearly as much as usual, is installed by default. (There is also another library, consolidate, from the same ridiculously prolific developer of express and jade for hooking into a whole bunch of other template engines in express.)
There are other frameworks out there too:
Flatiron, from the awesome folks at nodejitsu, is a bunch of small libraries that can be composed to make web or CLI apps. Pretty cool that you can use the same components to build both web and CLI apps. I've used their logger, winston, before and it just works.
Restify is a libray with a similar feel to express for building RESTful APIs.
ApiServer is a another library for building an API server.
A recent nodeup podcast covered some of these. Frankly, I dont have time to try them all, and dont have any real complaints with express. All the same, I decided to give tako a few hours and see what it was all about.
Mikeal Rogers, @mikeal, and Max Ogden, @maxogden, recently released a bunch of open source libraries for node. One of these projects is a web framework, called tako. It is really small, a single 24k file (compared to express, which looks like it is ~96k based on the files in lib). It is simple by design. From the author:
tako includes all the features we needed from a web framework to build our app. It’s not a middleware or plugin system and doesn’t include one. It’s a tool for handling HTTP requests in a sensible way.
It has a composable API around routes. A route is an object and based on what kinds of handlers you add and conditions you might set tako can respond properly to various HTTP methods and content-type requests in an appropriate manner.
It can also serve files sensibly using filed which already streams and returns/responds to proper etag and if-modified headers.
It already includes socket.io. It includes JSON support. It can serve buffers from cache.
The first thing you notice is that there is not a lot of documentation, basically just a minimal readme. The next thing is that it is pretty straightforward to get started. Here is a simple example for a single page app:
var fs = require('fs')
, path = require('path')
, tako = require('tako')
, gzip = require('tako-gzip')
// global variables
var app = tako()
, indexHtml = fs.readFileSync(path.join(__dirname, './html/index.html')).toString()
, notfoundHtml = fs.readFileSync(path.join(__dirname, './html/notfound.html')).toString()
// static files
app.route('/public/*').files(path.join(__dirname, './public'))
// routes
app.route('/')
.html(renderIndex)
.methods('GET')
// page not found
app.notfound(notfoundHtml)
// listen
app.httpServer.listen(8000)
// just render the html
function renderIndex(req, res) {
res.end(indexHtml)
}All it does is serve an index file and the static assets. I am using grunt to compile jade templates into html, combine and uglify javascript files, and combine and minify css files. So the web server is only serving static files. There is also an html file for 404 errors.
Tako includes socket.io. To use it:
app.sockets.on('connection', function (socket) {
socket.on('connect', function () {
app.sockets.emit('user connected') // broadcast
})
socket.on('disconnect', function () {
app.sockets.emit('user disconnected') // broadcast
})
})One thing that took me a few minutes to figure out is how to get to the socket.io settings. I think there are two ways:
app = tako({'socketio':{'log level':2}})app.socketioManager.set('log level', 2)Obviously, you can do more than change the log level, see more configuration options.
Tako does not support plugins. But there seems to be some plugins.
npm search tako-
NAME DESCRIPTION AUTHOR DATE KEY
tako-cookies A cookie middleware for tako =isaacs 2012-04-20 19:23
tako-gzip gzip for tako =kesla 2012-04-29 22:17
tako-session-token session tokens for tako =isaacs 2012-04-20 19:47Author isaacs wrote npm and modules like supervisor and inherited 'dictatorship' of node itself from Ryah Dhal, node's creator. I dont know why he is he using tako, but that is a good sign right?
So back to plugins, the gzip one is pretty straightforward:
var gzip = require('tako-gzip')
app.on('request', gzip)Not sure why you wouldn't want to do that...
If you listen to the [Nodeup podcast]((http://nodeup.com/) or read the author's writings, you know he is a crazy smart, thoughtful, and opinionated developer. I want to use this framework, but I am not a good enough node.js developer to be able to figure out everything it is doing. So I think it is a nice framework, but needs a lot of help getting the same level of documentation as other, more mature projects like express. If I need to put together something quick and relatively straightforward, then I love this, but for larger projects, I am sticking with Express until the documentation for this one gets a bit better. My hunch is that I am not the target audience and this is made for people that are going to dig into the source code and figure out exactly how it is working, but then again, if you are going to do that, then do you really need a web framework?
]]>Wijmo is a complete kit of over 40 UI widgets with everything from interactive menus to rich charts.
Great, another clone of JqueryUI. I bring it up because Chris Bannon, manager at Wijmo was on a recent episode or javascript jabber, a very good podcast on javascript. He was on the show to discuss 'data visualization', and being as that is what I do, I was interested to hear what he had to say. My take, this is someone who is probably an excellent developer, but someone who does not really know what 'data visualization' means.
There are lots of definitions for information visualization, as data visualization is more commonly called. The canonical definition is (Stuart Card):
The use of computer-supported, interactive, visual representations of abstract data to amplify cognition.
More succinctly (Ben Shneiderman):
The purpose of visualization is insight, not pictures.
So the guest started off talking about SVG, their use of HTML5 and Raphael, the need to understand transformations, and data bindings. All good.
Then he started talking about 'gauges', and I cringed a little bit. Here is a typical dashboard from the wijmo demo page. Yikes. That is a whole lot of screen space for very little information. Maybe no one told them that a table is a pretty effective means of communicating a few numbers? I assume he has read his Tufte, since he referenced the Challenger example Tufte always talks about. (Notwithstanding, that Tufte actually got this often cited example wrong.) But he probably hasn't read his Stephen Few, and his insightful rants on poor dashboard design, gauges, and the misinterpretation of data visualization. I love bar charts and scatterplots, but why is a 'data visualization' company perpetuating the use of gauges (it shows a single number - just show the number! or use a bullet chart to add some context in a small space) and pie charts?
Most of the most useful (and coolest) stuff in information visualization is coming from academia and research organizations, and increasingly from data journalists. Why are vendors not getting it? There are some exceptions, most notably Tableau, but there are even widget makers that seem to know a little about visualization, such as Panopticon. There are open source projects for creating rich, interactive visualization, such as Raphael and the increasingly popular d3. Look at the d3 examples for lots of interesting things people are doing with interactive visualization.
And finally, he said something to the effect of 'the best creators of visualizations are developers'. No. That is wrong. I have worked with a lot of excellent developers, but they think like engineers and have no training in information visualization design. InfoVis designers are the creators. They design meaningful visualizations that can facilitate new insights into complex phenomenon. Check out any one of a number of visualizations from the New York Times graphics department, such as: Facebook IPO, Obama's 2013 budget proposal, or the gap in wages between the sexes. Engineers create bad designs all the time, because they are not interaction or visualization designers! Same reason that architects and engineers work together to build a skyscraper. Wijmo, your heart is in the right place, but if you want to claim to be a company that does data visualization, then hire someone who knows about data visualization!
]]>Gauss, from Stackd, is a JavaScript statistics library that is ready to use with node.js featuring callbacks and method chaining. It seems to be actively updated. Gauss has methods for univariate and time series analysis (although the time series seems pretty limited so far).
Evented, asynchronous, and fast, Node.JS is an attractive platform for data mining, statistics, and data analysis. Gauss makes it easy to calculate and explore data through JavaScript.
npm install
npm install gaussSylvester is a Javascript library by James Coglan for math on vectors and matrices. Hard to tell if it is updated, since the source doesn't seem to be on github or some other public repository. Chris Umbel has created a node.js port.
Sylvester is a JavaScript library designed to let you do mathematics with vectors and matrices without having to write lots of loops and throw piles of arrays around. It includes classes for modelling vectors and matrices in any number of dimensions, and for modelling infinite lines and planes in 3-dimensional space. It lets you write object-oriented easy-to-read code that mirrors the maths it represents.
Later releases will add components for more specific geometric modelling functionality, building towards a feature-complete 1.0 release.
npm install
npm install sylvesterJStat is a Javascript statistical library intended for use in the browser. It optionally includes jQuery, jQuery UI and flot for building plots. It seems to be actively updated, but has no real documentation yet.
There is a github repo, but it is hard to tell if it is up to date, given this note on the github page: The code in this repository does not currently match that found on www.jstat.org. We are in the process of merging two similar projects and will update the website once the merge is complete.
jStat is a statistical library written in JavaScript that allows you to perform advanced statistical operations without the need of a dedicated statistical language (i.e. MATLAB or R).
Science.js is a new statistics library from Jason Davies originally intended for use with d3.js, the excellent visualization library for javascript. It has methods for statistics and linear algebra. It is a new project, coming soon on the home page, that seems pretty actively updated. No npm/node.js integration (yet?).
Science.js is a JavaScript library for scientific and statistical computing.
Currently, there are two modules:
- science.stats, containing various implementations of statistical methods similar to those provided by R;
]]>
- science.lin, for linear algebra.