Installer nodeJs, Cordova, ionic in vagarnt virtualBox


#sudo apt-get install python-software-properties
#sudo add-apt-repository ppa:webupd8team/java
apt-get update
apt-get install -y nodejs nodejs-legacy npm git openjdk-7-jdk ant expect

sudo chown -R vagrant android-sdk-linux/

echo "ANDROID_HOME=~/android-sdk-linux" >> /home/vagrant/.bashrc
echo "PATH=\$PATH:~/android-sdk-linux/tools:~/android-sdk-linux/platform-tools" >> /home/vagrant/.bashrc

npm install -g cordova
npm install -g ionic
expect -c '
set timeout -1   ;
spawn /home/vagrant/android-sdk-linux/tools/android update sdk -u --all --filter platform-tool,android-19,build-tools-19.1.0
expect { 
    "Do you accept the license" { exp_send "y\r" ; exp_continue }

sudo /home/vagrant/android-sdk-linux/platform-tools/adb kill-server
sudo /home/vagrant/android-sdk-linux/platform-tools/adb start-server
sudo /home/vagrant/android-sdk-linux/platform-tools/adb devices

18 commands to monitor network bandwidth on Linux server

Network monitoring on Linux

This post mentions some linux command line tools that can be used to monitor the network usage. These tools monitor the traffic flowing through network interfaces and measure the speed at which data is currently being transferred. Incoming and outgoing traffic is shown separately.

Some of the commands, show the bandwidth used by individual processes. This makes it easy to detect a process that is overusing network bandwidth.

The tools have different mechanisms of generating the traffic report. Some of the tools like nload read the « /proc/net/dev » file to get traffic stats, whereas some tools use the pcap library to capture all packets and then calculate the total size to estimate the traffic load.

Here is a list of the commands, sorted by their features.

1. Overall bandwidth - nload, bmon, slurm, bwm-ng, cbm, speedometer, netload  2. Overall bandwidth (batch style output) - vnstat, ifstat, dstat, collectl  2. Bandwidth per socket connection - iftop, iptraf, tcptrack, pktstat, netwatch, trafshow  3. Bandwidth per process - nethogs

1. Nload

Nload is a commandline tool that allows users to monitor the incoming and outgoing traffic separately. It also draws out a graph to indicate the same, the scale of which can be adjusted. Easy and simple to use, and does not support many options.

So if you just need to take a quick look at the total bandwidth usage without details of individual processes, then nload will be handy.

$ nload

nload command linux

Installing Nload – Fedora and Ubuntu have got it in the default repos. CentOS users need to get nload from Epel repositories.

# fedora or centos
$ yum install nload -y

# ubuntu/debian
$ sudo apt-get install nload

2. iftop

Iftop measures the data flowing through individual socket connections, and it works in a manner that is different from Nload. Iftop uses the pcap library to capture the packets moving in and out of the network adapter, and then sums up the size and count to find the total bandwidth under use.

Although iftop reports the bandwidth used by individual connections, it cannot report the process name/id involved in the particular socket connection. But being based on the pcap library, iftop is able to filter the traffic and report bandwidth usage over selected host connections as specified by the filter.

$ sudo iftop -n

The n option prevents iftop from resolving ip addresses to hostname, which causes additional network traffic of its own.

iftop command linux

Install iftop – Ubuntu/Debian/Fedora users get it from default repos. CentOS users get it from Epel.

# fedora or centos
yum install iftop -y

# ubuntu or debian
$ sudo apt-get install iftop

3. iptraf

Iptraf is an interactive and colorful IP Lan monitor. It shows individual connections and the amount of data flowing between the hosts. Here is a screenshot

$ sudo iptraf

iptraf linux command

Install iptraf

# Centos (base repo)
$ yum install iptraf

# fedora or centos (with epel)
$ yum install iptraf-ng -y

# ubuntu or debian
$ sudo apt-get install iptraf iptraf-ng

4. nethogs

Nethogs is a small ‘net top’ tool that shows the bandwidth used by individual processes and sorts the list putting the most intensive processes on top. In the event of a sudden bandwidth spike, quickly open nethogs and find the process responsible. Nethogs reports the PID, user and the path of the program.

$ sudo nethogs

nethogs command linux

Install Nethogs – Ubuntu, Debian, Fedora users get from default repos. CentOS users need Epel

# ubuntu or debian (default repos)
$ sudo apt-get install nethogs

# fedora or centos (from epel)
$ sudo yum install nethogs -y

5. bmon

Bmon (Bandwidth Monitor) is a tool similar to nload that shows the traffic load over all the network interfaces on the system. The output also consists of a graph and a section with packet level details.

bmon linux network monitor

Install Bmon – Ubuntu, Debian and Fedora users can install from default repos. CentOS users need to setup repoforge, since its not available in Epel.

# ubuntu or debian
$ sudo apt-get install bmon

# fedora or centos (from repoforge)
$ sudo yum install bmon

Bmon supports many options and is capable of producing reports in html format. Check the man page for more information

6. slurm

Slurm is ‘yet’ another network load monitor that shows device statistics along with an ascii graph. It supports 3 different styles of graphs each of which can be activated using the c, s and l keys. Simple in features, slurm does not display any further details about the network load.

$ slurm -s -i eth0

slurm command linux

Install slurm

# debian or ubuntu
$ sudo apt-get install slurm

# fedora or centos
$ sudo yum install slurm -y

7. tcptrack

Tcptrack is similar to iftop, and uses the pcap library to capture packets and calculate various statistics like the bandwidth used in each connection. It also supports the standard pcap filters that can be used to monitor specific connections.

tcptrack command linux

Install tcptrack – Ubuntu, Debian and Fedora have it in default repos. CentOS users need to get it from RepoForge as it is not available in Epel either.

# ubuntu, debian
$ sudo apt-get install tcptrack

# fedora, centos (from repoforge repository)
$ sudo yum install tcptrack

8. Vnstat

Vnstat is bit different from most of the other tools. It actually runs a background service/daemon and keeps recording the size of data transfer all the time. Next it can be used to generate a report of the history of network usage.

$ service vnstat status
 * vnStat daemon is running

Running vnstat without any options would simply show the total amount of data transfer that took place since the date the daemon is running.

$ vnstat
Database updated: Mon Mar 17 15:26:59 2014

   eth0 since 06/12/13

          rx:  135.14 GiB      tx:  35.76 GiB      total:  170.90 GiB

                     rx      |     tx      |    total    |   avg. rate
       Feb '14      8.19 GiB |    2.08 GiB |   10.27 GiB |   35.60 kbit/s
       Mar '14      4.98 GiB |    1.52 GiB |    6.50 GiB |   37.93 kbit/s
     estimated      9.28 GiB |    2.83 GiB |   12.11 GiB |

                     rx      |     tx      |    total    |   avg. rate
     yesterday    236.11 MiB |   98.61 MiB |  334.72 MiB |   31.74 kbit/s
         today    128.55 MiB |   41.00 MiB |  169.56 MiB |   24.97 kbit/s
     estimated       199 MiB |      63 MiB |     262 MiB |

To monitor the bandwidth usage in realtime, use the ‘-l’ option (live mode). It would then show the total bandwidth used by incoming and outgoing data, but in a very precise manner without any internal details about host connections or processes.

$ vnstat -l -i eth0
Monitoring eth0...    (press CTRL-C to stop)

   rx:       12 kbit/s    10 p/s          tx:       12 kbit/s    11 p/s

Vnstat is more like a tool to get historic reports of how much bandwidth is used everyday or over the past month. It is not strictly a tool for monitoring the network in real time.

Vnstat supports many options, details about which can be found in the man page.

Install vnstat

# ubuntu or debian
$ sudo apt-get install vnstat

# fedora or centos (from epel)
$ sudo yum install vnstat

9. bwm-ng

Bwm-ng (Bandwidth Monitor Next Generation) is another very simple real time network load monitor that reports a summary of the speed at which data is being transferred in and out of all available network interfaces on the system.

$ bwm-ng
bwm-ng v0.6 (probing every 0.500s), press 'h' for help
  input: /proc/net/dev type: rate
  /         iface                   Rx                   Tx                T
==           eth0:           0.53 KB/s            1.31 KB/s            1.84
KB             lo:           0.00 KB/s            0.00 KB/s            0.00
--          total:           0.53 KB/s            1.31 KB/s            1.84

If the console size is sufficiently large, bwm-ng can also draw bar graphs for the traffic using the curses2 output mode.

$ bwm-ng -o curses2

Install Bwm-NG – On CentOS bwm-ng can be installed from Epel.

# ubuntu or debian
$ sudo apt-get install bwm-ng

# fedora or centos (from epel)
$ sudo apt-get install bwm-ng

10. cbm – Color Bandwidth Meter

A tiny little simple bandwidth monitor that displays the traffic volume through network interfaces. No further options, just the traffic stats are display and updated in realtime.

cbm linux network monitor

$ sudo apt-get install cbm

11. speedometer

Another small and simple tool that just draws out good looking graphs of incoming and outgoing traffic through a given interface.

$ speedometer -r eth0 -t eth0

speedometer linux network monitor

Install speedometer

# ubuntu or debian users
$ sudo apt-get install speedometer

12. Pktstat

Pktstat displays all the active connections in real time, and the speed at which data is being transferred through them. It also displays the type of the connection, i.e. tcp or udp and also details about http requests if involved.

$ sudo pktstat -i eth0 -nt

pktstat linux network monitor

$ sudo apt-get install pktstat

13. Netwatch

Netwatch is part of the netdiag collection of tools, and it too displays the connections between local host and other remote hosts, and the speed at which data is transferring on each connection.

$ sudo netwatch -e eth0 -nt

netwatch linux network monitor

$ sudo apt-get install netdiag

14. Trafshow

Like netwatch and pktstat, trafshow reports the current active connections, their protocol and the data transfer speed on each connection. It can filter out connections using pcap type filters.

Monitor only tcp connections

$ sudo trafshow -i eth0 tcp

trafshow linux network monitor

$ sudo apt-get install netdiag

15. Netload

The netload command just displays a small report on the current traffic load, and the total number of bytes transferred since the program start. No more features are there. Its part of the netdiag.

$ netload eth0

netload linux network monitor

$ sudo apt-get install netdiag

16. ifstat

The ifstat reports the network bandwidth in a batch style mode. The output is in a format that is easy to log and parse using other programs or utilities.

$ ifstat -t -i eth0 0.5
  Time           eth0       
HH:MM:SS   KB/s in  KB/s out
09:59:21      2.62      2.80
09:59:22      2.10      1.78
09:59:22      2.67      1.84
09:59:23      2.06      1.98
09:59:23      1.73      1.79

Install ifstat – Ubuntu, Debian and Fedora users have it in the default repos. CentOS users need to get it from Repoforge, since its not there in Epel.

# ubuntu, debian
$ sudo apt-get install ifstat

# fedora, centos (Repoforge)
$ sudo yum install ifstat

17. dstat

Dstat is a versatile tool (written in python) that can monitor different system statistics and report them in a batch style mode or log the data to a csv or similar file. This example shows how to use dstat to report network bandwidth

$ dstat -nt
-net/total- ----system----
 recv  send|     time     
   0     0 |23-03 10:27:13
1738B 1810B|23-03 10:27:14
2937B 2610B|23-03 10:27:15
2319B 2232B|23-03 10:27:16
2738B 2508B|23-03 10:27:17

Install dstat

$ sudo apt-get install dstat

18. collectl

Collectl reports system statistics in a style that is similar to dstat, and like dstat it is gathers statistics about various different system resources like cpu, memory, network etc. Over here is a simple example of how to use it to report network usage/bandwidth.

$ collectl -sn -oT -i0.5
waiting for 0.5 second sample...
#         <----------Network---------->
#Time       KBIn  PktIn  KBOut  PktOut 
10:32:01      40     58     43      66 
10:32:01      27     58      3      32 
10:32:02       3     28      9      44 
10:32:02       5     42     96      96 
10:32:03       5     48      3      28

Install Collectl

# Ubuntu/Debian users
$ sudo apt-get install collectl

$ sudo yum install collectl


Those were a few handy commands to quickly check the network bandwidth on your linux server. However these need the user to login to the remote server over ssh. Alternatively web based monitoring tools can also be used for the same task.

Ntop and Darkstat are some of the basic web based network monitoring tools available for Linux. Beyond these lie the enterprise level monitoring tools like Nagios that provide a host of features to not just monitor a server but entire infrastructure.


Intégré Drag and Drop in symfony 2 formulaire

1. css


    border:2px dotted #0B85A1;
    padding:10px 10px 10 10px;
    line-height: 80px;
    text-align: center;
.progressBar {
    width: 200px;
    height: 22px;
    border: 1px solid #ddd;
    border-radius: 5px;
    overflow: hidden;
    margin:0px 10px 5px 5px;
.progressBar div {
    height: 100%;
    color: #fff;
    text-align: right;
    line-height: 22px; /* same as #progressBar height if we want text middle aligned */
    width: 0;
    background-color: #0ba1b5; border-radius: 3px;
    border-top:1px solid #A9CCD1;
    padding:10px 10px 0px 10px;
    padding:4px 15px;


2. template

<div class="widget-content" style="margin-bottom: 10px; ">
        <div id="dragandrophandler">Drag & Drop {{'form.faqfiles.associated'|trans}} Here</div>
        <div id="status1"></div>
function sendFileToServer(formData,status)
    var uploadURL ="{{ path('umdssupport_ticket_associatefile_drag_drop', {'id': ticketId })}}"; //Upload URL
    var extraData ={}; //Extra Data.
    var jqXHR=$.ajax({
            xhr: function() {
            var xhrobj = $.ajaxSettings.xhr();
            if (xhrobj.upload) {
                    xhrobj.upload.addEventListener('progress', function(event) {
                        var percent = 0;
                        var position = event.loaded || event.position;
                        var total =;
                        if (event.lengthComputable) {
                            percent = Math.ceil(position / total * 100);
                        //Set progress
                    }, false);
            return xhrobj;
        url: uploadURL,
        type: "POST",
        processData: false,
        cache: false,
        data: formData,
        success: function(data){
            $("#status1").append("File upload Done<br>");  
            $("{{ parentDiv }}").html(data);

var rowCount=0;
function createStatusbar(obj)
     var row="odd";
     if(rowCount %2 ==0) row ="even";
     this.statusbar = $("<div class='statusbar "+row+"'></div>");
     this.filename = $("<div class='filename'></div>").appendTo(this.statusbar);
     this.size = $("<div class='filesize'></div>").appendTo(this.statusbar);
     this.progressBar = $("<div class='progressBar'><div></div></div>").appendTo(this.statusbar);
     this.abort = $("<div class='abort'>Abort</div>").appendTo(this.statusbar);
    this.setFileNameSize = function(name,size)
        var sizeStr="";
        var sizeKB = size/1024;
        if(parseInt(sizeKB) > 1024)
            var sizeMB = sizeKB/1024;
            sizeStr = sizeMB.toFixed(2)+" MB";
            sizeStr = sizeKB.toFixed(2)+" KB";
    this.setProgress = function(progress)
        var progressBarWidth =progress*this.progressBar.width()/ 100; 
        this.progressBar.find('div').animate({ width: progressBarWidth }, 10).html(progress + "% ");
        if(parseInt(progress) >= 100)
    this.setAbort = function(jqxhr)
        var sb = this.statusbar;

function handleFileUpload(files,obj)
   for (var i = 0; i < files.length; i++)
        var fd = new FormData();
        fd.append('umds_supportbundle_ticketfiletype[file]', files[i]);
        fd.append('parentDiv','{{ parentDiv }}');
        fd.append('tmpTabId', '{{ tmpTabId }}');
        var status = new createStatusbar(obj); //Using this we can set progress.
        status.setFileNameSize(files[i].name, files[i].size);

    var obj = $("#dragandrophandler");
    obj.on('dragenter', function (e)
        $(this).css('border', '2px solid #0B85A1');
    obj.on('dragover', function (e)
    obj.on('drop', function (e)

         $(this).css('border', '2px dotted #0B85A1');
         var files = e.originalEvent.dataTransfer.files;

         //We need to send dropped files to Server
    $(document).on('dragenter', function (e)
    $(document).on('dragover', function (e)
      obj.css('border', '2px dotted #0B85A1');
    $(document).on('drop', function (e)


3. router

    pattern:  /associateFileDragDrop/{id}
    defaults: { _controller: umdsSupportBundle:Ticket:associateFileDragDrop  }
        id:  \d+  


4. controller

    public function associateFileDragDropAction($id)
    	$request = $this->getRequest();
        $translator = $this->get( 'translator' );
    	$submitForm = $request->get('submitForm');
    	$parentDiv = $request->get('parentDiv');
    	$tmpTabId = $request->get('tmpTabId');
    	$userId = $this->getUser()->getId();
        $ticketClass = get_class($this->container->get('Entity_Ticket'));
        $ticketFileClass = get_class($this->container->get('Entity_TicketFile'));
        $ticketFileTypeClass = get_class($this->container->get('Entity_TicketFileType'));
    	$em = $this->getDoctrine()->getManager();
    	$ticket = $em->getRepository($ticketClass)->findOneBy(array('id' => $id, 'isValid' => 1));
    	$ticketfile = new $ticketFileClass();
    	$formTicketFile = $this->createForm(new $ticketFileTypeClass(), $ticketfile);
    		if ($formTicketFile->isValid())
    			$file = $formTicketFile->getData();
    			$originalName = $file->file->getClientOriginalName();
    			$extension = pathinfo($originalName, PATHINFO_EXTENSION);
    			$tmpDir = $this->getTmpFileDir();
    			$tmpFileName = md5(mt_rand(5, 15));
                        $tmpFilePath = $tmpDir.'/'.$tmpFileName;    
    			$faqFileDir = $this->getFileDir();
    			$uploadedFile = $file->file->move($tmpDir, $tmpFileName);
    				// Ajout dans la base de données
    				$ticketfile->setCreateDate(new \Datetime);
    				$ticketfile->setUpdateDate(new \Datetime);
    				// Récupération de l'id 
    					// Déplacement du fichier temporaire (renommage)
    					$tmpFile = new File($tmpFilePath);
    					$fileName = $this->getFilePrefix().$ticketfile->getId().'.'.$extension;
    					if($tmpFile->move($faqFileDir, $fileName))
                                            $tabTicketFiles = $em->getRepository($ticketFileClass)->findBy(array('ticket' => $ticket, 'isValid' => 1));
                                            return $this->render('umdsSupportBundle:TicketFile:associate.html.twig', array(
                                                            'form' => $formTicketFile->createView(),
                                                            'ticketId' => $id,
                                                            'tabTicketFiles' => $tabTicketFiles,
                                                            'parentDiv' => $parentDiv,
                                                            'tmpTabId' => $tmpTabId
                $tabTicketFiles = $em->getRepository($ticketFileClass)->findBy(array('ticket' => $ticket, 'isValid' => 1));
    		return $this->render('umdsSupportBundle:TicketFile:associate.html.twig', array(
    				'form' => $formTicketFile->createView(),
    				'ticketId' => $id,
                                'tabTicketFiles' => $tabTicketFiles,
                                'parentDiv' => $parentDiv,
                                'tmpTabId' => $tmpTabId


symfony 2 : embed des controleurs dans le template twig

Si la doctrine de votre application ne vous permet pas des récupérer votre donnèes, il y a autre moyenne dans symfony2 pour afficher votre données, c’est embed le contrôleur dans le template twig, et lui passer des paramétrés.

Par example :

1. list.html.twig

 {{ render(controller("umdsHomeBundle:Tracking:contact", {'page' : 1 } )) }}

2. contact.html.twig

{{ render(controller("umdsHomeBundle:Tracking:contactView", {'pathInfo' : entity.pathInfo } )) }}
     {% if entity.action == "associateComplexAction" %}
     {% else %}         
     {% endif %}    
 {{ render(controller("umdsHomeBundle:Tracking:complex", {'id' : objs.complexId } )) }}

3. complex.html.twig

{{ }}

Linux – Find string in files

find . | xargs grep ‘string’ -sl

The -s is for summary and won’t display warning messages such as grep: ./directory-name: Is a directory

The -l is for list, so we get just the filename and not all instances of the match displayed in the results.

I find this useful for just quickly seeing which files contain a search time. I would normally limit the files searched with a command such as :
find . -iname ‘*php’ | xargs grep ‘string’ -sl

Another common search for me, is to just look at the recently updated files:
find . -iname ‘*php’ -mtime -1 | xargs grep ‘string’ -sl

would find only files edited today, whilst the following finds the files older than today:
find . -iname ‘*php’ -mtime +1 | xargs grep ‘string’ -sl

Some commands for cordova project

npm install -g cordova

cordova create workshop com.shen.workshop Workshop

cd workshop

npm install ant


set ANT_HOME=c:\ant
set JAVA_HOME=C:\Program Files\Java\jdk1.7.0_45
set PATH=%PATH%;%ANT_HOME%\bin

cordova platforms add android

///////////cordova cli/////////////////
cordova help
cordova -v
cordova create project_folder
cordova create project_foler app_id app_name
cordova create myapp com.cordovaprogramming.hello Hello

cordova platform add android ios
cordova platforms
cordova platform list

cordova plugin add
cordova plugin add
cordova plugin add
cordova plugin add
cordova plugin add
cordova plugin add
cordova plugin add
cordova plugin add org.apache.cordova.device-orientation
cordova plugin add
cordova plugin add org.apache.cordova.geolocation
cordova plugin add
cordova plugin add
cordova plugin add org.apache.cordova.globalization
cordova plugin add org.apache.cordova.contacts
cordova plugin add
cordova plugin add org.apache.cordova.inappbrowser
cordova plugin add org.apache.cordova.splashscreen

cordova plugin add camera
cordova plugin add c:\dev\plugins\my_plugin_name
cordova plugin add org.apache.cordova.console
cordova plugin rm plugin_name
cordova plugin remove org.apache.cordova.core.file

cordova prepare android
cordova compile android
cordova build android
cordova emulate android
cordova run android

cordova serve android
cordova serve android 8080

npm install –g weinre



D3 gallery


Visual Index

Box Plots
Bubble Chart
Bullet Charts
Calendar View
Non-contiguous Cartogram
Chord Diagram
Force-Directed Graph
Circle Packing
Population Pyramid
Stacked Bars
Node-Link Tree
Voronoi Diagram
Hierarchical Edge Bundling
Voronoi Diagram
Symbol Map
Parallel Coordinates
Scatterplot Matrix
Zoomable Pack Layout
Hierarchical Bars
Epicyclical Gears
Collision Detection
Collapsible Force Layout
Force-Directed States
Azimuthal Projections
Collapsible Tree Layout
Zoomable Treemap
Zoomable Partition Layout
Zoomable Area Chart
Drag and Drop Collapsible Tree Layout
Rotating Cluster Layout
Sankey Diagram
Fisheye Distortion
Hive Plot
Co-occurrence Matrix
Motion Chart
Chord Diagram
Animated Béziers
Zoomable Sunburst
Collatz Graph
Parallel Sets
Word Cloud
Obama’s Budget Proposal
Facebook IPO
Political Influence
Federal Budget
US Trade Deficit
Sequences sunburst
Koalas to the Max
Indented Tree
Rounded Rect
Euro Debt
Labeled Force Layout
Circle-Square Illusion
Voronoi Picking
Zoomable Map
Parallel Coordinates
Hacker News Popularity
Life Expectancy
NCAA Predictions
Wind History
Cubic Hamiltonian Graphs
Force-Directed Voronoi
Trulia Trends
Trulia Trends
Open Budget
Bederson Publications
Force Layout Editor
Open Knowledge Festival
Hierarchical Classification Tree
Gene Expression
d3 Analog Clock Dashboard
Concept network browser
Circular heat chart
Convert any page into bubbles
Directed Graph Editor
Animated wind chart
What makes us happy?
Simple SOM Animation
A mower demo
Map and context with brushing
Binary tree with transitions
D3 JezzBall
Gantt Chart
Day/Hour Heatmap
Sunburst and
Worldwide remittance flows
Language Network
Wimbledon 2012
Force directed tag/site explorer
Bus transit data
Airline data from Fusion Tables
Geographical hexbins
xkcd-style Comic Narrative Charts
GitHub Visualizer
WorldBank Contract Awards
Site or blog concept browser
Global power structure
Choropleth on canvas
Google calendar like visualization
Interactive Sales Data Pie Chart
Wikistalker – Wikipedia Visualization
D3 Cesium – Health and Wealth of Nations
BT Hotspots mapped
CoreNLP Sentence Parse Tree
Publications in journals over time
Another state budget visualization with open api
Interactive Bible contradictions & bar charts [source]
Force Edge Bundling For Graphs
[Source & Docs]
Bullet Charts
Arc Axis
Bar chart with tooltips
Tokyo Wind Map
Dependency Wheel
60 years of french first names
Hip Replacement by State
Compare time series with irregular interval
Table with Embedded Line Chart
Dual-scale Bar Chart
Animated Pie and Line Chart
Multivariate Data Exploration with Scatterplots
Live Power Outages In Maine
Relative Size Of The Planets
AWS EC2 Price Comparison Chart
Hurricane Forecast Path Evolution
Sandy’s Storm Surge
Monthly NCDC Climate Summary
Epidemic Game
UK Temperature Graphs
Data Heatmap with Sorting Functions
Node-Link Tree Showing Branches of Government
3D Force Layout
Rotating Arcs
The Movie Network
Bowls with Liquid
BiPartite Visualization
3D Donut
Graceful Tree Conjecture
Gradient Pie
Top Scorers in 2013/14 Champions League – Breakdown analysis
Sankey: How a Georgia bill becomes law
A game based on d3
Viroscope – virus taxonomy viewer
Twitter & Reddit topics during week one of MH-370’s disappearance
Eurovision song contest voting oddities
Fund Visualization

Basic Charts

Area Chart
Line Chart
Bivariate Area Chart
Multi-Series Line Chart
Stacked Area Chart
Bar Chart
Stacked Bar Chart
Normalized Stacked Bar Chart
Grouped Bar Chart
Donut Chart
Pie Chart
Donut Multiples
Bar Chart with Negative Values
Animated Donut Chart with Labels
Stacked Bar Charts on time scale
Bar Chart Multiples
d3pie – pie chart generator and lib

Techniques, Interaction & Animation

General Update Pattern
Sortable Bar Chart
van Wijk Smooth Zooming
Progress Events
Margin Convention
Focus+Context via Brushing
Difference Chart
Pie Chart Update
Hexagonal Binning
Contour Plot
Build Your Own Graph
Modifying a Force Layout
Spline Interpolation
Dispatching Events
Better force layout selection
v45 web theme using SVG
Interactive force layout