After testing this out on dozens of people and thousands of messages I’m ready to see if anyone else wants to use it. I’m also looking for tips on how to make it even more secure and better (attachments, emoticons) so if you have any ideas please leave a comment. Hopefully you find vanish.io as useful as I do.

Tip

Even though the message is not tied to you in anyway if you’re going to send certain information that doesn’t need an identity to be useful (credit card number, social security, etc) it’s best to do it in a series of messages. For example take the first eight digits of your credit card and send it in one message and take the other eight and send those in another. This just makes it a little more safe.

1
2
3

<script type="text/template" id="template_on_page">
    <p>This is a template from <%=template_engine%></p>
</script>

This works for small pages but on the current app I’m working on I have over 30 templates defined. Not only does this make for a huge (okay, not really that huge) download but it’s hard to find and make changes to the templates.

One of the suggestions people have is to put them in external files which solves the second issue but seems very clunky and if I include 30+ external files they’ll all download on page load no matter what.

The solution, Template Monster. Template monster is a very small and basic script that allows you to queue up or asynchronously download your template files and use them when they’re needed (or just before). This solves both issues; the templates are no longer all stuffed on the page and we can now only download templates when we need them.

I posted it up on Github and tested it with the underscore.js template system but it should work with any template library. Feel free to send pull requests.

https://github.com/ryanrdetzel/Template-Monster

The startapp and startproject management commands now have a –template option for specifying a path or URL to a custom app or project template.

Awesome! What this means is you can setup a project/app just the way you want it and then use that as a template for all future projects or apps you create. So if you like your settings files named foo.py you can do that or if you want your templates directory at the root instead of in each app go ahead and do that too.

I found it fasinating how people setup their projects and I have yet to find another Django developer that does it the exact same way as I do but that might changed now that we have templates. As more people start to create and open source their templates we’ll start to see a trend and some popular ones will surface just like jQuery did for javascript frameworks and bootstrap did for front-end frameworks. Here are my templates in case you’re curious:

Project Template

App Template

Some tips on using django templates

Passing a url

When you’re passing the –template option to startproject or startapp you can use a url instead of a local directory. This means that if you publish your template to a website or Github you can easily start a new project/app with one command:

django-admin.py startproject --template https://github.com/ryanrdetzel/django-base-template/zipball/master --extension py new_project_name

Note: If you’re using github take note of the changes to the path(zipball/master). This tells Github to compress your source into a zipball so it can be downloaded. You’ll have to do this if you want the template option to pick it up.

Template tags in your files

When django is using your template to create a new project/app it does so by rendering certain files through the template engine. This allows you to use tags as you would in a normal django template within your project/app and have them replaced during the process. The startproject provides the following tags.

• project_name – the project name as passed to the command
• project_directory – the full path of the newly created project
• secret_key – a random key for the SECRET_KEY setting

So if in your settings.py if you want the name of your project(maybe for installed apps) you can simpley use ” and when django is creating your project it will replace this tag with the name you passed into the startproject command.

This works for apps too, the startapp commands surfaces the following tags:

• app_name – the app name as passed to the command
• app_directory – the full path of the newly created app

Please note this warning which I did come across when playing with this feature.

When the app template files are rendered with the Django template engine (by default all *.py files), Django will also replace all stray template variables contained. For example, if one of the Python files contains a docstring explaining a particular feature related to template rendering, it might result in an incorrect example.

To work around this problem, you can use the templatetag to “escape” the various parts of the template syntax or don’t use any variables that you don’t want replaced in your templates. ;-) I hit this when I tried to include my app template in my project template. What happend is when I created a new project the tags were replaced with nothing since the startproject command tried to render them first. Instead of escaping I felt it was best to break the app template out anyway so I would use it individually.

Hopefully this gives you enough information on templates to start researching and creating your own. Hit me up in the comments if you’ve published your template, as I said it’s always interesting to see how others setup their projects and I might borrow some ideas from your template to include in my own.

I could give step by step instructions but it’s dead simple and they do a pretty good job of explaining it on their blog. The swap took literaly five minutes and we didn’t miss one single impression during the swap over.

I love you Redis.

Okay, Umm, do you know when the site will be back up? I’ve been using this for all of my invoices and I haven’t been able to get on in days.

