When I was thirteen, it became pretty clear to me that this would not happen in time, and I began questioning whether we’d actually achieve this in my own lifetime.

Now, a couple of years later, having been astonished by how far Google is with their self-driving Prius (and now Audi TT’s and Lexus RH450h’s as well), empowered by Sebastian Thrun’s Programming a Robotic Car course, and supported by my high school, I have been working a self-driving car of my own.

Taking on passengers might take some more time, though.

Sequences have been lengthened – the actual computation time for updating the probabilities after move and sense is ~6ms each. It’s moving the robot that takes time.

sci-bot: noun A knowing / self-aware robot. From the Latin sciō + Czech robot

The guts

iRobot Create (from iheartengineering.com)
The Create is a decently priced platform (about $200) to base a robot on. Given that it is simply a Roomba without the vacuum cleaner guts means that you get a reliable, tested, and complete system (from battery recharging to motors) with a decent programming interface.

Zach Dodds et al. from the Rose-Hulman Institute of Technology has written a brilliant python wrapper for the Create’s serial interface. I use it because it simplifies commands like move forward at 25cm/s rotating at 30°/s from:

to the more intelligible:

Laptop
The laptop acts as the middle man between the sensors and the robot, the brain some might say, interpreting the sensor data (the robot & LIDAR sensor just plug in over USB) and giving directions to the robot.

Hokuyo URG-04LX URG01 Laser (from Hokuyo)
While not exactly cheap at $1200, a LIDAR (short for Light Detection and Ranging) provides extremely accurate (around ±1 cm, though the URG01 is limited by Hokuyo to ±3 cm) distance information. Measuring distance given the change in phase of a reflected light wave it operates similarly to radar (though radar, using radio waves, is further along the electromagnetic spectrum). Using light rather than sound it is both quicker (after all you hear sound echo, but on a normal human scale don’t see light echo), less prone to interference and works over longer distances (military rangefinders reach 25km!) than say an ultrasound sensor. It may be overkill for a basic robot, but it becomes integral for advancing the robot.

The URG01 provides a 5.6m range over 240° (for reference, the Xbox Kinect sees about 55°) for 683 points along it’s rotation (it’s a laser diode and photo detector that rotate). Rotating at 10Hz (10 times a second) it provides about 6000 data points per second. Weighing 160g, it’s perfect for this application.

right is what the LIDAR sees in our hallway at home, with an outline of the hallway overlayed (one circle is 1m).

Consider it a tiny version of the LIDAR that’s used for Google’s cars and self-driving vehicle research…1.3 million data points / second…Wow!

Velodyne HDL-64E Laser Rangefinder (LIDAR) Pseudo-Disassembled

The brains

The robot uses basic Mote-Carlo localization (a histogram filter) to find out where it is at that moment in time. In other words, given a grid based map of the environment, the code will use probabilities to work out in which cell (or part of the map) it is likely to be. Given that this requires there to be a preexisting map of the world in which the robot is, it is not fully autonomous, or able to make decisions when things happen that you do not expect to happen (for example, somebody is standing in the hallway).

Anyway, it starts by having a map of environment, in this case our hallway at home represented by 1m² squares, or cells. Not only does the robot not know where it is, but it also doesn’t know in which direction it is facing – this becomes a big problem if you tell the robot to drive forward because you think its position is aligned with the North map, but it might actually be facing East, so it hit’s a wall… To counter this, there are four maps, one for each direction North, East, South, and West – in the East one, for example, we assume the robot is facing East, in the South one, we assume South, etc.

Since the robot has no idea where it is or what direction is is facing when it starts, each cell begins with the same probability of 2.8% (1 ÷ (9 cells × 4 orientations)):

Next, we take a look at what the sensor sees. In this case, say it it sees a wall to the left, space in front, and a wall to the right (in the code I’ve written, that is represented as [1, 0, 1]). With this new data, we can now cycle through all the cells and if this sensor measurement is what we’d expect at that location and orientation, we increase it’s probability, and if it is not, we decrease it. So this is what we get after the first sense:

And we see that it is unlikely that we’re facing East – after all, there is not a cell (facing east) in which we’d expect such a sensor reading.

Next up, we move the actual robot (after all, what use is it stationary?). The measurements from the LIDAR told us there is space ahead, so we move forward. If we can move to a particular cell, its probability becomes the probability of the cell that we moved from plus the probability that it stays on that cell (the robot’s movement is not perfect, so to factor that in, we add the (unlikely at about 10% – a value that I (somewhat arbitrarily) made up) chance that it doesn’t move). So, probabilities are shifted around and are changed a bit depending on whether we can move to a cell, or whether the robot breaks down. This forward movement then gives us:

Note how the probabilities have shifted and changed slightly.

Once we have a map (the first step, where each cell has a uniform probability) we just loop through sense() and then move() until we’ve either reached our destination or are happy with the result. So next there’s sense again with a reading, say, wall to the left, wall in front, and space to the right or [1, 1, 0]:

So, now there are three points where we’re (equally) likely to be. To improve the accuracy, we continue the loop with a move. This time, however, with the reading from the lidar saying that the only free space is to the right, we need to turn the robot 90° to the right, and then move forward. Since we change orientation, we need to move the maps as well. In this case, we turn right, so all the probabilities of the North map become the East map, all the probabilities of the East map becomes the South map, and so on. After the map turning, we just apply the normal move updating of probabilities – shift them and update them to include the chance of a failed move:

Continuing the loop, there is sense again with say, wall to the left, space in front, and wall to the right or [1, 0, 1] and we get the wonderful result of:

and there, after moving only 2 meters, the robot has a pretty decent idea of where it is and which way it is heading. If only the real world were so easy!

You may notice that the movement in this case was the same as in the video earlier. You might also have noticed that we got slightly different results this time round. The reason for this, is that for some reason (I’m still not sure myself) the robot sensed that there’s nothing in the way or [0, 0, 0] instead of wall to the left, space in front, and a wall to the right or [1, 0, 1] right at the start. Thus, since [0, 0, 0] isn’t something we’d expect so see anywhere in the map, we lost that first piece of information and just moved forward without sense updating the probabilities. It is because of this (the sensor is sometimes wrong), that there’s also a factoring of the sensor data, though it is unlikely (I guessed it at 1%) that this will happen.

In retrospect, I suspect it might be because the LIDAR was still turning on, and since it runs in a separate process (on a separate core), the code didn’t realize that. Something that needs investigating.

