Duo is a next-generation package manager that blends the best ideas from
Component,
Browserify and
Go to make organizing and writing front-end code quick and painless.
Install It
Install Duo straight from
npm with:
$ npm install -g duo
Getting Started
To get started just write normal Javascript, requiring from GitHub as you need them:
var uid = require('matthewmueller/uid');
var fmt = require('yields/fmt');
var msg = fmt('Your unique ID is %s!', uid());
window.alert(msg);
That
matthewmueller/uid will pull the dependency
straight from GitHub, without you needing to edit any package manifest file!
You can also require modules straight from your file system:
var modal = require('./modal/index.js');
Then use
duo to install your dependencies and build your file:
$ duo index.js
Finally, drop a single
<script> onto your page and you’re done!
<script src="build/index.js"></script>
Same goes for CSS! You can require dependencies and assets straight from GitHub or from the file system:
@import 'necolas/normalize.css';
@import './layout/layout.css';
body {
color: teal;
background: url('./background-image.jpg');
}
Then bundle up your CSS with
duo:
$ duo index.css
And add your bundled-up stylesheet to your page!
<link rel="stylesheet" href="build/index.css">
Features
- has first-class support for Javascript, HTML and CSS
- exposes a unix-y command line interface
- pulls source directly from GitHub with semantic versioning
- supports source transforms, like Coffeescript or Sass
- does not require a manifest
Philosophy
Duo was designed from the ground up to grow alongside your application, making your three main workflows incredibly simple:
- creating quick proofs of concept
- writing modular components
- building large web applications
I. Proofs of Concept
As developers, we often need to test out an idea or isolate a bug. One of the big issues with existing package managers is that you cannot use your package manager without a lot of boilerplate files like
package.json or
component.json.
Duo removes this boilerplate, letting you
require packages straight from your source code:
var events = require('component/events');
var uid = require('matthewmueller/uid');
You can also include versions, branches or paths:
var reactive = require('component/reactive@0.14.x');
var tip = require('component/tip@master');
var shortcuts = require('yields/shortcuts@0.0.1:/index.js');
And the same goes for CSS with
import:
@import 'necolas/normalize.css';
@import 'twbs/bootstrap@v3.2.0:dist/css/bootstrap.css';
You can even directly require
.html or
.json files:
var template = require('./menu.html');
var schema = require('./schema.json');
Duo will take care of the rest, transforming the
.html into a Javascript string, and
.json into a Javascript object.
When you’re ready to build your files, just run:
$ duo index.js index.css
The new files will be located in the newly created
build/ directory, using the same structure as your project.
II. Components
A successful package manager needs to have a strong component ecosystem. Duo supports all of the existing
Component packages out of the box. And, since Duo can load from paths, it supports many Bower packages too.
There are even plans to support Browserify packages as well.
We’re hoping to bridge the gap between all the different package managers and come up with a solution that works for everyone.
To create your own public component, just add a
component.json to your repository:
{
"name": "duo-component",
"version": "0.0.1",
"main": "index.js",
"dependencies": {
"component/tip": "1.x",
"jkroso/computed-style": "0.1.0"
}
}
And then publish your component on GitHub, so that others can install it by simply requiring it into their application:
var thing = require('your/duo-component');
If you’re coming from the Component community, you’ll notice that we no longer need to add
scripts,
styles or
templates. Duo handles all of this for you, walking the dependency tree like Browserify and including everything you need automatically, for both Javascript and CSS!
III. Web Applications
In order for a package manager to be truly useful, it needs to scale to accommodate building entire web applications. Once again, Duo makes this process seamless.
Duo allows for building multiple pages at once, so that you can split up your application into different bundles and keep your page assets slim. To build from multiple entry files, just pass more than one entry into
duo:
$ duo app/home.js app/about.js app/admin.js
You can even use brace expansion:
$ duo app/{home,about,admin}/index.{js,css}
If Duo discovers an asset like an image or font along the way, it will automatically include it in your
build/ directory. Say we have the following image in our CSS file:
@import 'necolas/normalize.css';
body {
background: url('./images/duo.png');
}
Duo will symlink
duo.png to
build/images/duo.png, so that you can serve the entire
build/ directory from your web server.
Examples
To see some more complex examples of Duo in the wild, check out any of these repositories on GitHub:
For more information, read through some of the resources put together by the folks in the Duo community:
The first thing that I noticed about these headphones was that the cord didn’t look like the plastic cord you usually see on a pair of headphones but rather a cord-like what you would see on a boot for a shoelace. This was both intriguing and a little bit disappointing, while I assume that the cable is designed this way to look fresh and possibly for better protection, I, for one, like to have a volume control device on my headphones cord. Still, I had to give the design props because, as I said, the RCA Sport Neckband Headphones looked very cool.
My friend said that the headphones were very inexpensive, under fifteen dollars, and that they had been using them for quite a while and had not noticed any decrease in the quality of sound. I thought that their sound quality was excellent too. Although it is not my favorite design for headphones to have them with a behind-the-neck fitting, these ones were not uncomfortable and very lightweight.
When it comes to canceling out a sound, I don’t think that these are the best headphones, though. If someone is using them and has their music turned up, then everyone else in the room can hear the music, although not clearly, and that can be kind of annoying for surrounding people, plus bad for the person listening to such loud music. When the TV is on, you have the urge to turn the volume up of the music because the RCA Sport Neckband Headphones do not keep out other noises very well.
I would recommend these headphones to anyone who was looking for a pair of headphones that had the behind-the-neck fitting. If you don’t like that kind of accessory or are looking for a couple of headphones that you can use to keep other people from hearing your music, as well as you from hearing other things while you are listening to your music I wouldn’t recommend these and would suggest that you check out the review of the Panasonic headphones that is mentioned at the beginning of this article. All in all, I thought that the RCA Sport Neckband Headphones were great; they just were not for me. 
Managed 