Hmm, at first I was a little taken back since I hadn’t thought about nor touched Invoice Journal in over four years. I had forgotten about it, I had neglected it, I had basically written it off but this soft voice reminded me that all though I had written it off she had not and that she actually relied on it to run her business. I was amazed. Being caught off guard and not really sure why it was in fact down I told her I was currently in the car but as soon as I got home I would check on the site and bring it back up for her. The call ended and for the next two hours Invoice Journal kept popping in my head.

Invoice Journal started as a pet project to occupy my time as I commuted on the train into work. I had roughly two hours of free time on the train everyday to do something so I figured why not build something I can use and learn something new in the process. At that point in time I was doing a decent amount of freelance work and being the cheap bastard that I am didn’t want to pay a service like Freshbooks to actually handle my invoices for me so I decided to write my own. From start to finish it only took a couple of months working on the train only and during the process I decided to build it in a fashion that anyone could use it once it was done. I never thought that it could actually catch on or that people might actually use it for real invoices. Boy was I wrong.

Later that evening when I arrived home I checked the server and for some reason apache was not running. I was probably messing with it last week and forget to fix an error in the config but a few keystrokes and she was up and running again. To close the loop I shot the women a quick email and she replied thanking me. Tired from a long vacation I crashed.

The next day while in the shower I thought about Invoice Journal again. I wondered, how many people are actually using the system still? Do people still sign up for accounts? I set a reminder(thanks Siri) to check these stats later that night. A few sql queries later and to my absolute amazement this is was I saw.

Not only were people still using it consistently to invoice clients but 130+ people on average were still signing up each month with zero advertising, zero promotional emails, zero effort at all. WTF? I hadn’t touched this code in over 4 years(4 years, 2 months, and 12 days to be exact), how is it possible that people still signup and use this after all this time. It must have major bugs in it, it must be missing major features that other services offer…this was crazy! Now I’m wondering if I had continued to work on it, if I hadn’t neglected it could it actually be a useful successful, dare I say profitable project?

Now, as for why this is happening I can only guess that I’m offering something a lot of budget conscious people(freelancers) are looking for. I’m really curious to pull some additional metrics like who has the most invoices, what’s the longest running user, and what’s the total dollar amount processed but I’ll save that for another night.

Unfortunately, I don’t have time to fix it up. It’s been way too long and I’ve moved on from Perl(I’m a Python boy now). I’d almost be afraid to look at the code and fix things for fear of breaking it for the people that are actively using it. As far as I can tell I have two options; I can let it run as is or I can find someone eager to take it over….any takers? :-)

First, the damn interface buttons are too small and too close together for quick glances. A day doesn’t go by where I don’t pause instead of skip or skip(Arg!) instead of pause. Since there is no tactical feedback on the iPhone I have to physically look down at the device to change songs; Bad idea when I’m cruising 80 mph down the Mass Pike. Instead why don’t you offer swipe to skip and double tap to pause/play. This would allow me to skips songs and/or play/pause with not so much as a glance at the phone. Here’s the code to implement it.

This code is not complete. My Objective-C is a little rusty but it should get the point across on how easy it is to implement these features. This code was not tested so it might not even work. :-P

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

- (void)viewDidLoad{
    //...Your other magical code

    UISwipeGestureRecognizer *rightRecognizer = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(handleSwipe:)];
    rightRecognizer.direction = UISwipeGestureRecognizerDirectionLeft;
    [self.view addGestureRecognizer:rightRecognizer];
    [rightRecognizer release];

    UITapGestureRecognizer *doubleTap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleDoubleTap:)];
    [doubleTap setNumberOfTapsRequired:2];
    [self.view addGestureRecognizer:doubleTap];
    [doubleTap release];
}

- (void)handleSwipe:(UISwipeGestureRecognizer*)gestureRecognizer {
    // Skip!
}

-(void)handleDoubleTap:(UISwipeGestureRecognizer*)gestureRecognizer{
    //If currently playing
        // Pause
    //Else
        // Play
}