Another pattern that you may have picked up, is that while sense adds information, the move function will sometimes make you lose information. This happens when the robot is driving up the straight part of the hallway (again, in the video) and is 83.2% sure that it that cell at the beginning, but by the end of the corridor, this drops to 64.8%. This because moving is far less reliable than sensing, so when we move in a straight corridor we begin to lose information. That’s not to say that move can’t add information, though – for example when turning corners (corners are fantastic for localization!).

Thankfully, computers exist to do all this menial computation for us, and to change this from a theoretical learning task to a practical application one, I’ve written this all up in python (3.2). The full code is available on GitHub: https://github.com/ahrensmalte/scibot and you don’t need a robot, gyroscope, or lidar to run it! (the localisation)

A few notes about the code though:

• The lidar data gathering and interpreting runs in a separate process (not thread) to improve performance – most computers these days have more than one core, so why not use it? This means, however, that all serial communications, and so, need to run in that process, alas the readability and debuggability is somewhat affected. The performance improvements, however, I believe are worthwhile – cutting down time between computation and moving the robot from 1 second to almost instant (it still stutters though because it’s not a continuous map and planning, but discrete)
• Gyroscope accuracy still leaves something to be desired (even after temperature calibrating it each time the robot is turned on – see sensors.py)

What’s next?

• Taking the robot into a different (read more complicated) environment and seeing how it handles there
• Using multiple sensor inputs to provide a more accurate output – for example using both the inbuilt wheel encoders and the gyroscope to measure turns (the gyroscope does not always pick up the start of the turn while the robot is still accelerating (linearly, nor radially) though is very accurate once it is in motion and the wheel encoders which aren’t precise, but do provide a rough guess)
• Implementing A* (pronounced a star) so that once the probability is above, say, 90% the robot turns around and heads back to it’s ‘home’ location
• Changing the current binary sensor output (wall-or-not) to a staggered one, which would allow the robot to traverse areas that don’t have at least two walls at each position – this would also allow the grid resolution to increase (the hallway, being 1m wide, was perfect for this basic implementation) so you’d get some more creative paths since there’s more than 9 places where the robot can be
• Using path smoothing for more…elegant turns
• Looking at more advanced Mote-Carlo localization implementations, like the ones discussed in this paper from Frank Dellaert, Dieter Fox, Wolfram Burgard, and Sebastian Thrun
• and of course, an implementation where the robot can be in a completely new environment, and map it. SLAM (Simultaneous Localization And Mapping) comes to mind, though landmark detection is probably going to be the challenge – their’s RANSAC (RANdom SAmple Consensus) and a couple of other landmark detection algorithms

endnote: To CS373 roboticist’s reading this, the process of physically implementing what we learn (this probably applies to all education) adds a whole new level of understanding to what we do in class – I highly recommend it.
and to those you prefer the names Robo, Robert, Robotina, or Robbie (did I spell that right?): sorry, I used the gender equal and more ambiguous (perhaps derogatory though?) name scibot here instead. To those who enjoy playing cards: sorry, I actually do too.

Note: All charts are interactive, so grab your mouse and hover over them! Also, you can download a PDF copy here.

Countries with a minimum legal age for marriage (women) below 18 years (per UNSD, Gender Info 2007):

Andorra – 16 (2001)	Argentina – 16 (2002)	Armenia – 17 (2002)	Austria – 16 (2003)
Azerbaijan – 17 (2007)	Barbados – 16 (2002)	Benin – 15 (2005)	Bolivia – 14 (1995)
Burkina Faso – 17 (2005)	Cameroon – 15 (2000)	Congo Dem. Rep. – 15 (2006)	Costa Rica – 15 (2003)
Dominica – 16 (2003)	Egypt – 16 (2003)	Equatorial Guinea – 12 (2004)	Gabon – 15 (2005)
The Gambia – none (2005)	Guinea – 17 (2007)	Indonesia – 16 (2007)	Iran – 15 (2003)
Israel – 17 (2003)	North Korea – 17 (2005)	South Korea – 16 (2007)	Kuwait – 15 (2004)
Luxembourg – 16 (1997)	Maldives – none (2001)	Mali – 15 (2006)	Mexico – 14 (2006)
Mozambique – 14 (2007)	Niger – 15 (2007)	Pakistan – 16 (2007)	Paraguay – 16 (2005)
Peru – 16 (2007)	Portugal – 16 (2003)	Republic of Moldova – 16 (2006)	Romania – 16 (2006)
Saudi Arabia – 17 (2003)	Thailand – 17 (2006)	Togo – 17 (2006)	Turkey – 17 (2005)
Uganda – 16 (2003)	Ukraine – 17 (2003)	Uzbekistan – 17 (2006)	Vanuatu – 16 (2007)
Venezuela – 14 (2006)	Yemen – 15 (2002)

That is 46 countries with a legal marriage age under 18 years, but is this illegal under International Law?

Under the Universal Decleration of Human Rights (1948):

and elaborated in the Convention on the Rights of the Child (1990):

the UN clearly recommends the minimum age of marriage to be 18. Individual countries, however, can still set their own age (un.org). So, in a country like Niger where marriage under 18 (minimum age of 15) is allowed, provided the child, the parents, and a judge agree, child marriage is legal.

Unfortunately, in most cases it doesn’t happen that way, and be it due to poverty, tradition, or gender (in)equality (Girls not brides) children are forcibly married.

But, does this just happen in countries with such a low legal minimum age?

There appears to be a correlation between the legal minimum age and the average age of marriage, however it is not necessarily clear whether this is a causation (cum hoc ergo propter hoc). If we limit the data to just Africa, however, a slightly smaller subset of global cultures, we see that this correlation continues, suggesting that the age at marriage is affected by the legal minimum age and not just external factors like tradition or culture.

Once the legal age is above 18, though, this effect is less pronounced.

Interesting to note, is that the countries: Nepal (legal age: 20), Papua New Guinea (legal age: 21), and Sierra Leone (legal age: 21) all have an average age when married below their respective legal ages (19 vs. 20 for Nepal, 20.8 vs 21 for Papua New Guinea, and 19.8 vs 21 for Sierra Leone). There is clearly something going on there…the rule of law does not necessarily play such a guiding force as we might have thought.

Conversely, as the red line (denoting an average age at marriage of 18) suggests with only Niger at 17.6 years (1998) and Saw Tome and Principe at 17.8 years (1997) having an average age under 18 years, regardless of the law, the average marriage age is almost-universally above 18, i.e. not child marriage.

But all these inferences need to be kept in context: we are just looking at the average ages here, something that can very easily be distorted by a couple (relatively speaking) of outliers. There is another statistic, however, that we can look at, the proportion of women now aged 20 to 24 that were married when they were still children.