The other thing that really grinds my gears is when you pop up that damn “Sorry, our music licenses…” alert. Sure I get why you have to alert me that I’ve skipped too many times but the alert interface(again while driving) is horrible. I skip(while trying to avoid the play button) and nothing happens. Damn, I have to look down again and I see the message and now I have to look even longer and aim for the OK button to dismiss it. Pain in the ass! A simple audible alert and a modal that fades away would be perfect. Here’s the code, help yourself.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

-(void)handleLicenseWarning{
    /* You already have this function, change that damn alert to this */

    NSURL *soundFileURL = [NSURL fileURLWithPath:[[NSBundle mainBundle] pathForResource:@"bong.mp3" ofType:@"mp3"]];
    AVAudioPlayer *player = [[AVAudioPlayer alloc] initWithContentsOfURL:soundFileURL error:nil];
    [player play];

    UIView *licenseWarning = [[UIView alloc] initWithFrame:CGRectMake(self.view.frame.size.width/2-100,
                                                                                                                                            self.view.frame.size.width/2-50,
                                                                                                                                            200, 100)];
    [licenseWarning setBackgroundColor:[UIColor darkGrayColor]];
    [licenseWarning setAlpha:0.8];
    [licenseWarning.layer setCornerRadius:8];
    [licenseWarning.layer setMasksToBounds:YES];
    [licenseWarning setTag:123];

    UILabel *warning = [[UILabel alloc] initWithFrame:CGRectMake(10,10,180,80)];
    [warning setBackgroundColor:[UIColor clearColor]];
    [warning setText:@"Blah blah, our license..."];
    [warning setTextColor:[UIColor whiteColor]];
    [licenseWarning addSubview:warning];
    [warning release];

    [self.view addSubview:licenseWarning];
    [licenseWarning release];

    [NSTimer scheduledTimerWithTimeInterval:4
                                          target:self
                                        selector:@selector(hideWarning)
                                        userInfo:nil
                                         repeats:NO];
}

-(void)hideWarning{
    [UIView animateWithDuration:0.5 animations:^{
        [[self.view viewWithTag:123] setAlpha:0.0];
    } completion:^(BOOL b){
        [[self.view viewWithTag:123] removeFromSuperview];
    }];
}

I’ll expect these features in your next release which is coming any day now, right?

Instead of diving into the issues with cloudfront and nginx I’ll just provide you with the settings that ended up working for me. The two settings to make note of are the gzip_http_version which is set to 1.0 and the gzip_proxied setting which is set to any. Buffers, comp_level and types can all be changed to fit what you’re trying to serve.

1
2
3
4
5
6
7

gzip on;
gzip_http_version 1.0;
gzip_buffers    4 8k;
gzip_vary on;
gzip_proxied any;
gzip_comp_level 9;
gzip_types text/plain text/html text/css application/x-javascript text/xml application/xml application/xml+rss text/javascript image/png image/gif image/jpeg;

Amazon’s interface for managing this is severely lacking mainly because they’ve built a system on APIs and thus the power comes from taping into those. My plan for this is to write a python script that when run will revoke old rules and add new ones based off the rules defined in the file. There will be three sections; one for ssh access which will be where developers deposit their ips, one for local servers which should only be used for other AWS instances and one for publicly accessible ports(web,ssl, etc)

Here’s how the rules will be laid out in the file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

## Add your home ip addresses here
ALLOWED_SSH = ['23.xx.xx.xx', ## Office
                              ]

## Server IPs that are given full access
INTERNAL = ['10.xxx.xx.xxx', # misc
            '10.xxx.xx.xxx', # static
            '10.xxx.xx.xxx', # solr
            '10.xxx.xx.xxx'  # www
           ]

PRODUCTION_RULES = [
    Rule("tcp", "80",  "80", "0.0.0.0/0", None),    # web
    Rule("tcp", "443", "443", "0.0.0.0/0", None),   # ssl 
    Rule("tcp", "8080", "8080", "0.0.0.0/0", None), # solr
]

The plan is to join these rules and revoke rules no longer in the list and authorize new ones that were added. By breaking it up like this and allowing comments it should be easy to keep our security group clutter free.

Here is the full script that runs nightly.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

import collections
import boto

group = 'ProductionSecurity'
dry_run = True

if dry_run:
    print "** DRY RUN **\nNo changes will be made"

Rule = collections.namedtuple("rules", ["protocol",
                                        "from_port",
                                        "to_port",
                                        "ip",
                                        "group_name"])

## these ips are allowed to ssh into all machines
ALLOWED_SSH = ['23.xx.xx.xx', ## Office
               ]

## Server IPs that are given full access
INTERNAL = ['10.xxx.xx.xxx', # misc
            '10.xxx.xx.xxx', # static
            '10.xxx.xx.xxx', # solr
            '10.xxx.xx.xxx'  # www
            ]

PRODUCTION_RULES = [
    Rule("tcp", "80",  "80", "0.0.0.0/0", None),    # web
    Rule("tcp", "443", "443", "0.0.0.0/0", None),   # ssl 
    Rule("tcp", "8080", "8080", "0.0.0.0/0", None), # solr
]

for ip in ALLOWED_SSH:
    PRODUCTION_RULES.append(Rule("tcp","22","22","%s/32" % ip,None))

for ip in INTERNAL:
    PRODUCTION_RULES.append(Rule("tcp","0","65535","%s/32" % ip,None))

conn = boto.connect_ec2()
groups = [g for g in conn.get_all_security_groups() if g.name == group]
group = groups[0]

existing = []
for rule in group.rules:
    for ip in rule.grants:
        rule_check = Rule(rule.ip_protocol,
                                    rule.from_port,
                                    rule.to_port,
                                    "%s" % ip,
                                    None)
        if rule_check not in PRODUCTION_RULES:
            if rule.ip_protocol == "tcp":
                print "Revoking %s (%s-%s)" % (ip,rule.from_port,rule.to_port)
                if not dry_run:
                    group.revoke(ip_protocol=rule.ip_protocol,
                                from_port=rule.from_port,
                                to_port=rule.to_port,
                                cidr_ip=ip,
                                src_group=None)
        else:
            existing.append(rule_check)

## Fill in missing rules 
for rule in PRODUCTION_RULES:
    if rule not in existing:
        print "Authorizing %s (%s-%s)" % (rule.ip,rule.from_port,rule.to_port)
        if not dry_run:
            group.authorize(ip_protocol=rule.protocol,
                            from_port=rule.from_port,
                            to_port=rule.to_port,
                            cidr_ip=rule.ip,
                            src_group=None)

TODO

One flaw with this system is you have to have access to the code to add an ip. An issue I’d like to solve soon is when you need to add an ip temporarily(coffee shop, airport, hotel, etc). Ideally I’d like to add a system where you email and ip to a certain address and it adds it for you either temporarily or permanently depending on what address you sent it to.

There is also no reason besides laziness that all servers should have all ports open internally. You’ll noticed that all the ips in the INTERNAL list get full access to the other servers which is not a good idea. I should change this to list out what ports should be open and for which servers. For example we probably only need to open ssh, mysql, memcached and redis between the servers.

An old colleague contacted me recently congratulating me on my cool script I wrote. We wont get into the details of the script but it was a bot that performed a certain task and since this person is following me he was able to spot it. Since I’ve worked with him in the past and he mentioned he’s been trying to do something similar I offered up the code. I thought he was going to use it for his job, maybe they were trying to do something similar to what we’re doing so there is no harm in that. After I sent off the code he messaged me back thanking me and telling me his true intentions. He planned on using the script to basically spam the Internet with useless pages filled with ads. Ugh. Maybe I should’ve asked him what he was going to use it for first; maybe I shouldn’t care but either way I couldn’t help but feel responsible for cluttering up the Internet with more useless content. I wish him luck on his ventures but going forward I’m probably going to be more reluctant to share clever code so I can avoid such moral dilemmas in the future.

Pros

• Reboots quickly and easily
• No software updates, no security patches to deal with
• Start/stop additional resources quickly and easily.
• Hot standby is really easy to setup
• Read replica’s are super easy to setup too
• Hot snapshots beat mysqldumps
• Price. It’s nice to start and stop instances when you need more

Cons

• You loose a lot of control so if something goes wrong you feel helpless.
• Along the same lines it’s a shared box which puts you in the dark
• You have to use a round-about system to changed mysql parameters.(turning on the slow query log for example)
• Price. You’re paying more than an ec2 instance and you can only use it as a database server