Combining this dataset (which, admittedly, doesn’t have each country’s figures for 2011 – Liberia’s stats come from 1986!) with data from the US Census for that year, we can work out a rough number of women 20-24 who were married as children.

Countries sorted by number of women 20-24 who were married as children

United Nations Statistics Division Gender Info 2007 and US Census

Country	Legal Age of Marriage	Child marriage among women 20-24	Number of women married as children
India	18 (2003)	46% (1999)	20.7 million
Bangladesh	18 (2003)	65% (1999)	4.1 million
Nigeria	no data	43% (2003)	2.6 million
Indonesia	16 (2003)	24% (2002)	2.5 million
Brazil	21 (2004)	24% (1996)	1.8 million
…
		Total:	47.4 million

The Girl Effect and Girls not brides quote that around 10 million girls aged under 18 are married worldwide every year. Staggeringly, even with this limited dataset (both in terms of countries and up-to-dateness) we get a similar figure – with 47.4 million women who were married as kids over 5 years of data (ages 20, 21, … 24), a number that we assume to stay ‘steady’, therefore as every year one ‘year’ leaves this dataset and a new one comes, we can only assume that around 9.54 million girls become new child brides every year.

10 million girls every year.

Originally, we looked at the impact that the legal age has on the average age at marriage, and we found a general trend that a higher legal age brings a higher average age. This new data, however, shows that 71% of these 10 million child brides – that’s 6.8 million girls – live in countries where the minimum legal age for marriage is at or above 18.

The law, clearly, doesn’t have the sort of impact that it should, and that we need it to have. Additionally, even in countries with a legal age under 18, for example Uzbekistan at 13% (2001), Armenia at 19% (2000), or Turkey at 23% (1998), all with a legal age of 17 (2003, 2004, 2007 respectively) the rate of child marriage is acutely lower than that of Bangladesh at 65% (1999) or Nepal at 56% (2001) both with legal age at or above 18 (18 (2003) and 20 (2001) respectively).

Yet with or without law, the horrors still continue.

With child marriage, comes a great difficulty for the child to abstain from sex, or insist on condom use and such, they are exposed to serious health risks such as premature pregnancy, sexually transmitted infections, and increasingly, HIV/AIDS (UNICEF Child Protection Information Sheet).

A trend that is clear when looking at the adolescent fertility rate, the number of births per 1,000 women aged 15 to 19.

If we limit the data to the five countries with the highest rate of child marriage, this relation is definite.

Women 20-24 who were married as children, Adolescent fertility rate

UNSD Gender Info 2007 and World Bank World Development Indicators

Country	Child marriage among women 20-24	Adolescent fertility rate (births / 1,000 women)
Niger	77% (1998)	199 (2010)
Chad	71% (1997)	145 (2010)
Bangladesh	65% (1999)	73 (2010)
Guinea	65% (1999)	143 (2010)
Mali	65% (2001)	176 (2010)
…

Niger, Chad, Guinea, and Mali, all countries with staggeringly high rates of child marriage, make up the four highest rates of adolescent births.

With the asymmetric power complex of a child marriage, it can only amplify any traditional or religious reluctance towards the use of contraceptives, the same contraceptives that would protect against premature pregnancy (which can create health complications in both mother and child, CDC), malaria (the risk increases during pregnancy, especially when the mother is under 19, National Institutes of Health) and sexually transmitted infections. As is shown when looking at contraceptive use around the world.

Contraceptive prevalence rate, women 15-49 UNCF The State of the World’s Children 2006-2010

Unmet needs for family planning UNSD Millennium Development Goals Database

Countries that have unmet needs for family planning, for contraceptives, are largely those that have the lowest contraceptive prevalence rate. When you sum the rate of use with the unmet needs for family planning, you get the proportion of people that are either using, or would like to use contraceptives. Surprisingly, this number is largely stable throughout different regions in the world, averaging at about 70%.

Stable, that is, (largely) everywhere except Sub-Saharan Africa (a lot of countries aren’t in the Millennium Development Goals Database for Unmet needs for family planning and such, they aren’t represented in this) where the rate stands around 40%, a lot lower than the average, and even lower than that of developed countries.

This is as we inferred, these Sub-Saharan countries, particularly Mali, Niger, and Chad, the same ones that have high rates of child marriage, and child fertility, dominate as countries with a low use of contraceptives and unmet needs. Right here looks to be one of the places where an increased (education, acceptance, and) use of contraceptives would be most useful in preventing this cascading chain, starting with chain marriage, from continuing.