1
2
3
4
5

<script>
    utmx_func('name');
</script>
This is my default version
</noscript> 

This breaks validation(do people still care about that?) and it looks odd but they are doing something pretty clever here. A quick stop over at jsbeautifier.org let me peek into their code to discover how this works. Basically since there is no beginning noscript tag the default text will always show even if the JS above it breaks which is a must in case something goes wrong(Google shouldn’t break your site). So how does the different version of the code get shown? Simple, when the function runs it prints the new content to the page along with the opening noscript tag which in turn hides the default text. The new content ends up looking like:

1
2
3
4
5
6
7

<script>
    utmx_func('name');
</script>
This is my new text I want shown.
<noscript>
    This is my default version
</noscript> 

I’ve based this project off error codes but you could just as easy use it for normal operations. Maybe when your circuit goes into a certain mode you could change the colors, or when it’s starting up it could be red and when it’s ready to go it could turn to green. An example of this type of operation is the Playstation 3, when it’s turning on and off it flashes and changes colors giving some indication what’s going on while there is nothing on the screen.

Hardware Setup

For my project I’m using a standard Arduino Duemilanove and two RGB LEDs. Since they’re RGB LEDs I’m capable of displaying nine basic error codes.

In addition to the three primary colors you could also display multiple colors at once and/or blink the leds giving an even greater selection of combinations. e.g. two fast blinks means X, while three fast blinks means Y.

Software

This sketch it meant to show you how easy it is to use RGB LEDs to display error messages. This is not a complete sketch but simply a snippet of how I use this in my own projects.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

int led1_red = 1;
int led1_green = 2;
int led1_blue = 3;

int led2_red = 10;
int led2_green = 11;
int led2_blue = 12;

#define RED 0
#define GREEN 1
#define BLUE 2

/* I prefer to name my errors */
#define INVALID_INPUT 1
#define INPUT_OUT_OF_RANGE 2
#define BATTERY_LOW 3

void setup(){
  pinMode(led1_red, OUTPUT);
  pinMode(led1_green, OUTPUT);
  pinMode(led1_blue, OUTPUT);

  pinMode(led2_red, OUTPUT);
  pinMode(led2_green, OUTPUT);
  pinMode(led2_blue, OUTPUT);

  reset_error();
}

void loop(){
  /* My normal code, do some operations */
  /* .... */
  /* Opps, there was an error with the input, lets display an error message */
  display_error(INVALID_INPUT);
  delay(5000);

  /* Later on, we accept some input and it's out of range */
  display_error(INPUT_OUT_OF_RANGE);
  delay(5000);

  /* Lets check the battery and issue a warning if it's low */
  display_error(BATTERY_LOW);
  delay(5000);
}

void reset_error(){
    digitalWrite(led1_red, LOW);
    digitalWrite(led1_green, LOW);
    digitalWrite(led1_blue, LOW);
    digitalWrite(led2_red, LOW);
    digitalWrite(led2_green, LOW);
    digitalWrite(led2_blue, LOW);
}

void display_error(int error_code){
  int led1,led2;

  switch(error_code){
    case 1:  led1 = RED;    led2 = RED;    break;
    case 2:  led1 = RED;    led2 = GREEN;  break;
    case 3:  led1 = RED;    led2 = BLUE;   break;
    case 4:  led1 = GREEN;  led2 = GREEN;  break;
    case 5:  led1 = GREEN;  led2 = BLUE;   break;
    case 6:  led1 = GREEN;  led2 = RED;    break;
    case 7:  led1 = BLUE;   led2 = BLUE;   break;
    case 8:  led1 = BLUE;   led2 = RED;    break;
    case 9:  led1 = BLUE;   led2 = GREEN;  break;
  }

  if (led1 == RED){
    digitalWrite(led1_red, HIGH);
    digitalWrite(led1_green, LOW);
    digitalWrite(led1_blue, LOW);
  }
  else if (led1 == GREEN){
    digitalWrite(led1_red, LOW);
    digitalWrite(led1_green, HIGH);
    digitalWrite(led1_blue, LOW);
  }
  else if (led1 == BLUE){
    digitalWrite(led1_red, LOW);
    digitalWrite(led1_green, LOW);
    digitalWrite(led1_blue, HIGH);
  }

  if (led2 == RED){
    digitalWrite(led2_red, HIGH);
    digitalWrite(led2_green, LOW);
    digitalWrite(led2_blue, LOW);
  }
  else if (led2 == GREEN){
    digitalWrite(led2_red, LOW);
    digitalWrite(led2_green, HIGH);
    digitalWrite(led2_blue, LOW);
  }
  else if (led2 == BLUE){
    digitalWrite(led2_red, LOW);
    digitalWrite(led2_green, LOW);
    digitalWrite(led2_blue, HIGH);
  }
}

Basically what this code does is it calls(displays) three different error messages. If this were a real project these errors would not just loop back and forth but they would only show up when something was wrong. Typically my projects contain 3-6 different errors, the table below shows the different combinations I can display using the above display_error

Below are some additional pictures and a video showing the circuit in action. Do you have any thoughts or ideas for this project, post them in the comments section below? I have a bunch of other ideas that I will be sharing shortly, the RGB LEDs are a great way to add feedback to your Arduino [or other] projects. Simply adding an additional two LEDs to this circuit we could generate over 80 combinations!

Supplies Needed

• 1 x Arduino Duemilanove or equivalent.
• 1 x USB cable to connect the Arduino to your computer
• 1 x Red LED light. Other colors will work but verify the resistor value.
• 1 x 150 ohm resistor

This workshop uses the built in LED on the Arduino Duemilanove. If you’re using an Arduino Duemilanove clone or you would rather use an external LED then you’ll need to connect an LED and a resistor to digital pin 13.

Prerequisites

In order to write and install Arduino projects you’ll need the Arduino software. The software is rather straight forward to install so if you don’t already have it simply head over to the official Arduino website to download the most recent version. Follow the instructions on the Arduino getting started section to complete the software setup process.

Step 1

Lets first hook up the Arduino board. Plug the USB cable into the Arduino Duemilanove board and then into your computer. If everything is hooked up correctly the power led should be lit up on the Arduino board. If you’re using the standard Duemilanove board you are now done with the hardware setup and can proceed to step 2. If you’re using a Arduino clone that doesn’t have a built-in LED or you’ve chosen to use an external LED simply follow the schematic below to attach the resistor and LED to the Arduino.

Step 2