When girls get married, particularly if they have a child to care for as well, they are likely to drop out of school. Even worse, with this lack of contraceptives, their own children may themselves struggle with their education (Melinda Gates) – with an increase in the number of children, so does the difficulty in feeding them all increase. This continues to be represented in our own data (note the correlation between countries with a low secondary school enrollment (which is around when puberty starts, which is around the age that children are married at – though some are as young as 7 (Washington Post) and a high rate of child marriage).

Primary School enrollment ratio (for girls) UNESCO Primary education (ISCED 1) Net enrolment rate

Secondary School enrollment ratio (for girls) UNESCO Total Secondary Net enrolment rate

Women 20-24 who were married as children, Primary & Secondary Enrollment rates

UNSD Gender Info 2007 and UNESCO Primary education (ISCED 1) Net enrolment rate, Total Secondary Net enrolment rate

Country	Child marriage among women 20-24	Primary enrollment	Secondary enrollment
Niger	77% (1998)	56.6% (2011)	7.8% (2008)
Chad	71% (1997)	51.1% (2003)	5.4% (2004)
Bangladesh	65% (1999)	no data	no data
Guinea	65% (1999)	70.5% (2010)	22.3% (2009)
Mali	65% (2001)	58.8% (2011)	25.4% (2011)
Central African Republic	57% (1994)	60.4% (2010)	7.9% (2009)
…

The relation is clear (secondary enrollment is also impacted by poverty and economic issues as well, but child marriage does make a difference); being married as a child, dramatically decreases secondary school enrollment.

And, without a proper education, you likely can’t earn the money that you need to escape poverty, which you need to escape child marriage, which you need to escape child births, which you need to escape dropping out of school.

ad infinitum.

These numbers, abstract as they may be, show the magnitude of this problem. One that needs to be addressed, and now.

How do we stop this vicious cycle?

• The law is what we started this piece with, yet the figures that 10 million girls become child brides every year – 71% of them from countries with a legal age at or above 18 – and that countries like Armenia, Turkey, and Uzbekistan with legal age less than 18 yet have drastically lower child marriage rates, show that the law makes less of an impact than one would have thought (enforcement of the law is another issue)
• Increased availability of contraceptives gives women the power to plan their own lives, it gives them the power of self-determination. With this, a woman can decide when and how many children she would like to have, a power that will enable her to space her children apart, improving both her own health (Mayo Clinic) and giving her the opportunity to care for her own child, right when they need it the most. Religious hierarchies (like the Catholic Church / Pope) can make this difficult, but to quote Melinda Gates, ‘let the women in Africa decide’ (Melinda Gates talking about contraceptives in Africa)
• Education empowers people, it allows them to take control of their life, and it can help take them out of poverty (Office of the High Commissioner for Human Rights). Education can raise awareness in communities about these issues (for example, can you imagine someone not being aware that contraceptives exist? Imagine a World… Without Contraception, Imagine a World…Where You Don’t Know Contraception Exists), and awareness changes traditions (Girls not brides). To quote Graça Machel, ‘traditions can change because they are made by people’
• By decreasing poverty, kids will be able to remain in school for longer and avoid a child marriage (something that, sadly, is sometimes done because the family cannot afford to take care of their daughter, International Center for Reasearch on Women – particularly with the exchange of wealth during a marriage, present in South Asia and sub-Saharan Africa).

Child marriage, and its implications of an unfinished education, a worsened health, and the removal of one’s liberty, is an abuse of human rights, abusing those most vulnerable in our society. But, what can *we* do about it?

How can *we* make a difference?

• Learn more about the issue (MIT’s MOOC (Massive Online Open Course) 14.73x: The Challenges of Global Poverty looks like a great introduction into the economic side of the issue), make up your own mind, and then spread the word
• Petition your government to provide aid / support for the above steps (for a list of countries that have pledged for providing contraceptives see London Summit on Family Planning pledges – Australia is one of them!)
• …

Notes:

• Data was sourced from UN Data and the US Census. I also looked at The World Bank Data but didn’t up using that site.
• You can download a copy of all the csv and Excel files that I used / edited here (zip folder)
• Besides using Excel (both VLookup / AverageIfs / SumIfs and scroll-select-copy-and-paste!), I used Python (3.2) to convert the csv files to the JavaScript array that Google Charts wants. You can download the code here
• Take a look at Gap Minder for a fantastic way to visualize the change in data over time
• If I have made any [statistical, legal, cultural, or otherwise] mistakes, please point them out, and then I can correct them
• Besides my (still going…) high-school education which has empowered me to make this informed research, I would like to thank Sebastian Thrun for his Intro to Statistics class on Udacity (which certainly helped!), and Rob Flavell (who also blogs on data visualisation)

Where I’m currently at – that RC car controlled via an Arduino.

I saw David Singleton’s Neural-Networks Car, blog.davidsingleton.org/nnrccar, and that’s where I decided to start – converting that old RC car into an Arduino controlled one. The key from David Singleton being, controlling the remote via Arduino rather than directly controlling the car via Arduino (which would probably require some a lot of disassembly of the plastic mold).

After taking apart the plastic shell of the remote, I needed to find how to connect up the Ardiuno. The method I used was:

1. Find ground (or just use the negative terminal of the battery) and connect one end of a wire there
2. Look for the switches (forward / back, left / right) on the circuit board
3. With the car & remote on, begin touching the other end of the wire to parts of the circuit and see what happens

Once you’ve found that connection (you’ll notice that the car begins to move…), that’s (between there and ground) where you’d add the transistor (a transistor is like a tap, with the base being the valve). Setting the Arduino pin (which you connect to the base) to LOW or HIGH then controls whether current can flow through the transistor, in essence, an electronic switch.

After playing around with that for some time, and buying 90cents worth of transistors (the 2N2222A NPN transistor) I was able to get it to work (connecting the Arduino’s ground with the remote’s ground, and having the transistor the right way round, were two things that I learnt in particular).

Image based on Howard Logsdon’s work at wiki.hplogsdon.com/Arduino/. GPL licensed.

Made with circuitlab.com

Writing the code for the Arduino isn’t too difficult since you only need to turn the pins on (HIGH) or off (LOW), since that’s all that’s needed to make the transistors conduct.

int left = 3;
int right = 5;
int back = 9;
int forward = 11;
void loop() { }
void setup()
{
//set up all the pins as outputs
pinMode(left,OUTPUT);
pinMode(right,OUTPUT);
pinMode(back,OUTPUT);
pinMode(forward,OUTPUT);
//begin driving straight ahead...
digitalWrite(forward, HIGH);
delay(1000); //wait 1.0 seconds
//turn a bit to the left...
digitalWrite(left, HIGH);
delay(500); //wait 0.5 seconds
//turn a bit to the right...
digitalWrite(left, LOW);
digitalWrite(right, HIGH);
delay(500); //wait 0.5 seconds
//drive ahead again...
digitalWrite(left, LOW);
delay(1000); //wait 1.0 seconds
//stop
digitalWrite(forward,LOW);
}

What’s next?

Currently, the Arduino / robocar is explicitly programmed, which is rather boring in comparison to giving it autonomy. So next up, I plan to experiment with using the Kinect’s depth image together with some code from Sebastian Thrun’s class…

My hallway (with a box in the way) as the Kinect sees it. Can you see the possibilities?

PowerPoint: https://skydrive.live.com/view.aspx?cid=A45FE702DE180B23&resid=A45FE702DE180B23!7420
OneNote Demos: https://skydrive.live.com/edit.aspx/Public/Demo?cid=a45fe702de180b23

Having used my tablet (almost) exclusively for the past two and a half years, I felt that I needed to revisit some of the other technologies available for education.

I started off with paper, which because of its sheer versatility will likely be with us for a long time to come (that is until every surface becomes a ‘screen’ as in Microsoft’s Future Vision video). Being cheap, light, and everywhere, it’s great for quickly jotting something down, demonstrating something, writing short notes, and the list goes on, but that’s about the only area where it comes out as the best – it’s messy (erasers don’t work 100%, you’re limited to a finite surface, you can’t easily add stuff from other sources, etc.) and difficult to organize. In the past year and a half, I’ve collected all the paper that we were given at school and that which we need to print out. Staggeringly, it comes to about 4000 sheets. That’s over 15kg of paper – more than enough to cover a tennis court! Very difficult to organize.

Next up I tried Apple’s iPad, which being nice and light and having a great battery life seemed like it could solve some of the organizational issues of paper, while keeping its versatility. In terms of hardware it is almost there (at least one USB port would be great though), except for one major issue – there is no digitizer, i.e. no way for the OS to recognize that a stylus is touching the screen. There are some creative ways around this including the Jot Pro capacitive stylus and iOS apps that have a ‘zone’ for you to rest your hand on (the program simply ignores the capacitive touches that the OS recognizes from that area), but the end result still looks like it was made with Microsoft Paint:

So much for an improvement in neatness.

The iPad has some great apps that are very useful for discovering information like interactive periodic tables (The Elements), but in terms of research, where quick referencing and being able to see two things at once (ala Windows 8 split screen) are paramount, or for taking notes where it [the iPad] is little more than a glorified piece of paper, its not on par with OneNote on a Tablet (see below).

Tapose (think Courier for the iPad) looks extremely promising and should address some of these issues (though will likely fall short for writing (with a stylus) due the iPad’s hardware (or lack thereof)).

Other students at school sometimes use Microsoft Word for taking notes in class, something that I do not completely understand. Sure, it’s a piece of software that most people are ‘familiar’ with, but typing out notes and painstakingly using [Insert → Shapes → {shape}] (repeat), or taking down diagrams on a separate sheet of paper, is not only slow & inflexible, but seems to perpetuate the idea that note-taking is like taking down a transcript. Students aren’t hansard’s (the people that transcribe everything said in parliament), and note-taking isn’t about transcribing everything – it’s about understanding. For the same reason why we sketch things before we go and make a mock-up, taking notes in low fidelity format, e.g. writing and drawing (by hand) helps us to understand. Using a high fidelity environment like Word, which was designed for printing not drawing, then impedes your learning because your focused on making the content look good, rather than understanding it.

So that just leaves OneNote on a Windows tablet (the iOS app is useful for little more than viewing rather than creating notes). It is not perfect, especially in terms of hardware (ultrabook-style tablets & slates should improve on this though), spontaneity (grab tablet out of bag → remove pen → put password in → switch to OneNote) and interface (the ribbon interface, while being great for mouse input, does not work that well with touch, especially when using your finger), but for schools (especially higher education) it is the best that we have.

Portable: A tablet with a weight generally under 2kg (or down to an almost-there 860 grams with the Samsung Series 7 Slate) is rather portable, especially when compared to (in my case) about 10kg of books and pens. It means that whether I’m getting to school, moving around the school, or coming home again, all that I need to carry with me is my tablet. No printing (mostly, unfortunately), no paper (mostly, again unfortunately), and no heavy books.

Organized: One of the primary advantages of doing work electronically is searchability. With OneNote’s ability to index text, ink, images, and audio, all my work is easily accessible (well most of the time – provided that I can remember what I’m looking for…, but still a lot easier than sifting from thousands of sheets of paper). With all my work in one place (exercise books, questions, solutions, web research, tests, scanned copies of exams, etc.), in OneNote , it is incredibly easy to back-up, and with SkyDrive, OneNote does it automatically – very useful in a school environment where things get lost and damaged.

Flexible: Since this is a tablet, switching between text or touch input is as easy as raising your finger and touching the screen. This means that you can take your notes and draw diagrams in ink, and then with the same machine, and very quickly, start doing research (especially web searches), or work on that report, with the keyboard. Additionally, with OneNote, you can also drag-and-drop content (images, tables, text, etc.) onto the page.

One challenge however, is a bit strange.

The challenge (ChallengeGeometricSeries) asks you to work out the Geometric Series where the first value is 7, and the sum of the first two values is 21.

A geometric series is the sum of a collection of numbers that increase geometrically, i.e. by a common ratio. A geometric series is calculated by:

Where:

• x is the number of terms to include (i.e. the first x terms)
• Sum_x is the sum of the first x terms
• a is the first value in the series
• r is the ratio between values

For example if we want to know the sum of the first 5 powers of two ( 2 + 4 + 8 + 16 + 32 ) (which increase by a ratio of two) it would look like this:

Coming back to Pex for fun, using the sum formula above, we therefore know that the sum of the first x values will be:

What got me thinking was that it said that the secret implementation result where x is 63 (i.e. the sum of the first 63 values of the secret sequence) is negative 7:

Not only does the sum of the first 63 values not equal to (they add up to approximately 3.23 × 10¹⁹), but it is mathematically impossible to get a negative result (the ratio, r, is bigger than 1, therefore r^x will always be a positive number).

Taking this to Visual Studio to do some debugging, the reason behind the fishy answer of -7 clear. An int in C#, by default, is a signed 32-bit integer, i.e. its possible values are limited to between -(2³²) and 2³¹ – 1 (between -2,147,483,648 and 2,147,483,647 ). Knowing this, it is clear why the secret implementation result is not the right answer (it is too big to store in an int data type), but why is it negative 7?

This is because in calculating the power through a loop, e.g.
static int Power(int startnumber, int power)
{
 int total = 1;
 for (int i = 0; i < power; i++)
  total *= startnumber;
 
 return total;
}

Once the limit of a (32-bit) integer has been reached (obviously it would be better if the Puzzle method were to be a double rather than an int), rather than giving an exception, the number (in this case total) goes to zero. When this comes back to the Puzzle method, the return value becomes -7 because

static int Puzzle(int x)
{
 int a = 7;
 int r = 2;
 
 return a * ((Power(r,x) - 1) / r - 1);
}
 Fishy.

Like this (a custom button in a custom tab in the ribbon):

This is a tutorial / guide on how to do this.

Rather not view this in a web browser? Ok, here’s the pdf and xps documents of this tutorial

This has been tested with Visual Studio 2008 Professional and Visual Studio 2010 Professional.

• Download the Visual Studio 2008 source code
• Download the Visual Studio 2010 source code

Part 1 – Creating the project

Whereas the “common” (not that OneNote isn’t) office programs, like Word, PowerPoint, Outlook, and Excel, all have VSTO (Visual Studio Tools for Office) templates, making it really easy to create add-ins for those programs. OneNote does not, but it does share a very similar add-in architecture.

1. Open Visual Studio as Administrator (so that Visual Studio can register your add-in with COM Interop)
2. New Project → [Your Language of Choice] → Windows → Class Library

   
   

   For this tutorial we will choose .NET 3.5 and C#, but you can choose what you want

3. First up we need to make the application COM-Visible
   
   1. Right-Click on the Project → Properties
      
   2. Application tab → Assembly Information
      
   3. Select ‘Make assembly COM-Visible’. This makes the class library / .dll generated by the project visible to OneNote.
      
   4. Click OK
   5. Build tab → Register for COM Interop. This gets Visual Studio to automatically register the application for COM Interop when it’s built.
      
4. To make debugging and building the project easier, we will change the AssemblyVersion attribute to automatically increment. This way, we won’t have to always update this attribute each time we want to update your application
   1. Open: Properties → AssemblyInfo.cs
      
   2. Change the following:
      [assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
      to:
      [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyFileVersion("1.0.*")]

Part 2 – Creating the Ribbon

The Fluent UI or Ribbon in Microsoft Office (the ‘new interface’) was launched with Office 2007 with the ‘common’ programs (again, not that OneNote isn’t) first – Word, PowerPoint, and Excel. In 2010 it came to the others, OneNote, Outlook, etc. Since the Fluent UI is controlled by an XML file, extending it (at least visually) is quite easy. So, our second step is to create an XML file that will contain this code to extend the ribbon:

1. Add a XML file to the Add-In Project (Right Click → Add → Add New Item → Data → XML File). Call it something like ribbon.xml

   

2. To make this XML file readable by our add-in during runtime we will make it a resource (so that it is embedded in the .dll created).
   1. Right Click on the Project → Properties → Resources → ‘Click here to create one’

      

   2. Next, just Click-and-drag ribbon.xml into the Resources box

      

3. MSDN has a great introduction to XML and the Ribbon. See: http://msdn.microsoft.com/en-us/library/aa338202.aspx Basically, we need a Tab (our own or an already existing one) to place our Group – a collection of controls – filled with our controls.
4. The XML document to customize the ribbon starts with:

   <?xml version="1.0" encoding="utf-8" ?>
<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui">
 <ribbon>
  <tabs>
   <!-- Our content goes here… -->
  </tabs>
 </ribbon>
</customUI>

5. In order to display images in the ribbon, they need to be parsed in a special way. We will do this later on in this guide, but we need to set-up the function so that we can do this. Just add the following attribute to the <CustomUI> element:

   loadImage="GetImage"
   so that it looks like this:
   <customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" loadImage="GetImage">
 ...
</customUI>

6. In the ribbon, the first thing that we need is a tab. Either we can hook into an existing tab or we can create our own. For this demo we will create our own tab. If you want to extend an already existent tab, check out the Control IDs (http://www.microsoft.com/downloads/en/details.aspx?FamilyID=3f2fe784-610e-4bf1-8143-41e481993ac6 ). Just replace id="" with the idMso="[the control id]" (without square brackets).

   All that a tab needs is an id and a label:

   <tab id="tabCustom" label="Custom">
</tab>

7. Next we need a group in which to place our controls. Again this can be our own group or an already existing one. For this demo we will create our own Group. Again, all it needs is an id and a label:

   <group id="groupHello" label="Hello">
</group>

8. In this group we place our controls – for example Buttons, Menus, Checkboxes, etc. For this demo we will just add a simple button. Again it needs an id and a label, but we will also change (the next ones are optional) its size to large (for a big button), and add a tooltip. Also, we need to give it the path to the image and we need to give it an onAction function (basically the OnClick() event):

   <button id="buttonHello" label="Hello World!" size="large" screentip="Press this for a 'Hello World!' message" onAction="showHello" image="HelloWorld.png" />

9. This is what it should look like now (like this):

   <?xml version="1.0" encoding="utf-8" ?>
<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" loadImage="GetImage">
 <ribbon>
  <tabs>
   <tab id="tabCustom" label="Custom">
    <group id="groupHello" label="Hello">
     <button id="buttonHello" label="Hello World!" size="large" screentip="Press this for a 'Hello World' message" onAction="showHello" image="HelloWorld.png"/>
    </group>
   </tab>
  </tabs>
 </ribbon>
</customUI>

Part 3 – Writing some code

With the ribbon done, next up we need to hook up the ribbon's events, and get
our add-in to do something.

1. Go to Class1.cs (you can rename it if you want, just be certain that if you change the class name public class [classname]), you update the ProgId as well)
2. Add a reference (Right-Click on References → Add Reference…)
   
   to the following:

   Tab	Name
   .NET	Extensibility (note the capital E) (for the COM Add-In code)
   .NET	System.Windows.Forms (for a MessageBox)
   .NET	System.Drawing (for putting Images into the ribbon)
   COM	Microsoft OneNote 14.0 Object (Type for VS2008) Library (for the OneNote API)
   COM	Microsoft Office 14.0 Object Library (for Ribbon Extensibility)

   If you are using .NET 4 / VS 2010 be sure to turn off ‘Embed Interop Types’ for Microsoft OneNote 14.0 Object Library. See Daniel Escapa’s post on how and why: blogs.msdn.com/b/descapa

3. Add a using to the top of Class1.cs, among the other ‘usings’:

   using System.Runtime.InteropServices;

4. Next, the Add-In requires a GUID to identify it. To create one:
   1. Tools → Create GUID (if it isn’t there, do a search in the start-menu for GUID)
   2. Choose Registry Format → Copy → Exit
      
5. Just above:
   public class Class1
   add:
   [GuidAttribute("[Your app’s Guid]"),ProgId("[Your app’s ProgId]")]
   [Your app’s Guid] = <paste> (without curly braces) the one created in Step 4
   [Your app’s ProgId] = Project.ClassName

   Ensure that you have these values on hand (i.e. copied into Notepad, or even better OneNote) as they are needed for the setup project (later).

6. Add a using to the top of Class1.cs, among the other ‘usings’:

   using Extensibility;

7. This will allow us to implement IDTExtensibility2 (it contains all the COM Add-in functions), so that our code now looks like this:

   public class Class1 : IDTExtensibility2
{ }

8. Right-Click on IDTExtensibility2 (in the code (above) that we just added) → Implement Interface → Implement Interface. This will generate all the method stubs that the Add-In encounters during runtime
   
9. So now there are a whole heap of stub methods with the code:

   throw new NotImplementedException();
   This needs to be removed; otherwise, when these methods are encountered during runtime, the application will exist because of these exceptions being thrown.

   So delete them, that only the methods remain:
   public void OnAddInsUpdate(ref Array custom) { }
public void OnBeginShutdown(ref Array custom) { }
public void OnConnection(object Application, ext_ConnectMode ConnectMode, object AddInInst, ref Array custom) { }
public void OnDisconnection(ext_DisconnectMode RemoveMode, ref Array custom) { }
public void OnStartupComplete(ref Array custom) { }

10. Add a using to the top of Class1.cs, among the other ‘usings’:

    using Microsoft.Office.Interop.OneNote;

11. The OnConnection() function is called when the Add-In is being loaded. Here OneNote passes in the current instance of the ApplicationClass, the programmatic interface to OneNote’s API, so we set a new class-wide variable, onApp,
    to equal it.

    ApplicationClass onApp = new ApplicationClass();
public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref System.Array custom)
{
 onApp = (ApplicationClass)application;
}

12. To hook the ribbon’s events to our code we need to add:

    using Microsoft.Office.Core;

13. This will allow us to implement IRibbonExtensibility (it contains all the Ribbon functions), so that our code now looks like this:

    public class Class1 : IDTExtensibility2, IRibbonExtensibility
{
 /* Code here… */
}

14. Right-Click on IRibbonExtensibility (in the code above that we just added) → Implement Interface → Implement Interface. This will create a stub of the Ribbon’s load event for us.

    

15. Replace the code:

    public string GetCustomUI(string RibbonID)
{
 throw new NotImplementedException();
}

    With returning the XML Resource (the ribbon.xml file) that we created in Step 2

    public string GetCustomUI(string RibbonID)
{
 return Properties.Resources.ribbon;
}

16. Now to make the button work we create a function with the same name that we mentioned in the ribbon.xml for our button’s onAction event. It is important that this function is both public and takes an IRibbonControl as a parameter:

    public void showHello(IRibbonControl control)
{
}

17. This is the part where you can do what you want with your own code. This function will be called when the (in our case) button is pressed. For this demo, we will just make it show a Messagebox with the current page’s ID.

1. First add:

   using System.Windows.Forms;

2. To get the ID of the current page, we call the ApplicationClass we created earlier:

   string id = onApp.Windows.CurrentWindow.CurrentPageId;

3. And we will show it in a MessageBox

   MessageBox.Show("Current Page ID = " + id, "Hello World!");

Part 4 – Fixing the Installer

The last thing to do now is to create an installer. Office Add-ins use the registry to specify settings and link the dll with the Office application. The installer needs to create these registry keys, and copy the Project Output (the dll created) to the Program Files directory.

1. Add a Setup Project to the solution: File → Add → New Project → Other Project Types → Setup and Deployment → Visual Studio Installer → Setup Project

   

2. Click on the setup project, and choose ‘Registry Editor’

   

3. Remove all the keys, so that only the default hives are left

   

4. Note your app’s GUID and ProgId, found in Class1.cs
   
5. Create the following keys (Right-Click on a [Key / Hive] → Key) with their respective values (Right-Click → New → <Type>). Be sure to check their spelling – a common source of frustration when the add-in doesn’t load in OneNote
• HKEY_CLASSES_ROOT\AppID\[Your app's GUID]
  

  Type	Name	Value
  string	DllSurrogate

• HKEY_CLASSES_ROOT\CLSID\[Your app's GUID]
  

  Type	Name	Value
  string	AppID	[Your app's GUID]

• HKEY_CURRENT_USER\Software\Classes\AppID\[Your app's GUID]
  

  Type	Name	Value
  string	DllSurrogate

• HKEY_CURRENT_USER\Software\Classes\CLSID\[Your app's GUID]
  

  Type	Name	Value
  string	AppID	[Your app's GUID]

• HKEY_LOCAL_MACHINE\Software\Classes\AppID\[Your app's GUID]
  

  Type	Name	Value
  string	DllSurrogate

• HKEY_LOCAL_MACHINE\Software\Classes\CLSID\[Your app's GUID]
  

  Type	Name	Value
  string	AppID	[Your app's GUID]

• HKEY_LOCAL_MACHINE\Software\Microsoft\Office\OneNote\AddIns\[Your app's ProgID]
  

  Type	Name	Value
  string	Description	[Your app's description]
  string	FriendlyName	[Your app's name]
  DWORD	LoadBehavior	3

  LoadBehavior should be "9" (load the add-in when the tab loads) for editing existing tabs or "3" (load the add-in when the application loads) for newly created tabs. We are using "3" in this tutorial, because otherwise (if we used "9") our tab would only load when the tab containing it would load, but because a tab is not contained in a tab, it would never load.

  For more information, see: http://msdn.microsoft.com/en-us/library/bb386106.aspx#LoadBehavior

  If you don’t want to add all the keys to Visual Studio’s Registry Editor manually:

  1. Open notepad and paste in the following code (regkeys.reg):
     Windows Registry Editor Version 5.00
      
     [HKEY_CLASSES_ROOT\AppID\[Your app’s GUID]]
     “DllSurrogate”=”"
      
     [HKEY_CLASSES_ROOT\CLSID\[Your app’s GUID]]
     “AppID”=”[Your app’s GUID]”
      
     [HKEY_CURRENT_USER\Software\Classes\AppID\[Your app’s GUID]]
     “DllSurrogate”=”"
      
     [HKEY_CURRENT_USER\Software\Classes\CLSID\[Your app’s GUID]]
     “AppID”=”[Your app’s GUID]”
      
     [HKEY_LOCAL_MACHINE\Software\Classes\AppID\[Your app’s GUID]]
     “DllSurrogate”=”"
      
     [HKEY_LOCAL_MACHINE\Software\Classes\CLSID\[Your app’s GUID]]
     “AppID”=”[Your app’s GUID]”
      
     [HKEY_LOCAL_MACHINE\Software\Microsoft\Office\OneNote\AddIns\[Your app’s ProgId]]
     “Description”=”Press for a Hello World!”
     “FriendlyName”=”Hello World!”
     “LoadBehavior”=dword:00000003
  2. Save the file as <filename>.reg (e.g. regkeys.reg)
  3. <Right-Click> on ‘Registry on Target Machine’ → Import…
     
  4. Find the save *.reg file and open it
  5. Visual Studio will insert the keys and values for you

     Be sure to check the imported values, sometimes (especially with the DWORD) insert doesn’t quite work)

6. Now it should look like this (your GUID will be different, and your ProgID will probably be different to the one displayed here):

   

7. Click on the setup project, and choose ‘File System Editor’
   
8. Second last, we need to add the project’s output (the dll created) to the install location:
   Click on the Application Folder (generally the \Program Files\ directory) → Right-Click → Add → Project Output… → OK
   
9. Running 64-Bit Office? Be sure to also change the TargetPlatform to x64 in the Installer Properties (Click on the setup project → F4) – Thanks for the tip, Ryan!
10. Change the installer setting (Click on the setup project → F4) RemovePreviousVersions to True.
    You may also want to change some of the other settings, especially Product Name and Manufacturer, as the default install location is:
    [ProgramFilesFolder]\[Manufacturer]\[ProductName]

Done!

So, now we are done with process in Visual Studio, so we just build the solution, install the setup project that it creates, and you should see your add-in in OneNote!

Tips & Good Sites

Currently, when you want to debug the addin you need to change the Version of the Installer (as it checks for later versions before installing), build the solution, and install it. This can become very annoying when compiling frequently and attempting to debug an add-in. Speeding up this process (after the installer has run once, and made all the changes to the registry as necessary) you can get Visual Studio to simply build the project at its install location, thus not needing to constantly reinstall the application. To do this:

1. First we will create a new Solution Configuration so that we can get Visual Studio to build the solution in the C:\Program Files path, while still easily able to go back to our previous config where Visual Studio built the solution in the bin\debug folder. Go to Solution Configurations Selector → Configuration Manager

   

2. From the ‘active solution configuration’, choose <New…>
3. Create a new Solution Configuration, copying settings from ‘Debug’

   

4. Click OK, and Close
5. Right-Click on the Project → Properties

   

6. In Properties, go to the Debug tab. Change the Output path (under Output) to the install path of the application (generally C:\Program Files\<Manufacturer>\<ProductName>\ )
7. Now simply build (Build → Build Solution) the project as normal, open OneNote again, and your add-in should have updated.

Note:

1. You may need to close dllhost.exe and OneNote before Visual Studio will allow you to build the project (files may be in use that would otherwise be overwritten)
2. If your addin hasn’t updated in OneNote, especially if the image in the ribbon hasn’t, ‘reload’ the addin in OneNote. To do this:
   1. File → Options → Add-Ins → (Manage: COM Add-Ins) → Go

      

   2. Deselect your add-in and click OK (and OK in the OneNote Options window)

      

   3. Repeat the process (starting at a) again, but this time selecting your Add-In again
   4. This generally works, as it gets OneNote to completely reload the add-in, thus (hopefully) loading the newer image for your add-in in the ribbon

Useful links

• Debugging a OneNote Add-in with Visual Studio (for OneNote 2007 add-ins, but it’s still relevant): http://blogs.msdn.com/b/descapa/archive/2007/05/01/debugging-a-onenote-toolbar-addin-c.aspx
• Debugging OneNote API access through the log: http://blogs.msdn.com/b/descapa/archive/2006/12/08/debugging-the-onenote-api-enable-logging.aspx
• OneNote Error Codes / COM Exceptions: http://msdn.microsoft.com/en-us/library/ff966472.aspx
• Customizing the Ribbon / Fluent UI (for Office 2007, but it’s still relevant): http://msdn.microsoft.com/en-us/library/aa338202(office.12).aspx
• Getting the Control IDs for Tabs, Groups, and Buttons in OneNote’s ribbon (useful for e.g. adding a button on the Home tab, rather than a new tab): http://www.microsoft.com/downloads/en/details.aspx?FamilyID=3f2fe784-610e-4bf1-8143-41e481993ac6&displaylang=en
• Editing content in OneNote through OneNote’s API: http://msdn.microsoft.com/en-us/magazine/ff796230.aspx
• OMSpy – taking a look at the XML structure of pages, sections (and section groups), and notebooks in OneNote: http://blogs.msdn.com/b/descapa/archive/2007/02/12/omspy-a-onenote-developer-s-tool.aspx
• Office Schema Reference (useful for trying to understand OneNote’s XML elements and attributes. It’s the 2007 one, but again it’s still relevant (and it provides it in a HTML format and *.xsd, whereas the 2010 one only has the *.xsd)): http://www.microsoft.com/downloads/en/details.aspx?FamilyId=15805380-F2C0-4B80-9AD1-2CB0C300AEF9&displaylang=en
• Source Code from the Table Sorting Powertoy (by Nani – Microsoft): http://blogs.msdn.com/b/johnguin/archive/2010/10/25/code-for-the-table-sorting-powertoy-for-onenote-2010.aspx
• All the OneNote blogs (especially John Guin and Daniel Escapa)

Before beginning to use Tablet PCs in 2008, I had a “standard” laptop. Using folders and having multiple files for notes, articles, and other minor pieces of work, cluttered my ‘My Documents’  folder. Word documents full of class notes, over 10,000 words / 55 pages long, made it difficult to find information. Doing my mathematics work on paper / in exercise books, was messy and confusing, making it difficult to learn from notes, and previous mistakes. And then there was the amount of paper that was given out. I don’t have an exact number of how much, but considering that last year, a year during which I exclusively used my Tablet, I went through roughly 1,000 sheets of paper, the vast majority being handouts, it certainly was a lot of paper.

This became too much for in early 2010, so I decided to use my Tablet PC for all my school work. I was able to put feelings of being overwhelmed by paper, loosing or ‘misplacing’ pieces of paper, and the messiness of things everywhere, behind me, largely through the use of OneNote.

The three main reasons why I choose to use OneNote were:

1. Easy to backup
   Paper gets lost. Paper gets damaged. (Most) work on your machine isn’t ‘backed-up’ all the time. It can be lost through viruses, and is ‘stuck’ in this one location (on your harddrive). OneNote on the other hand, not only keeps all your notebooks (by default) in a single folder, making for easy backups of your work, but also makes it easy to synchronize your work with the Cloud, using Office Live – automatically synchronizing your work, and enabling access from multiple devices (through PCs, the Internet, and Windows Phone). See Shared Notebooks: http://office.microsoft.com/en-us/onenote-help/share-notebooks-in-onenote-2010-HA010386952.aspx
2. Easy to organize
   You can’t easily find something in a pile of paper. Searching for a phrase in a collection of documents full of notes doesn’t always return relevant and timely results. OneNote, however, allows for quick and relevant searches throughout all you documents, including text, images, and ink. OneNote makes it simple to tag relevant selections of text, ink and images, making it easy to find (for example) all quotations in a History Notebook. See Tagging: http://www.addictivetips.com/microsoft-office/onenote-2010-tagging-guide/
3. Easy to take brilliant notes
   Taking notes on paper or in a Word document, frequently results in a collection of different documents of notes, completely separate from their context and relevance. OneNote makes it easy to take notes where the context is automatically saved. Also, by letting you write anywhere on a page, not restricting you to Top to Bottom, linear, content, as well as supporting inking,  OneNote makes it easy to take brilliant notes quickly. See Linked Notes: http://www.onenotehelp.com/2009/11/19/take-linked-notes-in-onenote-2010/

So, with all my notes in OneNote on my Tablet PC, synced with Office Live, I have been able to organize my school life without being in a mess of paper, loosing paper, or being overwhelmed by paper.

I haven’t look back.