Now that the hardware part is done we can now get started on writing the program(also known as a sketch. Open up the Arduino application and type the below code into the editor; we’ll go over what it does below.

1
2
3
4
5
6
7
8
9
10
11

int ledPin =  13;
void setup(){
  pinMode(ledPin, OUTPUT);
}

void loop(){
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

All Arduino sketches need to have two functions, setup() and loop(). These functions can be empty but they are required. The setup function shown on lines 3-5 is used to setup initial values and is only executed once at the start of your program. This function is called when the Arduino first boots up and then the loop() function is called continuously until the Arduino looses power.

Back to the top you can see that the first line initializes a variable named ledPin to the number 13. For this sketch we’re only using one digital pin and we’ve chosen 13 because on the Arduino Duemilanove this pin is attached to the built-in LED. Having variables at the top like this allows us to easily change them but for simple sketches you could always hardcode the value directly into the function call that use it; for example line 8 could just as well be written as digitalWrite(13, HIGH). Next we have the setup function which as mentioned above is only run when the Arduino boots. For this sketch we need to enable pin 13 as output using the pinMode function. This function accepts two arguments. The first argument is the pin number we want to set the mode for and the second is the mode we want to set that pin to which can either be INPUT or OUTPUT. Basically this tells the Microprocessor how to handle that pin, should it treat it as input and listen for changes or as output and write data to it.

Finally we have the loop function which is run after the setup function and will loop repeatedly as long as the Arduino has power. First we want to set digital pin 13 to high so we can light up the LED. In order to do this we call the digitalWrite function which accepts two arguments, the pin number we want to write to and the value we want to write to that pin which can either be HIGH or LOW. After we set the pin to high we want to pause the program for a certain amount of time so we can physical see the LED light up; the built-in function delay allows us to do just that. The argument passed into the delay function is the amount of time you want your program to pause in milliseconds. For this program we want to pause for 1 second so we delay for 1000 milliseconds but feel free to experiment with this value to make the LED blink faster or slower. Next we do a digital write again on pin 13 but this time we pull the pin LOW to shut the LED off. We delay for another 1 second and then the loop starts all over repeating the cycle of OFF, Delay, ON, Delay until the Arduino loses power.

Congratulations you’ve completed your first Arduino program. Go ahead and compile the sketch, install it on the Arduino and watch the LED blink!

Please note that the information on this page is in regards to the official Arduino Duemilanove. Since the Duemilanoves release in 2009 there have been many clones that work and look very similar. For all intents and purposes these clones should work exactly the same but there may be slight variations in the pin layout and power requirements so please read the datasheet.

Arduino Duemilanove Introduction

The Arduino Duemilanove (Duemilanove means 2009 in Italian) is a microcontroller board based on the ATmega168 or ATmega328. It has 14 digital pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, and a reset button. The Duemilanove comes built with everything you need to get started so using and programming the Arduino Duemilanove is as simple as connecting it to your computers USB port and installing the Arduino software.

While there are a many great things that make the Arduino Duemilanove great I think I can sum it up in two words; simple and flexible. The Arduino is such a great idea, it makes the complex world of microcontrollers so easy that it literally takes ~$30 and a computer to get started.

When the Arduino was born in 2005 the idea was to create an open-source prototyping platform that was built around available and affordable hardware and to release it to the world so that others could not only learn and benefit from it but also contribute back to it. One of the reasons I quickly fell in love with the Arduino was because a simple Internet search returned tons of results including demo circuits, example programs(sketches), and add-on boards(shields). Arduino has released a few boards since 2005 including the Diecimila(now superseded by the Duemilanove), the Arduino Mini/Nano and the Arduino Mega. These products are all great but the Arduino Duemilanove pulls everything the Arduino team has learned over the years into one complete easy to use embedded system.

Arduino Board Breakdown

The Arduino Duemilanove may look intimating at first glance but in reality you only need to know about some main components to take full advantage of what the Arduino has to offer. Lets take a look at the image below and I’ll explain what the numbers represent on the Arduino board.

1. USB connector. The Arduino Duemilanove has a built in FT232RL chip which allows your computer to communicate via TTL serial data with the Arduino. This connector also provides the Arduino Duemilanove with 5v of power when connected to a computer so no external power supply is needed.
2. 2.1mm center-positive barrel plug which allows you to power the Arduino from an external power supply like a wall-wart or battery pack. The Arduino Duemilanove can operate on an external supply of 6 to 20 volts but it’s recommended you provide it with at least 7v to keep it stable and under 12v to prevent overheating.
3. ATmega168/ATmega328 Microprocessor. This is the brains of the Arduino Duemilanove and since it’s in an easy to access DIP-28 package the chip can easily be removed and replaced if needed.
4. Digital pins(0-13) with a GND pin and the AREF(Reference voltage) pin. You can ignore the AREF pin for this is rarely used and it’s not worth discussing in this article.
5. Analog Pins(0-5).
6. Reset, 3.3v, 5v, GND, and Vin. When the reset pin is pulled low the Arduino resets. The 3.3v pin provides 3.3 volts with a max current draw of 50ma. The 5v pin can either be used as a 5v source if the Arduino is powered via an external power supply or a regulated 5v supply can be fed into the pin to provide power to the Arduino. Vin is the voltage in pin and can either be used to access the voltage of an external power source (if provided) or voltage can be supplied to this pin to power the Arduino.
7. The ICSP connector. These pins are used when you want to program the ATmega chip directly and for the most part we’ll be ignoring it.
8. Reset button. A press of this button pulls down the reset pin and resets the Arduino.
9. LED’s. To the left of the number 9 in the picture above we have an LED that is attached to digital pin 13 and the TX and RX LEDs so show when the serial connection is in use. Just under the number 8 is the power LED which illuminates when the Arduino has power.

Now that you’ve had a brief overview of what the Arduino Duemilanove is and what it’s made up of I suggest you head over to our first workshop on Writing your first Arduino sketch. We’ve given you the basics but to fully understand the power and beauty of the Arduino Duemilanove we suggest you get your hands dirty and start creating some stuff!