TIM GITTOS - graphics and artificial intelligence geek

Getting Started with VR

2016-04-19T00:00:00-07:00

I’ve had my Oculus Rift CV1 for a few weeks now and I’ve been having fun playing the available content, and having even more fun showing other people around in VR. I can’t help but feel that a lot of these experiences are fairly shallow though. Eve Valkyrie is a great dogfighter, but that’s all it is (yes, I have Elite Dangerous, if I ever manage to figure out the controlls). Lucky’s Tale is a fun little platformer, though I can only do one level before I get bored and have to quit. Other than those 3 titles, there’s not much compelling content for me on VR right now, at least until other developers start to release content.

Not being one to complain about a situation and not make any efforts to fix it, I am itching to do some developent for VR. I have a few ideas kicking around, virtual tabletop gaming, cockpit based games (mechs, space ships, etc) and a 3rd person game are among some of the ideas I have. The only problem is that I’m not a game developer – I have written one game in C++ that was an ugly clone of Pong. No 3D, nothing polished and nothing with a deep game. It’s safe to say that there’s a lot I have to learn.

I’m starting with one of my stronger interests, computer graphics. I’m currently running myself through the content at learnopengl.com in the attempt to get a handle on how OpenGL works, and sharpen up my terrible C++ skills, as well as aquaint myself with CMake. This is going well, and I’m currently working my way through the basic shading chapters. There’s a lot of content to cover and it’s going to take some time. Once I grok OpenGL and have a little more hands on experience with C++ and graphics programming, I’ll look into working in Unity or UE 4. I know that seems kind of backwards, but I can’t work with a tool or library if I don’t understand the fundamentals it’s built on.

As I work my way toward my goal, I will post about my experience, mostly for my own benefit, though anyone who is interested is welcome to follow along.

I Made A Thing - Notebook Edition

2015-08-13T00:00:00-07:00

I do a lot of interviewing at work which means I print a lot of resumes. I like to print them single sided so I can write notes on the back and so I’m often left with a lot of paper that has only been printed on one side. I have a kind of weird relationship with paper and I don’t often like to waste it.

For the last 6 or so months, I’ve been saving the paper from the old no longer needed resumes with the intention of recycling them somehow. After watching the video below, I suddenly knew how I wanted to do it:

Now, binding a book has been something I’ve been wanting to do for a long time. I’ve bought books on the topic, and was waiting on “time” to pull the trigger. After seeing how fast the guy above made his book and after a particularly slow day of testing installer builds which took forever to build and deploy, I decided to go for it.

I folded signatures of paper at work during downtime, and placed an order on Amazon for the following products:

I already had this book:

Bookcraft: Techniques for Binding, Folding, and Decorating to Create Books and More

Yesterday my box arrived, and I couldn’t wait to start binding when I got home.

I pretty much followed the same steps as in the above video, with my book filling in details as required, like how much space to leave between signature stitches.

After about 2 hours including 40 minutes of waiting for things to dry, I was left with the following notebook:

I made plenty of mistakes as I bound my first book – I wasn’t precise enough when putting the holes for the stitches, so some signatures were out of place. I didn’t use enough glue on the binding when placing the cloth, so the last signature sort of hangs out of the spine. I rushed the creation of my book cover, so it’s sized a little weird, and I accidentally glued it in crooked so the spine has an odd tilt to it.

Having said all that, I can’t help but pick it up and flick through it, knowing that yesterday it was just a pile of folded paper, and last week it was just sheafs of used paper sitting on my desk.

2014 In Review, And a Look Forward to 2015

2015-01-16T00:00:00-08:00

2014 was a crazy year for myself and my family. Full of childhood homes burning down, benign tumors, houses flooding and other general bad stuff. 2014 is not a year I will look back on fondly.

In 2013, I charged myself to “create things that are fun”, with a focus on building a new business idea.

Let’s see how I did:

Travelled to Australia and India to visit my family and friends, spending only 4 days in Australia and 4 days in India, losing luggage in Beijing on the way there. That was fun. We travelled to Jaipur and Agra to visit sights – I’ve finally visited the Taj Mahal on my second trip to India.

Travelled domestically to Chattanooga, Boston and Detroit. I enjoyed Chattanooga more than I thought I would, liked Boston less than I thought I would, and I’ve been to Detroit before.

I continued working on a business idea for custom 3D printed miniatures, then stopped. I’ll discuss this more in detail below.

I started drawing for an hour every day for about 78 days, then stopped because I stopped having fun. I’ll discuss this below as well.

I was going to start a game dev project similar to the “art everyday” project, but again I was too slow and Handmade Hero did what I was going to do, but way better, before I could do it. Now I’m an avid viewer.

Last year I mentioned that I was starting a business with some of my friends, and we were going to work on custom 3D printed miniatures for tabletop gaming. I was super excited to finally have found something that I was genuinely passionate about and that seemed like a great idea. We got to work immediately, and while I won’t go into the details right now, I learnt a lot of lessons really fast.

When we found the HeroForge Kickstart, at first my heart sank. They were funded and they had a bunch of really good artists on the team. Then I realised, “Hey, we’ve already started developing our tech! We have a head start!”. I felt better immediately and got back to work. Then I ran into a hard issue I still to this date haven’t solved. We were beaten to market at the end of the year. Their product is great looking, fair priced and generally awesome. We were originally only doing our idea because it hadn’t been done. Now that it exists, and is awesome, we agreed to … stop. I don’t know what’s next for us.

At the start of the year, I also started doing art for an hour every night. I managed ~78 nights before I stopped doing it. I stopped doing it because it stopped being fun. I was stressing out about making time to do the art even when I wasn’t feeling particularly inspired. I started doing really long, grueling multi-night pieces that sucked at my creativity. I wasn’t having fun, and that was before the break to travel. After getting back from international travel, it was hard to get back into the swing of things, so I stopped. I don’t regret stopping.

One thing I did which I wasn’t planning on doing is keeping more of my time “down” than I had before. I actually delved into my Steam library and played a few of the ~114 games I had, as well as a few games on console. I went out of my way to do things that were fun, but not necessarily productive. I wasn’t learning skills, I wasn’t building something I could use to make money, I was just having fun.

Looking back, 2014 was a fairly quiet year for me in terms of personal projects and making progress towards goals. At first I wondered if I was simply burning out and losing interest in the things that I used to like. But as I write this post during some downtime at work, I realized that work was probably the reason why I wasn’t super ambitious this year. For the last year I’ve been working on a team tasked to create a new product from scratch. We did market research, talked to users, developed paper prototypes, developed the final product – everything and all things lean startup. It took a lot of time and a lot of my energy, meaning I haven’t been super motivated.

Next year, I think I will make some more concrete goals for myself than I made in the previous years. I will share them here, but I want to think a little harder about them beforehand. When I do post them, I’ll link this article to them.

Failure

2014-06-05T00:00:00-07:00

Failing is an important part of learning and improving. In some ways, knowing what not to do and knowing how to fix mistakes are more important than knowing exactly what to do. I like the following quote, attributed to Thomas Edison: “I have not failed. I’ve just found 10,000 ways that won’t work.”

Last year I read The Creative Habit: Learn It and Use It for Life by Twyla Tharp. In the book she mentions that it’s important to fail in public. I didn’t understand why she said that until a few months ago.

At the start of this year, I promised myself to pick up art again as a hobby. I was going to film myself learning to draw all over again and post it up on the internet for strangers to see. When it came to start the project I began feeling huge amounts of anxiety. Eventually I got over it, but I had to take a break in May due to travelling. Since I got back I haven’t picked it up again, because that anxiety is stopping me.

I think the anxiety is coming from the idea of failing in public. I keep thinking of people watching me fumble around and judging me. I know this indicates a bunch of confidence related issues but rather than deal with all that, it’s probably easier to just stop failing in public.

To that end, I won’t be publishing any more stuff from my project online for the time. I don’t know if that will change in the future but right now my anxiety is stopping me from doing the work and that’s a bad thing.

Furthermore, I’m going to change the purpose of this site too alongside a redesign.

I originally started this blog with the intention of blogging about technical issues and sharing interesting things I come across in my work. Working on legacy tech doesn’t lend itself well to this kind of blogging however, and I’m also starting to think it’s a little egotistical to assume that anyone is interested in the things I think anyway.

I realized a few weeks ago that this website has kind of become a shrine to my failures – my failures to finish MooCs, various programming projects and generally to fulfill the intention of the blog.

Given that I no longer want to fail in public, I’m going to remove most of the content and instead just display the things I haven’t failed at – finished projects and any info relevant to my career that people might want to read about.

Hello World Open 2014

2014-04-16T00:00:00-07:00

About a week ago I found out about this cool AI programming competition called the Hello World Open which is currently running. My timing is not great though as I leave for a vacation to see family overseas and won’t be back until after the competition finishes.

The gist of the competition is that you need to build an AI bot to control a slot car around a track. It’s a time attack style competition with the fastest lap being what you’re aiming for. It has relatively simple rules that you are not necessarily told about – though you are given a protocol/API specification . Part of the task is to figure out the rules of the competion and to write a bot to take advantage of them.

The competition supports a wide variety of programming languages, and my intention was to use Clojure to build my bot. Although I don’t have to the time to write a bot in a new programming language in less than a day, I have been thinking about strategy.

My general strategy would have been to find out the acceleration, deceleration and top velocity of the slot car and the friction of the track. I would then have wrote my bot to figure out based on the friction how fast it can take the varying radius corners, and basically control the throttle so that the car is always just staying on the track. I then would have added lane switching logic to cut corners and maintain a race line that would be optimal for lap times.

Even though I can’t participate due to my lack of time, anyone reading this probably can. If you read this post and decide to participate, I’d love to hear your strategies and how you did, and whether or not my ideas were on the right track or not.

365 Days of Art - Day 78

2014-03-20T00:00:00-07:00

Fixing the face of my Iron Kingdoms character and cleaning up the illustration of the guns. I’ve decided against finishing this as I think my time is better spent drawing more figures. Tomorrow I’ll start drawing my D&D Next character that I tried to draw in January.

Day 77 | Day 79

365 Days of Art

2014-03-20T00:00:00-07:00

“You want to know the difference between a master and a beginner? The master has failed more times than the beginner has even tried” – doodlealley.com/2012/10/10/be-friends-with-failure/

“The ceramics teacher announced he was dividing his class into two groups. All those on the left side of the studio would be graded solely on the quantity of work they produced, all those on the right graded solely on its quality … the works of highest quality were all produced by the group being graded for quantity!” – sivers.org/qlq

365 Days of Drawing is going to be 365 failures in drawing. In an attempt to rekindle past skill in art, I’m deliberately practicing every day from January 1st, 2014, and recording it. I hope to get better at art, show my progress and possibly help anyone else who’s wanted to learn how to improve their art technique.

Device Ownership vs. Hosting

2014-03-19T00:00:00-07:00

Today I saw a video about a design experiment around the concept of hosting a product vs. owning a product. Here’s the video:

Before I get into why this struck me so much, I’d like to point out the similarities between Brad and the toaster from the Red Dwarf books. This is totally something I can see that guy doing.

Back to the experiment itself, I’ve identified within myself the tendency to buy a lot of stuff that I don’t really use. In fact just today I had to convince myself out of buying the Oculus Rift Developer Kit 2 because I didn’t use the original dev kit that I backed on Kickstarter. Even now I go back and forth on purchasing stuff because I’m worried I won’t use it, even when it’s clear I will. I’m debating purchasing a Yiynova Cintiq clone because I’m doing a lot of drawing lately, and still it’s a hard decision.

Couple that with the fact that I can absolutely see a resource crunch that means that new products become prohibitively expensive and I can completely understand what the thought experiment is about. Not only that but I also think it would be a positive change. Give your unused and unloved device to someone who will use it more and free up some clutter in your life.

PS: I also think the idea of a device peer network is both fascinating and terrifying.

365 Days of Art - Day 77

2014-03-19T00:00:00-07:00

Working on completing the design of my character. I’m fairly happy with the progress, but there is definitely a gap between what I’m producing and what I want to produce, although its not as bad as it was in past drawings.

Day 76 | Day 78

365 Days of Art - Day 76

2014-03-18T00:00:00-07:00

Although I had to resort to tracing to figure out how to draw a figure I liked, I am starting to make progress on a drawing. Hopefully in the future I won’t need to trace things to figure out construction.

Day 75 | Day 77

365 Days of Art - Day 75

2014-03-17T00:00:00-07:00

Learning to draw is hard. I’m finding myself continually frustrated by my lack of progress and the gap between my taste and my skill level. I think I need to find a happy medium between copying…

Day 73 | Day 76

365 Days of Art - Day 73

2014-03-17T00:00:00-07:00

Going over some design ideas for my character and doing a few bad drawings.

Day 72 | Day 75

365 Days of Art - Day 72

2014-03-17T00:00:00-07:00

Doing some character design today – not a lot of drawing, but some. I’m feeling more confident about my ability to draw from memory, but I still have to keep putting stuff into my memory.

Day 71 | Day 73

365 Days of Art - Day 71

2014-03-17T00:00:00-07:00

Started copying photos again, but this time to just practice approximating human features in looser sketches and building a mental library, not so much for realistic rendering.

Day 70 | Day 72

365 Days of Art - Day 70

2014-03-17T00:00:00-07:00

Things are getting tough.

Day 69 | Day 71

365 Days of Art - Day 69

2014-03-10T00:00:00-07:00

Due to burn out and family issues, I took 4 days off of the project. Today I started back and am starting to draw from imagination. This is frustrating and slow going work, and this session produced a whole lot of nothing in terms of drawings.

Day 64 | Day 70

365 Days of Art - Day 64

2014-03-05T00:00:00-08:00

I decided to take a break from this painting. My rendering technique was getting sloppy and I was feeling burnt out. I was make critical mistakes in proportions and volume placement as well. I don’t know if I will return to this painting, but I don’t want to do this for the rest of the week. I want to get into some composition studys and start doing original work.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 63 | Day 69

365 Days of Art - Day 63

2014-03-04T00:00:00-08:00

I estimate that I’m about 2 or 3 days out from finishing this painting. I’ll be glad to finish when I am.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 62 | Day 64

365 Days of Art - Day 62

2014-03-03T00:00:00-08:00

Losing a little steam on this, so I just painted for a short while today. I don’t want the quality of my rendering to suffer because I’m getting burnt out.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 61 | Day 63

365 Days of Art - Day 61

2014-03-02T00:00:00-08:00

Continuing to render the second gauntlet. Slow and steady wins the race.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 60 | Day 61

365 Days of Art - Day 60

2014-03-01T00:00:00-08:00

Started work on the second gauntlet, blocking in general shapes and starting to render at the bottom.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 59 | Day 61

365 Days of Art - Day 59

2014-02-28T00:00:00-08:00

I’ve finished the first gauntlet and I’m very happy with the result. Tomorrow I will try to make a lot of headway on the second gauntlet, and maybe even finish it. I’d love to have this done by the weekend is over, but I won’t hold my breath.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 58 | Day 60

365 Days of Art - Day 58

2014-02-27T00:00:00-08:00

More very slow progress. At this rate, I’ll finish a single gauntlet in 2 more days (2 more hours of painting) and probably take just as long for the second gauntlet. This will be my longest painting yet.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 57 | Day 59

365 Days of Art - Day 57

2014-02-26T00:00:00-08:00

I’m making very slow progress on painting the armor. Shiny metal with coloured reflections is surprisingly hard to paint.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 56 | Day 58

365 Days of Art - Day 56

2014-02-25T00:00:00-08:00

Today I started painting some armor that I was drawn to due to some interesting lifhting effects, and planned a little how I would attack painting it.

URL of image: http://www.pinterest.com/pin/333970128589346315/

Day 55 | Day 57

365 Days of Art - Day 55

2014-02-24T00:00:00-08:00

Finished the skull and talked a little about where I’m going next.

URL of image: http://2.bp.blogspot.com/-Xth-HVg2l1Q/TVYjmIVt8CI/AAAAAAAAB6c/oAtNwW7wmoA/s1600/real_bone_human_skull_male_s.jpg

Day 54 | Day 56

365 Days of Art - Day 54

2014-02-23T00:00:00-08:00

Today I played dentist as I worked on this skull’s teeth (haha) and lower jaw. Entering the home stretch tomorrow by finishing the cranium.

URL of image: http://2.bp.blogspot.com/-Xth-HVg2l1Q/TVYjmIVt8CI/AAAAAAAAB6c/oAtNwW7wmoA/s1600/real_bone_human_skull_male_s.jpg

Day 53 | Day 55

365 Days of Art - Day 53

2014-02-22T00:00:00-08:00

Detailing and texturing the upper jaw area and nose socket. Tomorrow I’m going to work on the teeth and finish the upper jaw.

URL of image: http://2.bp.blogspot.com/-Xth-HVg2l1Q/TVYjmIVt8CI/AAAAAAAAB6c/oAtNwW7wmoA/s1600/real_bone_human_skull_male_s.jpg

Day 52 | Day 54

365 Days of Art - Day 52

2014-02-21T00:00:00-08:00

I’ve started laying down detail and fixing values on the skull. Today was concentrating on the eye sockets. I think I got some nice texture down that I plan to add to other areas of the painting.

URL of image: http://2.bp.blogspot.com/-Xth-HVg2l1Q/TVYjmIVt8CI/AAAAAAAAB6c/oAtNwW7wmoA/s1600/real_bone_human_skull_male_s.jpg

Day 51 | Day 53

Find The Cracks - Then Break It Wide Open

2014-02-20T00:00:00-08:00

A lot of the things I do in my free time (and in my job) are overwhelming when I look at them superficially. I have a 4′ × 5′ canvas buried in my closet, a painting of my wife and I that I wanted to do for my mother-in-law, and it’s been sitting there for 3 years because it’s so overwhelming. Last year I joined NaNoWriMo because I’ve had (and recorded) a few dreams I’d like to try writing a story around. I immediately quit after realizing I have no idea how to extend a scene into a full length novel. Even at work, I had to learn how to configure a software package using a programming language I didn’t know in a programming paradigm I’ve never worked in. It felt hopeless when I first started.

I’m in the middle of an art project where I do art every day for a year". Several times I’ve felt the same about this project as I have about the stuff above. Every time I stuck to it though, because the project is about daily progress more than it is about results. Every time I found a small crack where I felt I could get a handle on the situation and where I started to see the results I wanted. I used that small glimmer of hope to persevere through, built on top of what got me there, and blew the whole thing wide open.

The same thing happened at work. Every time I thought I knew what was going on I’d try something and it would blow up. I felt that I would never get a hold of this task. Until I tried something and it stuck – it was doing exactly what I wanted it to do, meaning my understanding of the situation was correct. I used that understanding to try more things and as I worked through, I finally figured it out.

When you’re faced with a task or goal that seems almost unachievable, find the quickest, smallest win you can. Find the crack in the armor and then use that momentum to do it again, and again, and again. Eventually you’ll crack the problem and get to where you want to do.

365 Days of Art - Day 51

2014-02-20T00:00:00-08:00

Today I laid down some initial shapes to make this blob at least look a little like a skull. I also outlined a plan of attack to get stuck into the detail work.

URL of image: http://2.bp.blogspot.com/-Xth-HVg2l1Q/TVYjmIVt8CI/AAAAAAAAB6c/oAtNwW7wmoA/s1600/real_bone_human_skull_male_s.jpg

Day 50 | Day 52

365 Days of Art - Day 50

2014-02-19T00:00:00-08:00

A pretty dull video today as I prep for a more accurate representation of my subject by figuring out Photoshop grids and a basic shape.

URL of image: http://2.bp.blogspot.com/-Xth-HVg2l1Q/TVYjmIVt8CI/AAAAAAAAB6c/oAtNwW7wmoA/s1600/real_bone_human_skull_male_s.jpg

Day 49 | Day 51

365 Days of Art - Day 49

2014-02-18T00:00:00-08:00

Finishing my hands painting, and looking back and what I have (and haven’t) learned.

URL of image: http://www.pinterest.com/pin/541417186424884930/

Day 48 | Day 50

365 Days of Art - Day 48

2014-02-17T00:00:00-08:00

After struggling a little with painting the hands on my last painting, I’m going to focus specifically on painting hands.

URL of image: http://www.pinterest.com/pin/541417186424884930/

Day 47 | Day 49

365 Days of Art - Day 47

2014-02-16T00:00:00-08:00

Still feeling under the weather, I decide to stop working on the Patrick Stewart painting even though there’s still a lot of work to do.

URL of image: http://www.pinterest.com/pin/496592296382219241/

Day 46 | Day 48

365 Days of Art - Day 46

2014-02-15T00:00:00-08:00

Continuing work on my Patrick Stewart portrait whilst being sick. That’s putting in the work, which is what this whole thing is about.

URL of image: http://www.pinterest.com/pin/496592296382219241/

Day 45 | Day 47

365 Days of Art - Day 45

2014-02-14T00:00:00-08:00

Continuing to build on the things I’ve learnt through my last couple of paintings, I’m trying a painting of Patrick Stewart with a soft brush for organic shading. So far it’s doing fairly well and I’m fairly happy with it.

URL of image: http://www.pinterest.com/pin/496592296382219241/

Day 44 | Day 46

365 Days of Art - Day 44

2014-02-13T00:00:00-08:00

Today I tried to use what I had learnt from the last image about painting forms and layering for blending. I think I did an OK job, and although I thought I would have to take 2 days to get this to a place I liked, I think I got there in one. Tomorrow I’m going to experiment with soft edge brushes for organic shapes, and hard edge brushes for building texture.

URL of image: “http://www.pinterest.com/pin/333970128588507051/”http://www.pinterest.com/pin/333970128588507051/

Day 43 | Day 45

365 Days of Art - Day 43

2014-02-12T00:00:00-08:00

Though I ended with a disappointing result, I think I learnt a lot in this painting. I attempted to achieve an economy of painting strokes, but didn’t do enough layering. In addition, I painted light as I saw it in the photo, not as it would interact with 3D elements. I also fell victim to having the wrong aspect ratio again.

URL of image: http://www.pinterest.com/pin/333970128589220648/

Day 42 | Day 44

365 Days of Art - Day 42

2014-02-11T00:00:00-08:00

Another “speed” painting, this time of a forest. I struggled with this one a lot, and learnt about layering the painting. I still struggle with texture and pushing texture far enough. I’m thinking I need to research rendering texture.

URL of image: http://www.pinterest.com/pin/333970128589078882/

Day 41 | Day 43

365 Days of Art - Day 41

2014-02-10T00:00:00-08:00

Today I’m trying something new. I’m a little frustrated by how long it’s taking me to get each of my paintings for February done. Tonight I painted an interior scene and only gave myself tonight to do it. I wanted to limit the amount of time I had to stuff around and increase my economy of painting. I really like the results and so I’ll keep doing it from this point on, giving myself a single session to finish a painting.

URL of image: http://www.pinterest.com/pin/333970128588376215/

Day 40 | Day 42

365 Days of Art - Day 40

2014-02-09T00:00:00-08:00

Finishing up with the landscape I started a few days ago, and talking a little bit about what I’ve done so far and where I’m going.

URL of image: http://www.pinterest.com/pin/333970128588208962/

Day 39 | Day 41

365 Days of Art - Day 39

2014-02-08T00:00:00-08:00

I think I’ve cracked how to paint texture in a more representational/impressionistic way. I’ve gotten back into the swing of things tonight, and I’m looking forward to finishing the painting tomorrow.

URL of image: http://www.pinterest.com/pin/333970128588208962/

Day 38 | Day 40

365 Days of Art - Day 38

2014-02-07T00:00:00-08:00

Struggled today to keep up the enthusiasm for this painting – still, just have to put in the work

URL of image: http://www.pinterest.com/pin/333970128588208962/

Day 37 | Day 39

Nobody Cares So Don't Worry About Screwing Up

2014-02-06T00:00:00-08:00

Often, people won’t start something because they’re afraid of screwing up. They’re afraid that if they try and fail, people will mock them and criticize them. These are unpleasant events and so they’ll do everything to avoid them including not starting at all.

Other times, as is the case with me, this can manifest as a fear of success. I feel very uncomfortable in any kind of spotlight as I’m constantly fearful of criticism and confrontational interactions. I worry about the things I’m doing becoming successful because success might draw a spotlight which might draw these negative interactions I fear.

If these fears resonate with you, this is something that will hold you back. But there is good news – it’s something that is simple (but not easy) to combat.

When was the last time you really cared about a stranger’s failure? Assuming you’ve noticed it at all? You probably can’t remember. You’ll be able to remember when someone failed at something you had a stake in, but for something that is totally foreign to you, you probably can’t remember.

The truth is is that it’s hard to get people to care about anything, period. Entire industries are built around the art of getting people to notice and care about something. If it’s so hard to get someone to care about something you want them to care about, what are the chances that they’ll care about something you don’t want them to?

Even if they do notice your screw up, and even if they criticize or mock you, that interaction usually goes one of two ways:

1. They forget about you entirely and utterly, and it doesn’t matter
2. They dwell on it, and you get to live rent free in their mind.

#1 is more likely, but hope for #2 – because you’ll have their attention and they’ll care about what you’re doing. This gives you an opportunity to improve their opinion of you and win them over. It’s like the saying goes: “There’s no such thing as bad publicity.” You’ll never win everyone over, nor should you try, but as long as someone hasn’t made it obvious you can’t change their mind, you can keep trying to change their mind!

So if you’re worried about what people will say when you screw something up, remember you’ll be lucky if anyone even notices – most likely it will disappear in the sands of time.

365 Days of Art - Day 37

2014-02-06T00:00:00-08:00

I’ve started a new painting, this time a colour painting of a landscape. I’ve picked a photo that’s relatively low in texture and colours, so I have a chance at getting it right. Tonight was a short exploration of layout and proportions, and tomorrow I’ll get stuck into the detail work.

URL of image: http://www.pinterest.com/pin/333970128588208962/

Day 36 | Day 38

365 Days of Art - Day 36

2014-02-05T00:00:00-08:00

They say no work of art is finished, the artist only gives up. I think I’ve pushed this as far as I can given my current skill level, and any more work will be diminishing returns. I learnt a lot with this picture and improved so much in my painting technique over the 4 days. Tomorrow I’ll start it all again with a new picture.

URL of image: http://www.pinterest.com/pin/333970128588966124/

Day 35 | Day 37

365 Days of Art - Day 35

2014-02-04T00:00:00-08:00

I’m nearly at the finish line for this picture. I fixed a few of the errors that were obvious to me, and worked more on fixing the light/shade of her neck, then did some blending. Tomorrow I’m going to do more blending, finish her hair and then do some detail work, like eyelashes and eyebrow hairs.

URL of image: http://www.pinterest.com/pin/333970128588966124/

Day 34 | Day 36

365 Days of Art - Day 34

2014-02-03T00:00:00-08:00

Today I made more progress on my portrait. I was concentrating on fleshing out a little more of the major parts of her face and fixing the likeness. I’m still not at a point where I’m satisfied, but I’m close. I think I’ll do another hour on getting the major light/shadow blocks done, then spend about half an hour blending hard edges into soft edges.

URL of image: http://www.pinterest.com/pin/333970128588966124/

Day 33 | Day 35

365 Days of Art - Day 33

2014-02-02T00:00:00-08:00

I threw out the work I did on the portrait painting yesterday as I was very unhappy with it, and it was clear I didn’t know what I was doing (I still don’t, but that’s beside the point). The second try builds on the lessons I learnt from the first try, and I think I get a little closer to the mark this time.

URL of image: http://www.pinterest.com/pin/333970128588966124/

Day 32 | Day 34

365 Days of Art - Day 32

2014-02-01T00:00:00-08:00

Drawing has it’s place in the art work flow, but rarely as a final product. With that in mind, I want to try working on painting. Today I kick that off by trying to work with value only and paint a black and white photo, after watching the ConceptArt Color 1.1 video.

URL of image: http://www.pinterest.com/pin/333970128588966124/
URL of ConceptArt thread: http://www.conceptart.org/forums/forumdisplay.php?f=269

Day 31 | Day 33

365 Days of Art - Day 31

2014-01-31T00:00:00-08:00

I finished the arm study, and realized that I didn’t have much fun doing it, so I don’t think I’m going to draw the rest.

URL of reference: http://canadian-rainwater.deviantart.com/art/Anatomy-Human-Arm-Muscles-260160580

Day 30 | Day 32

365 Days of Art - Day 30

2014-01-30T00:00:00-08:00

Today I decided to do some anatomy studies of the arm, based on a coloured reference I found. Initially the plan was to draw the car I drew on day 2 tommorrow, so today was just to practice and kill some time, but I think I’ll push that back to 180 days and finish this study instead. Didn’t get a lot of drawing done, but some days are like that. You just need to push through and keep working.

URL of reference: http://canadian-rainwater.deviantart.com/art/Anatomy-Human-Arm-Muscles-260160580
URL of ConceptArt lessons: http://www.conceptart.org/forums/forumdisplay.php?f=269

Day 29 | Day 31

Book Notes: The ONE Thing

2014-01-30T00:00:00-08:00

Amazon: The ONE Thing: The Surprisingly Simple Truth Behind Extraordinary Results
(referral link – help me buy new books!)
ISBN: 1885167776
Read: 2013-12-18 (stopped)

I stopped reading this book about 30% in. Not because I thought it was bad, or the advice in the book was bad, but because I feel like I’d extracted the major point of the book – working on the one most important thing that reaches your goals will be more productive than trying to get lots of irrelevant tasks finished faster.

After transcribing my notes, however, I realise I was learning more from reading than I thought, so I will probably revisit this book as soon as I’m done with what I’m currently reading.

Notes

Like The Creative Habit , I intended to synthesize my one sentence excerpts into cohrerent sentences, but didn’t. Also, due to the fact that I didn’t finish this book, I don’t think that I could do it justice to do so.

Following are one sentence notes/excerpts from the book that I wrote down in my notebook as I read, in their raw form. They still probably contain some value.
—

“What’s the one thing you can do this week such that by doing it everything else would be easier or unnecessary?”
Success follows focus- success varies when focus does
Go small – do less things that have a large effect instead of many things that have a small effect
Geometric progressions of dominoes – a dominoe can knock down another dominoe 50% larger – tasks are dominoes
Find the first (dominoe) and work on knocking it over
Success is built sequentially over time – not simultaneously
One thing manifests in many ways:
– One person
– One passion/skill
(The one thing can change)
Passion → Skill → Results → Enjoyment → back to Passion
One thing should be specific, not generic – “be totally awesome” is not valid
Don’t trust everything you hear – especially if it sounds true.
6 lies between you & success -
1. Everything is equal
2. Multitasking
3. A disciplined life
4. Willpower is always on Will-Call
5. A balanced life
6. Big is bad

1. Everything is equal
Not everything important is urgent – when everything feels urgent & important, everything seems equal. Active & busy != productive
Achievers work with a clear sense of priority
Instead of todo list, succes list – list of stuff that will make you successful
What matters most right now?
A todo list with Paretos principle applied is a success list
Apply Pareto continuously until left with one thing
Say “no” more often – doesn’t matter whether it’s “not now” or “never”

2. Multitasking
Multitasking is merely the opportunity to screw up more than one thing at a time
The cost in terms of extra time from having to task switch depends on how complex or simple the tasks are – it can range from time increases of 25% or less for simple tasks to well over 100% or more for very complicated tasks
Our brain has channels, and as a result we’re able to process different kinds of data in different parts of our brain
Take on two things and your attention gets divided. Take on a third and something gets dropped.
The problem of trying to focus on two things at once shows up when one task demands more attention or if it crosses into a channel already in use (senses – sight, smell, hearing, touch, taste)
Multitasking short-circuits us:
1. Limited brain capability – dividing tasks up incurs cost in time and effectiveness
2. The longer you’re switched from a task, less likely to switch back. Loose ends pile up
3. Lose time switching tasks. Lose 28% of avg. workday to context switch.
4. Chronic multitaskers think tasks take longer to complete than actually required
5. Multitasking causes mistakes – make poorer decisions by favoring new information over old, even if old is more valuable
6. Causes stress
Multitasking can be fatal – surgeosn and pilots are expected to focus on their jobs.
Rest of us live by another standard – is our job less valuable or important?
Your work deserves no less respect

3. A disciplined life
Achievement doesn’t require full time discipline – sprint of discipline for long enough for habit to take over
We need just enough dicipline to build the habit
Disciplined people have just trained habits
Success is about doing the right thing, not doing everything right
Takes an average of 66 days to acquire a new habit
Build one habit at a time (no multitasking!)

4. Willpower is always on Will-Call
Powerful motivation won’t guarantee willpower
Using willpower effectively should be a high priority
When you have will, harness it
Willpower has limited battery lif, can be recharged with downtime
Each act of will decreases available willpower
When willpower fails, fallback on default behavior
What are your default behaviors? (linking back to habit)
Make doing what matters most a priority when your willpower is highest

5. A balanced life
Viewed wistfully as a noun, balance is lived practically as a verb (not something you have, something you do)
If balance is middle, out of balance is when away from middle
Living in middle is unextraordinary
Knowing when to pursue middle and when to pursue extremes is wisdom
Magic never happens in the middle – magic happens at the extremes
Don’t strive for balance – strive for counterbalance
Never go so far in one direction that you can’t find your way back, or stay so long that there is nothing waiting for you when you return (don’t neglect one aspect so long it atrophies)
Act on priority, automatically go out of balance
Challenge is in how long you stay on priority

6. Big is bad
Fear that big success causes pressure and stress

Book Notes: The Creative Habit

2014-01-30T00:00:00-08:00

Amazon: The Creative Habit: Learn It and Use It for Life
(referral link – help me buy new books!)
ISBN: 0743235274
Read: 2013-09-02

I struggled to finish this book, for reasons I can’t quite put my finger on. I initially started to figure out how to reign in my creativity and put it more “on tap” than it’s been before. This book definitely helped do that, but I still struggled to focus. I think because the author relied a lot on anecdotes from her career as a choreographer and dancer, I found it difficult to extract the moral from some stories.

Notes

I have a notebook full of about 3 pages of excerpts from, and single sentence ideas inspired by, this book. I intended to go back and form them into coherrent paragraphs of notes based on what I recalled from the book, but seeing as how I didn’t get around to it and it’s 4 months later, I can’t string my notes together well enough.

Rather than procrastinating on this and letting the notes languish in my notebook, I’m just going to dump the notes here raw. There’s still a lot of great ideas here, and if you want to find out more about what the notes mean, buy the book!

I will do better with writing my notes in the future (I hope).

—

Creativity is a habit
In order to be creative, you have to know how to prepare to be creative
Everything that happens in a day is a transaction between the external world and your internal world
Everything is relevant and usable
Establish rituals at beginning of creative process – when you are most likely to give up & chicken out. Remove the question “Why am I doing this?”
To get the creative habit, you need a work environment that is habit forming
Making the start automatic replaces doubt & fear with comfort & routine
Combat fears by confronting & analyzing them
Combat distractions by avoiding them
Artists have “creative DNA” that characterizes their work
Artists have a “focal length” in their work – how they view the world. Distant, medium & close.
Zoe – distant, from a far – zoology
Bios – close ,detail – biology
Stretch & endure discomfort to grow, but don’t go against your nature
Mine your memory for inspiration
Creativity is about connecting memories and creating metaphors
Copying is a way to learn skill, as long as you focus on the method, not the result.
When inspiration strikes, plumb it’s depths and explore it – like a brainstorm. Create metaphors.
Don’t worry about pivoting – if you feel a pivot, do it
“A photo is a memory captured” – shadow your heroes/inspirations, absorb the memory from their work, turn it into YOUR memory. Draw from it when you’re stuck.
Write everything down & organize it
Everyone uses reference material
Pre-idea: When you’re interested in something but you don’t know why
Begin each project with a stated goal
Ideas & research are not replacements for creativity
The quality of research determines the quality of your output
Scratching helps you find ideas – search for something that catches your attention
A good idea is one that expands upon itself. A bad one shuts itself off.
You don’t “scratch” for big ideas – they grow from small ones, or strike you unbidden.
You can’t think your way into a dance – you can only generate ideas by doing something physical (when in programming – REPL = better than thinking)
The act of restraining defeats the purpose of scratching – sketchbooks should be private
Scratching methods include:
– Reading – ImagineFX, novels, magazines
– Conversation
– Other people’s handiwork – art, music, etc
– Mentors & heroes – footsteps (create, don’t imitate)
– Nature
Don’t stop scratching at 1 idea
A + B = C – need to combine 2 ideas to have a concept
Rules of scratching:
– be in shape
– scratch in the best places
– never scratch in the same place twice
– maintain the white hot pitch
Scratching is unleashing furious, wordless energy
(Riff back and forth with a friend or colleague)
Productive artists know what they’re going to do, how to do it, what to do when something goes wrong
Be prepared to be lucky
Don’t sacrifice creativity for the plan
Don’t overplan – leave room for luck/accidents
Limited resources (time) enhance creativity. “Give me a writer who thinks he has all the time in the world and I’ll show you a writer who never delivers”
Mistakes in overplanning:
– Rely too much on others
– Waiting for perfect setup *
– Overthinking structure
– Feeling obligated to finish what you started *
– Working with the wrong materials
Scratch to find spine
Spine is core idea of work, keeps you on track
Spine doesn’t need to be obvious, but can be
Spine can be theme, technique, idea
All works of art have a story, a theme and a spine. Spine & theme can be the same.
Creativity does not eliminate need for skill
Deliberate practice
Beginners mind
Sometimes find self in a rut
Rut != creative block
Fix creative block by doing something
Rut is false start
Caused by bad idea, bad timing, bad luck
Fix by seeing rut, admitting in rut, get out with new idea:
– Identify concept not working
– Write down assumptions
– Challenge assumptions
– Act on challenge
Getting out of a rut is not getting into groove – avoiding bad idea is not coming up with good idea
Failing is healthy, but do it in private
Forget the pain of failure, remember lessons
Create bubble <=> startups

365 Days of Art - Day 29

2014-01-29T00:00:00-08:00

Drawing hands! I’ve always felt that drawing hands was very therapeutic and relaxing. I noticed while drawing today that my strokes are getting more confident, which is a good thing. I still struggle to draw what I really see, instead of what my brain is telling me I’m seeing.

Day 28 | Day 30

365 Days of Art - Day 28

2014-01-28T00:00:00-08:00

Finally finished the portrait today. I had a lot of trouble rendering the leather arm in a way that wasn’t distracting – it’s such a large mass that’s textured in a way that makes it difficult to render. I also struggled a little with the background, and ultimately decided against one for reasons stated in the video. Tomorrow I’ll probably try some anatomy exercises for hands.

URL: http://www.pinterest.com/pin/205124958001518518/

Day 27 | Day 29

Skeletal Animation

2014-01-27T00:00:00-08:00

http://www.3dkingdoms.com/weekly/weekly.php?a=4

Inverse Kinematics

2014-01-27T00:00:00-08:00

http://www.3dkingdoms.com/ik.htm

365 Days of Art - Day 27

2014-01-27T00:00:00-08:00

Today I continued my portrait of Peter Dinklage, and made some very questionable rendering decisions that I’ll deal with tomorrow.

URL: http://www.pinterest.com/pin/205124958001518518/

Day 26 | Day 28

365 Days of Art - Day 26

2014-01-26T00:00:00-08:00

Today I decided to try my hand at another portrait from a photo. It started really slow and frustrating as I struggled to get a grip on the size of the canvas, but once I got the ball rolling, it really fell into place nicely. Initially I wasn’t planning on continuing this tomorrow, but I like it too much to give up on it now.

URL: http://www.pinterest.com/pin/205124958001518518/

Day 25 | Day 27

365 Days of Art - Day 25

2014-01-25T00:00:00-08:00

Now that I’ve wrapped up the lips study, I copied from a bargue drawing of a statue’s nose and lips from various angles, as a way to cap off the last 4 days of studies. Not sure what I’m going to do tomorrow.

URL: http://www.pinterest.com/pin/564638872002840196/

Day 24 | Day 26

365 Days of Art - Day 24

2014-01-24T00:00:00-08:00

Not much to say about today other than that I finished my lip study. I also tried warming up to see if it helps with the initial mistakes I make at the start of each session, and I feel it did. Definitely reduced some of the frustration I feel at the start.

URL: http://www.pinterest.com/pin/564638872002840227/

Day 23 | Day 25

365 Days of Art - Day 23

2014-01-23T00:00:00-08:00

Today I got a start on studying lips. Again, I didn’t get as much done as I had wanted, but I think it’s best to take it slow and make sure I understand what I’m drawing.

URL: http://www.pinterest.com/pin/564638872002840271/

Day 22 | Day 24

365 Days of Art - Day 22

2014-01-22T00:00:00-08:00

Today I finished studying noses and did a little bit of hatching rendering. I discovered that I’m really not very good at rendering through hatching, especially on the graphics tablet. Tomorrow I’m going to start on lips and the mouth.

URL: http://www.pinterest.com/pin/564638872002861091/

Day 21 | Day 23

365 Days of Art - Day 21

2014-01-21T00:00:00-08:00

Today I continue addressing weaknesses in my last drawing from imagination, this time focusing on the nose. I didn’t quite get as much done as I wanted to do, so I’ll finish the rest tomorrow.

URL: http://www.pinterest.com/pin/564638872002861091/

Day 20 | Day 22

365 Days of Art - Day 20

2014-01-20T00:00:00-08:00

After identifying weak areas from the last drawing, today I begin working on fixing those weak areas. First up is, copying some eye bargue drawings to get familiar with a human eye from various angles.

URL: http://www.pinterest.com/pin/564638872003754000/

Day 19 | Day 21

365 Days of Art - Day 19

2014-01-19T00:00:00-08:00

Today I completed the drawing from yesterday. My line quality is awful, and the guy’s face looks so generic and ridiculous that it’s given me a direction. All in all, it wasn’t as terrifying as I was axious about it being, but it definitely didn’t end up great. Still, it’s a step in the right direction.

Day 18 | Day 20

365 Days of Art - Day 18

2014-01-18T00:00:00-08:00

After yesterday, I’ve decided that a more “project” based approach might be beneficial. My first project is to draw my current D&D character. I struggled a bit with the pose, like I was anxious I would, but in the end I think I got some kind of flow going.

Day 17 | Day 19

365 Days of Art - Day 17

2014-01-17T00:00:00-08:00

Today was tough. I got bored of finishing the castle staircase, and due to fatigue wasn’t really feeling drawing. But the whole point of this exercise is to put in the work and draw regularly, so I pushed through with some anatomy studies from Bridgmans.

Day 16 | Day 18

365 Days of Art - Day 16

2014-01-16T00:00:00-08:00

After a Windows Update took out my Wacom driver and fighting for an hour to get it installed again, I didn’t make as much progress on the final drawing as I’d have liked. At 2am I decided to stop and finish it the next day.

URL of image I drew: http://www.pinterest.com/pin/333970128588701224/

Day 15 | Day 17

365 Days of Art - Day 15

2014-01-15T00:00:00-08:00

After yesterday’s revelation, I’m trying my hand at drawing from another photo, this time taking a lot of effort to make sure I get it as close as possible. I chose an interesting castle staircase from Pinterest for this one, and realized it had some challenging perspective after the fact.

URL of image I drew: http://www.pinterest.com/pin/333970128588701224/

Day 14 | Day 16

You Build a Wall One Brick at a Time

2014-01-14T00:00:00-08:00

Back in 2013, I promised that I would show up and do the work and subsequently didn’t do it. The fear of starting took hold and I got too caught up in not sucking to get good at anything:

However, I made a snap decision to “show up and do the work” around Christmas while talking to some friends about New Years resolutions. Normally my go to “resolution” is to resolve to not make any resolutions. Instead of answering with that when asked though, I answered with a plan to draw a little every day and record it.

Normally I believe that if you want to make a change in your life, you should just make the change. Not hang it on some “significant” time, like next week, next month or next year. But with the new year coming up, restricting the drawing thing to a year seemed like a great idea. At the end of the year, I should have at least 100 hours of video and over 300 drawings with which to show the power of the idea of putting in the work.

Tonight I’ll have my 14th session, sticking with this plan for 2 weeks, and it’s amazing. I can already see progress and I’ve opened the idea up to doing “art” at least once per day. That way I’m not restricted to just drawing. In fact, the idea is so great that I’ve started applying it to other areas of my life.

Anyone who is following along with my blog (nobody as far as I’m aware, haha) will know that I’m also working on a business with some friends. As of about a week ago, I spend every lunch time I have free from work at a coffee shop working on the business. I’m only working about 45 minutes a day, not even a full working day through the week but I’m already getting a lot done. I completed something I’ve been wanting to do for a few months and it only took about a week of lunch times.

If you have a large task or goal that seems imposing, commit to doing a little bit every day and don’t be afraid of being terrible at it. This isn’t the first time I’ve repeated such advice but it is the first time I do so from a position of (admitedly little) experience. If you have any doubt, come back next year and see where I am with my art and business. The proof of the pudding is in the eating.

365 Days of Art - Day 14

2014-01-14T00:00:00-08:00

Today I drew from some photo references, focusing on the anatomy of the neck from an actual real person.

I discovered that I’m still not very good at drawing from life/photo reference, and that I’m not seeing shapes as 3D volumes. I also think I need to work value into my art sooner rather than later.

URLs of images I drew:
First guy: http://www.pinterest.com/pin/333970128588436241/
Second guy: http://www.pinterest.com/pin/333970128588346197/
Third guy: http://www.pinterest.com/pin/333970128588965142/

Day 13 | Day 15

365 Days of Art - Day 13

2014-01-13T00:00:00-08:00

I kept going with the Bridgman neck studies today, this time focusing on the neck abstraction and looking at how everything moves together.

Day 12 | Day 14

365 Days of Art - Day 12

2014-01-12T00:00:00-08:00

More Bridgman studies as today I tackle the neck/clavicle region, and how it all fits together.

Day 11 | Day 13

365 Days of Art - Day 11

2014-01-11T00:00:00-08:00

Today I followed Mr. Bridgman around and we examined the construction of the human jaw and how it interacts and moves.

Day 10 | Day 12

365 Days of Art - Day 10

2014-01-11T00:00:00-08:00

Drawing from a photo reference today. I thought I’d get some portraiture in, and work on some eyes given what I covered yesterday. I picked the image I picked due to the fact that it’s greyscale and her hair isn’t crazy difficult to draw.

The image of the girl I drew can be found here: http://www.pinterest.com/pin/333970128588720306/

Day 9 | Day 11

365 Days of Art - Day 9

2014-01-10T00:00:00-08:00

Before I draw anymore faces or figures, I want to look at how a human eye is constructed, not just how to draw what I see on the eye. This will help to come up with unique angles that I may not have a reference for.

The eye tutorial I used: http://conceptcookie.deviantart.com/art/Eye-Tutorial-Resource-327176361

Day 8 | Day 10

365 Days of Art - Day 8

2014-01-09T00:00:00-08:00

Time for some more photo reference practice. This time I drew a bust of a statue that I found on sxc.hu. Things got tricky as I realized that I need to use value to describe some of the shapes.

The URL for the stock photo I drew: http://www.sxc.hu/photo/1431577

Day 7 | Day 9

365 Days of Art - Day 7

2014-01-08T00:00:00-08:00

Continuing with the theme of proportions for the human body, I looked at proportions and methods to draw the human head. As it turns out, my knowledge of head construction leaves a lot to be desired. It’s an area that I’m going to want to focus more on.

The URL of the proportions I was using: http://nattosoup.blogspot.com/2012/03/facial-anatomy-and-construction.html

Day 6 | Day 8

365 Days of Art - Day 6

2014-01-07T00:00:00-08:00

Today I did the back view of the proportional guy, and explored some abstraction techniques for drawing figures.

The URL of the proportions I was using: http://www.goregoregore.com/steps/bodypattern1.jpg

Day 5 | Day 7

365 Days of Art - Day 5

2014-01-06T00:00:00-08:00

Continuing on from yesterday, I drew the proportions of a man from the side view.

The URL of the proportions I was using: http://www.goregoregore.com/steps/bodypattern1.jpg

Day 4 | Day 6

365 Days of Art - Day 4

2014-01-05T00:00:00-08:00

Today I took a crack at relearning human proportion. Wow, am I rusty. I was expecting to get through more, but it totally kicked my butt.

The URL of the proportions I was using: http://www.goregoregore.com/steps/bodypattern1.jpg

And the URL of the page I found it linked from: http://figure-drawings.blogspot.com/2008/10/human-anatomy-for-artists.html

Day 3 | Day 5

365 Days of Art - Day 3

2014-01-04T00:00:00-08:00

Today I applied a technique from Betty Edward’s “Drawing on the Right Side of the Brain”, where I draw something upside down to stop the brain interfering with while drawing what I see. It removes the association of the image and lets you concentrate on shapes. I drew the car again, this time upside down!

The URL of the image I drew (you’ll need to turn it upside down): http://img2.netcarshow.com/Gumpert-Apollo_2008_1024x768_wallpaper_01.jpg

Day 2 | Day 4

365 Days of Art - Day 2

2014-01-03T00:00:00-08:00

Today I set a ‘benchmark’ of sorts to establish a base level of starting skill, by drawing a supercar. I screwed up the mic volume on this one, so you can’t hear me ramble on about drawing what you see. Also, the file was really big and I had to halve the size. This might happen frequently.

The URL of the image I drew: http://img2.netcarshow.com/Gumpert-Apollo_2008_1024x768_wallpaper_01.jpg

Day 1 | Day 3

365 Days of Art - Day 1

2014-01-02T00:00:00-08:00

It’s the first day! Introductions and nervous, timid pen control exercises are the agenda for today.

Day 2

2013 In Review, And a Look Forward to 2014

2014-01-02T00:00:00-08:00

As should be obvious to me by now, 2013 was very different from what I expected in 2012 . I gave myself pretty much free reign to do whatever I wanted, as long as I was creating. So naturally, I read a few books, did half of some MOOCs and didn’t actually create much of anything (sort of).

Here’s what I did:

Travelled to the UK and Ireland in a whirlwind tour of London, Edinburgh and Dublin. Ate haggis, got mistaken for an exhibit at the Edinburgh castle (and scared some poor tourist half to death) and prayed for my life during the flight from Edinburgh to Dublin aboard a ATR-72

Travelled domestically in the US to LA, Colorado Springs and Las Vegas (only Las Vegas was a revisit) for work and pleasure.

Read books and wrote notes/thoughts about them. There are notes on 5 books on my blog, and notes for 2 more books in my little reading notepad. I’m half way through a 3rd that’s not on the site yet.

Attended SXSW and started something crazy that I’ll get into in a bit

Started 2 personal projects: PDF Stitcher and annot8 . PDF Stitcher was finished and deployed but annot8 hasn’t gone anywhere.

Started and abandoned 2 more MOOCs: Algorithms, Part 1 and Functional Programming Principles in Scala .

Had close to $14k worth of dental work performed after 4 years of no dental checkups. At last count it was 3 root canals and 7 crowns along with various other procedures. Taking care of your teeth is crazy important.

Continued use of a physical journal

Even though the year was fairly different from how I intended to spend it, I’m happy with how it turned out. I realized a few lessons that I think were important, and I finally took the plunge to do something I’ve wanted to do for years but was always scared to.

I learnt that it’s OK to stop doing something if the situation changes. I started the MOOCs with every intention of finishing them, but life changed around me. My workload increased suddenly due to a co-workers relocation, and I didn’t have the time to finish. So instead of causing myself a whole bunch of stress by trying to spread myself too thin, I stopped doing non-essential stuff, which meant the MOOCs. I do intend to go back and retake/finish them when it’s more convenient, but for now I’m glad I didn’t force myself to finish.

After hanging out with my friend Mark at SXSW, in May, he, myself, and 3 other friends started a company with the intention of helping tabletop RPG gamers to create custom miniatures easily. A long time ago I realized that my career as-is is going to cap out and that business ownership is the next logical step. I’ve been saturated in the startup world for 3 or 4 years now, and only now have decided to give it a crack myself with more than a little prodding from Mark.

This was a pivotal part of the year for me, as the product we’re developing has pretty much taken all my time from that point on. It’s interesting tech, we’re at the forefront of a new industry and it’s a product I would defenitely use myself. I’ve already made a lot of mistakes and learnt a lot of things and I look forward to making more.

I’m going to approach 2014 with a similar philosophy that I wanted for 2013. I’m not going to stick to any rules other than “create things that are fun.” Right now, I’m having fun trying to build a product for a new company and imagining where we can go. I’ll push that as far as I can while still having fun and then see what happens.

I’m also starting a new project as well. I intend to put in work on creating art every day, and record it. I want to be able to look back on 365 recordings at the end of the year, and see progress on a skill that I’ve been meaning to recapture for a few years.

Finally, I’m going to keep journaling, keep reading and taking notes and uploading them to this site.

Until 2015, when we do this all again.

Hack Weekends

2013-12-10T00:00:00-08:00

For a while now, I’ve been sitting on a bunch of small projects that I’ve wanted to knock out. Things like a simple marching cubes implementation and a quick tech demo of a simple guitar distortion effect to name a few. Small things that would probably take 4 or 5 hours over a weekend to knock out.

Until now, I’ve kind of just let the ideas sit in my mind until I either forget them, or they grow into a bigger project idea that I can justify adding to my queue of stuff to do. That I never get around to doing.

Now I have another idea, and this one is about how to get these small ideas to fruition. Every now and then I find myself burnt out or stuck on my usual hobbies and side projects, and have a few hours to kill. I’ve decided that it would be awesome to spend this time to just implement one of my small ideas in it’s infancy. Just spend a few hours to have a crack, record the code and then write my thoughts on the experience.

It doesn’t matter if I produce anything worth while or just end up with a pile of mistakes. It’s all still learning, and it’s all still progress in something that interests me.

In the odd chance that you’re like me and you have these fleeting ideas that you sit on to grow or die, maybe try to take a quick crack at them document your experience. The worst case scenario is you kill a few hours to learn more about something you didn’t know much about. The sky’s the limit on the best case.

You're an Adult - It's OK to be a Quitter

2013-10-18T00:00:00-07:00

Since April, I’ve been working on an MVP for Adventurin’, mostly before work and on weekends. Then I got an email from Coursera stating that two of the courses on my watch list were being offered again. I enrolled in both, and started watching lectures, taking notes and completing assignments at work, during lunches and late afternoon downtime when your brain starts to feel like mush.

I was plugging along for nearly a month in this fashion, then work hit me like a tonne of bricks. All of a sudden I had projects to finish on tight deadlines, and I started to starve the online courses so that I could finish actual work. Before I knew it, I found myself 3 weeks behind on one of my courses, and I’m currently 2 weeks behind on the other. Until recently, I was determined to finish everything, and it was causing me a lot of stress.

I started to have trouble sleeping, and was constantly preoccupied by what I should be doing at any given moment. I had so much to do and so many deadlines. Then it occurred to me one night that half of my deadlines are self imposed. Not only are they self imposed, but they’re for things that don’t really matter right now.

So I quit the online courses.

Yes, I would have loved to finish. I think they’re worthwhile and will help me improve my day-to-day programming. But the amount of stress they were causing me was robbing my family and myself out of piece of mind and ultimately wasn’t doing me any good. I can always go back and pick them up where I left them off.

When we’re growing up, a lot of us a taught that quitting something is bad. That you should be ashamed that you couldn’t follow through with an obligation. While I’m not going to analyze that in much depth, I can see some merit – you’re teaching grit and building a character that won’t just quit because something is hard. Some of those feelings carry into adult life and it’s important to recognize that the same rules no longer apply.

That’s not to say that you can just drop all your obligations when things do get hard. I didn’t quit my job and I’m not stopping work on the MVP. I’m quitting the extra stuff that isn’t essential. I’m not letting anyone else down but myself, and that’s OK because I’m gaining piece of mind. In fact I’m also helping my family – I’m not a pleasant person to be around when I’m distracted or stressed out.

It’s easy sometimes to push yourself past your limits, to a point where it’s negatively affecting your life. If you ever find yourself in that situation, it’s OK to quit doing some of the things that are causing stress. Just be mindful of who you might be disappointing. You don’t need to be ashamed that you quit if you’re doing it for the right reasons.

Coursera Functional Programming Principles in Scala - Week 3

2013-10-09T00:00:00-07:00

Class Hierarchies

In the last few lectures, we have looked in depth at a lot of different aspects of a single class. In this lecture, we’re going to generalize these apsects for class hierarchies. A class hierarchy is when more than one class cooperates to achieve a certain task.

We’re going to explore class hierarchies through implementing a set of classes that implements sets of integers with the following operations:

Note the above class is marked abstract - that means one or more of it's methods is unimplemented, and you cannot directly create an instance of it. Abstract classes in Scala work the same as abstract classes in Java and C#. We're going to implement the IntSet class using a binary tree. A binary tree is a data structure that contains a root element, and two subtrees. Given that it's possible to have a subtree that has no subtrees (only a root element), we're also going to have to implement an empty tree. When implementing the non-empty tree, we're going to keep to the following invariant: each node has a subtree on the left with values less than integer at the root, and a subtree on the right with values larger than integer at the root. Following are implementations of the Empty tree, and the non-empty tree:

With the above implementation, note that if the left or the right subtree is an Empty object, then the call for contains will return false. If you ask an empty tree or subtree if an element is in it, the answer will always be false. Also note that adding an element to an Empty tree will result in a NonEmpty tree, with Empty subtrees on the left and the right.

The above classes are purely functional – they involve no mutation. Each call to incl returns a new tree, not mutated trees. This makes the data structure what is called a persistent data structure. A persistant data structure is so called because even when the data structure changes, the old version doesn’t change – still there until it goes out of scope. This will aid the implementation of some recursive methods.

Also note that Empty and NonEmpty extend IntSet. They conform to IntSet, meaning they can be swapped out for each other. IntSet is superclass of Empty and NonEmpty, and Empty and NonEmpty are subclasses of IntSet.

In Scala, all user defined classes have a superclass. If no superclass is given, java.lang.Object object is used. Every class has a set of bases classes that are all of it’s direct or indirect superclasses. For example, the base classes of NonEmpty are IntSet and Object.

In our implementations above, contains and incl in Empty and NonEmpty implement the abstract functions in the base trait IntSet. It’s also possible to re-define existing, non-abstract definitions in subclasses using the override keyword.

Consider the following trivial example:

override is required in Scala when redefining method that has alredy been defined. In this way, Scala is more picky than Java (I assume override is optional in Java). Requiring the override provides additional compile time safety, as it will generate a compiler error if you try to implement a method that has already been defined, or try to override a method that doesn't exist on a base class. You can also use override when implementing abstract methods, but this usage is optional. h3. Singleton Objects In the above implementation of IntSet, one could argue there is only one single empty IntSet - we don't need to require the implementor to create many instances of it. Scala provides support for these semantics through an _object definition_. For example:

The above example will define a singleton object, not a class. You can’t create instances of it with new. The object itself is created the first time it’s referenced. Singleton objects are values themselves, so when applying an evaluation model, the singleton object evaluates to itself.

Scala Applications

So far we have executed Scala code from a REPL or worksheet. This is convenient for rapid development, however not for creating applications. Fortunately, it is possible to create standalone applications in Scala. A standalone application is a Scala object that contains a main method.

As an example, the following defines the typical “Hello World!” application:

After the source has been compiled, you can run the application with scala Hello, rr java Hello in a terminal. h3. IntSet Union Lets implement a few more methods on the IntSet implementations we built above. The first method we're going to implement is union. We need to add union to both Empty and NonEmpty:

Notice that union for NonEmpty is a recursive function. It unions the left and right subtrees of the first tree, then unions that with the other tree, then finally adds the existing root element to the tree.

How do we know if this recursion terminates?

Every call to union is on something smaller than starting set. The left subtree is smaller than the entire set, and the left and right subtrees combined are also smaller than the entire set. Due to this, at some point we union empty set, thus recursion terminates.

Dynamic Dispatch

Object oriented (OO) languages, including Scala, implement dynamic method dispatch to resolve overriden methods. This means that the code invoked depends on the runtype type of object that contains the method.

Example of evaluating with dynamic method dispatching:

Another example using NonEmpty:

Notice that the dynamic dispatch of methods is analgous to calls to higher-order functions. Can we implement one in terms of the other?

Objects in terms of higher-order functions?
Higher-order functions in terms of objects?

This is not something we’re going to answer in the lecture, however it’s an interesting topic to think on.

How Classes are Organized

In Scala (and Java), classes and objects organized in packages. To put class or object in package, use the package directive at the top of the source file:

This puts the Hello object into the package progfun.examples. You can refer to Hello by it's _fully qualified name_ progfun.examples.hello. You can use this fully qualified name in code when referring to the object, or when invoking it from a terminal or REPL:

To use code in other files, you can import their namespaces to avoid typing fully qualified name. You can import single entities from package using it’s fully qualified name or multiple entities by using braces (both known as named imports):

Or, you can import everything in a package (known as a wildcard import):

Some entities are auto imported into any Scala program:

Members of scala package
Members of java.lang package
Members of singleton object scala.Predef

Here are fully qualified names for some types and functions:

Int – scala.Int
Boolean – scala.Boolean
Object – java.lang.Object
require – scala.Predef.require
assert – scala.Predef.assert

To find out what entities are available to a Scala program by default, you can explore the standard Scala library at http://www.scala-lang.org/api/current

Traits

In Java and Scala, a class can only have one superclass. This can be limiting when implementing real-world applications. Luckily, iff a class has several natural supertypes, you can use traits. A trait is declared like an abstract class, only it uses the trait keyword instead of abstract class:

Classes, objects and traits can only inheret from one class, but they can implement many traits. For example:

Scala traits resemble Java interfaces, only they are more powerful. Traits can contain fields and concrete methods, unlike abstract classes. However, traits cannot have value parameters – only classes (including abstract classes) can have value parameters.

Scala’s Class Hierarchy

In most object oriented languages, there exists a class hierarchy. Often there is a root class, that every other class is a subclass of. Scala is no different, and a part of it’s class hierarchy looks as follows:

In the diagram above, the dotted lines mean the classes are in a conversion relationship, not a subtype relationship. The difference is when converting to a supertype from a subtype, no change in data is required. The inverse does not hold for the conversion relationship – the data representation may change, and information may be lost.

Looking at the diagram, we can see that:

Any is the base type of all types. Any defines many core methods available on all objects: ==, !=, equals, hashCode, toString

AnyRef is the base type of all reference types. It is an alias of java.lang.Object

AnyVal is the base type of all primitive value types.

Nothing is subtype of every other type. It has no value. How is it useful?
- Can be used to signal abnormal termination – useful in throwing exceptions
- Can be used as an element type of empty collections

In Scala, every reference class type also has null as a value. The type of null is Null Null is a subtype of every class that inherits from Object and is incompatible with subtypes of AnyVal. Null allows us to have missing values, which can be useful in a variety of ways.

An example of Null compatability:

h2. Polymorphism So far we've seen many kinds of types, such as primitives likes Integers and Floats, and class types like Rational. Next we're going to look at polymorphism, which is a flexible way to express and parameterize types. h3. Cons-List To explore polymorphism, we're going to implement a staple of many functional languages: the cons-list. A cons-list is an immutable linked list, which we're gonig to build from the 2 following building blocks * Nil - an empty list * Cons - cell containing first element and pointer ref to rest of list. For example: !/images/func/cons-list.png! This can be outlined in Scala as follows:

In the case of implementing a cons-list, every list is either:

an empty list (new Nil) or
a list (new Cons(x, xs)) considting of a head element x and a tail list xs

Note above we’ve introduced new Scala syntax – passing val with a parameter both defines a parameter of the class and a field of the class itself. This means that:

is equivalent to:

where _head and _tail are otherwise unused names.

Type Parameters

The cons-list defined above is good only for use with Integer types. It’s too narrow to define lists with only Int elements, because we may need a list for String types, or any custom type we might introduce. Instead of implementing multiple different lists for each type, we can generalize the list using generics through a type parameter:

Where type parameters in Java are in angle braces, in Scala they are square brackets. h3. Scala Implementation of List With generics in mind, we can define a cons-list as follows:

We’ve included isEmpty to allow clients to differentiate between objects of Cons and objects of Nil.

We can then implement this const-list with the following two classes:

Note that we don't have to override the head and tail methods in Cons, as val is doing that for us. Note also that for the Nil class, we're throwing an exception when trying to access the head or tail. This makes sense, as trying to get the head or tail of an empty list doesn't make sense. This works because the type of a thrown exception is Nothing -subtype of all types. So even though the trait specifies that head should be a T type, and tail should be a List[T] type, we can use Nothing in place of both of those types. h3. Generic Functions Like classes, functions can also have type paramaters. For example, the following function creates a list of a single element:

Scala can infer the type of a method from the value arguments of a function call. This means that the type argument can often be ommitted. The above can be replaced with:

Types and Evaluation

Type params do not affect evaluation in Scala. When using an evaluation model to analyze an algorithm, you can assume all type params and type arguments are removed. The types are only relevant to the compiler to verify programs satisfy certain correctness properties. This property of ignoring types during evaluation is known as type erasure Languages that use type erasure include Java, Scala, Haskell, ML, OCaml, and languages keep the type paramater information at run time, including C++, C#, F#

Conclusion

The above generics and type parameters are a form of polymorphism. Polymorphism refers to functions whose type comes in “many forms”, that the function can be applied to arguments of many types and that types can have instances of many types

So far we have seen two principlal forms of polymorphism

subtyping – instances of a subclass can be used as it’s base class
generics – instances of a function or class are created by type parameterization

These two mechanics work well together to allow us to write concise and flexible code.

Coursera Functional Programming Principles in Scala - Week 2

2013-10-04T00:00:00-07:00

Higher-Order functions

Functional languages treat functions as first-class values. This means that they can be passwed as a parameter and returned as a result just like any other value. This provides a flexible way to compose functions. Functions that take other functions as parameters or that return functions as results are called higher order functions. This is the opposte of a first order function, which only operates on non-function value types like ints, booleans, etc.

Consider the example of taking the sum of the integers between a and b:

Note that this is a recursive function. Next, consider the sum of the cubes of all integers between a and b:

This is essentially the same tail recursion, only instead of summing the int, we sum the cube.

Next, consider the sum of the factorials of all integers between a and b:

where fact is a method for computing factorials. Each of these 3 examples above are special cases of a generic function that we can represent mathematically as: $$ \sum^b_{n = a} f(n) $$ for different values of $f$. We can use higher-order functions to generalize the above examples programmatically, like we would be able to mathematically:

Notice that the sum takes an applies a function given to it, which we use to implement our previous examples.

Notice the new Scala syntax introduced above, known as a function type. The type A => B is the type of any function that takes an argument of type A and returns a result of type B. Int => Int is the type of all functions that map integers to integers.

Passing functions as parameters can lead to the create of many small functions, which is tedious and cluttery in the source code. However, just as you can pass a string literal to a function that takes a string, Scala lets you pass a “function literal” to a higher-order function through the anonymous function syntax.

To demonstrate, we can show the anonymous version of the cube function above:

If an anonymous function takes multiple arguments, they're separated by commas:

We can use anonymous functions to further refactor our example above:

Note that you can ommit the type in a function type if it can be inferred by the compiler from the context of the function. h2. Currying Recall the refactored example above. Even though we are now passing an anonymous function to our sum function, there is still some inefficiency as we pass the parameters a and b unchanged into the sum function. We can rewrite the sum function as follows:

sum is now a function that returns a function.

We can then simplify the rest:

However, we don't even need to define this intermediary sum functions - we can pass the functions directly to the sum function and evaluate the results:

To put it into English, sum(cube) applies the sum function to the cube function and returns the sum of cubes function, which is functionally equivalent to sumCubes. This function returned is then applied to 1 and 10.

The definition of functions that return functions is so useful in functional programming that there is a special syntax for it in Scala. Rather than having to define an interior function, we can pass the outer function argument (the function type) and the inner function argument (two integers) in one definition:

Generally, we can define a function with multiple parameter lists: $$ def \; f(args_1) ... (args_n) = E $$ is equivalent to the following, where $n > 1$: $$ def f(args_1) ... (args_{n-1}) = { def g(args_n) = E; g } $$ where $g$ is a fresh identifier. This in turn is equivalent to: $$ def f(args_1) ... (args_{n - 1}) = (args_n => E) $$ which returns an anonymous function. This expands until all the arguments have been converted into functions: $$ def f = (args_1 => (args_2) => ... (args_n => E) ... )) $$ This process is known _currying_, named for Haskell Brooks Curry (1900 - 1982). Given the following function definition:

the type of the sum function is (Int => Int) => (Int, Int) => Int. That is to say, it’s a function that takes a function that maps an int to an int, and returns a function that takes 2 ints and maps it to a single int. Functional types associate to the right.

Example: Finding Fixed Points

The fixed point of a function $f$ is the number $x$ such that:

$$
f(x) = x
$$

For example, the fixed point of:

$$
1 + \frac{x}{2}
$$

is $2$.

For some functions, we can locate the fixed point by starting with an initial estimate and then apply the function in a repetitive way until the value either does not change, or changes by some small acceptable value.

For functions that satisfy this properly, we can write a function to find the fixed point as follows:

We can use this to improve the sqrt function from "week 1":/learning/coursera-functional-programming-principles-in-scala/week-2/ , based on the following insights: If $y = \sqrt{x}$, then $y \times y = x $. This is equivalent to $y = \frac{x}{y}$, which means that the square root of $x$ is the fixed point of the function \(y = \frac{x}{y}). We can therefore use y => x / 2 as the f parameter above to calculate the square root:

Unfortunately, this ends up not converging, and instead the guess oscillates between 1 and 2. The solution to this oscillation is to prevent the estimation from varying too much by averaging successive values of the original sequence:

The examples so far have shown that the expressive power of a language is greatly increased if we can pass functions as arguments to other functions. The following example shows that functions that return functions can make a language equally expressive. Consider again the iteration toward a fixed point above. We dampened the guesses using the average of the last guess and the new guess. This technique of stabilizing by averaging is general enough to merit being abstracted into it's own function:

Functions and Data

So far the functions we have written deal with primitive types, such as integers, booleans and doubles. As the complexity of the programming task at hand rises, so too will the data we deal with. Thus we’re going to need more complex data types, and functions to create an encapsulate these data structures.

Take the example of working with rational numbers. As a refresher, a rational number is a number $frac{x}{y}$ represented by two integers:

the numerator, $x$
the denominator, $y$

We are going to design a package for doing rational arithmetic

First, lets implement the addition of two rational numbers. We could use two functions to add the numerator and denominator of two rational number separately, as follows:

However, with a lot of rational numbers, it will quickly become difficult to manage all the numerators and denominators. An alternative approach would be to combine the numerator and denominator fo a rational number into a single data structure:

The above class definition introduces two entities:

A new type named Rational
A constructor Rational to create elements of this type

Scala keeps the names of the types and values in a different namespace so there is no conflict between the two definitions of Rational.

We can create objects of the Rational object by calling the constructor with the keyword new:

The members of Rational are called by using the . infix operator, similar to Java. Before we go any further, lets review our rational number arithmetic: $$ \begin{align} \frac{n_1}{d_1} + \frac{n_2}{d_2} &= \frac{n_1d_2 + n_2d_1}{d_1d_2} \\ \frac{n_1}{d_1} - \frac{n_2}{d_2} &= \frac{n_1d_2 - n_2d_1}{d_1d_2} \\ \frac{n_1}{d_1} \times \frac{n_2}{d_2} &= \frac{n_1d_2}{d_1}{n_2} \\ \frac{\frac{n_1}{d_2}}{n_2}{d_2} &= \frac{n_1d_2}{d_1}{n_2} \\ \frac{n_!}{d_1} &= \frac{n_2}{d_2} \quad \text{iff} \quad n_1d_2 = d_1n_2 \end{align} $$ We could implement the class as a pure data type, where it simply holds data and allows us to retrieve data. We would then need to define additional functions to use with this data type:

Another approach is to package functions operating on a data abstraction in the data abstraction itself – these are known as methods. We would implement all the arithmetic operations we want directly on the Rational class: add, sub, mul, div, equal and toString:

Note that we're overriding the toString, which works exactly the same as C# or Java overriding. h2. More Fun with Rationals Continuing with the code above, if we define y such that:

We can see that the result rational number isn’t represented in it’s simplest form. When doing rational arithmetic, we usually simply the the rational number. To simply a rational, you reduce both of them to teir smallest numerator and denominator by dividing both with a divisor.

While we could implement this as a method on the Rational class, it’s easy to forget to use this simplification method. Instead, we can implement it as part of the constructor for the Rational class, and do it when objects are constructed.

Notice that gcd and g are private members of the Rational class. This is so that clients of this class cannot access these values directly. We could have written the number and denom as:

or even as:

In the first example, the numer and denom are computed on demand, and we save on memory required to store the data at the cost of computation time. This would be useful if we're expecting it to be called infrequently. In the second example, they're evaluated immediately, and we save the time required to compute it each time, at the cost of storing the value. This is useful if we're expecting it to be called frequently. Next, we're going to implement less and max:

Right now, it’s possible to create a Rational that is illegal – something like $\frac{1}{0}$. This will yield division by zero errors when trying to perform arithmetic operations on the Rational. The solution is to add a require call to assert that a certain condition holds true:

The above Rational will now throw an IllegalArgumentException exception when we try to create a Rational that is invalid. require is a check on preconditions in code, similar to assert. require is intended to enforce a precondition on the caller of a function or the instantiation of an object. assert checks the internal consistency or code of an object or function itself - if it fails, it's not necessarily the user's fault. Just like in all OO languages, classes in Scala can have constructors. If you do not provide a constructor, the class implicitly introduces a _primary constructor_. The primary constructor will take the parameters of the class and execute all the statements in the class body. Just like in Java, you can define multiple constructors for a class that takes a different parameter signature. For example, if we wanted to give our Rational class a constructor that only sets the denominator, we can do:

The def defines the new constructor, and the invocation of this(x, 1) calls the primary constructor with the parameter list given.

Evaluation and Operators

In week 1 , we defined the meaning of a function application using a computation model based on substitution. Now it’s time to extend this model to classes and objects.

Firstly, we can look at the instantiation of a class (new C(e_1, ... e_m)). This expression’s arguments e_1, ... e_m are evaluated like the arguments of a normal function. That is the arguments are evaluated to values, and indeed the whole expression itself is a value.

Next, suppose that we have a class definition:

class C(x_1, ..., x_m){ ... def f(y_1, ..., y_n) = b ... }

That is, we have a class which as the formal parameters x_1, ... x_m and the class defines a method f</codE> with formal parameters <code>y_1, ..., y_n.

For the sake of simplicity, we have omitted the parameter types, and the list of function parameters could be absent if the function requires no parameters.

How is the following expression evaluated?

new C(v_1, ..., v_m).f(w_1, ..., w_n)

The expression is rewritten to:

[w_1/y_1, ... w_n/y_n][v_1,x_1, ..., v_m, x_m][new C(v_1, ... v_m)/this]b

Unlike a function application, there are 3 substitutions at work here:

The substitution of the formal parameters y_1, ..., y_n of the function f by the arguments w_1, ..., w_n
The substituion of the formal aprameters x_1, ..., x_m of the class C by the class arguments v_1, ..., v_m
The substitution of the self reference this by the value of the object new C(v_1, ..., v_n).

We can demonstrate this with the Rational class we have been using this week:

Note that the second to last reduction in the above image is actually applying the first reduction.

Operators

In principle, the rational numbers defined by the Rational class are as natural as integers. But for the user of these abstractions, there is a noticeable difference:

we write x + y if x and y are integers, but
we write r.add(s) if r and s are rational numbers.

In Scala, it is possible to eliminate this difference.

Firstly, we need to know that in Scala, it’s possible to write any method with a parameter as an infix operator. For example:

Secondly, we need to know that In Scala, an identifier can take more forms than other programming languages. An identifier can be: * _Alphanumeric_: starting with a letter, followed by a sequence of letters or numbers * _Symbolic_: starting with an operator symbol, followed by other operator simbols With the above rules, an underscore character counds as a letter, and alphanumeric itentifiers can also end in an underscore, followed by some oeprator symbols. Here are examples of valid identifiers in Scala: * x1 * * * +?%& * vector_++ * counter_= With those two facts, it's simple to apply them and simplify our Rational arithmetic:

Note the unary_ method identifier prefix – this special prefix allows the method to be used prefix, like you would during a mathematical expression.

One thing that needs to be addressed when writing operators in this fashion is the precedence rules. In Scala, the precedence of an operator is determined by its first character. The following list of operator precedence is in increasing order of priority:

all letters
|
^
&
< >
= !
:
+ -
* / %
all other special characters

Coursera Functional Programming Principles in Scala - Week 1

2013-09-21T00:00:00-07:00

Programming Paradigms

Functional programming is a paradigm that is quite different from imperative or OO programming. Scala is a hybrid, and can provide a gradual transition to functional programming from OO programming. This course will take a clean break and teach functional programing from first principles, teaching a new way to think and reason about programs.

In science, a paradigm is a set of distinct concepts or thought patterns. In programming, there are 3 main programming paradigms:

Imperative programming
Functional programming
Logic programming

Some people assert that object oriented programming is a paradigm, however the instructor believes that OO is orthogonal, and can be used effectively with both imperative programming, which is that state of the art, and with functional programming.

Imperative Programming

Imperative programming is about modifying mutable variables, using assignments and controlling the flow of the program using control structures such as if statements, loops and breaking/continuing them, and returning.

The most common informal way of understanding imperative programs is as instruction sequences for a Von Neumann computer.

A simplified Von Neumann computer consists of a processor, some memory and a bus that transmits data between the two. The width of the bus is the word width of the processor – 32 bit, or commonly these days, 64 bits. More can be found out about the Von Neumann architecture on it’s Wikipedia page

The Von Neumann architecture has had a strong impact on the development of imperative computer programs.

Mutable variables correspond strongly to memory cells
Variable dereferences correspond strongly to load instructions
Variable assignments correspond strongly to store instructions
Control structures correspond strongly to jumps

The problem with this is that it makes conceptualizing programs at higher levels of abstraction hard. This was the idea behind John Bakus’ lecture entitled ‘Can Programming Be Liberated from the von Neumann Style?’

Bakus argued that pure, imperative programming had become limited by the “Von Neumann” bottleneck of reasoning about data structures word-by-word. He asserted that we needed techniques for defining higher levels of abstractions such as collections, polynomials, geometric shapes, strings, documents, etc. Not only that, but we also need theories with which to reason about these higher abstractions.

Theories

In mathematics, a theory describes:

one or more data types
operations on these types
laws that describe relationships between values and operations

It should be noted that these theories do not describe mutations. Operatons on data types result in new types and values, with a different identity.

For example, the theory of polynomials defines the sum of two polynomials by laws such as:

\[
(a \; x + b) + (c \; x + d) = (a + c) \; x + (b + d)
\]

It does not define an operator to change a coefficient while keeping a polynomial the same. However, in imperative programming, we can do exactly that:

  class Polynomial { double[] coefficient; }
  Polynomial p = ...
  p.coefficient[0] = 42;

That fragment of code will allow us to change the coefficient, but leave the identity of the polynomial the same.

Consequences for Programming

If we want to implement high-level concepts that follow mathematical theories, we need to do away with mutation. Mutation does not fit with any mathematical theories, and allowing mutation can break useful laws in theories.

Therefore we want to concentrate on defining operators expressed as functions, avoid mutation and create powerful ways to abstract and compose functions.

In a restricted sense, functional programming is programming without mutable variables, assignments and imperative control statements. A functional programming language will not have support for these features.
Examples of these languages are Pure Lisp, XSLT, XPath, XQuery, FP and Haskell without the I/O monad or UnsafePerformIO.

In a wider sense, functional programming is a focus on functions, where functions can be values that are produced, consumed and composed. A functional language will support functions as first class objects, meaning they can be:

declared anywhere, even inside other functions
passed as arguments and returned as results of other functions
have a set of operators defined for their composition

Examples of these languages are Lisp and lisp-like languages like Scheme, Racket and Clojure, SML, OCaml, F#, Haskell (full language), Scala, Smalltalk and Ruby.

SICP is recommended reading for this course. SICP can be read online for free .

Why Functional Programming?

Functional programming is becoming increasingly popular because it can offer the following benefits:

simpler reasoning principles
better modularity
good for exploiting parallelism for multicore and cloud computing.

To find out more, watch Martin Odersky’s OScon 2011 Keynote “Working Hard to Keep It Simple”:

Elements of Programming

Every non-trivial programming language provides support for primitive expressions containing the simplest elements (primitive types of the language), ways to combine expressions, and ways to abstract expressions by assigning them an identifier, and allowing us to refer to that expression by it’s identifier.

Scala, and many other functional programming languages, comes with a REPL (Read-Evaluate-Print-Loop) that allows us to interact with the programming environment live so that you dont have to compile and run source files.

Evaluation in Scala is performed with infix notation. That is, the operands are evaluated in a left to right order, and operators are applied to those operand values, left before right. Named references like variables are replaced with the value on their right hand side. The evaluation stops once it results in a value.

Following is an example of the evaluation of a non-primitive expression, where def pi = 3.14159 and def radius = 10

(2 * pi) * radius

(2 * 3.14159) * radius – first, the reference to the second operand of the first operator, pi, is evaluated
6.28318 * radius – next, the first operator is evaluated
6.28318 * 10 – then the reference to the second operand of the second operator, radius, is evaluated
62.8318 – lastly, the expression is evaluated. The result is a value, so the evaluation is terminated.

In Scala, definitions can have parenthesis, which define functions:

This results in the square function. Functions can call other functions:

When functions are evaluated, the evaluation is similar to that of a non-primitive expression. All the function arguments are evaluated, left to right, all function applications (aka function calls) are replaced by the function’s right hand side (it’s body) and at the same time, all formal arguments are replaced by the values of the real arguments.

For example:

sumOfSquares(3, 2+2)

sumOfSquares(3, 4) – first, the arguments are evaluated
square(3) + square(4) – next, the function application is replaced by the functions body
3 * 3 + square(4) – this is repeated for each function application
9 + square(4)
9 + 4 * 4
9 + 16
25

This expression evaluation method is known as the substitution model, and has been formalized as the $
\lambda$-calculus, which is the foundation of all functional programming.

The substitution model works on the concept of reducing expressions down to values, then applying those values in other expressions until all that is left is a value. It can be applied to all expressions so long as those expressions do not have side effects.

Note that it is possible that the substitution will never halt. Consider the example of a recursive program with no termination condition. That program will continue to have it’s reference reduced back to itself until the computer suffers a stack overflow.

The method of substitution that Scala uses, of evaluating arguments before substitution, is not the only method available. It is also possible to evaluate the arguments at the very end of substitution.

For example:

sumOfSquares(3, 2+2)

square(3) + square(2+2)
3 * 3 + square(2+2)
9 + square(2+2)
9 + (2+2) * (2+2)
9 + 4 * (2+2)
9 + 4 * 4
9 + 16
25

The first evaluation strategy that Scala uses is called call-by-value, whereas the second is known as call-by-name. Both strategies are guaranteed to reduce to the same value assuming that the reduced expression consists of pure functions, and all evaluations terminate.

The benefits of call-by-value is that function arguments are only evaluated once. The benefits of call-by-name are that function arguments may not be evaluated at all if they aren’t used in the function body.

Evaluation Strategies and Termination

As stated above, both call-by-value (CBV) and call-by-name (CBN) strategies reduce expressions to the same value, as long as those expressions terminate. What happens if they don’t terminate?

If an expression $e$ terminates under the CBV strategy, then it will always terminate under the CBN strategy. However, the reverse is not true.

Consider the following example:

Under CBN, the loop function application is never evaluated, and so the function terminates. Under CBV, the loop function application is evaluated and never terminates, thus first never terminates. Scala uses CBV over CBN despite the prevention of non-terminating functions because in real world practice, CBV reduces the evaluation of arguments and results in significant computational savings. Also it makes analysis of programs easier as you know where arguments will be evaluated. However, if you do want Scala to pass an argument by name rather than value, you can prepend it's type signature with =>:

Conditionals and Value Definitions

As all programming languages need support for choosing between two alternatives, Scala supports if-else conditional expressions. The difference between Scala and Java conditionals is that in Scala, conditionals are used for expressions, not as statements.

Scala conditionals take boolean predicates. h3. Boolean Expressions Boolean expressions can be composed of: * true, false //constants * !b //negation * b && b //conjunction * b || b //disjunction as well as the usual comparison operators: e < e, e <= e, e == e, e != e, e >= e, e > e Boolean expressions reduce as follows: * !true == false * !false == true * true && e == e * false && e == false * true || e == true * false || e == e Boolean predicates are dealt with by using "short-circuit evaluation", that is, if the first half of the predicate returns true, the rest of the predicate is not evaluated. h3. Value Definitions As function arguments can be passed by value or by name (by reference in .NET), so too can definitions. Using the def syntax is essentially a "by-name" definition. Everytime you apply the function, you replace the function name by it's body. You can also use the val syntax to define a value "by-value", similar to assigning a variable (the difference is, variables are mutable - these values are not). The right hand side of a val definition is evaluated before the definition.

You can observe the differences clearly when trying to use each syntax to define an infinite recursion:

h2. Example: Square Roots with Newton's Method Lets use what we have learnt so far to implement a function that calculates the square root of a number using Newton's approximation method. The function signature should look like this:

Newton’s method is as follows:

Start with an estimate y. Y can be any positive number, though the closer it is, the faster the square root will calculate
Repeatedly improve the estimate by taking the mean of y, and $\frac{x}{y}$.

For example:

Estimation	Quotient	Mean
1	$\frac{2}{1} = 2$	1.5
1.5	$\frac{2}{1.5} = 1.333$	1.4167
1.4167	$\frac{2}{1.4167} = 1.4118$	1.4142
1.4142	..	..

So how would we turn this algorithm into a Scala function.

Define a Function for Estimation

One good method to implement an algorithm is to build it step by step. That means that first, we need to define a function that does one step of this iterative process:

As you can see, we're implementing at a relatively high level of abstraction. We're not worring about how we improve a guess, nor how we determine if a guess is good enough. All that we're worrying about is making the decision to improve the guess, or return what we have. Note that sqrtIter is recursive, and in Scala, recursive functions require return type signatures. For other functions, they are optional. However it is good practice to include them for all functions. h3. Go Further Down the Abstraction Now we can worry about how we're going to determine if a guess is good enough:

and how we’re going to improve our guess:

Note that we're using the abs function defined above. h3. Square Root Itself Now that we can perform an estimation given an operator and a guess, we just have to wrap that in a function that initializes the guess:

Blocks and Lexical Scope

While it’s good to decompose a program into it’s logical steps, and write functions to perform those logical steps, this can lead to “namespace pollution” where we expose auxiliary functions that matter only to the implementation of a single function.

Consider our sqrt function above. We created the isGoodEnough, improve and sqrtIter functions just to support the implementation of sqrt. Outside the context of the sqrt function, these other functions don’t make sense.

We can use the concept of blocks and lexical scope to nest these functions inside sqrt so that we don’t expose them to the user and pollute the namespace.

This is possible due to the block syntax available in Scala. A block is delineated by braces ({ }) and contains a sequence of expressions or definitions. The last expression in the block is the one that defines it's value, but other expressions can precede the last one. A block is itself an expression, and can be declared and used anywhere an expression can. Variables defined in a higher scope than the block are visible in the block, and variables defined inside the block are available only to the block. Variables redefined in the block will shadow those in a higher scope (makes sense, since there is no mutation). This means that we can simplify our sqrt function:

Tail Recursion

Recall the substitution model. We can formalize this model by considering it as a rewriting of the program itself. Consider the function:

where f is the function definition and f() is the function evalution. We can model the substitution by rewriting the function itself:

where [v_1/x_1, ..., v_n/x_n]B means the expression B where all occurances of $x_i$ have been replaced by $v_i$. The [v_1/x_1, ..., v_n/x_n] is known as a substitution.

This is just a formalization of the substitution model we discussed above.

Consider the example of computing the greatest common divisor:

If we call this function with gcd(14, 21) and perform the substitution on it described above, we get the following results (remember, we're substituting but not evaluating - at each stage, the functions calls are the same in terms of the value):

gcd(14, 21)
if (21 == 0) 14 else gcd(21, 14 % 21)
gcd(21, 14 % 21)
gcd(21, 14)
if (14 == 0) 21 else gcd(14, 21 % 14)
gcd(14, 21 % 14)
gcd(14, 7)
...
gcd(7, 0)
if (0 == 0) 7 else gcd(0, 7 % 0)
7

Notice the cyclical nature of the substitution - the function substitutes down to a call to the same function that looks exactly the same. Next, consider the example of computer a factorial:

If we call this function with factorial(4) and trace the substitution:

factorial(4)
if (4 == 0) 1 else 4 * factorial(4 - 1)
4 * factorial(4 - 1)
4 * factorial(3)
4 * if (3 == 0) 1 else 3 * factorial(3 - 1)
4 * (3 * factorial(3 - 1))
4 * (3 * factorial(2))
...
4 * (3 * (2 * factorial(1)))
...
4 * (3 * (2 * (1 * 1)))
120

Notice how the substituted expression grows, and we build on it.

If a function calls itself as it’s last action, it can reuse that stack frame and save memory. This is called tail recursion. Because tail recursion allows us to reuse the stack frame, and the stack frame consumes a constant amount of space, it operates similarly to an iterative loop in an imperative language.

Generally, if the last action of a function consists of calling a function (either the same or different), one stack frame would be sufficient for both functions. This is known as a tail call.

Above, gcd calls itself as it’s last action, which is a tail recursive call and will execute in constant space. In factorial, after we evaluated the recursive call to factorial, we still need to multiply the value by n. This means we’re going to have to keep all those intermediary steps in memory, and this is not a tail recursive function.

Tail Recursion in Scala

Despite the memory savings, not all functions should be written tail recursive. This is due to the fact that tail recursive functions can be less clear than their non-tail recursive implementations, and unless you have a specific performance need to implement a function using tail calls, you should opt for the most readable implementation.

Functions should be made tail recursive if you expect the data could possibly form deep recursion stacks, and possibly cause a stack overflow.

In Scala, only directly recursive calls to the current function are optimized. If you want to ensure a function is tail recursive, you can add the tailrec attribute to the function, and the compiler will throw an error if it’s not tail recursive:

Coursera Functional Programming Principles in Scala

2013-09-16T00:00:00-07:00

What is this?

I’ve been interested in learning about functional programming ever since I first heard about it, but could never dedicate the time to do so. I’m taking this course to ensure that I at least get some exposure to functional programming.

Coursera Functional Programming Principles in Scala – Week 3

Data and Abstraction

Coursera Functional Programming Principles in Scala – Week 2

Higher order functions

Coursera Functional Programming Principles in Scala – Week 1

Functions & Evaluations

Vlondara

2013-09-09T00:00:00-07:00

Vlondara was an evil cleric of Llolth who joined one of my characters, Khara, during her rise to power.

She was a level 12 drow cleric follower in a Dungeons and Dragons (D&D) campaign a long time ago. The drawing was done at least 6 years ago.

Khara

2013-09-09T00:00:00-07:00

Khara was probably my favorite character. She battled her way out of Ravenloft, and eventually fell under the sway of an evil, demonic sword. Her days of good over, she started to accumulate power until stopped during a war with the wizard whom she used to call her friend.

This drawing was probably the last one I did of Khara, having done at least 5 previous. It was done a while ago, at least 6 years.

Harak and the Mirror

2013-09-09T00:00:00-07:00

Harak was an evil wizard who joined one of my characters, Khara, during her rise to power.

He was a level 12 wizard follower in a Dungeons and Dragons (D&D) campaign a long time ago. The drawing was done at least 6 years ago, purely digital.

At the Rose Portal

2013-09-09T00:00:00-07:00

At the Rose Portal

Gilaen Giluial was a simple rose gardener, until he was pulled through a portal into a strange new city.

He was an elven sorcerer in the Dungeons and Dragons Planescape campaign setting. Originally from Faerun, he was busy tending a rose garden when a thief ran through his garden. Chasing the thief, he entered a portal to Sigil which promptly closed behind him.

This drawing was done at least 6 years ago, I can’t remember when to be exact.

Ashan-Ri

2013-09-09T00:00:00-07:00

Ashan-Ri was a mechalus hacker specialist in a short lived Alternity game.

I don’t remember much about this character, and the drawing must be at least 6 years old.

Adventurin

2013-09-03T00:00:00-07:00

Back in April I wrote about my experiences at SXSW, and plans to start something with some friends . I’ve been slowly working on that, and now I am prepared to reveal a little about it.

Ever since I was a young teenager, I’ve been fascinated by table top pen & paper role playing games (RPGs). I’d heard of this one called Dungeons & Dragons, and looked on the internet for rules to play it. I found bits here and there, but realized you had to buy a book of rules. I went to my local game store and found out it cost $70! My parents wouldn’t buy it for me, so I saved up my lunch money at school for 6 months and went off and bought it myself. Convincing the group of guys at my school who played to let me join them took a little more effort but once they said yes I was hooked.

As I played through high school, univeristy, working full time and dating, I slowly stopped playing as it became a lower priority for me in my life. Although we had a lot of fun it was very time consuming to prep both as a player and a game master (GM). I’ve spent time on both sides of the table. I’ve written 20 page backstories and invented a host of supporting characters to flesh out a level 1 character. I’ve spent hours crafting a story to run my players through, making it as open ended as possible. I have a 13 story unfinished “Vampire: The Masquerade” chronicle sitting on my harddrive that’s in excess of 100 pages.

I don’t think this is unique. In fact, I know it’s not. Players and GMs put in so much time to create fantastic stories together that are experienced by a group of 5 or 6 people over the course of a handful of hours. Then they die. Then the stories languish on hard drives or in notebooks in drawers if they’re lucky, thrown out and destroyed if not. Really dedicated players and GMs might put their content online but that’s not always easy.

All that time, and the story is experienced once.

I want to make it easy for players and GMs to share their work. I want to build something that will make it possible to make money from their work. I want to build something that will enable people from all over the world to play with each other easily.

The first step is miniatures. I started playing again a few years ago, and found play with miniatures to be superior for visualizing action than the way we used to play, just sitting around a table. But finding a good miniature to represent the character I spent hours crafting was difficult, if not impossible. Many compromises were made.

With the rising popularity and ubiquity of 3D printing, I shouldn’t have to settle for someone else’s idea of my character. I should be able to mould my character exactly as I see it, in plastic, to play with. Right now I can’t, and that’s something that my friends and I want to fix.

It’s time to start Adventurin’

Princeton Algorithms, Part 1

2013-08-22T00:00:00-07:00

What is this?

While studying Software Engineering at school, I did most of my theoretical computer science work in the first year. That was over 10 years ago – suffice to say, I don’t remember much.

I think it’s important to periodically review things you’ve learnt, otherwise you will forget them. I’m taking this course both as a refresher now, and to build a set of notes I can use to refresh myself later.

PDF Stitcher - Combine multiple PDFs into one

2013-06-26T00:00:00-07:00

Description

For a while I’ve had a little utility script that will leverage Ghostscript and combine multiple PDF files into a single PDF. This script came about after finding a few really great free textbooks online that were broken up by chapter. This is both annoying to download and annoying to read.

After logging into my VPS for the third time just to stitch some PDF files together, I decided to turn my little script into a little service.
A few hours and a domain registration later, and I have the service available.

It’s available here: PDF Stitcher – Stitch Multiple PDF files into one

It’s super easy to use – paste the URL of a page that has a list of links to PDF files in the box, and press the button. The service will fetch all the linked files and stitch them together.

The source code for this service can also be found on my Github account just in case you want to self host.

Book Notes: The Launch Pad

2013-06-04T00:00:00-07:00

Amazon: The Launch Pad: Inside Y Combinator, Silicon Valley’s Most Exclusive School for Startups
(referral link – help me buy new books!)
ISBN: 1591845297
Read: 2013-05-13

After reading this post about DIY Y-Combinator I wanted to find out exactly what happens in YC.

Notes

When considering an idea, figure out how it expands. When doing so, think about how it affects the world as it is, not what the idea does. Example: app that gathers photos from a users Facebook profile and creates a photo book. Can eventually be expanded to replace yearbooks.

Also ask, would someone pay for that? Nobody would pay to save themselves a single click (full text of links in Twitter stream)

Look at competitors and figure out what they do that hurts them. Then don’t do that.

Beginners mind in all things – don’t dwell on how hard starting up will be (if you even know).

Sell pixaxes during a gold rush. That is, when people are creating software startups and services, sell tools they’ll need to build it. Your success is independent of theirs.

Reduce drag on things that are important. Remove obstacles that will increase resistance to doing things that move you forward. Remove distractions.

The best way to learn something is to do it.

It’s better to be a small fish in a big pond. Makes you hungrier.

Know when you create a start up that you’re competing against the odds. And do it anyway, because it’s what you want to do.

Make something that people want – something of incredible value to a niche of users who will pay.

Each time you swing the bat, you increase your odds of success. Ergo, each time you do something other than swining the bat, you theoretically decrease your odds.

Startups must be designed for scale.

“Ask yourself: ‘What do I wish someone would start a startup to do for me?’” or something for someone else that you know is a problem.

“Do you ever, in your work, say, ‘Boy, I wish somebody would just – blank’?”

Pick something you’re passionate about that you have domain knowledge in.

What will people in the future say was an unmet need today? – look forward

Solve a burning need

If you’re excited about an idea that most people are bored by, and it’s a problem, that’s an advantage.

Pick ideas where the cost of failure is low, and is basically just time.

“Friends will use stuff because they’re friends … the true test is if they start bringing other people into it … that’s something that they won’t do out of obligation to you”

Launch fast, get feedback, people can only tell you what they want when they see what you don’t do. Iterate.

You make what you can measure.

Every week, set a specific target for growth.

Imagine five years out you’re a huge company, guess why you’re a big company. That will give direction.

Find an industries influencers and influence them – that’s valuable to suppliers of that industry.

Don’t worry about domain names – it won’t break a good idea, and you’ll have money to buy the right one later.

Do work on things that matter – refactoring your code or dealing with databases is ‘work’ that won’t move you forward.

Doing the wrong thing is better than doing nothing at all.

Think 5 years down the track, what is success? What would you put on your resume saying what you did?

Rejection is inevitible, and frequent. When selling, no means not yet. There is no definitive no, only a to-be-continued.

Seeing how users interact with your product/idea and why they are rejecting you is valuable.

Start selling before your product is completed.

“Err on the side of sales. Just spend all your time doing sales and treating hacking as this side project”

Sell source code for failed startup/ideas/projects

When pivoting, if you have 2 ideas, work on both. Pick the best, or if both good, spin up 2 startups.

Look forward, but have a plan to make money now.

A startup can change it’s idea quickly, but not it’s cofounders. “Startups do to the relationship between the founds what a dog does to a sock; if it can be pulled apart, it will be.”

Your startup is never someone’s top priority but your own. Get their email address and treat them as a lead.

“When VCs decide they don’t like you, it’s based on gut feel” – the reason they give is an excuse.

Pitching the startup:

If it doesn’t feel wrong, you’re talking too fast.

Don’t use a slide that could work in another startup’s deck.

People aren’t going to work to understand you. You need to grab their attention and be simple and easy to understand.

Why you? Why not someone else?

Don’t go into too much detail.

You don’t want to be animated the whole time, and you don’t want to not be animated. Choose when you are animated. You tend to speak animatedly about the most important thing about your startup.

If a statement is not surprising, it’s probably not an insight.

Investors will often walk away from your pitch with a single noun in their mind.

Be excited about your product.

Being better (UX) than your competition is valuable in itself.

30% of YC companies will experience a split among cofounders.

Book Notes: LLC vs. S-Corp vs. C-Corp Explained in 100 Pages or Less

2013-04-30T00:00:00-07:00

Amazon: LLC vs. S-Corp vs. C-Corp Explained in 100 Pages or Less
(referral link – help me buy new books!)
ISBN: 0981454275
Read: 2013-04-30

A no-nonsense whirlwind tour of the essential difference between LLCs, S-Corps and C-Corps. A great foundation for going to talk to an attorney or accountant or someone who actually knows what they’re doing. I wouldn’t recommend doing any of the work yourself beyond forming an LLC, but then I’m pretty risk adverse.

The notes below are a condensed version of the book above, so that I can quickly and easily access the content without having to dig the book out on my Kindle.

Notes

Brief Outline

Part 1: A discussion of sole proprietorships and partner ships – it’s most likely than a currently operating business is one of the two. Chapters 1 – 7.

Part 2: LLC vs. S-Corp vs. C-Corp, and ramifications. Chapters 8 – 15.

Part 3: Related topics such as ramifications of becoming an employee of your business as a result of electing corporate tax treatment. Chapters 16 – 17.

Sole Proprietorships

From a federal standpoint, any business started by a single person is automatically a sole proprietorship, unless the owner decides to take some action, such as incorporating, in order to become a different type of entity.
State, county or city may have extra requirements, such as licenses.

An Employer Identification Number (EIN) is not required, however is convenient. EIN is to a business as a SSN is to an individual. Sole proprieterships can use the owners SSN, but an EIN can protect the SSN from identity theft.

Most states require a “Doing Business As” (DBA) if your name and the business name don’t match.

Sole proprietorships are a “pass-through” entity, meaning owner is responsible for profits and losses. File taxes as normal, profits are taxed as income (added to owners 1040 from calculation on Schedule C), with added self employement tax (calculated on Schedule SE) of 15.3%.
Half of the self employement tax can be deducted as an “above the line” deduction.

Sole proprietorships have “unlimited liability”, that is, owner is personally liable for debts of business.

Partnerships

Partnerships start similarly to sole proprietorships, by multiple people doing business as a unit, but require an EIN and a DBA.

Much more likely for local requirements on a partnership, so check city hall.

Also recommended is a partnership agreement. This is a contract that specifies how expenses are divided, profits allocated, how and when profits allocated, which partners are responsible for which tasks, under what circumstances a partner can sell his or her interest to someone else, how disagreements will be resolved. At least. Anything else that might come up.

Partnerships are taxed like sole proprietorships, only with the inclusion of Form 1065 to calculate the partnerships profit/loss. At the end of Form 1065 is a Schedule K where income is broken down into categories, and each member of partnership fills out a Schedule K-1 for their share of those incomes. These then show up on regular income tax return (Form 1040).

Partnership taxation is based on the concept of “tax basis”. Generally, owners of a partnership are taxed upon their share of the taxable income, regardless of how much is distributed. A partner is not taxed upon distributions from the partnership as long as the distributions don’t exceed the partner’s tax basis.

A partner’s tax basis in a partnership is:

1. Increased by any amount s/he invests in the business
2. Increased by his/her share of the partnership’s taxable income (and decreased by his/her share of the partnership losses)
3. Decreased by the amount of any distributions s/he recieves
4. Increased by his/her share of the debt owed by the partnership.

Partnerships have unlimited liability, and a partner is responsible for the partnerships liabilities in total, even if created by another partner.

Thus far, the term partnership refers to a general partnership. Concept of limited partnership also exists. Limited partners are only liable up to their investment in the partnership, but cannot engage in management or day to day operations. Usually reserved for outside investors.

LLC’s

An LLC has pass-through tax treatment with limited liability protection. It is a state level entity, and requirements will vary state to state. In most states, an LLC is formed by filing a document known as articles of organization with the Secretary of State. Generally, articles must include:

1. LLC’s name and address of it’s principal place of business
2. Names of the owners (members) of the LLC
3. Nature of the LLC’s business
4. The name and address of the LLC’s registered agent (party authorized to accept delivery of legal documents on behalf of LLC)

If you wish to have a physical presence in another state, you will need to “qualify” or “foreign qualify” the LLC with the Secretary of State in those states.

If the LLC will have multiple owners, as per a partnership, should include an operating agreement and have an EIN.

Converting between a sole proprietorship and an LLC, or between a partnership and an LLC is a non-taxable event given how LLCs are taxed.

If the LLC is single-member with no employees, owner should continue to use SSN instead of EIN for taxation.

An LLC is a “disregarded entity”, meaning for federal taxation requirements, it doesn’t exist, and is instead treated as a sole proprietorship or partnership.

An LLC can opt to be taxed as a corporation. This can be done by either forming a corporation and transfering all assets from the LLC to the corporation, or by filling out a form (form 8832 for C-Corp, form 2553 for S-Corp) electing for corporate tax treatment.

LLCs may be taxed differently in different states, and that may affect the viability of forming an LLC.

LLCs are usually formed for their limited liability, but it’s not perfect. Here are some situations where you are still liable for the actions of the LLC:

1. Signing personally for business debt
2. Liability resulting from tort of the LLC owner (where “tort” refers to wrongful acts other than breach of contract)

C-Corporations

A C-corp is similar to an LLC, and differs only in how it is taxed. Accountaints, doctors, engineers, lawyers and social workers are usually not allowed to form a regular C-corp, though this varies from state to state.

A C-corp itself is subject to income tax, as opposed to the owner/partners of an LLC. The taxation rate is unaffected by how many owners (shareholders) there are.

Taxation rates for a C-corp can vary year to year. For 2012, here are the rates:

Income range	Rate
$0 – $50,000	15%
$50,001 – $75,000	25%
$75,001 – $100,000	34%
$100,001 – $335,000	39%
$335,001 – $10,000,000	34%
$10,000,001 – $15,000,000	35%
$15,000,001 – $18,333,333	38%
$18,333,334+	35%

When a corporation makes a distribution to it’s owners, the payment is known as a divident, and is taxable to the recipient. That is, corporate profits are taxed twice.

To get around the double taxation, the corporation can pay the owners a salary or end of year bonus that will leave the corporation with zero income. This will be taxed on the owners at their income tax rates, as per an LLC.

Double taxation can be leveraged to save money, by paying a portion of income as salary rather than all of it. This can cause both the employees and the corporation to be in lower tax brackets, and save money. However, be aware of the 15% accumulated earnings tax charged on top of income tax on income that accumulates (not distributed) beyond the corporations reasonable needs. Keeping accumulation under $250,000 is a good rule of thumb.

Corporate losses are also not passed to the owners as an LLCs are. Instead, C-corp losses can be used to offset taxable income from the two prior years, or up to twenty years in the future.

Form 1120 is filed for a C-corps tax return. The second page (Schedule C) is only applicable if the corporation owns shares in other businesses. The third page (Schedule J) is where any tax credits are applied. The fourth page (Schedule K) is a mixed bag of questions, such as the number and nature of shareholders, whether the necessary forms have been filed, etc. The last pages (Schedules L, M-1 and M-2) are only required if the corporation has assets greater than $250,000 at the end of the year or total receipts of $250,000 or more for the year.

For liability, coprorations are distinct entities that can own things, rent things, sue or be sued.

In order for a corporation to keep it’s classification, a few legal requirements need to be met. For example, whenever a major decision is made, it must be recorded in a document known as a “resolution”. Also, most states require an annual meeting of the directors and shareholders of the corporation, and a record of everything that was discussed.

As in an LLC, it’s possible for the owners of a corporation to be liable as a result of any torts they personally commit.

The term “piercing the corporate veil” refers to breaking the separation between the owners of a corporation and the corporation itself.
Some factors that may lead to a court piercing the corporate veil:

Intermingling of funds between corporate accounts and personal accounts
Disregard for corporate formatlities
Undercapitalization of the corporation (corp. lacks capital to satisfy obligations)
Absence of corporate financial records
Anything else a court believes would mean that the corp. is just a formality and not materially distinct from it’s owners.

S-Corporations

S-corporations are similar to C-corporations, and differ only in taxation and a few rules of ownership:

Must be a domestic corporation
No more than 100 shareholders/members
Shareholders can only be individuals, estates or tax-exempt organizations. No corporations or partnerships.
No non-resident alient shareholders
Can only have one class of stock
Cannot be a bank or insurance company
All shareholders must consent to the election

An S-corp, like a partnership, is a pass-through entity. Taxes are filed on Form 1120S. Unlike a partnership, S-corps are not subject to the self employment tax, however each owner who also works as an employee must be paid a “reasonable” salary, which will be subject to Social Security and Medicare taxes to be paid half by the employee, and half by the corporation. This means the benefits from not having a self-employment tax only kick in once the S-corp is making enough money to pay it’s owners a reasonable salary.

Each state has it’s own rules regarding S-corp taxation, so check with the state the S-corp is incorporated in.

Being an Employee of Your Business

Being an employee of your corporation has rammifications.

As a business with employees, you will have to register as an employer in your state to pay unemployement tax.

You will also have federal and possible state level reporting requirements, such as needing to file:

Form 940 annually to report the Federal Unemployment Tax Act (FUTA) tax for wages paid,
Form 941 quarterly to report Social Security, Medicare and withheld income taxes on wages paid,
Form W-2 annually to report wages paid, taxes withheld and other related information.

Also need to make monthly payments of the employers share of Social Security and Medicare taxes on wages, plus amount withheld for employee’s share of taxes as well as income tax.

Another drawback to corporate taxation is the limitation imposed on the amount allowed to be contributed to a business retirement plan. For example, a sole proprieter can contribute to a SEP IRA for 2012 the lesser of $50,000 or 25% of the net earnings from self employment, but as an employee the most you can contribute is the lesser of $50,000 or 25% of your salary.

Book Notes: Start Small, Stay Small - A Developer's Guide to Launching a Startup

2013-04-15T00:00:00-07:00

Amazon: Start Small, Stay Small: A Developer’s Guide to Launching a Startup (referral link – help me buy new books!)
ISBN: 0615373968
Read: 2013-04-15

I actually read this one a while ago, but I think it deserves some note taking, so I re-read it.

In my opinion, one of the best ways to start a business is to bootstrap. This is probably due to the fact that I am fairly risk adverse, but that’s neither here nor there. This book covers some important information about bootstrapping, and provides a great balance between theory and practical advice.

Notes

Chapter 1 – The Chasm Between Developer and Entrepreneur

Aimed at developers who want to bootstrap. Not for VC funded, ultra fast growth startups.

Fast growth, VC funded startups have pressure to go after larger markets fast, which is hard, due to investors wanting a return. Bootstrapped startups can go after smaller niches and own them, and take their time to figure it out.

A bootstrapper needs to be a developer who can sell. They need to be able to manage a website and market, including finding a market.

Venture backed = high risk, high payoff. Bootstrapped = low risk, lower payoff (though still nice, otherwise why do it?)

The wrong reasons to build a software product:

Reason #1: Having a product idea
Beware product vs. project. A product is a software project with a market of people who want to buy it.

Reason #2: To get rich
Bootstrapping will not likely bring a million dollar payday. Venture backed startups or the lottery may, with terrible odds.

Reason #3: Because it sounds like fun
It’s only fun at the end. It’s hard work most of the time.

Break the link between dollars and hours. Make money from software, not time.

Set goals to harden your resolve during tough times:

1. Write goals down
2. Make a public commitment
3. Become accountable

Last 2 are reasons for a cofounder or entrepreneur community

Biggest roadblocks to success:

Roadblock #1: No market
You probably don’t have the clout to create a market. Don’t build a product if you don’t know there’s a market for it already.

Roadblock #2: Fear
Lean in. Fear means you’re growing.

Roadblock #3: Lack of goals
Use the steps above to manage goals.

Roadblock #4: Inconsistency
Make sure everything you’re doing is relevant. Stick to an information diet.

Roadblock #5: Believing you have to do everything yourself
Get someone who charges less for their time per hour than you do. You’ll always save money in the long run.

“Dollarize” – show how a price is less expensive due to the amount of money saved in the long run.

Dollarize your time to validate outsourcing – see roadblock #5. Calculate time value based on freelancing rates or salary. Keep in mind desired earnings isn’t actual earnings.

Shoot for a $100/hr rate in the long run. Your startup won’t start there, but once you have a firm dollar rate, you can work on increasing it.

Realizations of dollarizing time:

Realization #1: Outsourcing is a bargain, as long as they charge less per hour than your dollarized hour.

Realization #2: Keep work and play separate
Don’t do both at the same time, you’ll suck at both.

Realization #3: Wasting time is bad
Each wasted hour is $xx.

Realization #4: Information consumption is only good when it produces something.
Unless you do it for play.

Realizations from transition from developer to entrepreneur:

Realization #1: Being a good technician is not enough
As per “The E-Myth Revisited” by Michael Gerber, ned to be entrepreneur (dreamer, visionary), manager (business stuff), technician.

Realization #2: Market comes first, marketing second, aesthetic third, functionality fourth.

Realization #3: Things will never be as clear as you want them to be.
Selling (and anything fuzzy involving humans) involves lots of guesswork, lots of iteration. Guess, measure, tweak.

Realization #4: You can’t specify everything… but you do need a plan.
Be agile.

Realization #5: You need to fail fast and recover.
BE AGILE!

Realization #6: You will never be done.
An artist never finishes a work, he just stops working on it.

Realization #7: Don’t expect instant gratification.
Inertia. Starting for the first time is way harder than doing it for the second time.

Realization #8: Process is king.
Lighten your mental load by storing information in process.

Realization #9: Nothing about a startup is a one-time effort.
Most startups won’t be automated. They’ll require maintenance and tweaking.

Chapter 2 – Why Niches Are the Name of the Game

The single most important factor to a product’s success is whether there’s a group of people willing to pay for it.

Luck is the exception. Sites like Hot or Not and Plenty of Fish.

Find a niche to avoid big player competition and make a larger impact.

Reasons you must go niche:

Reason #1: A niche requires you to narrow your product focus.
The narrower you make your product while still maintaining a large enough market, the more profit you will generate. Selling software to 100% of the people in a 5,000 person niche is better than selling to 10% of the people in a 50,000 person niche. Advertising will be cheaper, communities easier to build, competition lower.

Reason #2: Nice advertising is more cost effective.
Niche advertising space is usually cheaper. This is true from magazines to Google AdWords.

Reason #3: Niches have less competition.
Big companies like big markets.

Reason #4: Niches have higher profit margins.
Owning your niche allows you to charge higher prices (but don’t price gouge).

Reason #5: Niche markets are not used to good marketing.
Good marketing will have a bigger impact.

Reason #6: It’s easier for prospects to trust you.
Easier to build a name/reputation in smaller markets.

A warm niche is a niche where you have some kind of association. You or someone you know is involved in it.

You can work your network to turn a cold niche into a warm niche by finding someone with experience.

Coming up with niches:

Approach #1: Look at all areas of your life
Think of problems with hobbies, interests, jobs, and those of people you know.

Approach #2: Look at occupations

Approach #3: Cheat
http://www.entrepreneur.com/businessideas/ – search Category → Online Businesses
http:www.sixmonthmba.com/2009/02/999ideas.html
http://www.ahbbo.com/ideas.html
http://ycombinator.com/ideas.html

Find niches based on experiences. For example, examine keyword entrances on your blog or website. Large segments of people entering a single page on a set of keywords might be a niche.

If your target market is not online, you have no chance of succeeding using the methodologies you’ll find in this book. Target market must be online.

Evaluate the size of a market by finding cheap advertising opportunities, either online or offline. Also look at competition. If you can’t find competitors, you haven’t found a market.

Determine if you can reach them inexpensively.

Vertical markets (dedicated to a single industry or hobby) are better than horizontal markets that cut across many:

Reason #1: Members of a vertical have similar behavior
Marketing and sales approach is simpler.

Reason #2: Members of a vertical talk to one another
Word of mouth, convincing thought leaders is easier.

Reason #3: Members of a vertical “hang out” together
Each marketing opportunity will reach more people.

Reason #4: Members of a vertical have similar needs.
Easier to narrow scope of product.

Determine pain in a niche that can be solved with software, either yourself of by talking to a contact.

Measure demand using

*Google AdWords Keyword Suggestion Tool: https://adwords.google.com/select/KeywordToolExternal
*SEO Logs Keyword Difficulty Tool
*Micro Niche Finder (paid)

Steps:

Step #1:
Enter main phrase without quotes, include synonyms, run search, change to “exact match”, search again. Results show search volume. Assuming you can rank #1 for that keyword, you would get roughly 50% of those hits. Then multiply this by 4, to account for long tail searches and other traffic streams. Estimate a reasonable conversion rate, and plug in your price: [volume] * [conversion rate] * [cost] = [revenue].

Step #2:
Choose valuable keywords, and any related terms.

Step #3:
Enter each keyword from above step one at a time. Score returned is measure of difficulty in ranking. 39 and below is good. 60 and above is bad.

Step #4:
Sanity check the keywords you’ve chosen by searching for them, clicking on the first page, checking it’s page rank with the Google Toolbar. Check SEO, domain age, and back links from PageRank meter on Google Toolbar. This determines the strength of your competition.

When final niche and keywords have been selected, set up AdWords/mini sales site with a monetary commitment attached. When user tries to buy, tell them it’s not ready, offer to put on mailing list.

Chapter 3 – Your Product

Success of product relies on product, market, execution.

Test pricing by doing A/B tests and tracking metrics.

Chapter 4 – Building a Killer Sales Website

When thinking about sales funnels, increasing conversion rate is usually easier than increasing size of funnel.

Don’t plan on selling to customers on their first visit.

Expect conversion rates between 0.5% – 4% depending on the price point of your product.

Primary goal of sales website should be to turn visitors into prospects, by getting an email address.

Getting an email address requires trust, relevance and a reward. A free download or a free trial.

Single call to action.

Home page may not be the most visited page. Deep linking. Every page needs a call to action. Every page needs a single purpose. Everything should be within 2 clicks. Make buttons look like buttons. Text sucks, people like images and video.

Find a hook that solves a pain point.

Email has a high conversion rate. Build your list by giving something away or have a short email course.

Email content relevant to your niche every 2-4 weeks. Possibly automate this, with emails being sent at days since sign up milestones. Send product updates.

Email tips:
1. Test and optimize when you send your emails.
2. Send HTML and text email.
3. No attachments
4. Pay attention to the “from” name and address
5. Good subjects
6. One goal for each email
7. Test

Chapter 5 – Startup Marketing

Not all traffic is the same, depending on source. Sources for quality traffic change as niche changes.

Use PPC to find SEO terms and optimize. Do not sustain a business on PPC.

Maintain a mailing list.

Blog.

Work on organic search results with SEO.

SXSW and Side Projects, Oh My!

2013-04-02T00:00:00-07:00

This year I was lucky to be sent to SXSW by my awesome employer. Along with some other co-workers, one of my personal friends was also going. Normally I attend conferences and stick strictly to sessions that are directly and clearly related to my work. After doing some reading about creativity, I decided to broaden my horizons this time and attend any session that caught my eye.

While attending, I took plenty of notes for each session for a total of 30 pages of a 3.5″ × 5.5″ notebook. My original intention was to sketchnote all the talks from these notes, but I think I might skip it. One thing The Sketchnote Handbook showed me was that caputuring the gist of a presentation, either in text or images, was the most important principle. Eventually I may transfer all my notes from my notebook to the site, however that probably isn’t too likely since I heard a lot of the talks were recorded and will be available online.

Back to the conference itself, I had a blast and felt very inspired through the whole thing. I saw sessions on a variety of topics, from particle physics to virtual reality to 3D printing to game design. I learned a lot from each session, and can probably find principles and ideas to apply to my day to day work in each one.

One of the best things to come out of the conference was clarification of a side project I’ve had in my mind for a while. My friend and I talked things through over the 5 days of the conference, and based on some of the sessions we saw, we have a clear roadmap for the development of the side project, one that may even lead it to becoming a fully fledged, adult business. To say we’re both excited is a bit of an understatement.

I said at the start of the year that I would make things that seem cool to me. This side project is definitely something that’s cool. As we progress, I’ll probably share some details, but to avoid putting the idea at risk , I won’t share anything I haven’t done yet. On the plus side, that will mean a more comprehensive write up, possibly with pictures. I can reveal that it’s a hardware project, which will be my first real hardware project.

I also have an RSS related idea that I may bump to the front of the queue as well given the imminent shutting down of Google Reader. That one would definitely be a case of eating my own dog food, however it requires other people to use it as well. Again, I won’t share details until I’ve done the work, but that one I will definitely do some write ups on.

As a side note, I recently started taking notes on books I’m reading, and haven’t posted any lately. That’s because my wife decided that now was the time for me to read all 7 Harry Potter books, so I’m slowly working my way through those. I’m onto book 4, so I anticipate being done in a few months. I will however try to squeak in the odd non-fiction book reading here and there. The next book I want to read is “The Creative Habit” by Twyla Tharp.

Book Notes: The Sketchnote Handbook

2013-02-24T00:00:00-08:00

Amazon: The Sketchnote Handbook (referral link – help me buy new books!)
ISBN: 0321885112
Read: 2013-02-22

Sketchnotes are a great way to visually record the analysis of a presentation. They are beautiful in and of themselves, but their real magic is in encoding a personal interpretation of presented material. This book goes into how to create them and gives tips. It also comes with a 70 minute video, which is similar in content to the book, however the live sketchnoting video is illuminating.

Notes

Should I sketchnote about The Sketchnote Handbook? How meta do I want to go?

Sketchnoting is enhanced note taking. It focuses on capturing the big ideas behind a presentation. It helps retention by getting the mind and the body to act together. It also infuses notes with personality, making them easier to read.

The Theory

Sketchnoting is about drawing ideas, not artwork.

The Dual Coding theory, formulated in 1970 by Allan Paivo, states that the brain processes information using 2 channels:

Verbal
Visual

When both channels are used at the same time, the brain creates mental cross references.

Creating Sketchnotes

When creating sketchnotes, the key is to listen actively. Try to spot patterns in the presentation and cache ideas as you draw, so that you can add them when you have time.

It helps to research the presentation and presenter before hand.
Sketch the title and determine layout before the presentation starts.

A good structure is the core of a sketchnote. Consider the structure is meat and potatoes – art would then be the gravy.

Patterns:

Tools:

Typography
Diagrams
Bullets
Drawing
Dividers
Icons
Handwriting
Arrows
Containers

Remember to build hierarchy and personality into sketchnotes.

Book Notes: How to Read a Book

2013-02-12T00:00:00-08:00

Amazon: How to Read a Book (referral link – help me buy new books!)
ISBN: 0671212095
Read: 2013-02-12

A good analytical approach to reading books with purpose. Readers for leisure need not apply. Although the author references scientific and mathematical works, the book shines when discussing how to gain meaning and understanding from books that are more concerned with the humanities.

Notes

Goals of reading books:

Entertainment
Gain information
Gain knowledge/understanding

There are four levels of reading, wich higher levels encompassing and including lower levels of reading:

elementary reading
inspectional reading
analytical reading
syntopical reading

Analytical reading is only required when the goal of reading is to gain understanding. For entertainment or informational reading, elementary or inspectional reading is sufficient.

Elementary Reading

Reading learnt in school. Great for reading for entertainment.

Inspectional Reading

Inspectional reading is performed in 2 parts. Experienced readers can accomplish both simultaneously, however for beginners it’s best to do them separately.

Systematic skimming or prereading

Look at the title page & preface
Study the table of contents
Check the index
Read the publisher’s blurb
Look at chapters that seem pivotal to the book’s argument, and read the chapter summary statements (if they exist)
Turn pages of the book and dip in here and there, reading a paragraph or two. Look for signs of the main contention
Read the book’s conclusion

The purpose of prereading is to attempt to figure out the book’s general theme or idea.

Superficial reading

Read through the book without stopping to look up or think about concepts that aren’t immediately understood. Read relatively fast – some speed reading techniques may apply here.

Analytical reading

Before you read the book, determine what kind of book it is: theoretical or practical.

As you read the book, ask the following questions of it:

What is the book about as a whole? What is the leading theme & how is it developed by division into sub themes or topics
1. Classify the book according to kind & subject matter
2. State what the whole book is about as succinctly as possible
3. Enumerate major parts in their order and relation, construct an outline
4. Define the problem or problems being solved
What is being said in detail, and how? What are the main ideas, assertions and arguments of the book?
1. Come to terms with the author – understand key words
2. Grasp leading propositions by dealing with the most important sentences
3. Know the arguments by finding them in, or constructing them from, sequences of sentences
4. Determine which problems were solved, which were not, and of the ones not solved, which the author knows he/she failed at.
Is the book true, in whole or in part? Make up your mind about the book.
1. Don’t criticize until you understand the book as per above
2. Do not disagree disputatiously or contensiously
3. Demonstrate knowledge of difference between knowledge & opinion by presenting good reasons for any critical judgement.
  When crticising a book:
4. Show wherin the author is uninformed
5. Show wherin the author is misinformed
6. Show wherin the author is illogical
7. Show wherin the authors analysis or account is incomplete
  If you cannot show the above, you must agree with the author.
What of it? What is the significance of the book to you? Is it important for you to know?

As you read analytically, take notes about both the books structure and the books concepts.

Syntopical reading

The purpose of syntopical reading is to analyze the contention in a subject. Do not defend an opinion, merely conduct a survey. Do this by reading multiple books on a single subject.

Before getting started, you must use elementary and inspectional reading to:

Create a tentative bibliography
Inspect all books and determine if they are relevant

These tasks can be performed in unison, building bibliographies from books determined to be relevant to the subject.

Once a bibliography has been created, read books using a combination of elementary, inspectional and analytical reading simultaneously. While reading, perform the following steps:

Find the relevant passages in each book
Bring the authors to terms with each other – construct a neutral argument to frame multiple authors terms to a single “language”
Get the questions in a subject clear
Define the issues central to the subject
Analyze the discussion of these issues across books.

Remember to be objective.

80/20 Expertise

2013-01-09T00:00:00-08:00

In his article “Teach Yourself Programming in Ten Years” , Peter Norvig asserted that it takes around 10 years, or 10,000 hours of deliberate practice to achieve expertise in anything. I am 28 years old, and if I’m lucky I will live until I’m around 78. Probably. Which gives me around 5 things that I can become an expert in between now and when I die. That sure doesn’t sound like much.

But what if I don’t want to become an expert? What if I just want to be OK at something, or just want to get some experience in it? Can I apply the Pareto Principle to get more bang for my time?

The Pareto Principle states that 80% of the effects come from 20% of the causes. I wouldn’t be surprised if that extended to the above 10,000 hour rule. Surely someone who spent 2,000 hours practicing something would be significantly better at it than someone who had spent 0 hours on it. Granted, you wouldn’t be an expert in that activity, but you would be knowledgeable in 5 times the activities as the expert.

It’s something to keep in mind as I scramble to do as much stuff as I can.

Do the Work

2013-01-06T00:00:00-08:00

In my 2012 year review post, I mentioned that one of my goals for 2013 was to make more, and do the work. I mentioned that I would expand upon what I mean when I say “do the work”.

In 2012, I challenged myself to do more art, and set a bunch of goals and milestones to track how well I was succeeding. I managed to hit none of them. I didn’t do a single meaningful thing. I think I filled 3 or 4 pages in a sketch book with sketches.

The reason I didn’t do anything, I think, is two fold. Firstly, I was putting things off until I felt I was good enough to do them. Secondly, I was waiting for inspiration to strike before doing any practice. This combination had me spinning my wheels in place for an entire year, where nothing I wanted to get done was done.

“I’ll finish that painting when I’m better at painting”, I would tell myself. By waiting until I was better, I never got any better. It would have been far better if I had screwed the painting up and tried again, and screwed up and restarted 10 times than what I did. Derek Sivers covers it well in his article, Quantity + Learning = Quality . Except I didn’t get any practice done, due to my other problem.

I was waiting for a great idea of something to express to come to me, and let it flow out of me and into the paper. But that’s not how it works. I’ve heard or read it before from a variety of sources, but it was a quote by Chuck Close in the book “Inside the Painter’s Studio” (found via this post) that really resonated with me:

Inspiration is for amateurs – the rest of us just show up and get to work. And the belief that things will grow out of the activity itself and that you will – through work – bump into other possibilities and kick open other doors that you would never have dreamt of if you were just sitting around looking for a great ‘art idea’

That’s exactly what I was doing! I was just sitting around, waiting, and look at how I did – I did nothing.

Doing the work is my answer at solving the second problem, which should also overlap and solve problem one. Just show up, start working and build fundamental skills. I’ll get more done by making crap and learning from it and enjoying the process than I will by waiting for the perfect combination of inspiration and skill to fall into place.

2012 In Review, And a Look Forward to 2013

2013-01-03T00:00:00-08:00

2012 is really easy to review, in terms of the goals I set last year : it was a bust. I didn’t complete a single goal I set myself. The painting remains unfinished, nothing was sold, nothing was submitted to Spectrum. Here is what I did manage to do:

Completed 2 more MOOCs – ‘AI for Robotics’ from Udacity , and ‘Foundations of Computer Graphics’ from edX .
Wrote a raytracer in the course of the edX class above
Actually wrote a full (but simple) game in C++ and half of another (and started a blog for it ).
Started and maintained a physical journal

That’s all I can remember! I don’t remember what I read or what I saw, beyond a few things that I’m not going to bother to post. This lets me know 2 things:

I wasn’t serious enough about my goals for 2012
I didn’t hold myself accountable for how I spent my time

I was going to post this year in review a few days ago, but I held off for some reason, and I’m glad I did. Yesterday, I can’t remember how, I came across this great page on creativity and more specifically, the “Sex & Cash Theory” . The theory is as follows: every creative person has two kinds of jobs – sex and cash. The sexy job is what you want to do, the cash one is what you do to pay the bills.

I’m lucky in that I find my cash job pretty sexy. Yet I spend so much time trying to create a lifestyle where I don’t have to do it. I noted in my journal yesterday that I spend a lot of time trying to create a lifestyle where I have more time, time that I would spend making things. That seems kind of dumb. Why not just make them in the first place?

This has influenced my goals for 2013. In 2013, I’m going to make things, and track my time better. Specifically, I’m not going to be restricted by making things that make money, or otherwise lead to a lifestyle where I don’t have to work. I’m happy with the cash part of my lifestyle – it’s the sex part I’m not doing too well.

In 2013, I’m going to make whatever grabs my fancy. Robots, eletronics, art, music, games, books, whatever. As long as I’m creating, and keeping track of my time, I’ll be happy. Concretely, these are my goals:

make/do the work
read more
write more
learn more
track time expenditure, what I read, what I wrote, what I learnt

I feel the first one needs a little more explaining, and I will probably do it in another blog post, but basically, you can never do anything good if you don’t do anything.

There are a few more loose goals in mind, but I feel the specificity of last years goals hurt my attempts to follow them rather than helped.

As always, in 2014 I will review the year and do it all again!

edX Foundations of Computer Graphics postmortem

2012-12-20T00:00:00-08:00

I have recently finished the “Foundations of Computer Graphics” massively open online class (MOOC) offered by edX, and I had a lot of fun and learnt a lot about ray tracing. In the following post, I will highlight what I liked about the course, what I didn’t like about the course, and offer suggestions to anyone who does the course when the offer it next in March, 2013 or anytime later.

As you can see on the course website, it covers 4 major topics: required math, transformations, OpenGL and lighting and ray tracing.

Unit 1 – Math

The first topic was largely review for me, and will be for anyone who knows linear algebra, or has worked with computer graphics before. Vectors and their operations, matrices and their operations and coordinate frames were covered. The assigment here was to get your programming environment set up with their code framework. While I’m sure it was helpful for those new to programming, anyone who has worked with C++ before probably doesn’t need to worry about this homework.

Unit 2 – Transformations and Projection

Next, 2D and 3D transformations were covered, including 2D scaling, shearing, rotation and translation and 3D scaling, rotation and translation, as well as final transform matrix composition and orthographic and perspective projection.
This section was very useful to me, though the pace was fairly fast. I had to do a lot of self learning on this topic, including how to derive perspective projection and a few other theorems.
The homework for this class was to implement a number of 3D transforms and a perspective projection in the framework, which was pretty much plug and chug. It was useful from the perspective of interpreting mathematical formula in code, but it didn’t particularly tax me.

Unit 3 – OpenGL and Shading

Once we covered the theory, we started into practice. The next section was on OpenGL programming and computer graphics theory, such as the Gouraud, Phong and Blinn-Phong shading models. I preferred other sources on OpenGL syntax, as there are much better sources that go into more depth that I’ve linked to from my notes on the unit . Again, I had to do a fair bit of self learning on light scattering and the shading algorithms and how they were derived and what they mean.
The homework again was to insert code into their framework, this time shading code and some file reading and scene set up. Again, I didn’t feel I learnt much from this homework, as you don’t really get to write your own full stack. I didn’t have to hook up shader variables and buffer vertices, because all that was done. I just had to shade them.

Unit 4 – Ray tracing

Up to this point, I was feeling fairly disappointed. I have done some self study in graphics, but have never gotten around to implementing what I learnt. I thought this would be a great way to be forced to do some implementing, but up to this point, I was wrong.

Then we started learning about ray tracers. If the previous 3 units could be faulted for excessive hand holding, this unit definitely threw you into the deep end. In one unit, we covered ray tracing theory and tips to ray tracing implementation. The theory extended to generating rays from a camera definition, ray object intersection and recursion and reflectance. The tips on impementation were on how to calculate rays from a camera, a repetition of the intersection theory, impelemting shading and recursion.

The homework was to write a ray tracer from scratch, including a file parser, from just a handful of lectures and the code from the previous homeworks. The goal was to render a series of images, one of which had 50,000 vertices and took some over 24 hours to render. To say this was challenging was an understatement. However, this is also where I felt I learnt the most, and it’s the homework that I’m most satisfied with. This section alone makes the course worth taking, to me.

Tips

For those of you who will take this course, here are some tips when writing your ray tracer:

when checking if a point on a surface is in light, don’t forget to discard surface collisions that occur behind the light
inverting matrices is expensive. When you invert a matrix, cache the result. This will speed things up significantly
when casting a ray from the camera, find the nearest intersection. When casting for lighting, any intersection will do
use floats for everything. If you think something can be implemented with an integer, use a float anyway
clamp your lighting values, the shading equations can cause numbers out of range and will give you weird renders
implement some sort of acceleration structure. Rendering the Stanford Dragon is painful to debug when it takes 3-4 hours to render.

Conclusion

Overall, I enjoyed the course, though mostly for the ray tracing part. I still feel like I didn’t get enough practice at actual OpenGL programming. If you’re not interested in ray tracing, skip the course and find some better stuff on iTunes U, such as “CSCI E-234 Introduction to Computer Graphics and GPU programming” and “Computer Graphics” .

edX Foundations of Computer Graphics - Unit 3

2012-11-29T00:00:00-08:00

Introduction

Ray tracing is an offline rendering technique (though research is being done in making it real-time) that aims to accurately simulate the interaction of light and the physical world. This involves the simulation of a number of effects that are difficult to do in real time rendering, such as:

Soft shadows with penumbras
Reflections
Transparency
Interreflections and color bleeding
Complex illumination such as global illumination, area lights
Realistic materials such as velvet, paint surfaces and glass

In real-time systems such as OpenGL, an image is calculated by rasterizing. Rasterizing starts from the objects in a scene, and determines which pixels belong to that object. Ray tracing operats on the pixels, determining which object is being displayed in the pixel. This makes the above affects easier to compute.

History of Raytracing

Appel 68
“An improved illumination model for shaded display”, T. Whitted 80 introduced recursive ray tracing.

Geometric intersections
Accelerations structures

Modern history:
NVIDIA Optix contains real time raytracer

Theory of Ray Tracing

Before we get into the nuts-and-bolts of creating a ray tracer, we need to learn a little about ray tracing theory first.

Outline of Process

Psuedocode:

Image Raytrace(Camera cam, Scene scene, int width, int height) {
  Image image = new Image(width, height);
  for(int i = 0; i < height; i++) {
    for(int j = 0; j < width; j++) {
      Ray ray = RayThroughPixel(cam, i, j);
      Intersection hit = Intersect(ray, scene);
      image[i][j] = FindColor(hit);
    }
  }
  return image;
}

Raycasting

Produces images similar to OpenGL.
Cast a ray through the pixel into the scene, determine what object is nearest to that pixel. Calculate lighting as per lighting algorithm, for example Phong or Blinn-Phong.

Alternative to rasterization, in that operating from the pixel eliminates need for visiblity and depth testing (or rather, acts in it’s place)

Costly when more pixels than images, however when using acceleration structures for scenes with more objects than pixels, performance can be higher than with rasterization.

Shadows & Reflections

We can add shadows and reflections to our scene by adding some simple functionality onto the ray caster.

Shadows

Building on ray casting, we can calculate shadows by sending a ray from the point of intersection of the first ray and the surface to the light source. If this ray intersects a surface before it intersects the light source, then the pixel is in shadow. Otherwise it is lit as per normal.

Something to keep in mind though is that we are dealing with floating point numbers, which are inherently inaccurate. To cope with this, the shadow ray is often cast from a distance above the intersection surface as a tolerance to inaccuracy errors.

In rasterization, shadowing not as straight forward. One method is to use something called a shadow map, where the scene is rendered as if the light source was a camera, and the depth information for that is stored. When each object is rasterized, the shadow map is consulted to see if the object is in shadow. This is complicated and can introduce artifacts into the image.

Reflections

Similar to the improvements made in shadowing, we can add reflection to our scene by sending a ray from the point of intersection of the first ray and the surface along the angle of reflection. If that ray intersects with an object, then that object will contribute lighting value to the original pixel. Otherwise it is lit as per normal.

Recursive Ray Tracing

Adding shadows and reflections to the ray casting introduces the need for a recursive algorithm for ray tracing, which is introduced in Whitted’s 1980’s paper.

If we revisit the pseudocode above, the method FindColor is responsible for generating a color from an intersection. In the case of a reflective material, the color of the pixel depends on the the color of the secondary intersection. To determine this color, we need to determine any shadows and reflections for that object. This is done with recursion.

As always, the recursion needs to have a guarantee that it will stop. This is usually done by limiting the depth of the recursion, or by setting some cut off value such that if the contribution of a surface is below some intensity threshold, it is ignored and ray tracing for that surface stops.

Ray-Surface Intersections

Properly calculating the intersection between rays and surfaces is the heart of a raytracer, and much of the early research in ray tracing was in this area. As a result, there are a number of highly optimized algorithms for calculating the intersection of a ray and various shapes.

Note that different types of rays need different information. For example, a shadow ray just needs to know if it intersected or not. A primary ray (from the pixel to the scene) needs to know the exact point of intersection, the surface normal and the texture coordinates to name just a few.

Ray-Sphere Intersection

In order to calculate a ray-sphere intersection, we first need a way of defining both a ray and a sphere mathematically. Consider the following diagram:

We can express the ray and the sphere with the following equations:

\[
ray \equiv \overrightarrow{P} = \overrightarrow{P_0} + \overrightarrow{P_1}t \\
sphere \equiv (\overrightarrow{P} – \overrightarrow{C})\; . (\overrightarrow{P} – \overrightarrow{C}) – r^2 = 0
\]

Where the ray is defined by $\overrightarrow{P_0}$, a starting point, and $\overrightarrow{P_1}t$, a point along the ray at distance $t$, and the sphere is defined by the vector from the center $\overrightarrow{C}$ to some point $\overrightarrow{P}$ such that the dot product of itself is equal to the radius of the sphere, $r^2$.

To solve the ray-sphere intersection, we need to subsittude the ray equation into the sphere equation and determine for what $t$ does the equation have an answer:

\[
(\overrightarrow{P_0} + \overrightarrow{P_1}t – \overrightarrow{C})\; . (\overrightarrow{P_0} + \overrightarrow{P_1}t – \overrightarrow{C}) – r^2 = 0
\]

We can substitude $\overrightarrow{P_0} – \overrightarrow{C}$ with a variable $x$ for the following:

\[
\begin{align}
(\overrightarrow{P_1}t + x)\; . (\overrightarrow{P_1}t + x) – r^2 &= 0 \\
\overrightarrow{P_1}t^2 + 2\overrightarrow{P_1}tx + x^2 – r^2 &= 0 \\
t^2(\overrightarrow{P_1}\;.\overrightarrow{P_1}) + 2t\overrightarrow{P_1}\;.x + (x\;.x) – r^2 &= 0
\end{align}
\]

which we can substitute $\overrightarrow{P_0} – \overrightarrow{C}$ back in:

\[
t^2(\overrightarrow{P_1}\;.\overrightarrow{P_1}) + 2t\overrightarrow{P_1}\;.(\overrightarrow{P_0} – \overrightarrow{C}) + (\overrightarrow{P_0} – \overrightarrow{C})\;.(\overrightarrow{P_0} – \overrightarrow{C}) – r^2 = 0
\]

This is a simple quadratic equation when solving for t, and the roots of the answer can tell us much about the solution:

If the answer is 2 real positive roots, the smaller value is the closest intersection
If both roots are the same, the ray is tangental to the sphere
If one root is positive and the other is negative, the ray originated from inside the sphere
If the roots are complex, there is no intersection. This can be avoided by checking the discriminant of equation first.

If you need to know the co-ordinates of the intersection point, you can substitute the value for $t$ found above back into the ray equation. The normal can be found by subtracting the center of the sphere from the intersection point and normalizing the vector:

\[
normal = \frac{\overrightarrow{P} – \overrightarrow{C}}{|\overrightarrow{P} – \overrightarrow{C}}
\]

Ray-Triangle Intersection

The ray-triangle intersection is one of the most common ray intersections due to the fact that most geometry is created as a collection of triangular faces. As a result, there are many fast implementations.

One approach is to first use a more generic ray-plane instersection, then check to determine if the plane is actually a triangle.

Consider the following triangle:

A plane can be defined by the equation:

\[
\begin{align}
plane &\equiv \overrightarrow{n}\;.(\overrightarrow{P} – \overrightarrow{A}) = 0 \\
&\equiv \overrightarrow{P}\;.\overrightarrow{n} – \overrightarrow{A}\;.\overrightarrow{n} = 0
\end{align}
\]

which shows that the dot product between any vector in the plane and the normal of the plan is 0. We can find the normal of a triangle using the following:

\[
\overrightarrow{n} = \frac{(C – A) \times (B – A)}{|(C – A) \times (B – A)|}
\]

which shows that the normal is the cross product of any two vectors in the triangle, normalized.

In order to solve the intersection, we can substitute in the equation for the ray into the equation for the plane:

\[
\begin{align}
(\overrightarrow{P_0} + \overrightarrow{P_1}t)\;.\overrightarrow{n} – \overrightarrow{A}\;.\overrightarrow{n} &= 0 \\
(\overrightarrow{P_0} + \overrightarrow{P_1}t)\;.\overrightarrow{n} &= \overrightarrow{A}\;.\overrightarrow{n} \\
\overrightarrow{P_0}\;.\overrightarrow{n} + t\overrightarrow{P_1}\;.\overrightarrow{n} &= \overrightarrow{A}\;.\overrightarrow{n} \\
t\overrightarrow{P_1}\;.\overrightarrow{n} &= \overrightarrow{A}\;.\overrightarrow{n} – \overrightarrow{P_0}\;.\overrightarrow{n} \\
t &= \frac{\overrightarrow{A}\;.\overrightarrow{n} – \overrightarrow{P_0}\;.\overrightarrow{n}}{\overrightarrow{P_1}\;.\overrightarrow{n}}
\end{align}
\]

Note that if $\overrightarrow{P_1}\;.\overrightarrow{n} = 0$, that is $\overrightarrow{P_1}$ is orthogonal to $\overrightarrow{n}$, the equation is undefined and has no solution. This makes sense, as if $\overrightarrow{P_1}$ is orthogonal to $\overrightarrow{n}$, then it is parallel with the plane and will never intersect.

If the ray intersects with the plane that the triangle, or indeed any polygon lies in, we can use a variety of methods to determine if the intersection point lies in the triangle.

First, let us consider the general case for a given polygon. If a line is taken from the point of intersection into the polygon to infinity, the number of intersections of that line will tell us if the item is in the polygon. If the number of intersections is even, the point is outside the polygon. If the number of intersections is odd, the point is inside the polygon.

To determine if the point lies in a triangle, we can use a variety of methods. First, we can use cross products to determine what side of a vector the point lies on. Consider the triangle above, and lets assume some point Q inside the triangle. Consider the vector $B – A$, and the vector $Q – A$. By the right hand rule, if the cross product of these two vectors should be in the same direction as the normal of the triangle. That is, if:

\[
((B – A) \times (Q – A))\;.\overrightarrow{n} \ge 0
\]

holds true, the point is inside the $B – A$ edge of the triangle. We can extrapolate this to all edges, so that if all of the following hold:

\[
((B – A) \times (Q – A))\;.\overrightarrow{n} \ge 0 \\
((C – B) \times (Q – B))\;.\overrightarrow{n} \ge 0 \\
((A – C) \times (Q – C))\;.\overrightarrow{n} \ge 0 \\
\]

then the point lies inside the circle.

From here, we can generate the barycentric coordinates for this intersection. This can be seen in this university handout.

Ray-Transformed Objects intersections

Often, you will want to test a ray against a primitive that has been transformed. For example, the scene may have a sphere that has been transformed into an ellipsoid, and you may want to take a ray intersection of that shape. Rather than perform a special ray-ellipsoid or ray-quadric intersection test, another method that can be used is to apply the inverse transformation to the ray, and test as if it were a sphere.

Intuitively, this works by thinking of applying the inverse transformation to the whole scene temporarily. The ellipsoid becomes a sphere again, and the ray gets the inverse transformation. If the ray hits the untransformed sphere while inverse transformed, then it will hit the transformed sphere when not under the effects of the inverse transformation.

To get the untransformed intersection, you merely apply the transformation to the the intersection. This is kind of like resetting the world back to normal.

Optimizations

Ray tracing has historically been a slow process due to the number of rays cast during rendering, especially since some objects are tested multiple times for multiple rays.

To speed up ray tracing, there are a number of optimizations you can apply, most of which fall under a few categories:

Cast fewer rays – adaptive sampling, depth control, etc
Cast generalized rays – rays that apply to more than one pixel, beam tracing, cone tracing, pencil tracing, etc
Faster intersection calculation – optimized algorithms, perform fewer intersections

Casting fewer rays involves the use of acceleration structures. It doesn’t make sense to test objects on the left side of a scene when you know the ray is cast into the right side of the scene.

Acceleration structures are data structures that can encapsulate bounding boxes for groups of objects. Most of these bounding boxes are created by dividing space up hierarchically. If a ray intersects with a bounding box in the hierarchy, it needs to be tested against any sub-bounding boxes. Eventually the ray will need to be tested only against a few objects.

The most simple acceleration structure is a grid, where the scene is divided into a 3D grid of a certain resolution. Casting the ray involves marking it through cells of the grid, and checking if the grid contains any objects. If it does, test the ray against the object. If no intersection occurs, continue marching through the grid.

More sophisticated examples of these structures are oct-trees, kd trees, BSP trees.

Ray Tracer Implementation

Now that we have a solid basis of ray tracing theory, we can look at some approaches to implementing a ray tracer.

Camera Ray Casting

Going back to the psuedocode at the start of the unit, camera ray casting involves the details of the function RayThroughPixel.

If you think back to OpenGL, we had a camera and a projection plane. This set up is the same for ray tracing. In ray tracing, we need to figure out the vector that represents a ray as it travels through one pixel of the projection plane that we are rendering onto. This angle is going to change for each pixel, and will also change if we move the camera.

To do this, we transform all the objects into a single world coordinate system, including the camera location, and calculate rays based in that coordinate system, the camera origin and the coordinates of the pixels in the world coordinates.

The RayThroughPixel function is given a camera and a pixel coordinate, i and j. To implement the function, first we need to to construct a coordinate frame based on the camera’s location and it’s up direction, which was covered in unit 1 during the derivation of gluLookAt, and will not be covered again.

Next, we need to determine the vector representing the ray that originates from the camera origin to the pixel given by i, j. With the coordinate frame $(u, v, w)$ given from the camera, the center of the image will be given by the camera’s look at vector. That is, the center of the image will be at one unit along the -w direction. Each pixel will be calculated as a delta of this vector.

As the ray moves horizontally, it changes its $u$ coordinate by an amount $\alpha$ and as it moves vertically, it changes its $v$ coordinate by an amount $\beta$. To determine the vector for the ray, we need to find $\alpha$ and $\beta$.

First, lets consider our projection plane to be a 2D coordinate system, with 2 axes $j$ and $i$, similar to the cartesian system, where $j$ maps to $x$ and $i$ maps to $y$. If the image is of $w$ length and $h$ height, then the origin will be at $(\frac{w}{2}, \frac{h}{2})$. In order to treat this like a standard co-ordinate system, and due to the fact pixels are ranged from $0 \to w$ and $0 \to h$, we need the origin to be at $(0, 0)$, so every pixel $j$ is actually at $j – \frac{w}{2}$ in this coordinate system, and every $i$ is at $\frac{h}{2} – i$. Because the plane is set at one unit along the $-w$ axis, we need to normalize the coordinate frame, so each pixel $j$ is actually at $\frac{j – \frac{w}{2}}{\frac{w}{2}}$ and each $i$ is given by $\frac{\frac{h}{2} – i}{\frac{h}{2}}$.

This will give our pixel as a proportion of change along half of the field of view in that axis. Which means we can compute the final distance with the following set of equations:

\[
\alpha = tan\left(\frac{fovx}{2}\right)\left(\frac{j – \frac{w}{2} }{\frac{w}{2}}\right) \\
\beta = tan\left(\frac{fovy}{2}\right)\left(\frac{\frac{h}{2} – i}{\frac{h}{2}}\right)
\]

With $\alpha$ and $\beta$ we can now move the eye coordinate by $\alpha u$, $\beta v$ and $-w$ components, to give a normalized ray:

\[
ray = eye + \frac{\alpha u + \beta v – w}{|\alpha u + \beta v – w|}
\]

Ray-Object Intersections

The implementation is mostly just converting the theory to actual code, so there is not much to say.

Lighting Calculations

Much of this is similar to the theory discussed earlier, and using the same Blinn-Phong shading model discussed in Unit 2. There are however a number of small changes. Consider the following formula:

\[
I = K_a + K_e + \sum^n_{i=1}V_iL_i(K_dmax(I_i\;.n, 0) + K_s(max(h_i\;.n, 0))^s)
\]

This is the same as discussed in unit 2, with the exception of the $V_i$ term, which represents visiblity. In a simple ray tracer, this will either be 1 or 0, for visible or not visible. However, if we were calculating particle effects, such as smoke or fog, then this visibility may be somewhere betwee 0 and 1, so a light blocked by smoke will contribute less color.

Also remember, this is evaluated per pixel per light, as opposed to fragments when implemented in a fragment shader.

Recursive Ray Tracing

As above in the theory section, when computing lighting on a point that has reflection, you need to recursively determine the reflected object’s color. This introduces some new terms to the lighting formula as given above:

\[
I = K_a + K_e + \sum^n_{i=1}V_iL_i(K_dmax(I_i\;.n, 0) + K_s(max(h_i\;.n, 0))^s) + K_sI_R + K_TI_T
\]

where $K_sI_R$ is the specularity of the reflected ray, and $K_TI_T$ is the transmission of the surface, which is not required in the homework for this unit.

edX Foundations of Computer Graphics - Unit 2

2012-11-25T00:00:00-08:00

Introduction

In order to write 3D graphics programs, you need to know how to write 3D graphics programs. This involves interfacing with the computers graphics hardware through a higher level API. This course will use OpenGL to teach aspects of programming 3D graphics systems.

Created in 1992 by Silicon Graphics, OpenGL was initially a fixed function pipeline. The API was a giant state machine, and you interacted with it by setting state, drawing pixels and flushing it to the rasterizer (scan conversion), which would then calculate the pixels that went into the framebuffer.

In 2003, with the release of OpenGL 1.5, OpenGL supported a programmable pipeline. With the programmable pipeline, a programmer interacted with the API by loading vertices into a buffer, sending them to a programmable shader called a vertex shader. Then the vertices were rasterized and passed into another programmable shader, the fragment shader, and from there the rendered pixels would be placed in the framebuffer.

This unit is about the programmable pipeline, and we will cover vertex and fragment shaders and GLSL in depth.

OpenGL & GLUT

Now, I’m going to go a little bit meta here and talk about the course itself. The instructor shows and explains some code, which is the skeleton code of Homework 0. At the start of Lecture 6, he talks about the old fixed function pipeline and the newer programmable pipeline. He says the course is about the newer programmable pipeline, but then shows code that uses glMatrixMode, which is a fixed function method.

I’m thinking at this stage that this course probably isn’t the best for learning how to code actual OpenGL programs. There ar far better sources to follow along with:

Learning Modern 3D Graphics Programming by Jason L. McKesson , aka the Arcsynthesis turtorial.

OpenGL Development on Linux

An Intro to Modern OpenGL

Modern OpenGL

OpenGLBook.com

The lecturer also goes into depth on how to use GLUT. To save space and effort, I’m going to link to a good GLUT tutorial:

Lightouse3d.com GLUT tutorial

Shading

Shading is important because our world is defined by how we see it. Correct and accurate lighting and shading will define the shapes of objects we see. The same geometry can be rendered with 2 different shading models and the resultant image can be different, as is the case with flat shading vs. Gouraud shading.

Shading can be done in either the vertex shader or the fragment shading. Shading performed in the vertex shader must be calculated on a vertex by vertex basis, and typically must be interpolated later in the fragment shader. The lighting can be calculated based on the vertex itself, or the normal at the vertex.

This can cause problems when geometry has large faces and relatively small highlights, however it is relatively fast. An example of this kind of shading is Gouraud shading, where lighting is calculated at the pixel and interpolated across the face.

Shading performed in the fragment shader is calculated on a fragment/pixel. Shading is calculated at a much finer detail and with more accuracy, however it involves more calculation and complexity. An example of this is the Phong shading model, which interpolates normals across a surface between it’s vertices, and calculate the lighting based on those interpolated normals for each pixel.

Note that Phong shading is different from Phong illumination, and you can use Phong shading with a different illumination model. A shading model determines how to determine how much light hits a pixel, an illumination model determines the characteristics of the light that hits that pixel (that is, the actualy determination of how much light and what color it is).

Gouraud Shading

Gouraud shading is performed by interpolating a pixel’s color from it’s bounding vertices during rasterization. Because OpenGL does the rasterization automatically, to use Gouraud shading in OpenGL you simply need to specify glShadeModel(GL_SMOOTH) and set the color at each vertex in the vertex shader.

For the sake of completeness, however, it is helpful to know what OpenGL is doing under the covers. Consider the following diagram:

The goal of Gouraud shading in this example is to find the colour of $I_p$. In order to find the colour at $I_p$, first we must find the colour at point $I_a$ and $I_b$ and linearly interpolate between them. First, we will find point $I_a$ by linearly interpolating between points $I_1$ and $I_2$, then we will find $I_b$ by interpolating between $I_1$ and $I_3$.

\[
I_a = \frac{I_1(y_s – y_2) + I_2(y_1 – y_s)}{y_1 – y_2}
\]

Similarly, we can solve for $I_b$:

\[
I_b = \frac{I_1(y_s – y_3) + I_3(y_1 – y_s)}{y_1 – y_3}
\]

$I_a$ and $I_b$ were solved by only considering the $y$ coordinates. To solve for $I_p$, we need to consider the $x$ coordinates:

\[
I_p = \frac{I_a(x_b – x_p) + I_b(x_p – x_a)}{x_b – x_a}
\]

In practice, the algorithm is much faster, as all the results of the previous calculation can be cached – this reduces the problem to a series of additions of each steps values.

Gouraud shading has problems when the lighting at a pair of vertices is 0 – any interpolated values will also be 0. This can happen if the light bounces away from the camera at a given vertex.

Gouraud shading also has problems when it comes to highlights. Before Phong shading, highlights had to be performed using triangle subdivision and tesselation. The pixels were then calculated from the subdivision triangle vertices. This was often inaccurate.

Phong Illumination and Shading Models

The Phong illumination model is different from the Phong shading model. The Phong illumination model describes how objects are lit, and specifically deals with specular lighting, which is the highlights on reflective materials. Phong shading attempts to mimic reality when it comes to specular lighting. For example, dielectric surfaces such as plastic reflect light differently from metallic reflective surfaces. The highlight on a reflective plastic will be the same colour as the lighting. the highlight on a metallic surface depends on the surface’s colour. These properties are encoded as variables in the algorithm, however the physics of decided what values to give these variables is a separate topic.

The Phong shading model is often used in conjunction with the Phong illumination model (but not always), and both of them together can define highlights well. The idea behind the Phong shading model is interpolating between vertex normals, instead of vertex colours. Then Phong illumination kicks in, and calculates the lighting at each pixel based on the interpolated normal for that pixel. This can be performed in the fragment shader.

Lighting and Shading

Lighting and shading in computer graphics is all a model of the physics of reality. The more closely lighting and shading models match the physics, the more accurate and more correct they are going to look. This course will cover some relatively basic models intuitively to teach the general approach, however it is possible to come up with more accurate models.

Alright, going meta again. The lecturer says that he’s going to cover some basics of lighting and shading, and boy is he not kidding. He discusses only a single light before moving onto materieals. The book Real-Time Rendering discusses lighting in a much more detailed fashion.

I will be writing notes on the lighting the lecturer discusses, because it is important for the assignment, however I would not refer to it for any real project.

Point light

A point light is a basic model of many types of lighting. In reality, there’s no such thing as a point light – everything has a non-zero size, and so the concept of a point light is an approximation.

To define a point light, it needs a position in the world which is specified by a homogenous 4-vector, and a colour value.
In the real world, lights attenuate based on the distance the camera is from the light. The model used to attenuate light changes based on the type of light being considered.

Point lights attenuate based directly off of physics, with an inverse-squared relationship:

\[
atten_p = \frac{1}{d^2}
\]

Lights based on lines, such as a flourescent tube, attenuate on a direct inverse relationship:

\[
atten_l = \frac{1}{d}
\]

and area based lights are often modelled as attenuating based on a constant:

\[
atten_a = \frac{1}{k}
\]

Keep in mind these are rough models of lighting, and there are far more accurate models available.

These can be rolled up into one general purpose attenuation model which is parameterized:

\[
atten = \frac{1}{k_c + k_ld + k_qd^2}
\]

$k_c$ would be the constant attenuation for an area light, and $k_l$ and $k_q$ would be set to 0. $k_l$ would be the coefficient for attenuation of a line based light, where $k_c$ and $k_q$ would be set to 0, and $k_q$ would be the coefficient for attenuation of a point light.

Materials

A material in computer graphics is a description of how the object reflects light. This is more complex than it sounds, as even many things can happen on a surface that affect the amount of light returned by a surface. For example, a matte surface can scatter the light, which would soften the highlight on the surface. Different coloured materials will absorb certain wavelengths of light, and reflect the rest, changing the colour of the reflected light. Some materials will be transparent, and refract/totally internally reflect light, leaving very little light to return. Some materials scatter the light underneath it’s surface, giving it a kind of glow as light escapes in places other than where the light struck. The accurate simulation of how light interacts with a material is complex, however algorithms light the Phong lighting algorithm and the Blinn-Phong lighting algorithm attempt to approximate this phenomenon.

In order to perform these complex calculations, algorithms need the normals of the vertices involved, and these normals are interpolated across the surface for each fragment. In the situation where you don’t have normals at each vertex, but instead each surface, you can average the normals at each surrounding face to determine a vertices normal.

The reflection of light can be specified by 4 terms: ambient reflection diffuse reflection, specular reflection and emissive reflection. The values of these terms are additive, and describe a proportion of incoming light that comes out.

The emissive reflection term describes how much light the material produces itself. This is for objects such as lights and phosphorescent materials. It does not affect the way light reflects from that material otherwise. In OpenGL, you have to render geometry in order to render an emissive light source – if there’s no geometry, nothing will be rendered, though it’s effects in the scene can be seen otherwise.

The ambient term describes how light in general reflects about the scene. This is light that is bouncing around the room, and may not be light that explicitly hits the surface under consideration. The process of actually calculating the bouncing of light in a scene is known as global illumination, and there is much research into how to accurately and efficiently calculate it. Simpler algorithms such as Phong and Blinn-Phong approximate this, often with a low value such as 0.1 or 0.2.

The diffuse term describes matte surfaces that scatter light on the reflection surface, and don’t perfectly reflect light in an ideal model. These surfaces are known as Lambertian surfaces. In the ideal model, light that is scattered is scattered equally – there is no weighting to certain directions. This of course doesn’t happen in real life, however due to the complexity of these calculations, often we have to make approximate models.

Consider the following diagram:

The light reflected in all directions is given by the following equation:

\[
\begin{align}
I_D &= L . N\,C\,I_L \\
&= |N| |L| cos\,\alpha \, C \, I_L \\
&= cos\,\alpha \, C \, I_L
\end{align}
\]

where $I_D$ is the intensity of the reflected light, $C$ is the color and $I_L$ is the intensity of the incoming light. The $cos\,\alpha$ is given by the fact that the reflection of the light is strongest when the light vector is perpendicular to the surface, that is, the angle between the normal and the light vector is 0 – $cos\,0 = 1$. It is weakest when the light vector is perpendicular to the surface normal, that is, the angle between the normal and the light vector is 90 – $cos\,90 = 0$. The direction of the eye doesn’t matter, because the light is equal in all directions under Lambertian reflectance.

The specular term describes the highlights on a smooth surface where light is reflected more along the angle of reflection, similar to a mirror. It models glossy objects such as glass. When calculating specular reflection, the angle of the eye with respect to the surface matters, as the difference between the angle of reflection and the viewing angle will change the amount of light entering the eye or camera. The Phong and Blinn-Phong algorithms model this phenomenon.

Phong Reflection Models

The Phong, and the enhanced Blinn-Phong models take into account all of the terms described above. It can be visualized using this great Wikipedia image:

In Phong reflection, each light in the scene has 2 components: $i_s$, the specular intensity of the material and $i_d$, the diffuse intensity of the material. The ambient lighting of the scene is given by the term $i_a$. Sometimes this term is a sum of all lighting contributions in the scene.

For each material in the scene, the following parameters are defined:

$k_s$: the specular reflection constant, representing the ratio of reflection of the specular term of the incoming light
$k_d$: the diffuse version of $k_s$ (the Lambertian reflectance defined above)
$k_a$: the ambient version of $k_s$ and $k_d$, coming from all lights in the scene
$\alpha$: A shininess constant of the materia. The larger this is, the more perfect the reflection from a surface.

Futher, $lights$ is the set of all lights in the scene, and for each light, $\bar{L_m}$ is the vector from the point on the surface toward each light ($m$ is the light), $\bar{N}$ is the normal of this point, $\bar{R_m}$ is the vector representing the perfect reflectance from the point, and $\bar{V}$ represents the vector from the point to the viewer.

Using all these values, the Phong reflection model is given by the following formula:

\[
I_p = k_a i_a + \sum_{m \in lights}(k_d(\bar{L_m} . \bar{N})i_{m,d} + k_s(\bar{R_m} . \bar{V})^\alpha i_{m,s})
\]

where the vector $\bar{R_m}$ is calculated as the reflection of $\bar{L_m}$ on the surface by the surface normal $\bar{N}$ given by:

\[
\bar{R_n} = 2(\bar{L_m} . \bar{N}) \bar{N} – \bar{L_m}
\]

Remember, as above the dot product between two vectors can be calculated using the cosine of their angle.

Blinn-Phong Reflection Model

The downside to the Phong reflection model is that $\bar{R} . \bar{V}$ needs to be recalculated for each light. This can be approximated by replacing $\bar{R} . \bar{V}$ with H:

\[
H = \frac{\bar{L} + \bar{V}}{|\bar{L} + \bar{V}|}
\]

which can be simplified to half the cosine of the angle between $\bar{L} . \bar{V}$ if $\bar{L}$, $\bar{R}$ and $\bar{V}$ all lie in the same plane.

edX Foundations of Computer Graphics - Unit 1

2012-11-13T16:29:00-08:00

Introduction

There are many co-ordinate systems in any computer graphics system. There can be world co-ordinates, model co-ordinates, body co-ordinates, etc. When building a scene, each of these co-ordinate systems will need to be transformed into a common system to be rendered correctly.

Even when rendering a single object, we need to transform co-ordinates to place an object in the correct location, or to make it bigger or smaller.

If we add interactivity, viewing that object from different angles actually involves transforming it to the correctr perspective, which is the goal of homework 1.

Tranformations are represented with matrices, and they transform points through matrix-vector multiplication.

All examples in this unit involve geometric figures in model space, which will be transformed to world space and then operated on using various different transforms. Vertices are represented as vectors, and transformations as matrices, as noted earlier.

2D Transformations

Scale

The scale transformation can be represented as the following matrix:

\[
\begin{bmatrix}
s_x & 0 \\
0 & s_y
\end{bmatrix}
\]

and it’s inverse is given by:

\[
\begin{bmatrix}
s^{-1}_x & 0 \\
0 & s^{-1}_y
\end{bmatrix}
\]

If both $s_x$ and $s_y$ are the same, the transformation is uniform. Otherwise, it is non-uniform.

In 3D this transformation is as follows:

\[
\begin{bmatrix}
s_x & 0 & 0 \\
0 & s_y & 0 \\
0 & 0 & s_z
\end{bmatrix}
\]

Shear

The shear transformation can be represented as the following matrix:

\[
\begin{bmatrix}
1 & a \\
0 & 1
\end{bmatrix}
\]

where $a$ is the amount you want to shear the object by. It’s inverse is given by:

\[
\begin{bmatrix}
1 & -a \\
0 & 1
\end{bmatrix}
\]

Rotation

Rotation in 2D is simple, rotation in 3D is fairly complicated, with issues like gimbal lock and so on which can be solved with quaternions.

Rotating the result of a vector addition is the same as adding the rotation of the components:

$R(X + Y) = R(X) + R(Y)$

Rotations in a linear operation, meaning it preserves the operations of vector addition and scalar multiplication, and they are commutative in 2D but not in 3D.

A 2D rotation can be derived as follows:

Represent $P$ as a polar coordinate:

$$ P = r \: cos\,\alpha, r \: sin\,\alpha $$

$P’$ can be expressed in polar coordinates as follows:

$$ P’ = r \: cos\,(\alpha + \theta), r \: sin\,(\alpha + \theta) $$

Using trig identities to convert from polar to cartesion coordinates:

\[
\begin{align}
P’_x &= r \: cos\,\alpha \: cos\,\theta \; – r \: sin\,\alpha \: sin\,\theta \\
&= x \: cos\,\theta \; – y \: sin\,\theta \\
P’_y &= r \: sin\,\alpha \: cos\,\theta \; + r \: cos\,\alpha \: sin\,\theta \\
&= y \: cos\,\theta \; + x \: sin\,\theta
\end{align}
\]

Thus, this can be represented by the following matrix:

\[
\begin{bmatrix}
cos\,\theta & -sin\,\theta \\
sin\,\theta & cos\,\theta
\end{bmatrix}
\]

NOTE: $\theta$ has to be in radians, not in degrees. If given $\theta$ in degrees, multply by $\frac{\pi}{180}$.

Composing Transforms

Often in computer graphics, you will want to combine several different transformations into a single transfermation. For example, if you want to place a model at a given co-ordinate and then rotate it, you would need to translate all the vertices, and then rotate them. Or, you could construct a single transform to do both.

The act of combining transforms is simply matrix multiplication, and the result will always be a single matrix. Keep in mind that matrix multiplation is not commutative, meaning that the order matters.

For example:

Consider the matrix $x_1$, and a scale matrix $S$ and a rotation matrix $R$.

\[
\begin{align}
x_2 &= Sx_1 \\
x_3 &= Rx_2 \\
\therefore x_3 &= R(Sx_1) = (RS)x_1 \\
x_3 &\ne SRx_1
\end{align}
\]

Likewise, if you have 3 transformations on a vector, you can invert those transformations in one of two ways.

Consider the following 3 transforms transformed into the matrix $M$:

\[
M = M_1 M_2 M_3
\]

Your options are as follows:

Calculate the composite matrix and invert it
\[
X = (XM) M^{-1}
\]
Invert each individual transform and then apply them in the reverse order
\[
X = (XM) (M_3^{-1}(M_2^{-1}(M_1^{-1}M_1)M_2)M_3)
\]

It is helpful to think of transformations applying to a vector to be a stack operation – the last transformation applied must be the first one undone.

3D Transformations

One important thing to note about 2D rotations is that they are orthogonal, meaning that $R^TR = I$ holds:

\[
\begin{align}
\begin{bmatrix}
cos\,\theta & -sin\,\theta \\
sin\,\theta & cos\,\theta
\end{bmatrix}
\begin{bmatrix}
cos\,\theta & sin\,\theta \\
-sin\,\theta & cos\,\theta
\end{bmatrix}
&=
\begin{bmatrix}
cos^2\theta + sin^2\theta & -cos\,\theta \; sin\,\theta + cos\,\theta \; sin\,\theta \\
-sin\,\theta \; cos\,\theta + sin\,\theta \; cos\,\theta & sin^2\theta + cos^2\theta
\end{bmatrix}
\\
&=
\begin{bmatrix}
1 & 0 \\
0 & 1
\end{bmatrix}
\end{align}
\]

Simple Rotations around X, Y, Z Axis

To begin with rotations in 3D, let us consider 2D rotations as 3D rotations around the $z$ axis. If you think of a rotation where the $x$ and $y$ axes change, then if you suddenly introduce the $z$ axis, it doesn’t change. So a 2D rotation is essentially a 3D rotation about the $z$ axis.

Therfore, we can represent a 3D rotation about the $z$ axis as follows:

\[
\begin{bmatrix}
cos\,\theta & -sin\,\theta & 0 \\
sin\,\theta & cos\,\theta & 0 \\
0 & 0 & 1
\end{bmatrix}
\]

A 3D rotation about the $x$ axis is similarly simple, as we just hold $x$ constant and treat it exactly the same:

\[
\begin{bmatrix}
1 & 0 & 0 \\
0 & cos\,\theta & -sin\,\theta \\
0 & sin\,\theta & cos\,\theta
\end{bmatrix}
\]

A 3D rotation about the $y$ axis is a little more complicated due to the $y$ axis being given by $z \times x$, however it’s still pretty close:

\[
\begin{bmatrix}
cos\,\theta & 0 & sin\,\theta \\
0 & 1 & 0 \\
-sin\,\theta & 0 & cos\,\theta
\end{bmatrix}
\]

We can derive the rotation matrix around the $z$ axis as follows:

Consider the rotation around the $x$ axis, as discussed earlier, in cartesian co-ordinates:

\[
\begin{align}
x’ &= x\;cos\,\theta – y\;sin\,\theta \\
y’ &= x\;sin\,\theta + y\;cos\,\theta \\
z’ &= z
\end{align}
\]

A rotation around the $y$ axis is similar to a $z$ axis rotation if we replace the (\x\) axis with the $z$ axis, the $y$ axis with the $x$ axis and the $z$ axis with the $y$ axis:

\[
\begin{align}
z’ &= z\;cos\,\theta – x\;sin\,\theta \\
x’ &= z\;sin\,\theta + x\;cos\,\theta \\
y’ &= y
\end{align}
\]

If we put these equations into matrix form, that gives us:

\[
\begin{bmatrix}
cos\,\theta & 0 & sin\,\theta \\
0 & 1 & 0 \\
– sin\,\theta & 0 & cos\,\theta
\end{bmatrix}
\]

These basic 3D rotations are orthogonal, like 2D rotations.

We can think of a rotation matrix as representing a new orthonormal basis, with each row of the matrix representing one of the unit vectors forming the basis:

\[
R_{uvw} =
\begin{bmatrix}
x_u & y_u & z_u \\
x_v & y_v & z_v \\
x_w & y_w & z_w
\end{bmatrix}
\]

where

$x_u$ is the $x$ coordinate of the $u$ vector
$y_u$ is the $y$ coordinate of the $u$ vector
$z_u$ is the $z$ coordinate of the $u$ vector
similarly for the $v$ and $w$ vectors.

The above matrix represents a transformation from the an orthonormal basis that represents the rotation transformed into the cartesion basis we’re used to.

We can consider, instead, the rotation from a higher dimensionality, and consider a vector of unit vectors. What happens if we multiply this by a single point?

\[
\begin{pmatrix}
\bar{u} \\
\bar{v} \\
\bar{w}
\end{pmatrix}
\begin{pmatrix}
\bar{P}
\end{pmatrix}
=
\begin{pmatrix}
\bar{u}.\bar{P} \\
\bar{v}.\bar{P} \\
\bar{w}.\bar{P}
\end{pmatrix}
\]

This is thinking about a rotation not as an operation, but as a subspace that we are projecting a point into. Multiplying this vector with a point will result in a new point that lives in the subspace of the rotation.

This approach will allow us to construct rotation matrices in any orthonormal basis, allowing us to do 3D rotations about arbitrary vectors.

3D rotation is not commutative like 2D rotations are, given that matrix multiplication is not commutative.

3D Rotations Around Arbitrary Vector Using Axis-Angle Rotations

Consider rotationg a vector $b$ by an angle of $\theta$ about a vector $a$.

The vector $b$ can be thought of being composed of components of two vectors: $a$, and a vector orthogonal to $a$. We will label these as $b_\|$ and $b_\perp$ respectively. $b_\|$ lies along $a$, and is unchanged through a rotation.

$b_\|$ can be given by:

\[
b_\| = (a \; . b) \bar{a}
\]

assuming $a$ and $b$ are both unit vectors. This follows from the intuition about dot products as measuring components of vectors/projecting vectors.

$b_\perp$ can be given by:

\[
b_\perp = b \; – b_\|
\]

Because the rotation is occurring in 3D, we need an orthonormal base to perform the rotation in. If we consider $a$ and $b$ to be two vectors in this space, we can use them to define the space by finding vector $c$, which is the vector orthogonal to $a$ and $b$.

$c$ can be given by:

\[
c = a \times b
\]

Now that we have these components, we can determine the result of the rotation. The new vector will be given by:

\[
b’ = \begin{bmatrix}
\bar{c} sin\,\theta \\
b_\perp cos\,\theta \\
b_\|
\end{bmatrix}
\]

This is due to the fact that the $\bar{c}$ and $b_\perp$ components of $b’$ will be determined by the angle of rotation, and $b_\|$ lies along the rotation axis, and so doesn’t change.

In matrix form, this is given by:

\[
R(a, \theta) = I\;cos\,\theta + sin\,\theta[a]_\times + (1 – cos\,\theta)a \otimes a
\]

where:

\[
a \otimes a =
\begin{bmatrix}
a^2_x & a_x a_y & a_x a_z \\
a_x a_y & a^2_y & a_y a_z \\
a_x a_z & a_y a_z & a_z^2
\end{bmatrix}
\]

and

\[
\lbrack a \rbrack_\times =
\begin{bmatrix}
0 & -a_z & a_y \\
a_z & 0 & -a_x \\
-a_y & a_x & 0
\end{bmatrix}
\]

In matrix operations, $a \otimes a$ can be calculated with $aa^T$.

Details about the derivation can be found on Wikipedia

You can check the results of the rotation by relating it to a similar rotation in cartesian coordinate space. Relate vector $b$ to the $x$ axis and vector $a$ to the $z$ axis to see if the rotation is what you would expect intuitively. The result of this will be rotating a point on the $x$ axis towards the $y$ axis.

Homogenous Coordinates

Homogenous coordinates solved a number of problems in computer graphics. The need for homogenous coordinates can be demonstrated by trying to translate a vector.

Consider the following equation:

\[
\begin{align}
\begin{bmatrix}
x’ \\ y’ \\ z’
\end{bmatrix}
&=
T
\begin{bmatrix}
x \\ y \\ z
\end{bmatrix}
\\
&=
\begin{bmatrix}
x + 5 \\ y \\ z
\end{bmatrix}
\end{align}
\]

where $T$ is a translation matrix that moves the vector by 5 units along the $x$ axis. What is the matrix $T$?

From matrix multiplcation, we know that it must be a 3×3 matrix. We know that it adds 5 to the $x$ value, and leaves the $y$ and $z$ values unchanged. So it must look something like this:

\[
\begin{bmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
\]

However, this is the identity matrix. Where does the 5 come from?

The solution to this is homogenous coordinates. If we add an extra coordinate, $w$, we can use a 4×4 matrix to add in extra values:

\[
\begin{align}
\begin{bmatrix}
x’ \\ y’ \\ z’ \\ w’
\end{bmatrix}
&=
\begin{bmatrix}
1 & 0 & 0 & 5 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & 0 & 1
\end{bmatrix}
\begin{bmatrix}
x \\ y \\ z \\ 1
\end{bmatrix}
\\
&=
\begin{bmatrix}
x + 5 \\ y \\ z \\ 1
\end{bmatrix}
\end{align}
\]

Homogenous coordinates enable the use of a variety of operations upon vectors and vertices in computer graphics, from all the transformations discussed above, to projection and view matrix calculation.

The only thing to remember with homogenous coordinates is the need to dehomegenize the result of these operations to get the point in cartesian space. This is done by dividing by the result by the $w$ coordinate.

Translation Using Homogenous Coordinates

Following is the general form for a translation in 3D using homogenous coordinates:

\[
\begin{align}
T &=
\begin{bmatrix}
1 & 0 & 0 & T_x \\
0 & 1 & 0 & T_y \\
0 & 0 & 1 & T_z \\
0 & 0 & 0 & 1
\end{bmatrix} \\
&=
\begin{bmatrix}
I_3 & t \\
0 & 1
\end{bmatrix}
\end{align}
\]

where $I_3$ is the 3×3 identity matrix, and $t$ is the 3×1 translation vector.

This can be used as follows:

\[
\begin{align}
P’ &= TP \\
&=
\begin{bmatrix}
1 & 0 & 0 & T_x \\
0 & 1 & 0 & T_y \\
0 & 0 & 1 & T_z \\
0 & 0 & 0 & 1
\end{bmatrix}
\begin{bmatrix}
x \\ y \\ z \\ 1
\end{bmatrix} \\
&=
\begin{bmatrix}
x + T_x \\ y + T_y \\ z + T_z \\ 1
\end{bmatrix} \\
&=
P + T
\end{align}
\]

Combining 3D Translation and Rotation

When combining translations and rotations, the order matters. A rotation followed by a translation is not the same as a translation followed by a rotation.

Typically, because it’s easier to think about rotations in terms of the origin, rotation will usually come before translation, however it is possible to do it in the opposite order.

We can see this as follows. Consider the case of rotating first, and then translating. Combining those operations into matrix $M$, we get:

\[
\begin{align}
M &=
\begin{bmatrix}
I_3 & T \\
0 & 1
\end{bmatrix}
\begin{bmatrix}
R & 0 \\
0 & 1
\end{bmatrix}
\\
&=
\begin{bmatrix}
R & T \\
0 & 1
\end{bmatrix}
\end{align}
\]

which when applied to a point $P$:

\[
\begin{align}
P’ &= MP \\
&=
\begin{bmatrix}
R & T \\
0 & 1
\end{bmatrix}
\begin{bmatrix}
P \\ 1
\end{bmatrix}
\\\
&=
\begin{bmatrix}
RP + T \\
1
\end{bmatrix}
\end{align}
\]

Now consider the case of translating first, and then rotating. Combining those operations into the matrix $M$, we get:

\[
\begin{align}
M &=
\begin{bmatrix}
R & 0 \\
0 & 1
\end{bmatrix}
\begin{bmatrix}
I_3 & T \\
0 & 1
\end{bmatrix}
\\
&=
\begin{bmatrix}
R & RT \\
0 & 1
\end{bmatrix}
\end{align}
\]

which when applied to a point $P$:

\[
\begin{align}
P’ &= MP \\
&=
\begin{bmatrix}
R & RT \\
0 & 1
\end{bmatrix}
\begin{bmatrix}
P \\ 1
\end{bmatrix}
\\\
&=
\begin{bmatrix}
RP + RT \\
1
\end{bmatrix}
\end{align}
\]

As we can see, when applying the translation first, and then a rotation, the translation itself is rotated, which means you end up translating around a different axis. This is unintuitive, however is clearly demonstrated with math.

Transforming Normals

A surface normal is a vector that is perpendicular with a surface. They are used to determine which way the surface faces, as well as how light bounces off of the surface in lighting.

Normals do not transform the same way as surface diagrams. If you consider a surface being sheared, althought the shape of the surface changes, it’s orientation does not change, and thus it’s normal does not change.

We can use some algebra to find out how normals transform.

Consider a surface, defined by a normal $n$ and a set of points tangent to that normal, $t$. This surface is undergoing some transformation, $M$.

As mentioned above, the surface is defined by a normal and a set of tangental points. The normal must be perpendicular to the tangental points:

\[
n^Tt = 0
\]

We know that the tangents undergo transformation as per normal, as they are geometry:

\[
t’ = Mt
\]

We also know that the normal undergoes a separate transform, $Q$, such that:

\[
n’ = Qn
\]

The goal is to find out what Q is. As it happens, we can use algebra to solve this:

\[
\begin{align}
n’^Tt’ &= 0 \\
(Qn)^Tt’ &= 0 \\
(Qn)^TMt &= 0 \\
n^TQ^TMt &= 0 \\
\therefore Q^TM &= I \because n^Tt = 0 \\
Q^T &= M^{-1} \\
Q &= (M^{-1})^T
\end{align}
\]

So the normal transformation is given by:

\[
Q = (M^{-1})^T
\]

where $M$ is some transformation acting upon geometry.

Note that the inverse transposition above is applied only to the upper 3×3 matrix. It does not apply to the homogenous coordinates, because the normal is never acted onto by translations.

Coordinate Frames

As discussed earlier in 3D rotations, a 3D rotation can be viewed in two ways:

A rotation of vertices in a given coordinate frame
A projection of vertices from one coordinate frame to another (aka rotation of the coordinate frame)

This is relevant because there are a number of coordinate frames in computer graphics: world view, camera view, model view, etc.

This generalizes to 2D in a similar way as it does for 3D.

Derivation of gluLookAt

The gluLookAt is a function that is used a lot in OpenGL code to position the camera in space, and point it to along a vector.

The function takes the camera’s 3D coordinates, the coordinates of the point the camera should look at, and the coordinates of the up direction for the camera. It outputs a 4×4 matrix that will transform points in the world coordinate space so that they lie in the camera coordinate space.

The arguments passed in help define 2 vectors that will form the orthonormal basis for the camera’s coordinate frame. These vectors can be used to find the third vector.

These two vectors are the vector $a$, which is given by:

\[
a = \begin{bmatrix}camera_x \\ camera_y \\ camera_z\end{bmatrix} – \begin{bmatrix}center_x \\ center_y \\ center_z\end{bmatrix}
\]

and $b$, given by:

\[
b = \begin{bmatrix}up_x \\ up_y \\ up_z\end{bmatrix}
\]

From these vectors, we can calculate an orthonormal basis defined by the vectors $w$, $u$ and $v$, where:

\[
w = \frac{a}{\|a\|}
\]

\[
u = \frac{b \times w}{\| b \times w \|}
\]

\[
v = w \times u
\]

If you’re not sure what’s going on here, see the notes for Unit 0 which discuss how to form a basis from 2 arbitrary vectors.

Once you have the new orthonormal basis, you can create a rotation matrix easily. Recall that a rotation can be interpretted as a pojection into a new coordinate frame. This means that the vectors $u$, $v$ and $w$ define the rotation matrix that will do the projection:

\[
R_{uvw} = \begin{bmatrix}
x_u & y_u & z_u \\
x_v & y_v & z_v \\
x_w & y_w & z_w
\end{bmatrix}
\]

However, the camera itself has a location, so you must combine a translation to the camera’s coordinates first, then apply the rotation. Because we’re acting on the world, rather directly on the camera, we need to apply the inverse translation to move the points of the world instead of moving the camera, so the camera is considered at origin:

\[
T_{uvw} = \begin{bmatrix}
-camera_x \\
-camera_y \\
-camera_z
\end{bmatrix}
\]

ˇYou can combine these into a matrix in a method similar to how we did above. I’ll skip the details and go straight to the final form:

\[
M = \begin{bmatrix}
R_{uvw} & R_{uvw} . T_{uvw} \\
0 & 1
\end{bmatrix}
\]

Projection

Projection is the act of projecting a 3D world onto a 2D image plane. This is also known as viewing transformation. In computer graphics, there are 2 main types of pojection:

orthographic projection
perspective projection

Until now, 3D transformations have all transformed within the same dimension, and have been formatted as 4×4 homogenous matrices.

In order to perform orthographic projection, we will continue to use 4×4 homogenous matrices. To perform the projection, we will utilize the last row of the 4×4 matrix that was previous an identity row.

Orthographic projection

Orthographic projection preserves the angles between vertices, and simply ignores a dimension.

In OpenGL, this is implemented as a function called glOrtho. Mathematically, the general approach is as follows.

Consider the world we want to project to be encompassed by a cuboid. That is, a 3D box that is not necessarily a cube. To perform the projection, we translate the cuboid so that it’s center lies at origin, and we scale it so that it becomes a unit cube. Then we drop the $z$ dimension.

This world cuboid is defined by $l$ the left most viewing edge, $r$ the right most viewing edge, $t$ the top most viewing edge, $b$, the bottom most viewing edge, $f$ the far clipping plane and $n$, the near clipping plane.

We perform the projection in two steps: translation, then a scale.

The translation can be given by the matrix $T$:

\[
T = \begin{bmatrix}
1 & 0 & 0 & -\frac{r + l}{2} \\
0 & 1 & 0 & -\frac{t + b}{2} \\
0 & 0 & 1 & -\frac{f + n}{2} \\
0 & 0 & 0 & 1
\end{bmatrix}
\]

As you can see, the matrix $T$ simply moves the cuboid to the origin.

Similarly, the scale can be given by the matrix $S$:

\[
S = \begin{bmatrix}
\frac{2}{r-l} & 0 & 0 & 0 \\
0 & \frac{2}{t-b} & 0 & 0 \\
0 & 0 & \frac{2}{f-n} & 0 \\
0 & 0 & 0 & 1
\end{bmatrix}
\]

Given we want the resultant cube to have a width, height and depth of 2, we need to convert the cuboid to that ratio.

The resultant projection matrix $M$ is:

\[
M = \begin{bmatrix}
\frac{2}{r – l} & 0 & 0 & -\frac{r + l}{r – l} \\
0 & \frac{2}{t-b} & 0 & -\frac{t + b}{t – b} \\
0 & 0 & \frac{2}{f-n} & -\frac{f + n}{f – n} \\
0 & 0 & 0 & 1
\end{bmatrix}
\]

Lastly, because in OpenGL the camera looks down the $-z$ axis, $f – n$ will be a negative number. Therefore in $M$, you need to replace $n$ with $-n$ and $f$ with $-f$. This will give you $glOrtho$:

\[
glOrtho =
\begin{bmatrix}
\frac{2}{r – l} & 0 & 0 & -\frac{r + l}{r – l} \\
0 & \frac{2}{t-b} & 0 & -\frac{t + b}{t – b} \\
0 & 0 & \frac{-2}{f-n} & -\frac{f + n}{f – n} \\
0 & 0 & 0 & 1
\end{bmatrix}
\]

Perspective projection

Perspective projection modifies the angles between vertices and most closely models how we see the world around us. An example of this is the optical illusion of parallel lines meeting under perspective to a vanishing point.

Consider the following diagram, which is a top-down view of a perspective projection:

The camera lies at $(0, 0, 0)$ and a projection plane of the image. Some point $(x, y, z)$ projects to point $(x’, y’, d)$. From similar triangles, we can see that:

\[
\frac{x’}{d} = \frac{x}{z}
\quad \quad \quad \quad
\frac{y’}{d} = \frac{y}{z}
\]

Therefore, we can see that:

\[
x’ = \frac{d \, x}{z}
\quad \quad \quad \quad
y’ = \frac{d \, y}{z}
\]

We can use homogenous coordinates to perform this division in a matrix during the dehomogenization process. If we make the resultant $w$ parameter equal to $\frac{z}{d}$, then when it comes to dehomogenizing, each element will be multiplied by the inverse. We can easily craft such a matrix, $P$, the perspective transformation matrix:

\[
P = \begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & \frac{1}{d} & 0
\end{bmatrix}
\]

The matrix $P$ above can be used as is in coordinate systems where the camera looks into the positive $z$ axis. Remember with OpenGL the camera looks into the negative $z$ axis, so $ P_{4,3} = -\frac{1}{d} $.

Multiplying this perspective matrix with a point gives the following:

\[
V = \begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & \frac{1}{d} & 0
\end{bmatrix}
\begin{bmatrix}
x \\ y \\ z \\ w
\end{bmatrix}
=
\begin{bmatrix}
x \\ y \\ z \\ \frac{z}{d}
\end{bmatrix}
\]

Finally, dehomogenizing this resultant vertex gives:

\[
V = \begin{bmatrix}
\frac{x\,d}{z} \\
\frac{y\,d}{z} \\
d \\
1
\end{bmatrix}
\]

Of course, we discard the $z$ coordinate as this is a 3D → 2D projection.

Derivation of gluPerspective

The gluPerspective function transforms the 3D world to a 2D perspective projection. This function is usually called after the camera is position, such as with gluLookAt.

The gluPerspective function takes 4 arguments: the field of view in the y direction, an aspect ratio, the $z$ coordinate of the near clipping plane and the $z$ coordinate of the far clipping plane. These 4 arguments help construct a viewing frustum:

The aspect ratio is the $\frac{width}{height}$, and $Z_{near}$ and $Z_{far}$ are positive numbers, even though the camera is looking down the negative $z$ axis.

From these values, we need to determine $d$ as per the perspective transform above. To compute $d$.

If $\theta$ is the angle between the $z$ axis and the projected point $(x’, y’, d)$, then:

\[
\theta = \frac{fov_y}{2}
\]

and therefore:

\[
\begin{align}
d &= \frac{1}{tan\,\theta} \\
&= cot\,\theta \\
&= cot\,\frac{fov_y}{2}
\end{align}
\]

This will take care of the perspective projection. However, the gluPerspective function does more than just project: it also fits the image to a given aspect ratio, and clips the rendered image at a near plane and a far plane.

We can fold these up into the perspective matrix as well.

First, consider the aspect ratio. The aspect ratio will affect geometry in the $x$ axis only. As the aspect ratio gets bigger, the elements should become thinner, and appear stretched. So we can add it to the perspective matrix as follows:

\[
P = \begin{bmatrix}
\frac{1}{aspect} & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & -\frac{1}{d} & 0
\end{bmatrix}
\]

Before we go further, lets multiply $P$ with the $d$ variable, to remove unnecessary fractions:

\[
P = \begin{bmatrix}
\frac{d}{aspect} & 0 & 0 & 0 \\
0 & d & 0 & 0 \\
0 & 0 & d & 0 \\
0 & 0 & -1 & 0
\end{bmatrix}
\]

Lastly, we need to consider the clipping planes, which will affect geometry in the $z$ axis. Because we’re projecting to a unit square, we need to map $-Z_{near}$ to -1, and $-Z_{far}$ to +1. To do this operation in matrices, we’re going to use $P_{3,3}$ and $P_{3,4}$, as these will directly affect the resultant $z$ coordinate:

\[
P = \begin{bmatrix}
\frac{d}{aspect} & 0 & 0 & 0 \\
0 & d & 0 & 0 \\
0 & 0 & A & B \\
0 & 0 & -1 & 0
\end{bmatrix}
\]

When multiplying $P$ with a point, this leaves us with the following $z$ and $w$ values (note, we’re ignoring the rest of the matrix for now):

\[
\begin{bmatrix}
A & B \\
-1 & 0
\end{bmatrix}
\begin{bmatrix}
z \\ 1
\end{bmatrix}
=
\begin{bmatrix}
Az + B \\
-z
\end{bmatrix}
\]

which can be dehomogenized to the following function:

\[
\frac{Az + B}{-z} = -A – \frac{B}{z}
\]

If you recall above the discussion about mapping $-Z_{near}$ to -1 and $-Z_{far}$ to +1, we get the following pair of equations by substituting $-Z_{near}$ and $-Z_{far}$:

\[
-A + \frac{B}{Z_{near}} = -1
\quad \quad \quad \quad
-A + \frac{B}{Z_{far}} = +1
\]

These simulatenous equations can be solved as follows. First, solving for $A$:

\[
\begin{matrix}
-A + \frac{B}{Z_{near}} = -1 &
-A + \frac{B}{Z_{far}} = 1
\\
\frac{B}{Z_{near}} = A – 1 &
\frac{B}{Z_{far}} = A + 1
\\
B = Z_{near}(A – 1) &
B = Z_{far}(A + 1)
\\
B = A\,Z_{near} – Z_{near} &
B = A\,Z_{far} + Z_{far}
\end{matrix}
\]

\[
\begin{align}
A\,Z_{near} – Z_{near} &= A\,Z_{far} + Z_{far}\\
A\,Z_{near} – Z_{near} – A\,Z_{far} &= Z_{far} \\
A\,Z_{near} – A\,Z_{far} &= Z_{far} + Z_{near}\\
A(Z_{near} – Z_{far}) &= Z_{far} + Z_{near} \\
A &= \frac{Z_{far} + Z_{near}}{Z_{near} – Z_{far}}
\end{align}
\]

Next, solving for $B$:

\[
\begin{matrix}
-A + \frac{B}{Z_{near}} = -1 &
-A + \frac{B}{Z_{far}} = 1 \\
-A = -1 – \frac{B}{Z_{near}} &
-A = 1 – \frac{B}{Z_{far}} \\
A = 1 + \frac{B}{Z_{near}} &
A = -1 + \frac{B}{Z_{far}}
\end{matrix}
\]

\[
\begin{align}
1 + \frac{B}{Z_{near}} &= -1 + \frac{B}{Z_{far}} \\
2 + \frac{B}{Z_{near}} &= \frac{B}{Z_{far}} \\
2 &= \frac{B}{Z_{far}} – \frac{B}{Z_{near}} \\
2 &= \frac{Z_{near}B}{Z_{near}Z_{far}} – \frac{Z_{far}B}{Z_{far}Z_{near}} \\
2 &= \frac{Z_{near}B – Z_{far}B}{Z_{near}Z_{far}} \\
2 &= \frac{B(Z_{near} – Z_{far})}{Z_{near}Z_{far}} \\
2\,Z_{near}Z_{far} &= B(Z_{near} – Z_{far}) \\
\frac{2\,Z_{near}Z_{far}}{Z_{near} – Z_{far}} &= B
\end{align}
\]

Finally, we can inset this back into our final gluPerspective transformation matrix, $P$:

\[
P = \begin{bmatrix}
\frac{d}{aspect} & 0 & 0 & 0 \\
0 & d & 0 & 0 \\
0 & 0 & \frac{Z_{far} + Z_{near}}{Z_{near} – Z_{far}} & \frac{2\,Z_{near}Z_{far}}{Z_{near} – Z_{far}} \\
0 & 0 & -1 & 0
\end{bmatrix}
\]

Nonlinear mapping

The $z$ mapping discussed just above is a nonlinear mapping, and is actually just one of many different proposed $z$ mappings. However, all proposed $z$ mappings are nonlinear.

This particular mapping has the benefit of being able to handle a wide range of values $z$ values, as $\frac{1}{\infty} \to 0$ and $frac{1}{100} = 0.01$, which are not significantly different from each other. This gives the $z$ mapping a large degree of flexibility.

Unfortunately, it also leads to a non-uniform resolution, favoring objects close to the viewing plane. This means that objects that are closer will have more resolution to them, and objects that are further have less.

However, do not make the mistake of setting the near plane to 0. If you set the near plane to 0, you’re giving every object in the scene a resolution of 0, and will result in nonsense projections.

The Whole Viewing Pipeline

The whole viewing pipeline is all of the transformations and steps we’ve discussed performed in sequence:

Usually these transform matrices will be rolled up into a single matrix, however the transformation into the eye coordinates might be saved separatenly for lighting. Lighting is performed in 3D right at the end before we project to 2D. More details on lighting will be covered in later units.

edX Foundations of Computer Graphics - Unit 0

2012-11-08T13:56:00-08:00

Goals of the course

Write complex 3D graphics programs, using both an online real-time OpenGL and an offline raytracer.
Learn theory such as mathematical aspects and algorithms that underly 3D computer graphics.

Why study 3D computer graphics?

There is a fundamental intellectual challenge behind studying computer graphics. In order to create an interact with a realisitic virtual world, you need to have an understanding of all aspects of the physical world, as well as computing methods, displays and other technology.

When it comes to implementing these understandings, there are a number of technical challenges. You need to understand various aspects of math, such as projections (especially perspective), curves and surface equations. You need to understand the physics of lighting and shading (optics). Finally, you need to know about 3D graphics software programming and hardware, the algorithms and data structures that you will use to bring it all to life.

The 3D graphics pipeline

Modeling – creating a polygon mesh of objects we want to model.
Animation – if you want motion. This course does not deal with this.
Rendering – simulating light in the scene.

Homework

Testing knowledge of transformations by building a real time viewer for a 3D teapot.
Real time scene viewer with lighting and shading implemented in OpenGL with the GLSL shading language (rasterization)
Create realistic images with an offline ray tracer (ray tracing)

Ray tracing vs. rasterization

Rasterization is essentially going through geometric primitives and determining where on the screen, if at all, it should be drawn. This is in terms of which pixel does this primitive own. Ray tracing does the opposite, and iterates through each pixel in an image and determines which geometric primitive should it belong to.

More details will be forthcoming in further lectures.

History of computer graphics

2D computer graphics

The term computer graphics was first coined by Willian Fetter of Boeing in 1960, even though the first graphics systems were developed in the mid 1950s by MIT for the US Air Force, used in the SAGE radar systems.

Text itself is a landmark in computer graphics. Turing’s Manchester Mark 1 had only a bank of LED lights that represented memory content. The proper display of text and the way fonts are rendered to give a smooth appearance was one of the early problems in 2D computer graphics.

From text, the next major advance was the concept of the Graphical User Interface, or GUI, which was invented at Xerox Palo Alto Research Center (Xerox PARC) around 1975, and used in the Xerox Star released in 1981. After Xerox, Apple released the Apple Lisa, which implemented a GUI as well as what we know today of a menu bar in 1983. The Apple Lisa was the first computer to offer a GUI in an inexpensive machine aimed at individual business users.

In 1963, Ivan Sutherland at MIT developed a piece of software called Sketchpad, which was a light pen based software application that allows the user to draw images on a computer. It also introduced many concepts in modern GUIs such as pop up menus, constraint based drawing and hierarchical modeling.

After Sketchpad came paint systems, the pioneer of which was SuperPaint, developed by Xerox PARC in 1973. SuperPaint was the originator of a whole genre of computer graphics software such as Adobe Photoshop and Paint Shop Pro, etc.

Now, 2D computer graphics are used to manipulate and process images and video. Functions such as cropping, scaling and compositing, in all aspects of like such as television and advertising.

3D computer graphics

Geometric modeling

Geometric modeling is the process of creating 3D geometry. In the 70’s and 80’s, a major development in the field was the creation of spline curves and surfaces. One of the arguably most famouse 3D images is the Utah Teapot, which was made using these techniques, created at the University of Utah.

Now, most 3D geometry is represented by a mesh of triangles, and advances in this field involve the accurate representation of triangles and tesselation and subdivision algorithms, which increase the level of detail of triangle meshes without increasing the geometry stored.

Rendering

During the 1960’s, the main fundemental problem being solved in computer graphics was that of handling visibility and hidden line/surface removal. Through this time, a number of algorithms and techniques were created.

In 1963, L. G. Roberts published the paper “Machine Perception of Three Dimensional Solids”, detailing the first algorithm to solve the problem of hidden line removal. He proposed that “an edge may be obscured by the volume of an object that lies between the edge and the viewpoint” Sutherland (1974).

Robert’s way was only one way, however, and soon others found more approaches to solve the problem. These can be divided into hidden line removal, and hidden surface removal.

With respect to hidden line removal, a number of algorithms were created. A. Appel in 1967 with the paper “The Notion of Quantitative Invisibility and the Machine REndering of Solids”, P. P. Loutrel in 1967 with the paper “A Solution to the Hidden-Line Problem for Computer-Drawn Polyhedra” and R. Galimberti and U. Montanari in 1969 with the paper “An Algorithm for Hidden Line Elimination” all proposed testing edges against other edges, and storing edges to compare against other edges that share vertices.

With respect to hidden surface removal, two standout algorithms were created. J. E. Warnock in 1968 with the paper “A Hidden-Surface Algorithm for Computer-Generated Halftone Pictures” describes an algorithm that creates sample areas on the screen and the algorithm traverses each face to be rendered, and checks it’s interaction with the sample window, and takes action based on that. G. S. Watkins in 1970 with the paper “A Real-Time Visible Surface Algorithm” describes a similar algorithm.

Finally, I. E. Sutherland, R. F. Sproull and R. A. Shumacker published a paper in 1974, “A Characterization of Ten Hidden Surface Algorithms” outlined algorithms of Sproull and Shumacker that organized surfaces in a priority list, and used the list to determine visibility.

While visibility was being solved, several advances in the rendering of actual surfaces were also taking place. In 1971, H. Gouraud published a paper entitled “Computer Display of Curved Surfaces”, where he described a technique of lighting and rednering geometric survaces as if they were curved. The result is a matte diffusely lit product that looks more round than it is.

In 1975, Bui Tuong Phong published the paper “Illumination for Computer Generated Pictures”, which built on Gouraud’s work and developed an algorithm to add specular highlighting to geometric models.

Jim Blinn in turn built on Phong’s work as well as some of his own. In 1976 he released a paper entitled “Texture and Reflection In Computer Generated Images” and a paper “Simulation of Wrinkled Surfaces, Computer Graphics” in 1978, both of which introduce texturing and bump mapping, and he improved on Phong’s lighting algorithm in the 1977 paper “Models of Light Reflection for Computer Synthesized Pictures”.

In 1974, Ed Catmull published the paper “A Subdivision Algorithm for Computer Display of Curved Surfaces”
Ed Catmull. Although the paper is about subdivision of curved surfaces, he outlines the method known today as Z-Buffer hidden surface removal.

As graphics progressed into the 1980’s, the focus seemed to shift toward the development of lighting algorithms, specifically, solving problems with global illumination.

In 1980, T. Whitted introduced the world to ray-tracing in the paper “An improved illumination model for shaded display” . Ray-tracing was a new method of calculating global illumination that will be covered in detail later in the course.

The 1984 paper “Modeling the Interaction of Light Between Diffuse Surfaces” by C. Goral, K. Torrance, D. Greenberg and B. Battaile described a method of calculating radiosity in computer images. Radiosity is the color bleed effect, when light bouncing off of a colored surface will color other surfaces.

All of this research culminated in the paper “The Rendering Equation”, a paper by J. Kajiya published in 1986. The rendering equation is an integral equation which describes the total amount of light emmitted from a point along a particular viewing direction, given a function for incoming light and a Bidirectional Reflectance Distribution Function (BRDF).

There are a number of aspects of lighting that that the rendering equation doesn’t cover, including

phosphorescence – light absorbed at one moment in time and emitted at another
fluorescence – absorbed and emitted light are different wavelenths (colors)
interference – light displays it’s wave properties
subsurface scattering – spatial locations of incoming and departing light are different

These days, advances are made in perfecting the rendering equation (global illumination) to create photo-realistic images, and real time ray tracing.

More details on the history of computer graphics can be found from these articles:

Computer animation

Given that the course is about rendering 3D graphics, it doesn’t delve deeply into the history of computer animation. However, you can find some information in the following videos, which are a cut down and edited version of “The Science of Animation”:

Math review

Vectors

Dot product as growth in a dimension: http://betterexplained.com/articles/vector-calculus-understanding-the-dot-product/

Cross product as finding a vector orthogonal to two other vectors.

Coordinate frames

A coordinate frame is any set of n vectors in n dimensional space such that:
- |u| = |v| = |w| = 1 (unit vectors)
- u . v = v . w = w . u = 0 (mutually orthogonal)
- w = u x w (obeys right hand rule via cross product)

A vector can be written in terms of it’s projection onto the vectors of the base. Consider vector p.
p = (p . u)u + (p . v)v + (p . w)w

Why construct a coordinate frame? Generate camera space from a looking direction and a canonical up direction.

Construct a coordinate frame from two vectors, a and b, that are not orthogonal or unit vectors.

Normalize a = w
Find u = b x w, normalize
Find v = u x w, normalize

Then both a and b can be expressed as part of the same basis.

Matricies

For a more detailed dive, check out my MIT linear algebra notes .

Dot product = a . b = a^T b
Cross product = a x b = A* b where A* is a dual matrix of A. I haven’t covered this in linear algebra yet.

edX Foundations of Computer Graphics

2012-11-08T13:56:00-08:00

THIS IS A PLACEHOLDER SO THAT THE INDEX APPEARS IN THE PROJECT LIST

Mind the Taste Gap

2012-11-06T00:00:00-08:00

I’ve been drawing in some form or another for a very long time. I can remember the instant I decided that it was something I wanted to pursue – I saw a really cool illustration of Nintendo’s Link in a magazine for the Ocarina of Time release. I started by tracing that picture, and continued from there.

When my brother and I were young, I remember a few occasions where he would ask me to teach him to draw, because he wanted to draw but couldn’t. I would try to teach him, and he would try to draw, and eventually he would give up in disgust at his own crappy work.

I didn’t realize back then, but he fell into the “taste gap”. The “taste gap” is the difference between what you like, and what you produce. Ira Glass covers it in this video:

Somehow I made it past the taste gap, after I saw that picture of Link. Whatever caught my brother’s eye about drawing made him want to try. Maybe it was my work. Maybe not. But he didn’t make it past the disappointment in his own work.

If I could go back in time, I would tell him to not worry. I would tell him that it’s OK to suck, because he was just started. I would tell him to draw as much as he can, to work through all the suck. It’s why writers write drafts, why concept artists do thumbnails. It’s why programmers refactor. If you get all the obvious, less than impressive stuff out first, you’ll start to put out some gems of work.

I’m very interested in the Zen concept of beginners mind. I can recall several instances where my ignorance into a topic allowed me to perform very well in those topics. When I was 13, I wrote a clone of the then popular children’s toy the Tamagotchi in Logo. I didn’t know anything about programming when I started. I think there’s some relationship between the “taste gap” and beginners mind. Maybe the “taste gap” defeats beginners mind, by putting a standard which we hold ourselves to.

Likewise, I think being able to put yourself into the beginners mind can help overcome the “taste gap”. If you concentrate on quantity rather than quality, on deliberate practice instead of trying to reach your taste goal, you can overcome that gap, and put yourself onto the road of being able to reach that goal after all. I believe this applies to all aspects of life.

If you find yourself getting frustrated by the quality of your output, realize it’s because you’re running into that “taste gap”, and realize that as you work, you are closing that gap. Don’t give up, just keep on producing.

Becoming a Game Developer

2012-06-27T00:00:00-07:00

Ever since I started programming, I have always been interested in making games. I can remember one of my first major programming experiences was when I was 13, in language called Logo . I duplicated the functionality of a Tamagotchi , where the player had to take care of this little critter. I even had evolution, if I remember correctly. My interest in graphics and AI can find it’s roots in my interest in game development.

Once I got a professional career in development, and heard some of the horror stories of AAA game development, I shelved the dream indefinitely. The recent successes of Minecraft and other indie studios/games have reignited my interest in game development. I’m not about to do anything drastic like quit my day job and go chasing after a game development studio, but tinkering in game development on the side sounds like it might be fun.

Of course, game development is a very different beast from web development, and I know that I’ll essentially be starting from scratch, much like many young, aspiring game developers.

If you’ve ever spent any time at a developer forum or social site, you’ll be familiar with the throngs of game development newbies who are clamouring for information on how to get started on their huge 3D MMORPG game idea, before being brought back down to earth by those who know better. The same questions come up time and time again – what language should I program in? How do I get started?

The path for each game developer at the learning phase of their careers seems to be similar – pick a language, start writing some really basic games. Apply proper polish such as saving, menu screens, splash screens, etc and then iterate.

Due to this, I thought it might be fun to publish my learning experience online, so that maybe these kinds of questions can be answered with “do what that guy did, he put EVERYTHING online.” To that end, I am writing a blog called Confirmed Crit where I write about everything that happens. So much so that I have a tool that will create blog posts out of git commits. Combine that with Literati, and literally every piece of code I write should be reasonably explained and open for examination.

I’m not intending on shutting this blog down, or not posting here, but I felt my game development trials and tribulations deserved their own home. I’d love for anyone who reads this blog and is interested in game development to checkout Confirmed Crit and follow along in my journey.

Free Online Education is Blowing Up

2012-04-19T00:00:00-07:00

At the end of 2011, I participated in 2 of 3 free, online courses offered from professors from Stanford University in an experiment in online education. From that experiment, 2 new startups spun out of Stanford – Udacity and Coursera. Since then, both Coursera and Udacity have started to increase their class offerings, and now a wide variety of university level classes can be taken online for free.

Those who know about MIT’s OpenCourseWare program and iTunes U have known for a while that these courses were there for taking anyway. The difference between those and the courses offered by Coursera and Udacity is one of time and deadlines. The OCW and iTunes U video lectures are available online, always. No time limits. The Coursera and Udacity courses run on a strict time frame, and have weekly deadlines for homework. This helps you stay on track and provides a basic level of accountability.

I just finished Udacity’s AI for Robotics class, and as a result of a particularly busy period of work, I’ve had to miss out on some great courses offered by Coursera. At first I thought the online classes I’ve been taking were just a one off, a 12 week event that once finished, I walked away from.

Coursera are offering several computer vision classes, and I’ve been saving the videos from the natural language processing course. I’m now starting to realize that this online learning is going to become a regular part of my life, like working and socializing. I’m more than OK with this, it just means having to juggle things around in my life.

I think this sort of continuous learning should be a part of everyone’s life. If you haven’t checked out the offerings from Coursera or Udacity, I suggest you do so. Chances are one of the courses will pique your interest. Sign up. Spend 2 hours a week watching lectures instead of TV. The worst that can happen is you fail an online class you previously weren’t thinking of taking.

Udacity AI for Robotics - Week 6

2012-03-26T00:00:00-07:00

Putting It All Together

Localization to determine where in the map you are
Planning to plot a route from current suspected location to goal
PID to smooth the planned route

CTE Revisited

Computing CTE for arbirary vector trajectories

SLAM

Every localization technique thus far has required the agent to have predefined knowledge of it’s environment before being able to navigate it’s way through it.

Simultaneous localization and mapping, or SLAM, removes that constraint. The difficulty of doing this is that robot motion and sensing is uncertain.

Linear GraphSLAM

Assume an agent starts at a location $x_0 = 0, y_0 = 0$. The agent has a perfect compass and doesn’t need to keep a belief state about orientation. The robot has no knowledge of the environment.

If the agent moves 10 “units”, under perfect motion it will be at $x_1 = 10, y_1 = y_0 $. However, an agent’s movement is uncertain, so it’s final location is represented by a Gaussian distribution, centered at $x_1 = x_0 + 10, y_1 = y_0$:

and the Gaussian is given by the formula:
\[
\frac{1}{\sqrt{2 \pi \sigma^2}} exp – \frac{1}{2} \frac{(x_1 – x_0 – 10)^2}{\sigma^2} \frac{1}{\sqrt{2 \pi \sigma^2}} exp – \frac{1}{2} \frac{(y_1 – y_0)^2}{\sigma^2}
\]

This Gaussian is a constraint on the location of the agent. It’s initial location is a constraint, each relative motion introduces new constraints and every observed landmark introduces a relative measurement constraint.

Implementation

Implementing GraphSLAM involves tracking the constraints observed above in relation to each other. To do this, a matrix is used.

Suppose an agent moves from a starting position $x_0$ to points $x_1$ and $x_2$.
While travelling on this path, it observes 2 landmarks, $l_0$ and $l_1$.

The constraints on each pose and each landmark are represented as follows:

The matrix, $\Omega$, represents the constraint between each pose and landmark. The vector, $\xi$ represents the sum of all constraints on each pose and landmark. Each constraint is initialized as zero, and as movement and observations occur, the constraints are added into the matrix.

For example, consider an agent starting at $x_0$. The agent moves 5 units to $x_1$.
The position of $x_1$ subtracted from $x_0$ should equal -5, which means that $x_1$ should be 5 units further than $x_0$. Likewise, $x_0$ subtracted from $x_1$ should equal 5.

Each additional constraint is added to the last.

Next, the agent moves 9 units from point $x_1$ to point $x_2$. $\Omega$ and $\xi$ are updated as follows:

When determining the location of each pose and landmark, this operation can be performed with a simple algorithm:
\[
\mu = \Omega^{-1} \xi
\]

This will use all the constraints collected at that point in time to estimate the location of each pose and landmark. As the matrix fills and is updated, the more accurate these estimations will become.

Confidence measure

Consider again the formula for a Gaussian distribution:
\[
\frac{1}{\sqrt{2 \pi \sigma^2}} exp – \frac{1}{2} \frac{(x_1 – x_0 – 10)^2}{\sigma^2}
\]

The above Gaussian tries to maximize this equation, finding the largest values of $x_1$ and $x_0$ that satisfies the constraint of being 10 units apart.

In the above equation, the first fraction is a constant, and thus can be ignored when considering the core of the formula. Likewise, the exponentail and the second fraction can be ignored.

What is left is the following relationship:
\[
\begin{align}
&\frac{1}{\sigma^2}(x_1 – x_0 – 10)^2 \\
&\frac{1}{\sigma}(x_1 – x_0 – 10)
\end{align}
\]

$\sigma$ is known as the confidence measure, or a measure of uncertainty. When $\sigma$ is small, GraphSLAM weights the constraint higher, which means it will adhere to that constraint much more heavily than the others. Likewise when it is large, the constraint is relaxed more than the others.

Previous examples were dealing with a $\sigma$ of 1, which doesn’t change the weighting of a constraint.

The confidence measure is a way of representing noise in the scenario. If a sensor or motion is very noisy, you can give that sensor’s readings a high $\sigma$. Each sensor or motion can have a different confidence measure.

Drawbacks in GraphSLAM

The $\Omega$ matrix in GraphSLAM grows linearly with the length of the path, no matter the size of the environment the agent is in. This leads to a case where when an agent has been running for a long time, $\Omega$ is a lot larger than the environment, and it can get so large that the agent will eventually stop.

The solution is to run SLAM online – keep only the most recent position in $\Omega$:

Udacity AI for Robotics - Week 5

2012-03-19T00:00:00-07:00

Introduction

Previously discrete robot motion was discussed, where the world was split into discrete nodes and a path was found through these discrete nodes. This is impractical for the real world, as the paths and plans found does not suit the actual motion of robots, and are often sub-optimal.

Smoothing

In order to produce continuous robot motion, a smoothing algorithm is applied to the discrete path found by techniques covered in Week 4, rather than tackling the complex and expensive task of finding a path in a continuous problem space.

Going back to Week 4, where the world was discretized into cells or nodes. Consider a world of $n$ nodes, and label each node $x_i$, where the range of nodes is $x_0 \ldots x_{n-1}$.
The general idea behind the smoothing algorithm is as such:

$y_i = x_i$
$min (x_i – y_i)^2$ and $min (y_i + y_{i+1})^2 $

where $y_i$ is the new, smoothed $x_i$. Step 2 is minimizing the difference between the new, smoothed node and the old discrete node, and minimizing the difference between the new smoothed node and the next smoothed node. These minimizations are competing, so they are performed with a weighting so as to control the smoothness of a path vs. the exactness of the path:
\[
y_i = y_i + \alpha (x_i – y_i)^2
\]

The last equation can be improved by comparing the points both before and after the current point:
\[
y_i = y_i + \beta (y_{i+1} + y_{i-1} – 2y_i)
\]
The above shows that $y_i$ is simulatenously close to both $y_{i+1}$ and $y_{i-1}$.

$\beta$ controls how much smooting is done, and $\alpha$ controls how close to the original path the smoothed path stays.

Code

h2. PID Control PID control is a vast field, so only the basics will be covered. h3. P Controller A P controller will align an agent to a predefined path, called a reference trajectory. It does so by correcting the heading of the agent proportionally to the crosstrack error, giving the P in the P controller The crosstrack error is the error between the desired trajectory and the current trajectory. The larger the CTE, the more the heading is changed to reduce the CTE. A rough way of modelling this is with the following formula: \[ \alpha = - \tau \; \text{CTE} \] However, the above equation will overshoot the reference trajectory, as although the wheels will be pointing straight once the agent is on the target trajectory, the agent itself will not be straight. This will cause it to oscillate between overshooting and undershooting the reference trajectory. This state is known as being marginally stable, or just stable. To solve the oscillation with the P controller, there is the PD controller h3. PD Controller The PD controller is a P controller augmented by taking into consideration the rate of change of the CTE (differential CTE, D in PD controller). If the rate of change of the CTE is high, the steering backs off quite a bit. As the rate of change of the CTE drops, the steering approaches that of a P controller more accurately. This can be modelled as follows: \[ \alpha = - \tau_P \; \text{CTE} \; - \tau_D \frac{\delta}{\delta t} \text{CTE} \] h3. Bias A problem with real life agents is one of steering bias. The above models assume the agent is absolutely aligned, however the actual bearing of an agent may not be it's actual bearing - this is a bias in it's steering. This will cause the P and PD controllers to have a consistent CTE error that is proportional to the bias. The solution is to correct for the observed error over a time window with the PID controller h3. PID Controller The PID controller is a PD controller augmented by taking into consideration the integral of the CTE, (I in PID controller) or the observed error over time. This can be modelled with the following: \[ \alpha = - \tau_P \; \text{CTE} \; - \tau_D \frac{\delta}{\delta t} \text{CTE} \; - \tau_I \sum \text{CTE} \] h3. Coordinate Ascent or Twiddle Choosing control gains ($\tau_P, \tau_D, \tau_I$) poses a small challenge. Coordinate ascent, or 'twiddle' can be used to find the optimal control gains. Psuedo code for the 'twiddle' algorithm is as follows:

This algorithm is doing the following:

Initialize p to be blank control gains, and dp to be the amount to change the p on each step. Run the PID controller with blank control gains, and store that error.
While the sum of the dp is higher than sum threshold (which will indicate how precise the optimisation will be), do the following:
For each control param independently, add the delta and run the PID controller. If the result is the best thus far, store it. If not, try subtracting the delta and run the PID controller. If the result is the best thus far, store it. If not, reduce the delta and wait to try again.

This will find the optimal control gain within a tolerance threshold.

Code:

MIT OCW Single Variable Calculus - Week 5

2012-03-19T00:00:00-07:00

Approximations

Remember from the last lecture the discussion of approximations with an example that related to relativity.
We discussed the following linear generalization:
\[
T’ = \frac{T}{\sqrt{1 – \frac{v^2}c^2}} \approx T(1 + \frac{1}{2}\frac{v^2}{c^2})
\]

This generalization tells us the change in T, divided by T is approx to:
\[
\frac{\Delta T}{T} \approx \frac{1}{2} \frac{v^2}{c^2}
\]

This expresses the change, or fraction of error, in time on earth proportional to the time on the satellite is a relationship of the velocity of the satellite, considering that $c$ is constant.
Or, you could say that the error fraction is proportional to $\frac{v^2}{c^2}$ with a factor of $\frac{1}{2}$. This is a linear relationship, as expressed with our linear generalization.

These simplifications make designing complex systems easy, as the error between the approximation and the exact value is often negligable. If we tried to build complex systems based on the exact equations, it would be too difficult and complicated to complete the task.

Quadratic approximations

Quadratic approximations are used when linear approximations are not accurate enough.
Remember the formula of the quadratic approximation is as follows:
\[
f(x) \approx f(x_0) + f’(x_0)(x – x_0) + \frac{f’’(x)}{2}(x – x_0)^2
\]
where the base point for the approximation is near 0: $x \approx 0$.

Consider a parabola. A parabola is itself a quadratic function. Therefore, it’s quadratic approximation must equal itself:
\[
\begin{align}
f(x) &= a + bx + cx^2 \\
f’(x) &= b + 2cx \\
f’’(x) &= 2c
\end{align}
\]
We want to recover $a$, $b$, $c$ using the derivatives evaluated at 0:
\[
\begin{align}
f(0) &= a \\
f’(0) &= b \\
\frac{f’’(0)}{2} &= c
\end{align}
\]
This explains why the linear approximation involves half of the second derivative ($\frac{f’’(x)}{2}$) instead the second derivative entirely.

Recall some common approximations derived from the basic formula in the last lecture:
\[
\begin{align}
sin \; x &\approx x \\
cos \; x &\approx 1 – \frac{1}{2}x^2 \\
e^x &\approx 1 + x + \frac{1}{2}x^2 \\
\end{align}
\]
where $x \approx 0 $

Next we will derive the following quadratic approximations:
\[
\begin{align}
ln(1 + x) &\approx x – \frac{1}{2}x^2 \\
(1 + x)^r &\approx 1 + rx + \frac{r(r – 1)}{2}x^2
\end{align}
\]

Derivation is as follows:

\[
\begin{array}{ l | l | l | l | l | l | l }
f & f’ & f’’ & f(0) & f’(0) & f’’(0) & f(0) + f’(0)x + \frac{f’’(0)}{2}x^2 \\ \hline
ln(1 + x) & \frac{1}{(1 + x)} & \frac{-1}{(1 + x)^2} & 0 & 1 & -1 & x – \frac{1}{2}x^2 \\
(1 + x)^r & r(1 + x)^{r-1} & r(r-1)(x + 1)^{r – 2} & 1 & r & r(r-1) & 1 + rx + \frac{r(r – 1)}{2}x^2
\end{array}
\]

Applications of quadratic approximations

Example:

Consider the equation below
\[
a_k = (1 + \frac{1}{k})^k
\]
which tends to $e$ as $k$ tends to $\infty$.

This equation was solved previously using differentiation, however it can also be solved simply by using linear approximation:
\[
\begin{align}
ln\;a_k &= k(ln(1 + \frac{1}{k})) \\
&\approx k(\frac{1}{k}) \\
&\approx 1 \\
\therefore ln\;a_k &\to 1 \quad \text{(as } k \to \infty \text{)}
\end{align}
\]
due to the linear approximation of $ln(1 + x) \approx x$, which holds if we set $x = \frac{1}{k}$.

$a_k$ tends to $e$ because $ln\;e \to 1$ and $ln\;a_k \to 1$.

If we wanted to find the rate of convergence, that is, how fast $ln\;a_k \to 1$, we can use a quadratic approximation. We won’t be solving this just yet.

Example:

Find the quadratic approximation for the function x near 0, where the function is:
\[
e^{-3x}(1 + x)^{-\frac{1}{2}}
\]

Solving:
\[
\begin{align}
e^{-3x}(1 + x)^{-\frac{1}{2}} &\approx (1 + (-3x) – \frac{(-3x)^2}{2})(1 + (-\frac{1}{2})x + \frac{1}{2}(-\frac{1}{2})(-\frac{1}{2} – 1)x^2 \\
&\approx 1 – 3x – \frac{1}{2}x + \frac{3}{2}x^2 + \frac{9}{2}x^2 + \frac{3}{8}x^2 \quad \text{(dropping higher order terms than} \; x^2 \text{)} \\
&\approx 1 – \frac{7}{2}x + \frac{51}{8}x^2
\end{align}
\]

Note that the first half of the answer is the solution to the linear approximation for this problem in week 4, example 1 . The last fraction is the extra information obtained by performing a quadratic approximation.

Curve sketching

The goal of curve sketching is to draw the graph of $f$ using $f’$ and $f’’$, whether they’re positive or negative.
However, don’t abandon your precalculus skills and common sense. Common sense often trumps calculus, and calculus is there to fill in the gaps.

Principles

If $f’ > 0$ then $f$ is increasing. Similarly, if $f’ < 0$, then $f$ is decreasing.

If $f’’ > 0$ then $f’$ is increasing. Similarly, if $f’’ < 0$, then $f’$ is decreasing. When $f’$ is increasing, then $f$ is said to be concave up. When $f’$ is decreasing, $f$ is said to be concave down.
The following diagram illustrates the reasoning behind this:

As you can see at the top the gradients $f’$ of $f$ are decreasing – thus the curve is concave down.
The gradients in the curve on the bottom are increasing – thus the curve is concave up.

We can use these principles to analyze what a graph should look like, without drawing it. Take for example:
\[
\begin{align}
f &= 3x – x^3 \\
f’ &= 3 – 3x^2 \\
&= 3(1 – x)(1 + x)
\end{align}
\]

We can see from the above factored form of $f’$ that when $-1 < x < 1$, $f’ > 0$ and $f$ is increasing.
When $x < -1$ and $x > 1$, $f’ < 0$ and $f$ is decreasing.

From the example, we can expect our graph to look a little like this:

As we can see from the estimated graph, there are two points where the gradient, $f’(x)$ is 0. This is what is called a turning point, or more formally, a critical point.

If $f’(x_0) = 0$, the point at x is called a critical point. Thus $y_0 = f(x_0)$ is called a critical value.

So far, everthing we have done can be solved using a graphing calculator. One thing we can’t solve with a graphic calculator is what happens at the ends of the function, off the screen. To determine this, we can use our principles.

As $x$ tends to infinity, we can see $f(x) \approx -x^3$, and tends to negative infinity.
As $x$ tends to negative invinity, we can see that $f(x)$ tends to infinity.

To get any more information about this curve, we need to take the second derivative:
\[
\begin{align}
f’(x) &= 3 – 3x^2 \\
f’’(x) &= -6x
\end{align}
\]

From the above, we can see that $f’’(x)\ < 0$ if $x > 0$ and $f’’(x) > 0$ if $x < 0$. In the first case it’s concave down, and in the second case it’s concave up.

We can see that the point $0, 0$ is the point where the function changes from concave down to concave up, and $f’’(x) = 0$. This is known as a point of inflection.

and the actual graph looks like this:

Take for example this new function:
\[
\begin{align}
f(x) &= \frac{x + 1}{x + 2} \\
f’(x) &= \frac{1}{(x + 2)^2}
\end{align}
\]

There is an important thing to note about this example – $f(x) \ne 0$, which means there are no critical points

On the surface, it may look like there’s nothing to sketch because there are no critical points.
However, it is useful in a situation like this to start plotting points. The most important points to plot are those where the function is undefined.

Consider the value $x = -2$. The function is undefined for this value of x, and we can determine what is happening to the curve at this point by examining points around it.

First, approach $x = -2$ from the positive side, with a number that is a little more than $-2$:
\[
\begin{align}
f(-2^{+}) &= \frac{-2^{+} + 1}{-2^{+} + 2} \\
&= \frac{-1}{0^{+}} \\
&= -\infty
\end{align}
\]

Remember, the $x^+$ represents a number that is a small amount larger than $x$.

Next, approach $x = -2$ from the negative side:
\[
\begin{align}
f(-2^{-}) &= \frac{-2^{-} + 1}{-2^{-} + 2} \\
&= \frac{-1}{0^{-}} \\
&= \infty
\end{align}
\]

Therfore, there exists an asymptote at $x = -2$.

Next, we can analyze what occurs at the ends of the function ($x \to \pm \infty $):
\[
\begin{align}
f(x) &= \frac{x + 1}{x + 2} \\
&= \frac{1 + \frac{1}{x}}{1 + \frac{2}{x}} \quad \text{dividing numerator and denominator by x} \\
&= 1
\end{align}
\]

This tells us there is another asymptote at $y = 1 $. We also know that there are no critical points, due to the gradient of the function never equalling 0. This means there are no “dips” or “cross-overs” of the asymptotes.

From the above knowledge, the sketch of the function should resemble the actual function:

We can doublecheck this work by examining the first and second derivative:

\[
\begin{align}
f(x) &= \frac{x + 1}{x + 2} \\
f’(x) &= -\frac{1}{(x + 2)^2} \\
f’’(x) &= -\frac{2}{(x + 2)^3}
\end{align}
\]

As you can see, first derivative is positive when $x \ne -2 $, which the graph reflects.
The second derivative is negative when $-2 < x < \infty $ and positive when $ -\infty < x < -2 $, which the graph also reflects.
It is concave down above $-2$, and concave up below $-2$.

General strategy

Plot
1. Discontinuities (especially infinte)
2. end points (or $x \to \pm \infty $)
3. easy points (optional, just fills out more information)
1. Solve $f’(x) = 0$
  1. Plot critical points
Decide whether $f’(x)$ is positive or negative for each interval between critical points or discontinuities, consistent with steps 1 & 2. If you can succeed in steps 1 & 2, you won’t need to do this step, unless you want to doublecheck your answers.
Decide whether $f’’(x)$ is positive or negative, and thus whether $f(x)$ is concave up or down. Determine inflection points, where $f’’(x) = 0$.
Combine all the steps.

Udacity AI for Robotics - Week 4

2012-03-12T00:00:00-07:00

Motion planning enables a robot with a known target location to successfully navigate to that location in a predefined map, without having a predefined path. Motion planning will generate the best path for the robot to get to it’s location.

The planning problem can be defined as such: given a map, a starting location, a goal location, and a cost function that will determine the cost of a path, the planning algorithm needs to find a path that minimizes the cost.

One discrete planning algorithm that can be used is the A* path finding algorithm.

A* path finding

A* is a path finding algorithm that is effective in finding a path from one location to another. It starts with a basic naiive search, and is then augmented by a heuristic function that improves it’s efficiency.

Search

The search that the A* planning algorithm is based on involves considering the environment in discrete nodes. The start node is added to a list of nodes to be explored (or expanded), called an open list, along with the number of nodes that were expanded, called it’s g-value. In the start case, the node will be added with a g-value of 0.
The algorithm then selects the node with the smallest g-value from the open list. First it checks if this node is the goal node. If it is, the algorithm terminates. If it is not, the algorithm removes it and adds it to a visited list. Each node the algorithm can reach from the node just expanded is added to the open list, along with it’s g-value, in this case, 1. If a node found through expansion is in either the open list, or the visited list, it will be ignored.

Heuristic function

The heuristic function is a function that applies some sort of prior knowledge about the environment to the search algorithm. There are many heuristic functions that can be used, and one of them is to calculate the manhattan distance to the goal.

The only requirements for a heuristic is that it must be optimistic. That is, the cost of the node must be less than or equal to the actual distance to the goal. The heuristic can underestimate the cost of the node, but not over estimate it.

Code

h2. Dynamic programming Another discrete planning algorithm that can be used is called dynamic programming. It has an advantage over A* in that it can calculate a plan from anywhere in the predefined map, which makes it suitable for use in stochastic environments. Every cell in the discrete world has an optimal action, so that if the agent finds itself in a non-optimal location, the optimal path is easy to find. This is actually similar to another technique called influence maps, which operate in a similar fashion, but more easily allow multiple obstacles to influence a path. The optimal action for a given node is determined by the policy. The policy will take a node and return the optimal action. !/images/air/dynamic.png! h3. Value function A value function assigns to each node the number of steps to the goal. Mathematically, it can be expressed as follows: \[ f(x,y) = min_{x', y'} f(x', y') + 1 \] This expresses that the algorithm calculates a node's value by considering it's lowest value neighbour, and adding the number of steps it takes to reach that neighbour. If the algorithm starts at the goal, it's value is 0. The nodes that are adjacent to the goal node have a value of 1. The nodes adjacent to those adjacent nodes have a value of 2, and so on until every node in the environment has a value. h3. Code Note: This code was taken from the Udacity forums, and annotated by me. I can't find the specific thread.

Udacity AI for Robotics - Week 3

2012-03-05T00:00:00-08:00

Introduction to Particle Filters

Along with Histogram filters and Kalman filters, Particle filters are a technique that can be used to track and localize a robotic agent.
While a Histogram filter is discrete and multimodal algorithm, and has storage requirements that increase exponentially with each dimension of state, and a Kalman filter is a continuous and unimodal algorithm with quadratic storage requirements, Particle filters are continuous, multimodal algorithms. The complexity and storage requirements have not fully been determined.
All filters are approximate, in that they do not exactly model reality.

Global Localization with Particle Filters

The robotic agent starts with a known map of the environment. The robot has range finder sensors that can determine the range of obstacles. The particle filter algorithm has the agent make “guesses” about it’s current location, with each guess having an x and y co-ordinate and a heading value. The agent at any given time makes n guesses, where in is a large number such as 1,000. Below is a map of an environment in an initial state, with each guess being represented as a dot. Notice the uniform distribution of guesses:

As the robot moves, and reads from it’s sensors, the particles begin to converge on it’s actual location:

The particles survive when they are closer to the measurements made by the robotic agent. As a result, locations of higher probability will collect more particles.

Robot World

In order to put the particle filter algorithm into practice, a theoretical robot world will be used:

This robot world is cyclical, and there are four landmarks the robot can read the distance to. The robot has an x, y value, and a heading.

Importance Weight

As the robot moves through the world, the random distribution of particles are moved with the robot, along their headings. This movement is subject to noise, so a Gaussian is usually interpolated into the results. When the robot reads it’s sensors, each particle simulates reading sensors based on it’s current position and heading.

In the above diagram, the robot is in blue, and one of the particles is in red. The readings of the robot form a 4-dimension vector, with distances to each of the 4 landmarks, modified by a Gaussian distribution to account for sensor noise. The particle simulates reading it’s sensors, and another 4-dimension vector is generated. The particle’s generated sensor reading is comapred to the actual sensor reading, and a weight of likeliness is calculated. The given particle will have a low likeliness, as it’s sensor readings differ significantly from the actual readings.

Resampling

Once all the particles have importance weights calculated, resampling occurs. During the process of resampling, n new particles are redrawn, proportional to the prior particle importance weights. That means that particles with a higher importance are more likely to be included in the new set of particles. This means that particles that are closer to the actual robot’s location tend to survive for many resamplings, and as the robot continues to move, the newer particles start to converge on the robot’s actual location.

Each particle’s importance weight is first normalized, and then a new selection of n particles is drawn from a pool of old particles, at the normalized probabilities. It is possible to draw the same particle multiple times, and that is how particles that are more likely to be correct persist through multiple resamplings.

Resampling Wheel

The process of sampling particles at their normalized probability is not a straight forward task. However, it can be simplified by imagining the weight of each particle as a portion of a circle:

If the weight of each particle can be thought of as a portion of a pie, or a wheel, then the circumference of that circle that belongs to the particle is proportional to the weight. We can then employ the following algorithm:



  particles = []

  index = random(0 – N)

  b = 0

  m = max(weights)

  for i in N

    b += random(2 * m)

    while weights[i] < b

      b -= weights[i]

      i = (i + 1) % N

    particles.append(prior[i])

This algorithm is equivalent to the following:

Randomly pick a particle
Rotate around the wheel by a random amount, limited by twice the distance of the largest probability
The amount rotated will point to the weight that corresponds to the particle to pick.
Repeat steps 2 & 3 n times, until there is a new pool of particles.

Through n iterations, and with a random b, particles with a larger weighted probability are more likely to be picked, and picked more often as well.

Orientation through Movement

In the above resampling, orientation doesn’t converge, as the robot has not performed any movement. When the robot moves, the orientation is going to affect the next sensor reading, and thus will affect how a particle gets resampled

Math

Similar priciples are used in particle filters as were used in histogram filters.

When performing measurement updates, particle filters leverage Bayes rule:
\[
P(X | Z) \propto P(Z | X) P(X)
\]

When performing the motion updates, particle filters leverage conditional probability:
\[
P(X’) = \sum P(X’ | X) P(X)
\]

Code

MIT OCW Linear Algebra - Week 4

2012-03-02T00:00:00-08:00

Computing the Nullspace (Ax = 0)

Consider the matrix $A$:
\[
\begin{bmatrix}
1 & 2 & 2 & 2 \\
2 & 4 & 6 & 8 \\
3 & 6 & 8 & 10
\end{bmatrix}
\]

The means of computing the nullspace is matrix elimination. The difference between this and the row elimination we’ve done previously, is that this will operate on rectangular matrices, not just square ones, and we’ll need to possibly deal with $0$ in the pivot position. Notice that column 2 is not linearly independent, and that row 3 is not linearly independent.

It is important to note that performing matrix elimination doesn’t change the nullspace, although it does change the column space. That is, the solution to the equation doesn’t change.

Following is matrix elimination to solve the equation: $Ax = 0$:
\[
\begin{bmatrix}
1 & 2 & 2 & 2 \\
2 & 4 & 6 & 8 \\
3 & 6 & 8 & 10
\end{bmatrix}
\to
\begin{bmatrix}
1 & 2 & 2 & 2 \\
0 & 0 & 2 & 4 \\
0 & 0 & 2 & 4
\end{bmatrix}
\]

Notice above that in the $2,2$ pivot position there is a zero, and that it’s not possible to perform a row exchange with the row beneath it, because that too has a zero in the pivot position.

This tells us that the second column is not linearly independent, and that it can be formed by a combination of another column.

To continue, we consider $2,3$ to be our pivot position instead:
\[
\begin{bmatrix}
1 & 2 & 2 & 2 \\
0 & 0 & 2 & 4 \\
0 & 0 & 0 & 0
\end{bmatrix}
\]

This gives us the matrix $u$. It’s not upper triangular, but it is in echelon form, which describes the structur of the 0’s in the matrix. We can see that this matrix has 2 pivots – this means that it has a rank of 2. That is, the rank of a matrix is the number of pivots.

The matrix $u$ has 2 pivot columns. A pivot column is a column that holds a pivot. The other columns, that don’t hold a pivot, are called free columns. They are called free columns because we can assign any value to the unknowns that correspond to those columns, and solve for the unknowns in the pivot colums.

For example:
\[
x = \begin{bmatrix}
? \\
1 \\
? \\
0
\end{bmatrix}
\]

We can break out the rows of the matrixs and represent them into their equation form:
\[
\begin{align}
x_1 + 2x_2 + 2x_3 + 2x_4 &= 0 \\
2x_3 + 4x_4 &= 0
\end{align}
\]

From here, using the numbers we picked for the unkowns, we can perform back substitution, and get:
\[
\begin{align}
2x_3 + 4(0) &= 0 \\
x &= 0
\end{align}
\]

To solve for $x_1$:
\[
\begin{align}
x_1 + 2(1) + 2(0) + 2(0) &= 0 \\
x_1 + 2 &= 0 \\
x_1 &= -2
\end{align}
\]

The solution to this is a vector in the nullspace:
\[
x = \begin{bmatrix}
-2 \\ 1 \\ 0 \\ 0
\end{bmatrix}
\]

Any multiple of the vector $x$ will also lie in the nullspace. This describes a line that is in the nullspace.

We can also flip the position of the 0 and the 1 for the free columns:
\[
x = \begin{bmatrix} ? \\ 0 \\ ? \\ 1 \end{bmatrix}
\]

And the result of the back substitution is:
\[
x = \begin{bmatrix} 2 \\ 0 \\ -2 \\ 1 \end{bmatrix}
\]
which also lies in the nullspace.

With two vectors in the nullspace, we can determine the entire nullspace. The nullspace is composed of all the combinations of the two vectors found above, and can be represented as:
\[
c\begin{bmatrix} -2 \\ 1 \\ 0 \\ 0 \end{bmatrix} + d\begin{bmatrix}2 \\ 0 \\ -2 \\ 1\end{bmatrix}
\]

To generalize:
A matrix $m \times n$ with a rank of $r$ will have $n – r$ free variables, and it’s nullspace will be composed of the combinations of $n – r$ vectors. You can find these vectors by assigning the value of $1$ to each free variable while assigning the others a value of $0$, and performing back substitution. You do this $n – r$ times and can derive the nullspace. This is due to the fact that there were only $r$ equations – the free variables are the result of non linearly independent equations.

We can further clean up the matrix $u$, by expressing it in reduced row echelon form. We will call this matrix $R$.
Consider again matrix $u$:
\[
\begin{bmatrix}
1 & 2 & 2 & 2 \\
0 & 0 & 2 & 4 \\
0 & 0 & 0 & 0
\end{bmatrix}
\]

Notice the row of zeros – this comes from the fact that the third row was a combination of the first two rows.

The reduced row echelon form has zeros both above and below the pivots, and the value of 1 in all the pivots:
\[
\begin{bmatrix}
1 & 2 & 0 & -2 \\
0 & 0 & 2 & 4 \\
0 & 0 & 0 & 0
\end{bmatrix}
\]
We subtracted the second row from the first to get a 0 above the second pivot. Now we can divide the second row by 2, which won’t change the solution (as it’s part of the combination of vectors):
\[
\begin{bmatrix}
1 & 2 & 0 & -2 \\
0 & 0 & 1 & 2 \\
0 & 0 & 0 & 0
\end{bmatrix}
\]

This is the matrix $R$. Now, we can break out the linear equations, and solve them like we did above:
\[
\begin{align}
x_1 + 2x_2 – 2x_4 &= 0 \\
x_3 + 2x_4 &= 0
\end{align}
\]

If we then use the procedure to determine the vectors that define the nullspace:
\[
\begin{align}
x &= \begin{bmatrix}
? \\ 1 \\ ? \\ 0
\end{bmatrix} \\
x_3 + 2(0) &= 0 \\
x_3 &0 0 \\
x_1 + 2(1) – 2(0) &= 0 \\
x_1 &= -2
\end{align}
\]
which gives us the solution vector:
\[
\begin{bmatrix}
-2 \\ 1 \\ 0 \\ 0
\end{bmatrix}
\]

and for the other free variable:
\[
\begin{align}
x &= \begin{bmatrix}
? \\ 0 \\ ? \\ 1
\end{bmatrix} \\
x_3 + 2(1) &= 0 \\
x_3 &= -2 \\
x_1 + 2(0) – 2(1) &= 0 \\
x_1 = 2
\end{align}
\]
which gives us the solution vector:
\[
\begin{bmatrix}
2 \\ 0 \\ -2 \\ 1
\end{bmatrix}
\]
which as you can see is the solution we arrived at before, with $Ux = 0$. This equation is called $Rx = 0$.

Looking at the matrix $R$, we can see that the identity matrix I exists in the pivot points. And, that the solution to the pivot unknowns exists in the free variables, but with the signs reversed.

Let us consider a general reduced row echelon form matrix, assuming that the pivot columns are grouped together. It will look like this:
\[
R = \begin{bmatrix}
I & F \\
0 & 0
\end{bmatrix}
\]
where $I$ is the identity matrix, and $F$ are the free variables. There may or may not be a row of zeroes.
This matrix will have $r$ pivot rows, $r$ pivot columns, and $n – r$ free columns.

The nullspace for this general reduced row echelon form matrix can be given by:
\[
\begin{bmatrix}
-F \\ I
\end{bmatrix}
\]
where the columns are the vectors that define the nullspace. These vectors are called the null basis, or the basis of the nullspace.

Remember that the vectors $\begin{bmatrix}1 \\ 0 \\ 0 \end{bmatrix}, \begin{bmatrix}0 \\ 1 \\ 0 \end{bmatrix}, \begin{bmatrix} 0 \\ 0 \\ 1 \end{bmatrix}$ form the basis of the 3 dimensional cartesian space.

Example
Convert the matrix $A$ to reduced row echelon form, and find the solution for the nullspace.
\[
A = \begin{bmatrix}
1 & 2 & 3 \\
2 & 4 & 6 \\
2 & 6 & 8 \\
2 & 8 & 10
\end{bmatrix}
\]
Performing elimination:
\[
\begin{bmatrix}
1 & 2 & 3 \\
0 & 0 & 0 \\
0 & 2 & 2 \\
0 & 4 & 4
\end{bmatrix}
\to
\begin{bmatrix}
1 & 2 & 3 \\
0 & 2 & 2 \\
0 & 0 & 0 \\
0 & 4 & 4
\end{bmatrix}
\to
\begin{bmatrix}
1 & 2 & 3 \\
0 & 2 & 2 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{bmatrix}
\]
The last matrix is the form $U$, the upper triangular or row echelon form. This matrix has a rank of 2, with 2 pivot columns and 1 free column.
To compute the special solutions, we can solve the linear equations by setting the free variable to 1:
\[
\begin{align}
2x_2 + 2(1) &= 0 \\
x_2 &= -1 \\
x_1 + 2(-1) + 3(1) &= 0 \\
x_1 +1 &= 0 \\
x_1 &= -1
\end{align}
\]
This gives us the special solution of:
\[
x = \begin{bmatrix}
-1 \\ -1 \\ 1
\end{bmatrix}
\]

The nullspace is given by the equation: $c\begin{bmatrix}-1 \\ -1 \\ 1 \end{bmatrix}$. This is a line in 3 dimensional space.

We could have continued to reduced row echelon form:
\[
\begin{bmatrix}
1 & 0 & 1 \\
0 & 2 & 2 \\
0 & 0 & 0
\end{bmatrix} \to
\begin{bmatrix}
1 & 0 & 1 \\
0 & 1 & 1 \\
0 & 0 & 0
\end{bmatrix}
\]
Here we can see the identity matrix come out, and the solutions to the pivot variables, $\begin{bmatrix}1 \\ 1 \end{bmatrix}$, with signs inverted.

Solving Ax = b

We will continue using matrix $A$ to demonstrate how to solve a system of linear equations.
The following system of equations is the matrix $A$ in linear equation form:
\[
\begin{align}
x_1 + 2x_2 + 2x_3 + 2x_4 &= b_1 \\
2x_1 + 4x_2 + 6x_3 + 8x_4 &= b_2 \\
3x_1 + 6x_2 + 8x_3 + 10x_4 &= b_3
\end{align}
\]
and remember the 3rd row is the sum of rows 1 & 2 – it is not independent. Therefore, $b_3$ is dependent on $b_1$ and $b_2$. A solution such as $\begin{bmatrix}1 \\ 5 \\ 17\end{bmatrix}$ will not solve this system.

To solve $A$, we need to reduce this matrix:
\[
{
\left[
\begin{matrix}
1 & 2 & 2 & 2 \\
2 & 4 & 6 & 8 \\
3 & 6 & 8 & 10
\end{matrix}
\left|
\begin{matrix}
b_1 \\ b_2 \\ b_3
\end{matrix}
\right.
\right]
}
\rightarrow
{
\left[
\begin{matrix}
1 & 2 & 2 & 2 \\
0 & 0 & 2 & 4 \\
0 & 0 & 2 & 4
\end{matrix}
\left|
\begin{matrix}
b_1 \\ b_2 – 2b_1 \\ b_3 – 3b_1
\end{matrix}
\right.
\right]
}
\rightarrow
{
\left[
\begin{matrix}
1 & 2 & 2 & 2 \\
0 & 0 & 2 & 4 \\
0 & 0 & 0 & 0
\end{matrix}
\left|
\begin{matrix}
b_1 \\ b_2 – 2b_1 \\ b_3 – b_2 – b_1
\end{matrix}
\right.
\right]
}
\]
The last line of the resultant matrix tells us the solvability condition for matrix $A$. That is that $b_3 = b_1 + b_2$. If that doesn’t hold, then $b$ is not a solution. This tells us there is a solution to $A$.

If we suppose that the $b$ before elimination is $\begin{bmatrix} 1 \\ 5 \\ 6 \end{bmatrix} $, then the resultant $b$ after elimination will be:
\[
b = \begin{bmatrix} 1 \\ 3 \\ 0 \end{bmatrix}
\]

To generalize, $A$ is solvable when $b$ is in the column space of $A$, ($C(A)$).

In general, if a combination of rows of $A$ gives a zero row, the same combination of the entries of $b$ must give 0.

To continue finding the complete solution to $Ax = b$, first we find a single solution by setting all free variables to 0 and then solve $Ax = b$ for the pivot variables, using the values for $b$ from above:
\[
\begin{align}
2x_3 + 4(0) &= 3 \\
\therefore x_3 &= \frac{3}{2} \\
x_1 + 2(0) + 2(\frac{3}{2}) + 2(0) &= 1 \\
x_1 + 3 &= 1 \\
\therefore x_1 &= -2
\end{align}
\]
As we can see, one of the solutions to x is:
\[
x = \begin{bmatrix}
-2 \\ 0 \\ \frac{3}{2} \\ 0
\end{bmatrix}
\]

Now that we have one particular solution, the complete solution will be that particular solution added to all vectors in the nullspace.

The complete for solution for $A$ (for the given $b$) is:
\[
x_{complete} = \begin{bmatrix} -2 \\ 0 \\ \frac{3}{2} \\ 0 \end{bmatrix}
+ c \begin{bmatrix} -2 \\ 1 \\ 0 \\ 0 \end{bmatrix} +
d \begin{bmatrix} 2 \\ 0 \\ -2 \\ 1 \end{bmatrix}
\]

This result is a 2 dimensional subspace of $R^4$, that goes through the solution of $x$ that we found, instead of through the origin.

Generally, consider an $m$ by $n$ matrix $A$ of rank $r$. Remember the rank of a matrix is how many pivot columns it has.
We know that $r \le m$ and $r \le n$.
Full column rank means that $r = n$. This means that all the columns independent, the columns are all pivot variables, and that there are no free variables, and that the nullspace will only contain the zero vector. The solution to $Ax = b$ will be unique, if it exists.
Full row rank means that $r = m$. This means that all the rows have pivot variables. This means that we can solve $Ax = b$ for every $b$, and that there are $n – r$ free variables.
A matrix that is full rank has $r = m = n$, and a matrix that is full rank is invertible, it’s reduced row echelon form is the identity matrix, and there is a unique solution.

To summarize:
The rank of a matrix tells you everything about the number of solutions, except what those solutions are.

When $r = m = n$ (full rank)
\[
R = I
\]
and there is 1 solution to $Ax = b$

When $r = n < m$ (full column rank)
\[
R = \begin{bmatrix} I \\ 0 \end{bmatrix}
\]
and there is 0 or 1 solution to $Ax = b$

When $r = m < n$ (full row rank)
\[
R = \begin{bmatrix}I & F \end{bmatrix}
\]
where $I$ and $F$ can be intermingled, and $I$ will be in pivot columns.
There are $\infty$ solutions to $Ax = b$

When $r < m, r < n$
\[
R = \begin{bmatrix} I & F \\ 0 & 0 \end{bmatrix}
\]
where $I$ and $F$ can be intermingled, and $I$ will be in pivot columns.
There are 0 or $\infty$ solutions to $Ax = b$

Udacity AI for Robotics - Week 2

2012-02-29T00:00:00-08:00

Tracking with Kalman Filters

Localization involves orienting a robot in a known environment. When that environment contains moving obstacles, such as other robots, or in the case of a self driving car, pedestrians and other cars, tracking is used to identify those obstacles, and determine how fast they are moving and make predictions about their movements.

Both Kalman filtering and monte carlo methods can be used for both localization and tracking.
Kalman filters are a continuous, uni-modal method, while monte carlo is a discrete, multimodal method.

Later, particle filters will be introduced, which combines both techniques to result in a continuous, multi-modal method.

Gaussian distributions

Monte carlo localization used a histogram to model the probability the robot was in a given location. This histogram is an approximation to a continuous probability:

The Gaussian distribution is another probability distribution. It is characterized by 2 features:
- the mean, $\mu$, or the value of the top of the curve
- the variance, $\sigma^2$, or the width of the curve.

In Kalman filters, the values of $(\mu, \sigma^2)$ will identify the belief state of the location of a given obstacle.
This belief is modelled with the function:
\[
f(x) = \frac{1}{\sqrt{2 \pi \sigma^2 }} e^{-\frac{1}{2}\frac{(x – \mu)^2}{\sigma^2}}
\]
$\frac{1}{\sqrt{2 \pi \sigma^2 }}$ is a constant used to normalize the probability.

Kalman filtering is called a uni-modal method because the Gaussian distribution is uni-modal. This means that it has a single peak in the graph of the distribution. Gaussian distributions are also symmetrical.

$\sigma^2$ is a measure of uncertainty, and in the above equation, it acts to normalize the difference of a value and the mean. The larger the $\sigma^2$, the more uncertain the distribution is.

Stages

Similar to the process of localization, Kalman filters involve repetition over two stages of execution: measurement updates and prediction updates. In localization, and in Kalman filters, the measurement update process involves Bayes rule and calculating products of probabilities, and the prediction updates involve total probability and convolution. The main difference is the probability distributions used, in that Kalman filters use a Gaussian distribution.

Measurement update

As in localization, the robot starts with a prior belief state, which in the case of Kalman filters, is a Gaussian distribution. It is typically very uncertain. If the robot reads it’s sensors, and obtains a new Gaussian distribution that represents what the sensors detected, it needs to multiply those Gaussians together to get the posterier belief state.

This is given by the following equation:
\[
\begin{array}{l}
\mu’ = \frac{r^2\mu + \sigma^2\nu}{r^2 + \sigma^2} \\
{\sigma^2}’ = \frac{1}{\frac{1}{r^2} + \frac{1}{\sigma^2}}
\end{array}
\]

Prediction/Motion update

Due to the uncertain nature of robot movement, as in localization, when the robot moves, it loses information. In the case of Kalman filters, this means that the new calculated Gaussian belief state has a higher variance than it did before it moved. Otherwise, the move works similar to convolution in localization.

The update to the Gaussian belief state is given by:
\[
\begin{array}{l}
\mu’ = \mu + u \\
{\sigma^2}’ = \sigma^2 + r^2
\end{array}
\]

This is saying that the resultant mean is the move distance ($u$) plus the old mean, and the resultant variance is the old variance plus the new variance (uncertainty value in the motion).
This succinctly models the loss of certainty involved in moving.

Multivariate Gaussians

So far, all discussion has been referring to Kalman filtering in 1-D, or one dimension. Real life Kalman filtering will likely take place in 2-D or even 3-D space. To do filtering in these higher dimensions, multivariate Gaussians are used.

Multivariate Gaussians differ in that the mean value becomes an array of means, and the variance value becomes an array of covariance values, of $D \times D $ size, where D is the dimensionality of the matrix.

For more on multivariate Gaussians, see this Stanford handout from the Machine learning class and my Machine Learning notes, particularly the notes on unsupervised learning.

To design a Kalman filter in higher dimensions, the Kalman filter needs a state transition function and a measurement function.

State transition function

When updating the state, as per 1-D Kalman filters, the new location is the old location plus the velocity, and the new velocity is the same as the old velocity. This can be represented by the following equation:
\[
\begin{bmatrix} x’ \\ \dot{x}’ \end{bmatrix} \leftarrow \begin{bmatrix} 1 & 1 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} x \\ \dot{x} \end{bmatrix}
\]

The matrix is known as F, and will be used in the update equations.

Measurement function

Making a measurement involves reading the new location of the object. This can be represented by the following equation:
\[
z \leftarrow \begin{bmatrix} 1 & 0 \end{bmatrix} \begin{bmatrix} x \\ \dot{x} \end{bmatrix}
\]

The row vector is known as H, and will be used in the update equations.

Update equations

The following image outlines the general approach to Kalman filtering with multivariate Gaussians:

The first step is the prediction step. To update the prediction, the location needs to be updated, and the uncertainty covariance needs to be updated.
Updating the location involves multiplying the current belief of the location by the state transition matrix, described above, and adding a motion vector that describes external motion acting on the item.
After updating the location, the uncertainty covariance matrix needs to be updated.

The last step is the measurement update step. To update the measurement, the location needs to be updated, and the uncertainty covariance needs to be updated.
First, calculate the error in the previous prediction to the current measurement. Project the previous uncertainty into the measurement function and add in noise. Calculate the Kalman gain which is a function of the uncertainty. Update the estimate by adding the current value to the Kalman gain influenced error, and update the uncertainty by adding a manipulated Kalman gain value to the existing uncertainty covariance.

More information

An Introduction to the Kalman Filter
Stochastic Models, Estimation and Control – Volume 1, Chapter 1
Kalman Filtering

Code

MIT OCW Single Variable Calculus - Week 4

2012-02-24T00:00:00-08:00

Exponents

To recap from last time, we took the derivative of
\[
a_k = \left(1 – \frac{1}{k} \right)^k
\]
as $k$ tends to infinity:
\[
\lim_{k \to \infty} a_k = e
\]

We came to this result by means of the following (abreviated) process:
\[
\begin{array}{l}
ln\;a_k \to 1 \qquad \text{as k approaches infinity} \\
e^{ln\;a_k} \to e \qquad \text{as k approaches infinity} \\
e^{ln\;a_k} = a_k \quad \text{because} e^{ln\;a} = a
\end{array}
\]

We then used that to come up with a formula for $e$:
\[
e = \lim_{k \to \infty} \left( 1 + \frac{1}{k} \right)^k
\]

We previously covered solving:
\[
\frac{\delta}{\delta x} x^r = r\;x^{r – 1}
\]
for all real r. Now we will cover solving it for all r.

Method 1: use base e.
\[
\begin{align}
x^r &= \left(e^{ln\;x} \right)^r\\
&= e^{r\;ln\;x} \\
\frac{\delta}{\delta x}x^r &= \left( e^{r\;ln\;x} \right)’ \\
&= e^{r\;ln\;x}(r\;ln\;x)’ \\
&= x^r \frac{r}{x} \\
&= r\;x^{r – 1}
\end{align}
\]
which shows that it holds for the above.

Method 2: logarithmic differentiation.
\[
u = x^r, \quad ln\;u = r\;ln\;x
\]
\[
\begin{align}
\frac{u’}{u} &= (ln\;u)’ \\
&= \frac{r}{x} \\
u’ &= u \frac{r}{x} \\
&= x^r \frac{r}{x} \\
&= r\;x^{r – 1}
\end{align}
\]
which shows that it holds for the above.

Review

General formulas

Practice $(u + v)‘, (c\;u)’, (u\;v)‘, (\frac{u}{v})’$, the last two being the product rule and the quotient rule respectively.
Also know the chain rule:
\[
\frac{\delta}{\delta x}f(u) = f’(u)\;u’(x) \qquad \text{where} \quad u = u(x)
\]
and implicit differentiation – inverses, logarithmic differentiation.

Specific functions

$ x^r, sin\;x, cos\;x, tan\;x, sec\;x, e^x, ln\;x, tan^{-1}x, sin{-1}x $

Chain rule

We previously didn’t explain why the chain rule was true. Now we will show it through an example.
Take the function: $y = 10x + b$. $y$ is changing 10 times as fast as x, therefore $\frac{\delta y}{\delta x} = 10$.
Now consider: $x = 5t + a$, then $\frac{\delta x}{\delta t} = 5$.
The chain rule says that if $y$ is increasing 10 times as fast as $x$, and $x$ is increasing 5 times as fast as $t$, then $y$ is increasing 50 times as fast as $t$.

You can use the chain rule to make other rules easier to use.
For example, the quotient rule:
\[
\begin{align}
f &= \left( \frac{1}{v} \right) \\
f’ &= \left( \frac{1}{v} \right)’ \\
&= ( v^{-1} )’ \\
&= ( v^{-1} )’ v’ \qquad \text{by the chain rule} \\
&= -v^{-2}v’
\end{align}
\]
and the full derrivation of the chain rule:
\[
\begin{align}
f &= \left( \frac{u}{v} \right) \\
f’ &= \left( \frac{u}{v} \right)’ \\
&= (u\;v^{-1})’ \\
&= u’v^{-1} + u(-v^{-2}v’) \\
&= \frac{(u’v – uv’)}{v^2}
\end{align}
\]

Examples

Consider: $\frac{\delta}{\delta x} sec\;x$.

\[
\begin{align}
\frac{\delta}{\delta x} sec\;x &= \frac{\delta}{\delta x}(cos\;x)^{-1} \\
&= – (cos\;x)^{-2} cos’x \\
&= – (cos\;x)^{-2}( -sin\;x) \\
&= \frac{sin\;x}{cos^2x} \\
&= \frac{1}{cos\;x} \times \frac{sin\;x}{cos\;x} \\
&= sec\;x\:tan\;x
\end{align}
\]

Generally, when differentiation trig functions, express the answer in terms of the original trig function if at all possible, as we did above.

Consider: \(\frac{\delta}{\delta x} ln(sec\;x)

\[
\begin{align}
\frac{\delta}{\delta x}ln(sec\;x) &= ln(sec\;x)‘(sec\;x)’ \\
&= \frac{1}{sec\;x}(sec\;x)’ \\
&= \frac{1}{sec\;x}(sec\;x\;tan\;x) \\
&= tan\;x
\end{align}
\]

Consider: $\frac{\delta}{\delta x}(x^{10} + 8x)^6$

\[
\frac{\delta}{\delta x}(x^{10} + 8x)^6 = 6(x^{10} + 8x)^5(10x^9 + 8)
\]

We used the chain rule above because expanding the equation out to the 6th power would have taken a lot of space.

Consider: $\frac{\delta}{\delta x}e^{x\;tan^{-1}x}$

\[
\begin{align}
\frac{\delta}{\delta x}e^{x\;tan^{-1}x} &= e^{x\;tan^{-1}x}(x\;tan^{-1}x)’ \\
&= e^{x\;tan^{-1}x}(x(tan^{-1}x)’ + tan^{-1}x) \\
&= e^{x\;tan^{-1}x}\left(tan^{-1}x + \frac{x}{1 + x^2}\right)
\end{align}
\]

Review Continued

The definition of the derivative:
\[
\frac{\delta}{\delta x}f(x) = lim_{\Delta x \to 0} \frac{f(x + \Delta x) – f(x)}{\Delta x}
\]
We discovered the derivative of the following functions using the first principles of differentiation:
$\frac{1}{x}, x^n, sin\;x, cos\;x \text{last two using} \quad x = 0, a^x, (uv), \left(\frac{u}{v}\right)$

We also discussed the meaning of a derivative, that is, the rate of change with respect to some variable.

You can also read the formula for a derivative backwards, and get the function from the limit:
\[
\begin{align}
\lim_{u \to 0}\frac{e^u – 1}{u} &= \frac{e^{u – 0} – e^0}{u} \\
&= \frac{\delta}{\delta x}e^u \bigg|_{u = 0} \\
&= 1
\end{align}
\]

Applications of Differentiation

Linear approximations

The formula for linear approximations:
\[
f(x) \approx (fx_0) + f’(x_0)(x – x_0)
\]

This means that if you have a curve, such as $y = f(x)$, then it is approximately the same as it’s tangent line, $y = f(x_0) + f’(x_0)(x – x_0)$.

For example, consider the function $f(x) = ln\;x$ and it’s derivative, $f’(x) = \frac{1}{x}$, at $x = 1$:
\[
\begin{align}
f(1) &= ln\;1 = 0 \\
f’(1) &= 1 \\
ln\;x &\approx 0 + 1(x – 1) \\
&\approx x – 1
\end{align}
\]

This shows that for the function $ln\;x$, when $x = 1$, it is approximate to the function $y = x – 1$. When $x$ changes significantly, this is no longer true, and $ln\;x$ will approximate some other function:

Remember the definition of a derivative is the limit as the change in $x$ goes to zero, of the ratio of the change in the result of the function and the change in $x$:
\[
f’(x) = \lim_{\Delta x \to 0} \frac{\Delta f}{\Delta x}
\]
You can also look at this backwards, by looking at the limit and determining the derivative based off of that.

In linear approximation, what we’re essentially saying is that as $\Delta x$ gets close to 0:
\[
\frac{\Delta f}{\Delta x} \approx f’(x_0)
\]
That is, the average rate of change ($\frac{\Delta f}{\Delta x}$) is close to the infintesimal rate of change ($f’(x)$) as $x$ approaches some value.

The formula above is the same as the formula for linear approximation:
\[
\begin{align}
\frac{\Delta f}{\Delta x} &\approx f’(x_0) \\
\Delta f &\approx f’(x_0)\Delta x \\
f(x) – f(x_0) &\approx f’(x_0)(x – x_0) \\
f(x) &\approx f(x_0) + f’(x_0)(x – x_0)
\end{align}
\]

Systematic discussion of linear approximation

When performing a systematic discussion, convention is to use $x_0 = 0$. This will result in the formula for linear approximation:
\[
f(x) \approx f(0) + f’(0)x
\]

Below will be an analysis of the linear approximation of a few notable functions:

\[
\begin{array}{ l | l | l | l | l }
f & f’ & f(0) & f’(0) & f(0) + f’(0)x \\ \hline
sin\;x & cos\;x & 0 & 1 & x \\
cos\;x & -sin\;x & 1 & 0 & 1 \\
e^x & e^x & 1 & 1 & 1 + x \\
ln(1 + x) & \frac{1}{1 + x} & 0 & 1 & x \\
(1 + x)^r & r(1 + x)^{r – 1} & 1 & r & 1 + rx \\
\end{array}
\]

And geometrically:

$sin\;x$

$cos\;x$

$e^x$

The last two examples are important. Due to the convention of $x = 0$, we can’t find the tangent of $ln$, because the slope of $ln(0)$ tends $-\infty$. The slope of $x^r$ also tends to $\infty$. To deal with this, we shift the function by starting from a base of one.

Going back to our earlier approximation of $ln$, we can consider the following:
\[
ln\;u \approx u – 1
\]
from above, and just set $u = 1 + x$ to achieve the approximation at $x = 0$.

Applications of linear approximation

Consider the following example:
\[
ln\;1.1 \approx \frac{1}{10}
\]
We achieved this by using the rule from above:
\[
ln(1 + x) \approx x
\]
and just set $x = \frac{1}{10}$.

This only holds because $x$ is sufficiently small. We work with linear approximations of functions because they are easier to calculate than the functions themselves.

You can see this in the following examples:

Example 1
Find the linear approximation “near $x = 0$” ($x \approx 0$) of:
\[
\frac{e^{-3x}}{\sqrt{1 + x}}
\]
We can find this from the formulas and their approximations above:
\[
\begin{align}
\frac{e^{-3x}}{\sqrt{1 + x}} &= e^{-3x}(1 + x)^{-\frac{1}{2}} \\
&\approx (1 – 3x)(1 – \frac{1}{2}x) \\
&\approx 1 – 3x – \frac{1}{2}x + \frac{3}{2}x^2 \\
&\approx 1 – \frac{7}{2}x
\end{align}
\]
Note that we discared the quadratic term $\frac{3}{2}x^2$, because in the transitions above from the functions to their linear approximations, we already discard a lot of quadratic and exponential information, and we’re only concerned with a linear approximation. It stands to reason that we discard all quadratic information. Also note that when $x$ is sufficiently small, any quadratic terms are significantly smaller than the linear terms, and can safely be ignored.

This is kind of the opposite as big O notation in computer science, where we discard smaller terms because we’re only interested in the high value approximations.

Example 2

This example is intended to be relatively real life, and model something you’ll come across in real life.

Consider the surface of the earth, and a satellite in orbit around the earth at velocity $v$. The satellite is a GPS satellite, and requires keeping time, $T$. On the earth, from our frame of reference, we have time $T’$. Special relatively tells us there will be a time dilation between the times $T$ and $T’$, given by:
\[
T’ = \frac{T}{\sqrt{1 – \frac{v^2}{c^2}}}
\]
where $v$ is the velocity of the satellite, and $c$ is the speed of light.
The goal is to determine the difference between times on the satellite and on the earth, or $\Delta T$

We can solve this by using the approximations above, by setting $u = \frac{v^2}{c^2}$:
\[
\begin{align}
T’ &= T(1 – u)^{-\frac{1}{2}} \\
&\approx T(1 + \frac{1}{2}\frac{v^2}{c^2})
\end{align}
\]

To show how this is real life based, when putting the GPS system into orbit, scientists needed to determine whether or not the time dilation would cause errors. The way the satellites are now, $v = 4km/s$ and $c = 3 \times 10^5 km/s$, which means that $\frac{v^2}{c^2} \approx 10^{-10}$. As you can see, this resolves to an error of a few mm of resolution. Therefore it was determined the dilation wouldn’t cause significant error.

Quadratic approximations

The quadratic approximation is an extension of linear approximation. The formula for quadratic approximation is:
\[
f(x) \approx f(x_0) + f’(x_0)(x – x_0) + \frac{f’’(x)}{2}(x – x_0)^2
\]
As you can see, it involves second derrivatives.

Now we can extend the common functions we did for linear approximation, and fill them for quadratic approximation:
\[
\begin{array}{ l | l | l | l | l }
f & f(0) + f’(0)x & f’’ & f’’(0) & f(0) + f’(0)x + \frac{f’’(0)}{2}x^2 \\ \hline
sin\;x & x & -sin\;x & 0 & x \\
cos\;x & 1 & -cos\;x & -1 & 1 – \frac{1}{2}x^2 \\
e^x & 1 + x & e^x & 1 & 1 + x + \frac{1}{2}x^2 \\
\end{array}
\]

Geometrically, the significance of the quadratic term can be shown in the following graph:

As you can see in the graph, the quadratic approximation is a parabola beneath the linear approximation that more closely fits the cosine wave at $x = 0$. This tells us more information about the function, such as what it’s doing on both the positive and negative limits.

Udacity AI for Robotics - Week 1

2012-02-22T00:00:00-08:00

Localization

The problem that localization solves is that of determining the robot’s position to within a 2 – 10cm precision. Using GPS is not sufficient, as it can have a 2 – 10m precision, which can result in the robotic car crashing on the side of the road.

Conceptual Overview

Before getting stuck into the specifics of localization, it will help to get a conceptual overview of what localization does. Localization is a way of modeling where in the environment the robot is.
This is done by way of computing probabilities of possible locations, in a multi step process that involces reading sensor data from the environment, calculating the belief, moving, recalculating belief and then reading from sensor data again, and recalculating belief.

The following diagram will illustrate this process, and then it will be explained step by step:

First, we’re modeling a robot in an environment with 3 doors. The initial belief is called the uniform maximum confusion. This indicates that the robot has absolutely no idea where in the environment it is. It does know what the environment as a whole looks like, however.

First, it takes a sensor reading from the environment, and detects that it is in front of a door. This reading allows the robot to calculate the probability it is at a given position. As can be seen, it believes it is at one of three positions. Note also that there is a margin of error on the sensors, so there is also a low probability that it could be in a position that is not in front of a door. This is called the posterier belief, because it occurs after a measurement.

Next, the robot moves a certain distance, and it updates it’s belief state. This is called a convolution of it’s belief state. Notice that the probabilities have flattened out somewhat, as there is also a margin of error on the movement. This updated belief state is called the prior belief, because it is a belief before any measurement.

Lastly, the robot takes another sensor reading of the environment, and detects it is infront of another door. It calculates the probability that it is at a given point, and multiplies it with the prior probability. This has the effect of reinforcing the fact that it saw a door, moved and saw another door. It now strongly believes it’s currently in front of the second door.

If it moved, convoluted it’s belief, and read the environment again and detected another door, then the strong belief that it was in front of the second door would be weakend, representing the fact that the robot could have had a malfunction in movement.

Uniform maximum confusion

Consider there are 5 discrete locations the robot can be in. The initial uniform maximum confusion will be a uniform probability distributed over the 5 discrete locations, and it will be normalized, meaning it sums to one. Therefore, each location will have a probability of 0.2 of being correct.

Posterier update

After a measurement, the robot updates the probabilities for each location being considered. The probability in a cell is weighted based on the measurement result. An example of this can be seen below:

In the above example, the robot observes it is on a red square. The belief state of all red squares is multiplied by 0.6, which is the probability of measuring red, and the belief state of all green squares is multiplied by 0.2, which is the probability of measuring green.

These probabilities are not valid, however, as they need to be normalized. Here is the result of the normalization:

Robot Motion

When the robot moves, we typically model this action as uncertain. The robot motion may fail for any number of reasons, and so we assign a probability to the success of the motion. In an exact motion model, the probability of motion is 1.

When motion is uncertain, the robot’s position in the world itself because even more uncertain:

Everytime the robot moves, it loses information. This is because the movement is uncertain.

Conclusion

Robot localization is a loop of move and sense. When the robot senses, it gains information. When the robot moves, it loses information.
Here is some python code that demonstrates the concepts discussed above:

Formal Definition

The heart of the localization algorithm is probability and Bayes rule. For the formal definition, please see the notes on the Stanford online AI class, specifically Week 2.

In the above Python code, we applied Bayes rule as follows:

Assume $X$ is the collection of grid cells, and $Z$ is the measurement made.
\[
P(X_i|Z) = \frac{P(Z|X_i) P(X_i)}{P(Z)}
\]

The above represents the following statement in Bayes Rule:
The probability of being in cell $X_i$ given measurement $Z$ can be found by multiplying the probability of measuring $Z$ while in cell $X_i$ multiplied by the prior belief that the robot is in $X_i$, normalized by the probability of observing $Z$ in any cell.

We represented it programatically as:
\[
\begin{align}
\bar{P}(X_i|Z) &\leftarrow P(Z|X_i) P(X_i) \\
\alpha &\leftarrow \sum \bar{P}(X_i|Z) \\
P(X_i|Z) &\leftarrow \frac{1}{\alpha} \bar{P}(X_i|Z)
\end{align}
\]
where $\alpha$ is the sum of the probabilities of observing $Z$. This was programmed in the sense function of the Python code above.

Motion in localization is covered by the concept of total probability:
\[
P(X_i^t) = \sum_j P(X_j^{t-1}) . P(X_i | X_j)
\]

This says that the probability of being in cell $X_i$ at time $t$ is the sum of the probabilities of being in that cell at $t-1$ times the probability of getting to that cell from any other cells, $X_j$.

You can see this programmed into the move function of the Python code above.

This can be generalized to:
\[
P(A) = \sum_B P(A|B) P(B)
\]

Udacity AI for Robotics

2012-02-21T00:00:00-08:00

THIS IS A PLACEHOLDER SO THAT THE INDEX APPEARS IN THE PROJECT LIST

MIT OCW Linear Algebra - Week 3

2012-02-18T00:00:00-08:00

Permutations

Permutation matrices $P$ execute row exchanges.

The concept of $A = LU$, that is, a matrix $A$ can be factorized into an elimination matrix $U$ and a set of operations performed during the elimination $L$. This model supposes no permutations were required during elimination.

$PA = LU$ is the description of elimination that takes into account row exchanges, or permutations, occur.

Transposes

Transposing a matrix:
\[
\begin{bmatrix}
1 & 3 \\
2 & 3 \\
4 & 1
\end{bmatrix}
^T
=
\begin{bmatrix}
1 & 2 & 4 \\
3 & 3 & 1
\end{bmatrix}
\]

Generally:
\[
A^T_{i,j} = A_{j,i}
\]

Symmetric matrices are matrices that are the transposes of themselves. That is, $A^T = A$. Needless to say, a symmetric matrix must be square.

The product of a matrix and it’s transpose is a symmetric matrix. $A^TA$ is always symmetric:
\[
\begin{bmatrix}
1 & 3 \\
2 & 3 \\
4 & 1
\end{bmatrix}
\begin{bmatrix}
1 & 2 & 4 \\
3 & 3 & 1
\end{bmatrix}
=
\begin{bmatrix}
10 & 11 & 7 \\
11 & 13 & 11 \\
7 & 11 & 17
\end{bmatrix}
\]

Generally:
\[
(A^TA)^T = A^TA^{TT} = A^TA
\]

Vector spaces & subspaces

A vector space is a space, or set of vectors that allow us to take linear combinations of vectors, and multiply vectors by any scalar, and perform vector addition.

Examples:
$R^2$ is a space of all 2-dimension real vectors. Such as $ \begin{bmatrix}3 \\ 2 \end{bmatrix}, \begin{bmatrix}0\\0\end{bmatrix}, \begin{bmatrix}\pi\\e\end{bmatrix}$. This is also known as the x-y plane.

$R^3$ is a space of all 3-dimensional real vectors, similar to above, that is, 3 real compents.

Generally, $R^n$ is the space of all vectors with $n$ real numbers.

Let us imagine the vector space $R^2$, only lets define it only for positive components. This reduces the vector space to $\frac{1}{4}$ of it’s normal size. Consider the task of multiplying a vector by the scalar $-1$. This would produce a result that is undefined for this restriction. Therefore, this restriction is not a vector space, as it doesn’t satisfy the rules of a space. That is, it’s not closed under multiplication of real numbers.

Imagining the same vector space $r^2$, and inside this space we have a vector. Lets say we restrict our space to only linear combinations of our vector. That is, we can make our vector as long as as short as we want, and can add and subtract vectors that lie on the same line as the original vector. By that definition, we have defined a vector space inside $R^2$, called a subspace of $R^2$. Note, to be a valid subspace, it must contain 0. Therefore the line must pass through the origin in our $R^2$ space.
Note, that the subspace of $R^2$ is not $R^1$ – the vectors still contain 2 components.

Subspaces of $R^2$:
1. all of $R^2$. A space is a subspace of itself.
2. any line through the point $\begin{bmatrix}0\\0\end{bmatrix}$.
3. the zero vector only – $Z$

Lets apply this concept of subspaces to matrices.

Consider the matrix A:
\[
\begin{bmatrix}
1 & 3 \\
2 & 3 \\
4 & 1
\end{bmatrix}
\]

The columns of this matrix and all their combinations form a subspace. This is called the column space, $C(A)$.
Note this is a subspace of $R^3$, because each column is $R^3$, and they form a plane.

The union of two subspaces does not make a subspace in itself. If you add a vector from one subspace to another vector from a different subspace may result in a vector that lies outside the union of subspaces.

However, the intersection of two subspaces is a subspace. Consider two subspaces, $S$ and $T$, and two vectors in the intersection of those subspaces, $v$ and $u$. If $v$ and $u$ are both in $S$, and $S$ is a subspace, then $v+u$ will also be in $S$. Likewise, $v$ and $u$ are both in $T$, and $T$ is a subspace, therefore $v+u$ will be in $T$. This shows that the intersection of $S$ and $T$ is a subspace.

Column Space

Column space of matrix $A$:
\[
\begin{bmatrix}
1 & 1 & 2 \\
2 & 1 & 3 \\
3 & 1 & 4\\
4 & 1 & 5
\end{bmatrix}
\]

The column space of $A$ is a subspace of $R^4$, because $A$ is a $4 \times 3$ matrix. It contains:
- The columns of $A$
- All linear combinations of the columns of $A$
- The zero vector
The column subspace is itself a subspace of $R^4$.

To answer how we know that, we need to reframe our purpose in studying linear algebra.
The purpose of studying linear algebra is to understand the equation:
\[
Ax = b
\]
and to know if, there is a solution to this equation for ever $b$.

There is not a solution for every $b$, because if you look at A, you can see there are 4 equations with only 3 unknowns:
\[
Ax =
\begin{bmatrix}
1 & 1 & 2 \\
2 & 1 & 3 \\
3 & 1 & 4 \\
4 & 1 & 5
\end{bmatrix}
\begin{bmatrix}
x_1 \\
x_2 \\
x_3
\end{bmatrix}
=
\begin{bmatrix}
b_1 \\
b_2 \\
b_3 \\
b_4
\end{bmatrix}
\]
This is because the linear combinations of the columns of $A$ won’t fill all of $R^4$.

However, there are some solutions, and all of these solutions lie in the column space, that is, they are linear combinations of the columns of $A$.

Note that all the columns of $A$ are not linearly independent – column 3 is linearly dependent on columns 1 & 2, and column 1 is linearly dependent on 2 & 3. We can get rid of either column 1 or column 3 (but not both) and not lose information about the column space.
Therefore, the column space is actually a subspace in $R^2$ of $R^4$.

Nullspace

Lets consider again the matrix $A$, above.

The null space of $A$ contains all solutions $x$, as above, to the equation:
\[
Ax = 0
\]
That is, all vectors that nulify the matrix $A$.

The nullspace is a subspace of $R^3$, because there are only 3 unknowns, as you can see by looking at $x$.

\[
Ax =
\begin{bmatrix}
1 & 1 & 2 \\
2 & 1 & 3 \\
3 & 1 & 4 \\
4 & 1 & 5
\end{bmatrix}
\begin{bmatrix}
x_1 \\
x_2 \\
x_3
\end{bmatrix}
=
\begin{bmatrix}
0 \\
0 \\
0 \\
0
\end{bmatrix}
\]

One solution to the above equation is:
\[
\begin{bmatrix}
1 \\ 1 \\ -1
\end{bmatrix}
\]
and in fact, the definition of the nullspace of $A$ is any combination of the above vector, or:
\[
c
\begin{bmatrix}
1 \\ 1 \\ -1
\end{bmatrix}
\]

The nullspace of $A$ is a subspace of $R^3$ and forms a line.

We can prove that the solutions to $Ax = 0$ always give a subspace algebraically:
if $Av = 0$ and $Aw = 0$, then $A(v + w) = 0$. We can restart $A(v + w) = 0$ as $Av + Aw = 0$. $0 + 0 = 0$ will always hold, therefore the solutions to $Ax = 0$ will always give a subspace.

MIT OCW Single Variable Calculus - Week 3

2012-02-17T00:00:00-08:00

Implicit differentiation

Implicit differentiation is a technique that allows you to differentiate functions that you may not have even been able to see.

\[
\frac{\delta}{\delta x}x^2 = ax^{a-1}
\]

So far we’ve covered the case where $a$ is an integer: $a = 0, \pm 1, \pm 2, \ldots $. Now we’re going to consider the case where $a$ is a rational number: $ a = \frac{m}{n}$, where m & n are integers.

Example 1

\[
\begin{align}
y &= x^{\frac{m}{n}} \qquad \text{(1)} \\
y^n &= x^m \qquad \text{(2)}
\end{align}
\]

Now, we apply $\frac{\delta}{\delta x}$ to equation (2). We don’t apply to equation (1) because right now, we don’t know how to differentiate it. We do know how to differentiate (2).

\[
\begin{align}
\frac{\delta}{\delta x} y^n &= \frac{\delta}{\delta x}x^m \\
\left( \frac{\delta}{\delta y}y^n \right) \frac{\delta y}{\delta x} &= mx^{m-1} \qquad \text{(by the chain rule)} \\
ny^{n-1}\frac{\delta y}{\delta x} &= mx^{m-1} \\
\frac{\delta y}{\delta x} &= \frac{m x^{m – 1}}{n y^{n – 1}} \\
&= \frac{m}{n} \frac{x^{m-1}}{(x^\frac{m}{n})^{n-1}} \\
&= a x^{m-1-(n-1)\frac{m}{n}} \\
&= a x^{m-1-m+\frac{m}{n}} \\
&= a x^{-1 + \frac{m}{n}} \\
&= a x^{a-1}
\end{align}
\]

NOTE: THE CHAIN RULE WILL CAUSE YOU ISSUES

Example 2

\[
x^2 + y^2 = 1
\]

This is defining $y$ as a function of $x$ implictily. That means it can be arranged to express $y$ in terms of $x$.

Solving for y:

\[
\begin{align}
y^2 &= 1 – x^2 \\
y &= \pm \sqrt{1 – x^2} \\
y &= (1-x^2)^{\frac{1}{2}} \qquad \text{considering positive branch only} \\
y’ &= \frac{1}{2}(1 – x^2)^{-\frac{1}{2}}(-2x) \\
y’ &= (1 – x^2)^{-\frac{1}{2}}(-x) \\
y’ &= \frac{-x}{\sqrt{1 – x^2}}
\end{align}
\]

The above is the explicit differentiation.
Following is the implicit method:

\[
\begin{align}
\frac{\delta}{\delta x} (x^2 + y^2 &= 1) \\
2x + 2yy’ &= 0 \qquad \text{(by the chain rule)} \\
y’ &= -\frac{2x}{2y} \\
y’ &= -\frac{x}{y} \\
\end{align}
\]

The result of the explicit and implicit methods are the same, and the implicit is better than the explicit because it doesn’t differentiate between positive and negative values for $y$ and $x$.

Example 3

Consider the equation $y^4 + xy^2 – 2 = 0$.

We can solve it explicitly: (using the quadratic forumula )

\[
\begin{align}
y^2 &= \frac{-x \pm \sqrt{x^2 – 4(-2)}}{2} \\
y &= \pm \sqrt{\frac{-x \pm \sqrt{x^2+8}}{2}} \\
\end{align}
\]

Notice the 4 different roots of the equation (because it’s to the 4th power).
It’s very complex and time consuming.

Compare this to the implicit method:

\[
\begin{align}
\frac{\delta}{\delta x}(y^4 + xy^2 -2 = 0) \\
4y^3y’ + y^2 + x(2yy’) – 0 &= 0 \\
(4y^3 + 2xy)y’ + y^2 &= 0 \\
(4y^3 + 2xy)y’ &= -y^2 \\
y’ &= \frac{-y^2}{4y^3 + 2xy}
\end{align}
\]

To solve $y’$ in terms of x, we’d need to put the result of the explicit method (so far) into the implicit method. The two go hand in hand.
Although the implicit method hides the conplexity of solving a quartic equation, it still exists, and at some point, we’re going to have to deal with it. That means going through all possible 4 roots to find the answer.

Inverse functions

The inverse of a function is the function that gets us back to our original arguments. For example:
\[
y = \sqrt{x} \text{for x \gt 0}, y^2 = x
\]
if we define these in terms of functions:
\[
f(x) = \sqrt{x}, g(y) = x, g(y) = y^2
\]

In general:
\[
\begin{array}{2,1}
y = f(x), g(y) = x \\
g(f(x)) = x, g = f^{-1}, f = g^{-1}
\end{array}
\]

Consider the case of graphing a function and it’s inverse. The inverse can be obtained by swapping the $x$ and $y$ values, which in effect is mirroring the function along the line $x = y$.

Implicit differentiation allows us to find the derivative of any inverse function, provided we know the derivative of the function.

Example 1:

Consider the function:

\[
y = tan^{-1}x
\]

which can be rearranged/simplified by taking $tan$ of each side:

\[
tan\;y = x
\]

This can be graphed as follows:

Recall that

\[
\begin{align}
\frac{\delta}{\delta y} tan\;y &= \frac{\delta}{\delta y} \frac{sin\;y}{cos\;y} \\
&= \frac{1}{cos^2y}
\end{align}
\]

\[
\begin{align}
\frac{\delta}{\delta x} (tan\;y &= x) \\
(\frac{\delta}{\delta y} tan\;y)\frac{\delta y}{\delta x} &= 1 \\
\frac{1}{cos^2y} y’ &= 1 \\
y’ &= cos^2y
\end{align}
\]

Where we apply $\frac{\delta}{\delta x}$ to both sides (thats why the x turns into a 1). However, we wanted to find $\frac{\delta}{\delta x}tan^{-1}x$. We can simplify this by expressing $cos\;y$ in terms of it’s defining ratio:

which shows us the hypotenuse is $\sqrt{1 + x^2}$. This gives us:

\[
\begin{align}
cos\;y &= \frac{1}{\sqrt{1 + x^2}} \\
cos^2y &= \frac{1}{1 + x^2}
\end{align}
\]

and then we substitute in the above:

\[
\begin{align}
\frac{\delta}{\delta x}tan^{-1}x &= cos^2(tan^{-1}x) \\
&= \frac{1}{1 + x^2}
\end{align}
\]

Example 2:

\[
\begin{align}
y &= sin^{-1}x \\
sin y &= x \\
(cos\;y)y’ &= 1 \\
y’ &= \frac{1}{cos\;y} \\
y’ &= \frac{1}{\sqrt{1 – sin^2y}} \\
y’ &= \frac{1}{\sqrt{1 – x^2}} \\
\therefore \frac{\delta}{\delta x}sin^{-1}x &= \frac{1}{\sqrt{1 – x^2}}
\end{align}
\]

Exponentials & Logarithms

First, lets review exponents.
Consider some base, $a$, such that $a > 0$. We know that $a^0 = 0$, $a^1 = a$, $a^2 = a \times a$. Generally:
\[
a^{x_1 + x_2} = a^{x_1}a^{x_2}
\]

This is known as the law of exponents. From this we can derive:
\[
(a^{x_1})^{x_2} = a^{x_1x_2}
\]

Likewise:
\[
a^{\frac{m}{n}} = \sqrt[n]{a^m}
\]

$a^x$ is defined for all x by continuity. We can calculate things like $a^\pi$ and $a^{\sqrt{2}}$ using the rules above.

Example graph of $y = 2^x$:

WThe ultimate goal is to be able to solve
\[
\frac{\delta}{\delta x}a^x
\]

We can begin by going back to first principles:
\[
\begin{align}
\frac{\delta}{\delta x}a^x &= \lim_{\Delta x \to 0} \frac{a^{x + \Delta x} – a^x}{\Delta x} \\
&= \lim_{\Delta x \to 0} \frac{a^x a^{\Delta x} – a^x}{\Delta x} \\
&= \lim_{\Delta x \to 0} a^x \frac{a^{\Delta x} – 1}{\Delta x} \\
&= a^x \lim_{\Delta x \to 0} \frac{a^{\Delta x} – 1}{\Delta x}
\end{align}
\]

We move the $a^x$ out of the limit, because as the limit tends to 0, $a^x$ is constant, and can be moved out of the limit.
Next, lets define a new variable, and express the above equation in a new way:
\[
M(a) = \lim_{\Delta x \to 0} \frac{a^{\Delta x} – 1}{\Delta x}
\]
so that
\[
\frac{\delta}{\delta x}a^x = M(a)a^x
\]

If we recall back to the start of the course, we can recognise that as the equation of a line, the tangent line. From here, we can work out the slope of $a^x$. First, plug in $a = 0$ to the above:
\[
\begin{align}
\left. \frac{\delta}{\delta x}a^x \right|_{x = 0} &= M(a)a^0 \\
&= M(a)
\end{align}
\]

So we can see that the slope of $a^x$ at $x = 0$ is $M(a)$. What is $M(a)$?
Solving $M(a)$ is difficult. Lets beg the question, and instead, define $e$ as the number such that $M(e) = 1$.
The consequences of having a number such as $e$ are as follows:
\[
\begin{align}
\frac{\delta}{\delta x}e^x &= M(e)e^x \\
&= e^x
\end{align}
\]
which is based on the above derivation.
Also note that $M(e)$ at $x = 0$ is 1. That is, the slope of the tangent line at $x = 0$ is 1.

How do we know that a number such as $e$ exists?

Without defining $e$, we can show graphically that it must exist.

Consider the graph of the function $y = 2^x$, and compare the tangent line at $x = 0$ ($M(2)$) to the secant line through the points $(0,1), (1,2)$:

Notice the slope of the line $M(2)$ is less than the secant.

Now compare the graph of the function $y = 4^x$ and compare $M(4)$ against the same secant:

Notice the slope of the line is greater than the secant.

This shows that somewhere between the bases of 2 and 4, there is a number where $M(a) = 1$.

To fit this concept together with where we left the derivation off, we need to use the natural log.
If $y = e^x$, then $ln\;y = x$. That is, the natural log is the inverse of $e^x$.

A refresher on logarithms:
- $ln(x_1x_2) = ln\;x_1 + ln\;x_2$
- $ln\;1 = 0$
- $ln\;e = 1$

Next, we need to cover computing the derivative of a logarithm. Remember from implicit differentiation, we can compute the derivative of a function if we know the derivative of it’s inverse. That’s the rational behind finding the derivative.

First, lets define $w = ln\;x$. Using the above rules of $ln$ and $e$ we can show that:
\[
\begin{align}
e^w &= x \\
\frac{\delta}{\delta x}e^w &= \frac{\delta}{\delta x} x \\
&= 1 \\
(\frac{\delta}{\delta w}e^w)(\frac{\delta w}{\delta x}) &= 1 \\
e^w \frac{\delta w}{\delta x} &= 1 \\
\frac{\delta w}{\delta x} &= \frac{1}{e^w} \\
&= \frac{1}{x}
\end{align}
\]

See that $\frac{\delta}{\delta w}e^w = e^w$ based on the assumption that $M(e) = 1$.
For further info, check the lecture notes for this lecture.

Therefore we get:
\[
\frac{\delta}{\delta x}ln\;x = \frac{1}{x}
\]

To summarize, we have these two rates of change:
\[
\frac{\delta}{\delta x} e^x = e^x
\]
and
\[
\frac{\delta}{\delta x} ln\;x = \frac{1}{x}
\]

With these two derivatives in hand, we can return to the task of solving $M(a)$, and so differentiate $a^x$. There are two methods we can use to solve any exponential.

Method 1:

Convert the exponential to base $e$:
\[
\begin{align}
a^x &= (e^{ln\;a})^x \\
&= e^{x\;ln\;a}
\end{align}
\]
and then differentiate:
\[
\begin{align}
\frac{\delta}{\delta x}a^x &= \frac{\delta}{\delta x}e^{x\;ln\;a} \\
&= (ln\;a)e^{x\;ln\;a}
&= (ln\;a)a^x
\end{align}
\]
and we can see therefore that $M(a) = ln\;a$.

The above works because of 2 things, and can be illustrated as follows:
\[
\frac{\delta}{\delta x}e^{3x} = 3e^{3x}
\]
The 3 is the derivative of $3x$, and is multiplied by the derivative of $e^{3x}$, which is $e^{3x}$.
The same is occuring above. $ln\;a$ is a constant, and so we differentiate out the $x$ and multiply it by the derivative of $e$, which is itself.

Method 2:

The second method involves logarithmic differentiation.

Sometimes it’s easier to differentiate the logarithm of a function instead of the function itself.
Lets assume some function $u$, and solve:
\[
\begin{align}
\frac{\delta}{\delta u} ln\;u &= \left(\frac{\delta ln\;u}{\delta u}\right)\left(\frac{\delta u}{\delta x}\right) \\
&= \frac{1}{u} \frac{\delta u}{\delta x}
&= \frac{u’}{u}
\end{align}
\]
where we switch notation in the last step.

It’s easy to see where to go now from here to solve for $a^x$:
\[
\begin{align}
\frac{\delta}{\delta x} a^x \bigg| u = a^x \\
ln\;u &= x\;ln\;a \\
\frac{\delta}{\delta x} x\;ln\;a &= ln\;a \\
(a^x)’ &= (ln\;a)a^x
\end{align}
\]

Example 2 of method 2
An example of having moving exponents and a moving base.

Let’s consider the function:
\[
v = x^x
\]

Solve $\frac{\delta}{\delta x} v$ using logarithmic differentiation:
\[
\begin{align}
ln\;v &= x\;ln\;x \\
(ln\;v)’ &= ln\;x(x)’ + x(ln\;x)’ \\
&= ln\;x + x . \frac{1}{x} \\
&= ln\;x + 1 \\
\frac{v’}{v} &= ln\;x + 1 \\
v’ &= v(ln\;x + 1) \\
&= x^x(1 + ln\;x)
\end{align}
\]
Where on the second line, we apply the product rule.

Example 3

We’re going to evaluate:
\[
\lim_{n \to \infty}\left(1 + \frac{1}{n}\right)^n
\]
\[
ln \left( \left(1 + \frac{1}{n} \right)^n \right) = n\;ln\left(1 + \frac{1}{n}\right)
\]
here, we’re going to assign $\Delta x = \frac{1}{n}$, which makes $n = \frac{1}{\Delta x}$:
\[
n\;ln \left( 1 + \frac{1}{n} \right) = \frac{1}{\Delta x} (ln(1 + \Delta x) – ln\;1)
\]
here, we’re adding 0, in the form of $ln\;1$.
This results in an equation that matches the form of another equation we know:
\[
\begin{align}
\frac{ln(1 + \Delta x) – ln\;1}{\Delta x} &= \frac{\delta}{\delta x}ln\;x \quad \text{at x = 1} \\
&= \frac{1}{x} \quad \text{at x = 1} \\
&= 1
\end{align}
\]
Now we can just work back:
\[
\begin{align}
\lim_{n \to \infty}\left( 1 + \frac{1}{n} \right)^n &= e^{\left[ ln \left[ lim_{n \to \infty} \left( 1 + \frac{1}{n} \right)^n \right] \right]} \\
&= e^1 \\
&= e
\end{align}
\]

MIT OCW Linear Algebra - Week 2

2012-02-03T00:00:00-08:00

Matrix Multiplication

Consider the problem of multiplying two matrices:

\[
A \times B = C
\]

We can view this problem in 4 different ways.

The first way is as a row x columns problem.
Consider the element $C_{i,j}$. It is given by:

\[
\begin{align}
C_{i,j} &= A_{i,1} B_{1,j} + A_{i,2} B_{2,j} + \ldots \\
&= \sum_{k=1}^n A_{i,k} B_{k,j}
\end{align}
\]

This illustrates the matrix multiplication rule that:

\[
m \times n \;. n \times p = m \times p
\]

Namely, you can only multiply matrices if the first matrix has the same number of columns as the second does rows. The result of the multiplication is a matrix with the same amount of rows as the first matrix and the same amount of columns as the second matrix.

We can also think of multiplying matrices in terms of multiplying columns, or vectors. In the case of $AB = C$, we can think of $B$ as a group of column vectors: $A \times [\vec{b_1}, \vec{b_2}, \vec{b_3}] = [A \vec{b_1}, A \vec{b_2}, A \vec{b_3}] $. Each column of C is a combination of the columns of A.

Another way we can think of multiplying matrices is in terms of multiplying rows. In the case of $AB = C$, we can think of $A$ as a group of row vectors: $ \begin{bmatrix} \vec{a_1} \\ \vec{a_2} \\ \vec{a_3} \end{bmatrix} \times B = \begin{bmatrix} \vec{a_1}B \\ \vec{a_2}B \\ \vec{a_3}B \end{bmatrix} $. That is, each row of C is a combination of the rows of B.

Next, we can think of multiplying matrices in terms of columns x rows.
Remember a column is a m x 1 matrix, and a row is a 1 x n matrix. Multiplying these together gives:

\[
m \times 1 \;. 1 \times p = m \times p
\]

Consider $AB = C $ generally:

\[
\begin{bmatrix}
\vec{a_1} & \vec{a_2} & \vec{a_3}
\end{bmatrix}
\times
\begin{bmatrix}
\vec{b_1} \\
\vec{b_2} \\
\vec{b_3}
\end{bmatrix}
=
\vec{a_1} \vec{b_1} + \vec{a_2} \vec{b_2} + \vec{a_3} \vec{b_3}
\]

where $\vec{a}$ are column vectors of dimension $m \times 1$ and $\vec{b}$ are row vectors of dimension $1 \times n$, and $\vec{a}\vec{b}$ is a matrix of dimension $m \times n$.

Lastly, it should be noted that you can segment matrices and multiply the segments and still obtain the correct answer, so long as the segments are compatible.

For example:

\[
\begin{bmatrix}
a_1 & a_2 \\
a_3 & a_4
\end{bmatrix}
\times
\begin{bmatrix}
b_1 & b_2 \\
b_3 & b_4
\end{bmatrix}
=
\begin{bmatrix}
a_1 b_1 + a_2 b_3 & a_1 b_2 + a_2 b_4 \\
a_3 b_1 + a_4 b_3 & a_3 b_2 + a_b b_4
\end{bmatrix}
\]

where $a$ and $b$ are matrices, segments of a larger matrix.

Inverses

Inverses don’t always exist. Not every matrix is invertable. There are two kinds of inverses. Left inverse ($A^{-1}A = I$) and right inverse ($AA^{-1} = I$).

For a square matrix, $A^{-1}A = I = AA^{-1}$ is true, if A has an inverse.

A matrix that has an inverse is called invertible or nonsingular.

Singular Matrices

The following matrix is singular, and thus has no inverse:

\[
\begin{bmatrix}
1 & 2 \\
3 & 6
\end{bmatrix}
\]

The above matrix is singular because it’s determinate is 0. Determinates are covered later. It is also singular because each column is a multiple of the other, that is, they lie on the same line. When this matrix is multiplied with another matrix, the resultant matrix’s columns will be a combination of the above matrix’s columns – and they too will lie on the same line. There is no way to achieve $\begin{bmatrix}1 & 0 \\ 0 & 1 \end{bmatrix}$ because neither column of $I$ lies on that line.

Another reason a square matrix won’t have an inverse is that it is possible to find a non-zero vector $x$ such that $Ax = 0$:

\[
\begin{bmatrix}
1 & 3 \\
2 & 6
\end{bmatrix}
\begin{bmatrix}
3 \\ -1
\end{bmatrix}
= 0
\]

A matrix can’t have an inverse if some combination of it’s columns gives nothing.
If we assume A does have an inverse, then:

\[
\begin{align}
(Ax)A^{-1} &= 0A^{-1} \\
x &=0
\end{align}
\]

which we can see is clearly not true ($x = \begin{bmatrix} 3 \\ -1 \end{bmatrix} $), therefore this matrix does not have an inverse.

Non-singular matrices

Consider the following matrix:

\[
\begin{bmatrix}
1 & 3 \\
2 & 7
\end{bmatrix}
\]

This matrix is invertible and non-singular.

\[
\begin{bmatrix}
1 & 3 \\
2 & 7
\end{bmatrix}
\begin{bmatrix}
a & c \\
b & d
\end{bmatrix} =
\begin{bmatrix}
1 & 0 \\
0 & 1
\end{bmatrix}
\]

We need to find out the value of $A^{-1}$, $\begin{bmatrix} a & c \\ b & d \end{bmatrix}$.
Going back to matrix multiplication, we can see that we can decompose this into two problems:

\[
\begin{bmatrix}
1 & 3 \\
2 & 7
\end{bmatrix}
\begin{bmatrix}
a \\ b
\end{bmatrix}
=
\begin{bmatrix}
1 \\ 0
\end{bmatrix}
\]

and

\[
\begin{bmatrix}
1 & 3 \\
2 & 7
\end{bmatrix}
\begin{bmatrix}
c \\ d
\end{bmatrix}
=
\begin{bmatrix}
0 \\ 1
\end{bmatrix}
\]

These two equations can be solved at once using Gauss-Jordan. First, create an augmented matrix, with the left hand side as $A$ and the right hand side as $I$:

\[
\left[
\begin{matrix}
1 & 3 \\
2 & 7
\end{matrix}
\quad
\left|
\quad
\begin{matrix}
1 & 0 \\
0 & 1
\end{matrix}
\right.
\right]
\]

We can now perform Gaussian elimination on this augmented matrix:

\[
\left[
\begin{matrix}
1 & 3 \\
0 & 1
\end{matrix}
\quad
\left|
\quad
\begin{matrix}
1 & 0 \\
-2 & 1
\end{matrix}
\right.
\right]
\]

The left hand side is now in upper triangular form, and under normal Gaussian substitution, we’d finish. However in Gauss-Jordan, we then do a upwards elimination to achieve $I$ on the left side:

\[
\left[
\begin{matrix}
1 & 0 \\
0 & 1
\end{matrix}
\quad
\left|
\quad
\begin{matrix}
7 & -3 \\
-2 & 1
\end{matrix}
\right.
\right]
\]

The right hand side is now $A^{-1}$.

We can show how Gauss-Jordan works by the following sum:

\[
\begin{align}
E[A \quad I] &= [EA \quad EI] \\
&= [I \quad E]
\end{align}
\]

where E is the elimination matrix that performs the above calculation (augmented matrices). You can see that if $E \times A = I$, then $E$ must be $A^{-1}$, and therefore $E \times I = E$, which gives the result we observed above.
$E \times A = I$ was true because we made it true, by eliminating to $I$.

Inverse of a product

We know $AA^{-1} = I = A^{-1}A$.

For products, $AB B^{-1}A^{-1} = I$ This is due to the associative nature of matrix multiplication.
Performing the calculation:

\[
\begin{align}
AB ( B^{-1}A^{-1} ) &= I \\
A ( B B^{-1} ) A &= I \\
AI A^{-1} &= I \\
A A^{-1} &= I \\
I &= I
\end{align}
\]

The same holds for $B^{-1}A^{-1}AB = I$, which is placing the inverse group on the left of the equation.

A note about transposing. Two things about transposing a matrix:

When you transpose a matrix, you have to swap arguments:
\[
A A^{-1} = I = (A^{-1})^T A^T
\]
The inverse of a transposed matrix is the inverse of the matrix transposed:
\[
(A^{-1})^T = (A^T)^{-1}
\]

Factorization into A = LU

Elimination with no row matrices

Consider the following:

\[
E_{2,1}
\begin{bmatrix}
2 & 1 \\
8 & 7
\end{bmatrix}
=
\begin{bmatrix}
2 & 1 \\
0 & 3
\end{bmatrix}
\]

This is the first step in Gaussian elimination, where the first matrix is matrix $A$, and the last matrix is matrix $U$. The $E_{2,1}$ matrix elminates $A_{2,1}$ to make $U$ an upper-triangular matrix.

\[
\begin{bmatrix}
1 & 0 \\
-4 & 1
\end{bmatrix}
\begin{bmatrix}
2 & 1 \\
8 & 7
\end{bmatrix}
=
\begin{bmatrix}
2 & 1 \\
0 & 3
\end{bmatrix}
\]

is the solution for $E_{2,1}$.

To put this in the form of $A = LU$, we need to recognise that $L = E_{2,1}^{-1}$, and multiply both sides:

\[
\begin{array}{rcl}
( E_{2,1} E_{2,1}^{-1} )
\begin{bmatrix}
2 & 1 \\
8 & 7
\end{bmatrix}
=&
E_{2,1}^{-1}
\begin{bmatrix}
2 & 1 \\
0 & 3
\end{bmatrix}
\\
\begin{bmatrix}
2 & 1 \\
8 & 7
\end{bmatrix}
=&
\begin{bmatrix}
1 & 0 \\
4 & 1
\end{bmatrix}
\begin{bmatrix}
2 & 1 \\
0 & 3
\end{bmatrix}
\end{array}
\]

Notice that $U$ is an upper-triangle and $L$ is a lower-triangle. $U$ has the pivots in the matrix, and these can be pulled out:

\[
\begin{bmatrix}
2 & 1 \\
0 & 3
\end{bmatrix}
=
\begin{bmatrix}
2 & 0 \\
0 & 3
\end{bmatrix}
\begin{bmatrix}
1 & \frac{1}{2} \\
0 & 1
\end{bmatrix}
\]

where the first matrix on the right hand side is the matrix $P$ for pivot, and is a diagonal matrix, and the second matrix is $U$, the upper triangular matrix.

Now lets consider the same operations a larger matrix, assuming again we don’t perform a row exchange:

\[
E_{3,2}E_{3,1}E_{2,1}A = U
\]

Where we eliminate $A_{2,1}$ first, then from the resultant matrix we elminate $A_{3,1}$ and then from that matrix we eliminate $A_{3,2}$. To put this into the form of $A = LU$, we need to invert the matrices and move them to the other side of the equation:

\[
\begin{align}
A &= E_{2,1}^{-1}E_{3,1}^{-1}E_{3,2}^{-1}U \\
&= LU
\end{align}
\]

We perform $E_{2,1}^{-1}E_{3,1}^{-1}E_{3,2}^{-1}$ instead of $(E_{3,2}E_{3,1}E_{2,1})^{-1}$ because it’s easier to compute.

If we perform no row exchanges, the multipliers in $E$ used to eliminate elements of A go directly into $L$. For example:

\[
\begin{array}{rl}
E_{2,1}^{-1}E_{3,1}^{-1}E_{3,2}^{-1}U =&
\begin{bmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 5 & 1
\end{bmatrix}
I
\begin{bmatrix}
1 & 0 & 0 \\
2 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
U \\
=&
\begin{bmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 5 & 1
\end{bmatrix}
\begin{bmatrix}
1 & 0 & 0 \\
2 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
U \\
=&
\begin{bmatrix}
1 & 0 & 0 \\
2 & 1 & 1 \\
0 & 5 & 1
\end{bmatrix}
U \\
=&
LU
\end{array}
\]

In terms of computation, performing elimination on an $n \times n$ matrix is $O(\frac{1}{3}n^3)$ in the worst case. It’s no coincidence that this looks like the integral of $x^2$, as it represents a small change in $x^2$ over time.

There are 6 permutation matricies for $3 \times 3$ matricies:

For permutations matrices, $P^{-1} = P^T$. In general, there are $n!$ for an $n \times n$ matrix.

MIT OCW Single Variable Calculus - Week 2

2012-01-25T00:00:00-08:00

Week 2

Derivative Formulas

To work towards the goal of “differentiating everything”, need to talk about derivative formulas.

Specfic – $f’(x)$, where $f(x) = x^n, \frac{1}{x}$ as a few examples.
General – $(u + v)’ = u’ + v’$ and $(cu)’ = cu’$ where c is constant, as a few examples.

Start with specific trigonometric derivative formulas.

$\frac{\delta}{\delta x} sin \; x$

\[
\frac{\delta}{\delta x} sin \; x = \lim_{x \to 0} \frac{sin(x + \Delta) \; – sin(x)}{\Delta x}
\]

To solve this, we need to revist the trigonometric sum and difference formulas, namely:

\[
sin(A + B) = sin A \; cos B + cos A \; sin B
\]

This is a proof of the identity, using Eulers formula

Going back to the derivative:

\[
\begin{align}
\frac{\delta}{\delta x} sin \; x &= \lim_{x \to 0} \frac{sin(x + \Delta) \; – sin(x)}{\Delta x} \\
&= \lim_{x \to 0} \frac{sin\:x \; cos\:\Delta x + cos\;x \; sin\:\Delta x – sin\:x}{\Delta x} \\
&= \lim_{x \to 0} \quad sin\:x(\frac{cos\:\Delta x – 1}{\Delta x}) + cos\:x(\frac{sin\:\Delta x}{\Delta x}) \\
&= cos\:x
\end{align}
\]

due to the fact that $\frac{cos\:\Delta x – 1}{\Delta x}$ tends to 0 as $\Delta x$ tends to 0, and $\frac{sin\:\Delta x}{\Delta x}$ tends to 1 as $\Delta x$ tends to 0. Label these as A and B respectively, as we will prove them later.

$\frac{\delta}{\delta x} cos x$

Same as above, only this time using the identity:

\[
cos(A + B) = cos A \; cos B – sin A \; sin B
\]

\[
\begin{align}
\frac{\delta}{\delta x} cos \; x &= \lim_{x \to 0} \frac{cos(x + \Delta) \; – cos(x)}{\Delta x} \\
&= \lim_{x \to 0} \frac{cos\;x \: cos\;\Delta x – sin\;x \: sin\;\Delta x – cos\;x}{\Delta x} \\
&= \lim_{x \to 0} \quad cos\;x(\frac{cos\;\Delta x – 1}{\Delta x}) – sin\;x(\frac{\sin\;\Delta x}{\Delta x}) \\
&= \quad – sin\;x
\end{align}
\]

again, by A and B as stated above.

Proofs of A and B

First, some remarks:

\[
\frac{\delta}{\delta x} cos\;x \quad \Bigg|^{x=0}
\quad \lim_{\Delta x \to 0} \frac{cos(\Delta x) – 1}{\Delta x}
\]

This shows that the rate of change of $cos x$ at $x = 0$ is a limit as $\Delta x$ tends to 0, which has been simplified:

\[
\begin{align}
&\frac{cos(0 + \Delta x) – cos(0)}{\Delta x} \\
= &\frac{cos(\Delta x) – 1}{\Delta x}
\end{align}
\]

and likewise

\[
\frac{\delta}{\delta x} sin\;x \quad \Bigg|^{x=0}
\quad \lim_{\Delta x \to 0} \frac{sin(\Delta x)}{\Delta x}
\]

because of the simplification:

\[
\begin{align}
&\frac{sin(0 + \Delta x) – sin(0)}{\Delta x} \\
= &\frac{sin(\Delta x)}{\Delta x}
\end{align}
\]

We should note that the derivatives of sine and cosine at $x = 0$ give all values of $\frac{\delta}{\delta x} sin x$, $\frac{\delta}{\delta x} cos x$

Back to the proofs:

Property B

Geometric proof:

Lets rename $\Delta x$ as $\theta$.

Consider the ratio of the arc length to the line $sin \theta$. Then double it for the two $\theta$ that were drawn:

\[
\begin{align}
&\frac{2 sin \theta}{2 \theta} \\
= &\frac{sin \theta}{\theta}
\end{align}
\]

Now, as $\theta$ approaches 0, the lines $sin \theta$ and $arclength \theta$ get close and close to the same line, so the result of the ratio is 1, intuitively because short pieces of curves are nearly straight.

Property A

The basis for the proof for cosine is the same as the proof for sine – that of short pieces of curves being nearly straight.

First, $cos \theta$ is going to be negative, so we need to invert the statement:

\[
\frac{1 – cos \theta}{\theta}
\]

This is a similar image as before, only magnified.
The distance from the centre of the circle to the circumference is 1 (because this is a unit circle, and the gap between the $sin \theta$ line and the circumference is $1 – cos \theta$. As $\theta$ tends to 0, this gap gets smaller and smaller, and as such, $\frac{1 – cos \theta}{\theta}$ tends to 0.

NOTE TO SELF – RECORD GEOMETRIC PROOF

General Derivative Rules

Product Rule

\[
(uv)’ = u’v + uv’
\]

can be remembered as changing one variable at a time. Will be proven as such.

Example:

\[
\frac{\delta}{\delta x} (x^n sin\;x) = nx^{n-1}sin\;x + x^n cos\;x
\]

Proof:

Going back to first principles of calculus, we can rewrite the sum in terms of the rate of change:

\[
\begin{align}
\frac{\delta}{\delta x} uv &= \lim_{\Delta x \to 0} \frac{u(x + \Delta x)v(x + \Delta x) – u(x)v(x)}{\Delta x} \\
&= \lim_{\Delta x \to 0} \frac{u(x + \Delta x)(v(x + \Delta x) – v(x)) + v(x)(u(x + \Delta x) – u(x))}{\Delta x} \qquad \text{(1)} \\
&= \lim_{\Delta x \to 0} u(x + \Delta x)\frac{\delta v}{\delta x} + v(x)\frac{\delta u}{\delta x} \\
&= uv’ + vu’
\end{align}
\]

We converted the sum in (1) to a new form to aid in the proof. You can multiply out (1) to show that it is indeed equal:

\[
\begin{align}
u(x + \Delta x)(v(x + \Delta x) – v(x)) + v(x)(u(x + \Delta x) – u(x)) &= u(x + \Delta x)v(x + \Delta x) – v(x)u(x + \Delta x) + v(x)u(x + \Delta x) – v(x)u(x) \\
&= u(x + \Delta x)v(x + \Delta x) – v(x)u(x)
\end{align}
\]

As $\Delta x$ tends to 0, then $u(x + \Delta x)$ approaches $u(x)$, which will complete the proof.

Quotient Rule

\[
\left(\frac{u}{v}\right)’ = \frac{u’v – uv’}{v^2}
\]

only works when $v \ne 0$.

Proof:

First, recall that $\frac{\delta}{\delta x}$ is equal to $\frac{\Delta y}{\Delta x}$ and we can compute $\Delta y$ in a separate step, and then just divide by $\Delta x$.

\[
\begin{align}
\Delta \left( \frac{u}{v} \right) &= \frac{u + \Delta u}{v + \Delta v} – \frac{u}{v} \\
&= \frac{uv + v(\Delta u) – uv – u(\Delta v)}{(v + \Delta v)v} \\
&= \frac{v(\Delta u) – u(\Delta v)}{(v + \Delta v)v} \\
\frac{\Delta \left( \frac{u}{v} \right) }{\Delta x} &= \frac{ \frac{\Delta u}{\Delta x}v – u\frac{\Delta v}{\Delta x} }{(v + \Delta v)v} \\
\frac{\delta}{\delta x} \left( \frac{u}{v} \right) &= \lim_{\Delta x \to 0} \frac{ \frac{\delta u}{\delta x}v – u\frac{\delta v}{\delta x} }{v^2} \\
&= \frac{u’v – uv’}{v^2}
\end{align}
\]

Let us reconsider the above, setting $u = 1$:

\[
\begin{align}
\frac{\delta}{\delta x} \left( \frac{1}{v} \right) &= \frac{-1v’}{v^2} \\
&= -v^{-2}v’
\end{align}
\]

and now, lets consider the above example generally, with $\frac{1}{x^n}$ represented as $x^{-n}$:

\[
\begin{align}
\frac{\delta}{\delta x} x^{-n} &= \frac{\delta}{\delta x} \left( \frac{1}{x^n} \right) \\
&= -x^{-2n}nx^{n-1} \\
&= -nx^{-n-1}
\end{align}
\]

You’ll notice that this follows the same pattern that applies to $x^n$.

Chain rule

We’ll start by derriving the rule, then writing it down.

Proof:

\[
\begin{align}
\frac{\Delta y}{\Delta t} &= \frac{\Delta y}{\Delta x} \frac{\Delta x}{\Delta t} \\
\frac{\delta y}{\delta t} &= \frac{\delta y}{\delta x} \frac{\delta x}{\delta t}
\end{align}
\]

TODO: FIND A BETTER PROOF OF THIS, OR SHOW A MORE EXPLICIT EXAMPLE *

Example:

\[
\begin{align}
\frac{\delta}{\delta t} (sin\;t)^{10} &= x^{10} & \text{Substituting x = sin t} \\
&= 10x^9 cos\;t \\
&= 10(sin\;t)^9 cos\;t & \text{Substituting the value of x back in}
\end{align}
\]

Example 2:

\[
\begin{align}
\frac{\delta}{\delta t} sin(10t) &= sin(x) & \text{Substituting x = 10t} \\
&= cos(x) \times 10 \\
&= cos(10t) \times 10 & \text{Substituting 10t = x back in}
\end{align}
\]

Higher derrivatives *

Refers to multiple steps of differentiation.

Consider the function $u = u(x)$, then $u’$ is a new function in and of itself. We can differentiate this function: $u’’$. This is the second derivative, and it too is a new function, and can be differentiated.

You can continue this to any number of higher derrivatives, second, third, fourth, etc.

Notation:
\[
\begin{align}
u’ &= \frac{\delta u}{\delta x} = \frac{\delta}{\delta x} u \\
u’’ &= \frac{\delta}{\delta x}\frac{\delta u}{\delta x} = \frac{\delta}{\delta x}\frac{\delta}{\delta x} u \\
&= \left(\frac{\delta}{\delta x}\right)^2 u \\
&= \frac{\delta^2}{(\delta x)^2} u \\
&= \frac{\delta^2}{\delta x^2} u
\end{align}
\]

Example:

\[
\begin{align}
D^nx^n &= ? \\
Dx^n &= nx^{n-1} \\
D^2x^n &= n(n-1)x^{n-2} \\
D^3x^n &= n(n-1)(n-2)x^{n-3} \\
D^{n-1}x^n &= (n(n-1)(n-2) \ldots 2)x^1 \\
D^nx^n &= (n(n-1)(n-2) \ldots 2 \times 1) \times 1 \\
&= n!
\end{align}
\]

MIT OCW Single Variable Calculus - Week 1

2012-01-18T00:00:00-08:00

Differentiation

What is a derivative?

Geometric interpretation

Consider the problem of finding the tangent line to some function $y=f(x)$ at $P=(x_0,y_0)$:

The tangent line has an equation of the form $y – y_0 = m(x – x_0)$, where m is the slope or gradient of the line.
Finding $y_0$ is easy – $y_0 = f(x_0)$.
Finding m involves calculus – $m = f’(x_0)$.
That is, $f’(x_0)$, the derivative of $f$ at $x_0$ is the slope of the tangent line to $y = f(x)$ at P.

Consider the following graph:

How do we know which of these two lines is the tangent, given that both pass through the same point?
Lets define the point where the secant and the tangent intersect as P, and the other point on the secant as Q.
As the point Q gets closer to the point P, the slope of the secant line starts to match the slope of the tangent line.
Therefore:
The tangent is the limit of the secant line $PQ$ as the point $Q \rightarrow P$, assuming P is fixed.

Again consider the secant line $PQ$.
Calculating the gradient of $PQ$:
The difference between Q’s x value and P’s x value is known as $\Delta x$ (delta x), or the change in x.
The change in y is called $\Delta f$ (in this case?).
The gradient between $P$ and $Q$ is the ratio of $\frac{\Delta f}{\Delta x}$.
As the point Q gets closer to P, $\Delta x$ gets smaller.
Thus $m = \lim_{\Delta x \to 0} \frac{\Delta f}{\Delta x}$

If P is the point $(x_0, f(x_0))$, then we can represent Q as $(x_0 + \Delta x, f(x_0 + \Delta x))$.
Therefore $m = \lim_{\Delta x \to 0} \frac{f(x_0 + \Delta x) – f(x_0)}{\Delta x}$.
This is the heart of the derivative.

Example:
Consider the graph for $\frac{1}{x}$

Find the tanget at point $x_0$:
$$m = \lim_{\Delta x \to 0} \frac{ \frac{1}{x_0 + \Delta x} – \frac{1}{x_0} }{\Delta x}$$
$$m = \lim_{\Delta x \to 0} \frac{1}{\Delta x}\left( \frac{ x_0 – (x_0 + \Delta x) }{ (x_0 + \Delta x)x_0 } \right)$$
$$m = \lim_{\Delta x \to 0} \frac{1}{\Delta x}\left( \frac{ -\Delta x }{ (x_0 + \Delta x)x_0 } \right)$$
$$m = \lim_{\Delta x \to 0} -\frac{1}{ (x_0 + \Delta x)x_0 }$$
$$m \rightarrow -\frac{1}{ x_0^2 }$$

Example 2:
Find the area of the triangle formed by the axes and the curve described by $y = \frac{1}{x}$.
This is a word problem with only one part of calculus – the rest is regular math.
Graph the problem:

The only part of the problem that involves calculus is finding the tangent. We found the gradient $m$ above, so lets use that.
$y – y_0 = -\frac{1}{x_0^2}(x – x_0)$
To calculate the area of the triangle, we need the base length (along the $x$ axis) and the base height (along the $y$ axis).
We can find those by calculating the $x$ intercept and $y$ intercepts.
$x$ intercept is at $y = 0$, and we can express $y_0$ in terms of $f(x)$:
$$ – \frac{1}{x_0} = -\frac{1}{x_0^2}(x – x_0) $$
$$ – \frac{1}{x_0} = -\frac{x}{x_0^2} + \frac{1}{x_0} $$
$$ \implies \frac{x}{x_0^2} = \frac{2}{x_0} $$
$$ \implies x = 2x_0 $$
Using symmetry, we can find the $y$ intercept quickly.
Firsly, a note about symmetry:
$$ y = \frac{1}{x} \implies xy = 1 \implies x = \frac{1}{y} $$
$$ \therefore y = 2y_0 $$
The area of a triangle is $\frac{1}{2}$ base x perpendicular height.
$\therefore area = \frac{1}{2}(2_x0)(2y_0) = 2x_0y_0$ = 2
The area is 2 because $y = \frac{1}{x}$, and $xy$ will always equal 1.

Notation:
$y = f(x), \Delta y = \Delta f$
$f’ = \frac{\delta f}{\delta x} = \frac{\delta y}{\delta x} = \frac{\delta}{\delta x}f = \frac{\delta}{\delta x}y$

Example 3:
$y = \frac{\delta}{\delta x}x^n$
$$ \frac{\Delta f}{\Delta x} = \lim_{\Delta x \to 0} \frac{(x + \Delta x)^n – x^n}{\Delta x} $$
In order to solve this, we need to revist the binomial theorem (algebra).
Binomial theorem states that:
$ (x + \Delta x)^n = (x + \Delta x) … (x + \Delta x) $
$ = x^n + nx^{n-1} + O((\Delta x)^n)$
continuing:
$$ \frac{\Delta f}{\Delta x} = \frac{1}{\Delta x}\big((x + \Delta x)^n – x^n \big) $$
$$ \frac{\Delta f}{\Delta x} = \frac{1}{\Delta x}\big(x^n + nx^{n-1}\Delta x + O((\Delta x)^n) – x^n \big) $$
$$ \frac{\Delta f}{\Delta x} = \frac{1}{\Delta x}\big(nx^{n-1}\Delta x + O((\Delta x)^n) \big) $$
$$ \frac{\Delta f}{\Delta x} = nx^{n-1} + O((\Delta x)^n) $$
$$ \frac{\Delta f}{\Delta x} = \lim_{\Delta x \to 0} nx^{n-1} + O((\Delta x)^n) = nx^{n-1} $$
$$ \therefore \frac{\delta}{\delta x}x^n = nx^{n-1} $$

Rate of Change

Geometrically, a derivative can be thought of as the slope of a tangent line for a curve.
It can also be considered from the point of view of relative rate of change. That is, the change in variables $x$ and $y$ for a given function $f(x)$.
$\frac{\Delta x}{\Delta y}$ is the average rate of change – that is, the entire change over the entire interval.
$\frac{\delta x}{\delta y}$ is the average rate of change limited, and is the instantaneous rate of change.

Examples:
1. q = charge, $\frac{\delta q}{\delta t}$ = current. The rate of change in charge over time is current.
2. s = distance, $\frac{\delta s}{\delta t}$ = speed. The rate of change in distance over time is speed.

Consider the MIT pumpkin drop:
From the top of one of the buildings in MIT, on Halloween, students drop pumpkins from the top of building to the ground.
Assume the building is 80m high, and assume the rate of acceleration due to gravity is 5m² (not 9.8m²).
$ h = 80 – 5t^2 $
at t = 0, h = 80
at t = 4, h = 0

The average speed is:
$\frac{\Delta h}{\Delta t} = \frac{0 – 80}{4 – 0} = -20m/s $

The instantaneous speed as it hits the ground is:
$\frac{\delta}{\delta t}h = 0 – 10t$ (differentiated the function for height)
at t = 4, instantaneous speed is -40m/s.

Examples that don’t involve time:
3. T = temperature, $\frac{\delta T}{\delta x}$ = temperature gradient (used in weather forecasting & airflow)
4. Sensitivity of measurements

Limits & Continuity

Left & right hand limits.
$\lim_{x \to x_0^+}$ – right hand limit. Says that x is bigger than $x_0$ and we’re approaching $x_0$ with a negative $\Delta$
$\lim_{x \to x_0^-}$ – left hand limit. Says that x is smaller than $x_0$ and we’re approaching $x_0$ with a positive $\Delta$

Example:
$$
f(x) = \left\{
\begin{array}{l l}
x + 1 & \quad x > 0\\
-x + 2 & \quad x < 0\\
\end{array} \right.
$$

$$\lim_{x \to x_0^+} f(x) = \lim_{x \to x_0} x + 1 = 1$$

$$\lim_{x \to x_0^-} f(x) = \lim_{x \to x_0^-} -x + 2 = 2$$

Note: we didn’t need x = 0 value.

Continuity:
$f(x)$ is continuous at $x_0$ when $\lim_{x \to x_0} = f(x_0$
Requirements:
- $\lim_{x \to x_0} f(x)$ exists (from left & right, and left & right must be the same)
- $f(x_0)$ is defined
- Both of the above are equal to each other

Continuous functions are easier to calculate limits for because you can just insert the $x_0$ term into the function and determine the limit.

Discontinuity:
If $f(x)$ is not continuous, then it is discontinuous.
Jump discontinuity – Limit from left and right exist but are not equal
Removable discontinuity – Limit from left and right are equal. Discontinuity can be removed by redefining the function for the point of discontinuity.
Example:
$$
\begin{array}{1 1}
g(x) = \frac{sin x}{x} \\
h(x) = \frac{1 – cosx}{x}
\end{array}
$$
g(0) is undefined, but:
$$
\begin{array}{1 1}
\lim_{x \to 0} \frac{sin x}{x} = 1 \\
\lim_{x \to 0} \frac{1 – cos x}{x} = 0
\end{array}
$$

These functions have a removable discontinuity at x = 0

Infinite discontinuity
Consider $\frac{1}{x}$:
$$
\begin{array}{1 1}
\lim_{x \to x_0^+} \frac{1}{x} = \infty \\
\lim_{x \to x_0^-} \frac{1}{x} = -\infty
\end{array}
$$

Other (ugly) discontinuities
$y = sin \frac{1}{x} \text{as} \; x \to 0$
No left or right limit

Differential implies continuous theorem

If f is differentiable at $x_0$, then x is continuous at $x_0$
Proof:
$$
\lim_{x \to x_0} f(x) – f(x_0) = 0
$$

$$
\lim_{x \to x_0} \frac{f(x) – f(x_0)}{x – x_0} (x – x_0) = f’(x_0) . 0 = 0
$$

MIT OCW Single Variable Calculus

2012-01-18T00:00:00-08:00

THIS IS A PLACEHOLDER SO THAT THE INDEX APPEARS IN THE PROJECT LIST

D&D Monster Tokens

2012-01-09T00:00:00-08:00

Announcing Adventurin – August 8^th, 2013

I wrote this post a year and a half ago because I was frustrated by the mini market, how expensive it is, and how bad the art was on the minis.

Some friends and I decided to work on the problem togther, and we’re launching Adventurin, a service where you can use your browser to design and get delivered to your house a custom miniature for your D&D games. No plugins, no special software needed.

You can print your characters minis, or even build NPC and eventually monsters to print out.

I’m probably not going to update the tokens below, as the game I was creating them for fell apart a long time ago. However, I highly recommend joining the mailing list for Adventurin and checking it out when we’re done.

Everyone knowns how much easier combat is to understand when you have some spatial aids. Wizards of the Coast and other gaming companies are pushing hard on minis, but they’re fairly expensive and take up a lot of storage room. Did I also mention they happen to be expensive to collect a lot?

As an alternative, you can use tokens, and make them at home. I used to think home-made tokens looked cheap, because the tokens I saw people use had hodge-podge artwork on them, in different styles and mediums, and there was no sense of cohesion.

Which is why I decided to make my own tokens. I like to think I’ve come up with a pretty streamline way to make tokens fast, and I’m quickly expanding my repetoire.

Here are the things you need:

- One of these bad boys:

which is used in scrapbooking. This will do for most medium sized creatures, but if you need to go larger, you can use one of these:

which is a circle cutter, and should do 1" – 5" circles, which should be good for any monster you can come up with.
- Some contact paper, available at any stationary store.
- Some card stock
- A computer and a printer.

Using these supplies, you can make your own tokens fairly quickly and easily. Now, I like to draw, and I’m fairly good at it, so I draw my own tokens. For those of you who either don’t have the time, inclination or skill to draw your own, I’m making mine available for free.

As you can see, the art is consistent, and the templates are pretty easy to use. Simply print the template onto card stock, contact both sides so you can write on them with dry erase markers, line up the circle punch and punch them out. Instant tokens.

I’m slowly adding more monsters as my adventuring party encounter them, so periodically check back for updated monsters.
Here are the monsters that I have currently:
- Zombie
- Skeleton
- Hobgoblin
- Spider
- Ghoul
- Homunculus
- Evil cleric
- Human berzerker
- Gelatinous cube (coming soon)
- Goblin (coming soon)
- Kobold (coming soon)

(current as of 01-09-2012, and we play once a week, with new monsters twice a month or so)

MIT OCW Linear Algebra - Week 1

2012-01-06T00:00:00-08:00

Linear equations

n equations, n unknowns – easy to solve.

Example:
$$
\begin{array}{1 1}
2x – y = 0 \\
-x + 2y = 3
\end{array}
$$
can be solved with matrices as follows:
$$
\begin{bmatrix}
2 & -1 \\
-1 & 2
\end{bmatrix}
\begin{bmatrix}
x \\
y
\end{bmatrix}
=
\begin{bmatrix}
0 \\
3
\end{bmatrix}
$$

The matrix of co-efficients will be called $A$, the vector of unknowns will be called $X$ and the resultant matrix will be called $b$.

Row picture

The point of intersection is the solution to this pair of linear equations.

Column picture

We can reinterpret these two equations into a single matrix equation:
$$
x \begin{bmatrix}
2 \\
-1
\end{bmatrix} + y \begin{bmatrix}
-1 \\
2
\end{bmatrix} = \begin{bmatrix}
0 \\
3
\end{bmatrix}
$$

Now the equation is asking us to find the correct linear combination of the columns, or vectors, that solves the equation.
The linear combination is the proportion of each vector that solves the equation.

Lets plug in the correct results from above, and take 1 of $\begin{bmatrix}2\\-1\end{bmatrix}$ and 2 of $\begin{bmatrix}-1\\2\end{bmatrix}$:

As you can see, we get the answer $b$, which is $\begin{bmatrix}0\\3\end{bmatrix}$

Example 2
Now lets consider 3 equations with 3 unknowns:

$$
\begin{array}{1 1}
2x – y = 0 \\
-x + 2y – z = -1 \\
-3y + 4z = 4
\end{array}
$$

Matrix form:

$$
A =
\begin{bmatrix}
2 & -1 & 0 \\
-1 & 2 & -1 \\
0 & -3 & 4
\end{bmatrix}
\quad
b =
\begin{bmatrix}
0 \\
-1 \\
4
\end{bmatrix}
$$

Row picture:

A 3D cartesian axis with 3 planes that meet in a point. Omitting the plot due to the complexity of the problem.
This points to a weakness in this interpretation of the problem in higher dimensions.

Column picture:

$$
x
\begin{bmatrix}
2 \\
-1 \\
0
\end{bmatrix} + y
\begin{bmatrix}
-1 \\
2 \\
-3
\end{bmatrix} + z
\begin{bmatrix}
0 \\
-1 \\
4
\end{bmatrix} =
\begin{bmatrix}
0 \\
-1 \\
4
\end{bmatrix}
$$

The solution is $x = 0, y = 0, z = 1$, which is clearly seen from the matrices.

Consider the case where we have a different RHS:

$$
x
\begin{bmatrix}
2 \\
-1 \\
0
\end{bmatrix} + y
\begin{bmatrix}
-1 \\
2 \\
-3
\end{bmatrix} + z
\begin{bmatrix}
0 \\
-1 \\
4
\end{bmatrix} =
\begin{bmatrix}
1 \\
1 \\
-3
\end{bmatrix}
$$

You can see the solution is $x = 1, y = 1, z = 0$.

Consider all RHS sides? Can we solve $Ax = b$ for every b? To restate, do the linear combinations of the columns fill 3D space?
The answer for the above matrix A, the answer is yes. This means the matrix is non-singular and invertable.
If the answer is no, then the matrix is singular and non-invertable.

For example, if the three vectors lie in the same plane, then the combinations will lie in the same plane – but not all of 3D space.

A matrix is singular and non-invertable if the columns are linearly independent from each other.

Multiplying a matrix by a vector:
Column way, as opposed to the row way:

$$
\begin{bmatrix} 2 & 5 \\ 1 & 3 \end{bmatrix}
\begin{bmatrix} 1 \\ 2 \end{bmatrix}
$$
$$
= 1 \begin{bmatrix} 2 \\ 1 \end{bmatrix} + 2 \begin{bmatrix} 5 \\ 3 \end{bmatrix}
$$
$$
= \begin{bmatrix} 12 \\ 7 \end{bmatrix}
$$

So you can see that $Ax$ is a combination of the columns of $A$

Matrix Elimination

Discovered by Gauss.

We will be working from the following example equations:

$$
\begin{array}{1 3}
x + 2y + z = 2 \\
3x + 8y + z = 12 \\
4y + z = 2
\end{array}
$$

the coefficients of which can be represented by the following matrix:

$$
A = \begin{bmatrix}
1 & 2 & 1 \\
3 & 8 & 1 \\
0 & 4 & 1
\end{bmatrix}
$$

the answer with:

$$
b = \begin{bmatrix}
2 \\
12 \\
2
\end{bmatrix}
$$

and the full equation represented by:

$$
Ax = b
$$

To begin, the purpose of elimination is to get rid of as many unknowns as we can and then solve for the remaining unknown.
The first step in this case would be to subtract $x + 2y + z = 2$ from $3x + 8y + z$ with the goal of eliminating the $x$ variable.

Firstly, declare the $x$ coefficient in the first row of matrix $A$ to be the pivot. Then find the multiple of the pivot required to eliminate it. In this case, it’s 3. Then subtract the first row multiplied by the multiple from the second row. This will result in:

\[
\begin{matrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 4 & 1
\end{matrix}
\]

This has eliminated $x$ from the second row, the [2, 1] position. The next step would be to eliminate $x$ from the [3, 1] position, however there is no need to do this, as it is already 0.

Next, eliminate $y$ from the third row. Set the pivot to be the $y$ coefficient in $A$ and find the multiple required to eliminate it. The multiple is 2. Then subtract the second row multiplied by the multiple from the third row:

\[
\begin{matrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 0 & 5
\end{matrix}
\]

This results in a type of matrix called an upper-triangular matrix. This is the form of matrix we need to complete this form of elimination. We can call this matrix $u$.

Note: pivots can’t be 0.

This process will fail if there’s a 0 in a pivot position. This will require reorganizing the matrix if possible, so that there is a non-zero number in the pivot position. If you can’t find 3 pivots, the matrix is non-invertable and the solution cannot be found.

Back substitution

After finding the multiples, we can apply the same algorithm to the right hand side of the equation:

\[
b =
\begin{matrix}
2 \\ 12 \\ 2
\end{matrix}
\quad
\rightarrow
\quad
b =
\begin{matrix}
2 \\ 6 \\ 2
\end{matrix}
\quad
\rightarrow
\quad
b =
\begin{matrix}
2 \\ 6 \\ -10
\end{matrix}
\]

This leaves us with the augmented matrix:

\[
\begin{matrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 0 & 5
\end{matrix}
\left|
\begin{matrix}
2 \\ 6 \\ -10
\end{matrix}
\right.
\]

and we can see that we have the equation $5z = -10$ and that $z = -2$.

We can then substitute that back in to the above equation for $2y – 2(-2) = 6$ to get $y = 1$, and then substitute that back into the first equation for $x + 2(1) + 1(-2) = 2$ and get $x = 2$.

Thus using elimination and substitution we have solved the equation with $x = 2$, $y = 1$ and $z = -2$

Matrices

Now we’re going to represent the above calculation in matrix form. We want to perform elimination on the following matrix:

\[
\begin{bmatrix}
1 & 2 & 1 \\
3 & 8 & 1 \\
0 & 4 & 1 \\
\end{bmatrix}
\]

First, we want to find the matrix that will subtract 3 times row 1 from row 2, and leaves the other rows. So we want to find the matrix $X$ that solves the following:

\[
X \begin{bmatrix}
1 & 2 & 1 \\
3 & 8 & 1 \\
0 & 4 & 1
\end{bmatrix}
\quad = \quad
\begin{bmatrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 4 & 1
\end{bmatrix}
\]

Lets go back to the concept of multiplying matrices first, in order to solve this intuitively.

Consider this problem:

\[
\begin{bmatrix}
x_{1,1} & y_{1,2} & z_{1,3} \\
x_{2,1} & y_{2,2} & z_{2,3} \\
x_{3,1} & y_{3,2} & z_{3,3}
\end{bmatrix}
\begin{bmatrix}
4 \\ 5 \\ 6
\end{bmatrix}
\]

This is saying take 4 of the first column, 5 of the second column and 6 of the third column:

\[
\begin{bmatrix}
4 (x_{1,1} + x_{2,1} + x_{3,1}) \\
5 (y_{1,2} + y_{2,2} + y_{3,2}) \\
6 (z_{1,3} + z_{2,3} + z_{3,3})
\end{bmatrix}
\]

\[
= \begin{bmatrix}
12x \\
15y \\
18z
\end{bmatrix}
\]

which is a combination of the columns of the matrix. This will result in a column vector.

Where as this problem:

\[
\begin{bmatrix}
4 & 5 & 6
\end{bmatrix}
\begin{bmatrix}
x_{1,1} & y_{1,2} & z_{1,3} \\
x_{2,1} & y_{2,2} & z_{2,3} \\
x_{3,1} & y_{3,2} & z_{3,3}
\end{bmatrix}
\]

is saying "take 4 of the first row, 5 of the second row and 6 of the third row:

\[
\left[
\begin{array}{3 1}
4 (x_{1,1} + y_{1,2} + z_{1,3}) + \\
5 (x_{2,1} + y_{2,2} + z_{2,3}) + \\
6 (x_{3,1} + y_{3,2} + z_{3,3})
\end{array}
\right]
\]

\[
= \begin{bmatrix}
15x & 15y & 15z
\end{bmatrix}
\]

which is a combination of the rows of the matrix. This will result in a row vector.

Now going back to the problem at hand:

\[
X \begin{bmatrix}
1 & 2 & 1 \\
3 & 8 & 1 \\
0 & 4 & 1
\end{bmatrix}
\quad = \quad
\begin{bmatrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 4 & 1
\end{bmatrix}
\]

You can see that we need 1 of the first row, and 1 of the last row to solve this equation. Thus, we can see that:

\[
X =
\begin{bmatrix}
1 & 0 & 0 \\
x_{2,1} & x_{2,2} & x_{2,3} \\
0 & 0 & 1
\end{bmatrix}
\]

because if you consider $\begin{bmatrix} 1 & 0 & 0 \end{bmatrix}$ as a row vector, that will take 1 of the first row of the matrix and none of the second and third rows of the matrix, which is what the first row of the answer is. Likewise for the last row.

Now we need the row that will subtract 3 of the first row from the second row. We can see the answer is:

\[
X =
\begin{bmatrix}
1 & 0 & 0 \\
-3 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
\]

We can also call this matrix $E_{2,1}$, the elimination matrix to eliminate the 2,1 position of the co-efficient matrix.

Now we need to represent step 2, which will eliminate the position 3,2, matrix $E_{3,2}$:

\[
E_{3,2}
\begin{bmatrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 4 & 1
\end{bmatrix}
\quad = \quad
\begin{bmatrix}
1 & 2 & 1 \\
0 & 2 & -2 \\
0 & 0 & 5
\end{bmatrix}
\]

Using the above steps, we know that:

\[
E_{3,2} =
\begin{bmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & -2 & 1
\end{bmatrix}
\]

We can now roll both steps into a single step, a single matrix $E$ that does all the steps at once.
Firstly, lets represet what we did in an equation:

\[
E_{3,2}(E_{2,1}A) = u
\]

where u is the final result of the elimination, before we started the back substitution.

Given that matrix multiplication is associative, we can represent that as:

\[
(E_{3,2}E_{2,1})A = u
\]

which will give E:

\[
\begin{bmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & -2 & 1
\end{bmatrix}
\begin{bmatrix}
1 & 0 & 0 \\
-3 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
\quad = \quad
\begin{bmatrix}
1 & 0 & 0 \\
-3 & 1 & 0 \\
6 & -2 & 1
\end{bmatrix}
\]

However, that’s not the optimal way. Lets consider the equation again:

\[
(E_{3,2}E_{2,1})A = u
\]

Lets consider, instead of how we’d get from A to u, but from u to A, using inverses. That’s a topic for next time.

Note: If we needed to exchange rows, we would have done so using a permutation matrix. This is easy to derrive by thinking about it in terms of functions of rows in terms of row exchanges, and columns in terms of column exchanges, as per the above examples.
For example, exchanging rows in a 2×2 matrix:

\[
\begin{bmatrix}
0 & 1 \\
1 & 0 \\
\end{bmatrix}
\begin{bmatrix}
a & b \\
c & d
\end{bmatrix}
\quad = \quad
\begin{bmatrix}
c & d \\
a & b
\end{bmatrix}
\]

and exchanging columns in a 2×2 matrix:

\[
\begin{bmatrix}
a & b \\
c & d
\end{bmatrix}
\begin{bmatrix}
0 & 1 \\
1 & 0
\end{bmatrix}
\quad = \quad
\begin{bmatrix}
b & a \\
d & c
\end{bmatrix}
\]

MIT OCW Linear Algebra

2012-01-06T00:00:00-08:00

THIS IS A PLACEHOLDER SO THAT THE INDEX APPEARS IN THE PROJECT LIST

2011 In Review, And a Look Forward to 2012

2012-01-02T00:00:00-08:00

Although I didn’t start out with a plan for 2011, I’m going to perform a brief review of the last year and outline some of the remarkable things that happened to me. This will hopefully help me feel like I’ve achieved something significant.

Got married
Moved to the US permanently
Started a new job at an Austin based startup
Made some new friends, and started playing D&D again (this is something I didn’t think I could ever do again, so it’s a good thing for me)
Visited India for the first time
Completed 2 courses in Stanfords experimental online university courses – Introduction to Artificial Intelligence, and Machine Learning. This lead me to watch some lectures and learn material I’ve been meaning to get around to for a few years
Realized the importance of working on only one thing at a time.

The last one, I think, is the most important to my future growth.

Up until now, I’ve been trying to do too many things at once, and thus got nothing done. I’ve always been saying I’ll concentrate on one thing at a time, but I never follow through.

The Stanford online classes helped me finally follow through with that goal, and for 2 months, I focused only on completing those classes. It opened my eyes to just how important it is to work on only one thing at a time.

Due to this, I am devoting the entirety of 2012 to my artwork, and I’m setting some specific goals to measure my progress. After all, if you’re not measuring it, you can’t learn from it.

These goals are as follows:

Finish the 4′×5′ airbrush portrait of myself and my wife for my mother-in-law.
Sell a piece of artwork
Earn enough money through art on the side to buy a Cintiq
Submit art for Spectrum 20 (being accepted would be fantastic, but submitting is good enough)

This isn’t the full list of goals, but it is a list of landmarks to mark my progress. I’m hoping that I’ll get the first 2 done before June.
At the end of 2012, I’ll review how I did with these goals.

Things that Suck

2011-12-16T00:00:00-08:00

I do a lot of reading about startups and entrepreneurship. A common theme on the subject of getting started is finding problems to solve. “Easier said than done”, I’ve always thought. People in the tech startup world love to claim that ideas are cheap and easy, execution is where it counts. Ideas weren’t cheap and easy to me, until I learned a trick.

Startup literature writes that you should find meaningful problems to solve in order to start your startup. That seems kind of abstract to me. If I had a meaningful problem, usually I’ve already solved it myself.
Getting more specific, people bring up “pain points.” Find something in your life that is a “pain point” and fix that, and chances are, other people have the same “pain point” and you can help them solve it. Again, that’s a little abstract. What causes me pain in my life? Not much.

While dwelling on the meaning of “pain point”, I came up with a rephrasing and a quick acid test. A pain point is something that makes you say “Man, this sucks.”

“Driving home in traffic sucks”
“Planning a wedding sucks”
“Changing travel plans sucks”
“Lost luggage sucks”

Something is a “pain point” if doing it, or experiencing it, or fixing it makes you think “Man, this sucks.”

If something sucks, and you can fix it, then you start to put the idea through the whole “will people pay for this” wringer.

Stanford Online Artificial Intelligence Class

2011-12-15T00:00:00-08:00

What is this?

Stanford is running an artificial intelligence class during the summer of 2011. I am participating in this class, and this page will track my progress. I will be posting things like lecture notes and additional reading/research.

I hope to both provide help to other people who are running the class, information to people who may have missed the class, and accountability for myself to follow this class through to completion.

Update: December 15, 2011

With the class come to a close, I can publish all of my individual lecture notes in a single document:
Entire course notes
and the solution to the last week’s programming exercise:
aiclassnlp1.rb – solution for the first question
aiclassnlp2.rb – solution for the second question
corpus.txt – training corpus for the second question (Flatland by Edwin A. Abbot, from Project Gutenberg
input.txt – input for the second question (from the notes on the video)

Week 1

Lecture notes for the first week’s lessons.

Week 2

Lecture notes for the second week’s lessons.
Also, the homework for Week 2 really kicked my butt. I had some issues getting my head around some of the probability, so here are some resources I’m finding useful:
- http://www.reddit.com/r/aiclass/comments/lrojo/understanding_bayes_rule_intuitively_without/
- http://www.reddit.com/r/aiclass/comments/lm7g7/dseparation_and_the_bayes_ball_algorithm/
- http://postimage.org/image/udh7nv217/

Week 3

Lecture notes for the third week’s lessons.

Week 4

Lecture notes for the fourth week’s lessons.

Week 5

Lecture notes for the fifth week’s lessons.

Week 6

Lecture notes for the sixth week’s lessons.

Week 7

Lecture notes for the seventh’s week’s lessons.

Week 8

Lecture notes for the eighth week’s lessons.

This week, we also (kind of) learn how the Kinect does it’s thing. Kind of awesome.

Week 9

Lecture notes for the ninth week’s lessons.

These notes are in txt format because I had to take the notes on a laptop and not my iPad as I normally do.

Week 10

Lecture notes for the tenth week’s lessons.

This week we also got to do optional programming assignments. Here are my solutions in Ruby (1.91):
aiclassnlp1.rb – solution for the first question
aiclassnlp2.rb – solution for the second question
corpus.txt – training corpus for the second question (Flatland by Edwin A. Abbot, from Project Gutenberg
input.txt – input for the second question (from the notes on the video)

Stanford Online Machine Learning Class

2011-12-11T00:00:00-08:00

What is this?

Stanford is running a machine learning class during the summer of 2011. I am participating in this class, and this page will track my progress. I will be posting things like lecture notes and additional reading/research.

I hope to both provide help to other people who are running the class, information to people who may have missed the class, and accountability for myself to follow this class through to completion.

Week 1

Lecture notes for the first week’s lessons.

Week 2

Lecture notes for the second week’s lessons.
Programming exercise posted in the second week. (I’ll put these up at the end of the course, considering you can submit late)

Week 3

Lecture notes for the third week’s lessons.
Programming exercise posted in the third week. (I’ll put these up at the end of the course, considering you can submit late)
Practical classifying with logistic regression – an interesting write up about how Khan Academy uses logistic regression to assess student mastery through a course.

Week 4 & 5

Both weeks 4 & 5 are about Neural Networks, and due to a change in the structure of week 4 a little into week 5, I’ve rolled these two weeks into one.

Lecture notes for the fourth and fifth week’s lessons.
Programming exercise posted in the fourth week and the programming exercise for the fifth week. (I’ll put these up at the end of the course, considering you can submit late)

Also, I want to say that these two weeks’ programming exercises were to me the most interesting. Not only did we achieve a real, practical goal (recognizing hand written digits), but we got some insight about how to represent data in machine vision problems.
Week 4 was to implement forward propagation, and week 5 was backward propagation. In the end you end up with a neural network that can classify hand written digets that you built and trained from scratch yourself. Very cool.

Week 6

Lecture notes for the sixth week’s lessons.
Programming exercise posted in the sixth week. (I’ll put these up at the end of the course, considering you can submit late)

Week 7

Lecture notes for the seventh week’s lessons.
Programming exercise posted in the seventh week. (I’ll put these up at the end of the course, considering you can submit late)

Week 8

Lecture notes for the eighth week’s lessons.
Programming exercise posted in the eighth week. (I’ll put these up at the end of the course, considering you can submit late)

Week 9

Lecture notes for the nineth week’s lessons.
Programming exercise posted in the nineth week. (I’ll put these up at the end of the course, considering you can submit late)

Time

2011-11-08T00:00:00-08:00

The Knife Maker

Firstly, this film resonates with me strongly. It’s how I feel about my work, and the hobbies I choose to invest my time in.

One of my favorite insights from the HN thread I found this in: “Time must be used up. You don’t get to just stop using your time until you have something in particular you want to use it for. If making something by hand is rewarding to you, and someone else will pay you for it then it’s probably a good use of your time.”

Rails 3.1 Model Property Name Gotcha

2011-10-28T00:00:00-07:00

If you’re trying to instantiate a Rails model and you keep getting nil back instead of an instance of that model, chances are you have done something dumb like try to create a property on that model called “class”, or something equally ill-advised.

I haven’t tested this for all Ruby keywords, but chances are good that if the build in Object class has an instance property by the same name as one of your model properties, you’re going to run into trouble.

It’s obvious when you’re not dealing with the consequences, but when you’re sitting there in a console and your .new instantiation is returning nil, this get pretty confusing.

Games as Platforms

2011-10-18T00:00:00-07:00

I just read an article about Minecraft’s direction away from a platform towards a computer game , and couldn’t help thinking of one of my recent posts about businesses doing the opposite . If anything, it reinforces the concept of a platform for inverting the responsibility of creating value.

I know I’d much rather sell a game that makes money by itself, and enable others to create value for it by modding it. Hell, you could even let content creators earn money and take a commission.
I guess the only thing you need to be aware of is becoming a lame middleware vendor instead of a consumer product vendor.

Platform as product first, then extendable by the community.

Platforms and Sandboxes

2011-10-12T00:00:00-07:00

I’m in the middle of reading this HackerNews posting and I’m starting to see some parallels between building a tech business on a platform, and creating a sandbox RPG game¹.

Both are based on inverting the work load. Provide a means for other people to do your work for you and they will. The tech business (RPG) will move in a direction your customers (players) want, and you can focus on more important parts of your business (game).

Interesting.

_{1. For those unfamiliar with sandbox RPG games, the person running the game basically presents a complete world with an overall plot, and lets the characters choose their own actions and interact how they will with this world, as opposed to creating individual, fixed story adventures for their players to run through.}

A Case for Brevity

2011-10-10T00:00:00-07:00

I have a somewhat keen interest in speed reading, because the world is fascinating and I only have so many years to learn it’s secrets. One speed reading technique involves reading only the first few sentences of a paragraph, because that’s where the author makes their point. The rest is just to convince you of it’s validity. I have seen this true in most places, especially on the internet in blog posts.

Which is why I find myself wondering why I even write posts, every time I write a post. What am I trying to say? If I have something to say, is it worth an entire post? Do I need to convince people it’s true?

I just read a post about perseverence being the key to success, and it was quite long. At least 600 words. I read the first few sentences, then the first sentence of each paragraph and gained no new insights. The author spent their entire post trying to convince me that perseverence is essential for success in anything. Is that something that people need to be convinced of? Are there really people who don’t already know this? If so, would they likely be reading this article? I don’t think so.
The entire article could have been replaced with “Natural talent is mistakenly assumed to be largely responsible for success; perseverence has more effect on success”.

That’s what’s been holding me back from blogging a lot. I find it difficult to justify padding a simple point out to a “respectable” sized post. I think it’s time I embraced brevity.

Literati - Ruby based literate programming library

2011-08-15T00:00:00-07:00

Description

One of the big issues with development is how fast code
documentation becomes out of date, when it is written at all.

While programs are executed by computers, we write them mostly
for the benefit of other programmers, hence the proliferation of
high level languages such as Ruby and Python.

Literate programming is an attempt to solve this problem by
tightly coupling the code to the documentation, and to help
programmers write clearer programs for each other first, and for
computers second.

Literate programming was pioneered by Donald Knuth, and while there
are a lot of software packages to tangle/weave literate programming
files, there’s a wide variety of syntaxes for writing documents.

Literati attempts to keep the literate programming syntax as
close to regular text as possible, so you don’t have to think
about how to format your programs and documentation.

Literati keeps out of your way so you can do what you do best: code.

Status

This is still very much a rough proof of concept.

At the moment, the library is contained in one file: literati.rb.
There are 2 sample programs that you can run through Literati and it
will produce a Ruby and a Python based calculator.

I’m in the middle of a rewrite of Literati, in Literati format.
This can be found in the lib directory, however it’s not functional.

Source

http://github.com/tgittos/literati

Syntax

I’ve tried to keep the literati syntax as simple as possible. You should be able
to pick it up by just reading through the two sample programs, however there
may be some finer points that aren’t obvious.

Each code block must have a header, in the form of
== Identifier ==
The identifier will uniquely identify that code block, and allow you to reference
it later in the document.

You can optionally put more documentation after the header. This documentation
can be any format you wish.
After your documentation, you can close the documentation section with
@api, doc
This tag tells literati which documentation types this documentation block belongs to.

Then your source code comes next. You can terminate your source code by starting a new block.

At the end, you need a program description block, which looks like
== @filename.rb ==
The @ in the header marks the name of the file, and below the header block are code section
references, as defined in the unique identifiers above.

I know none of this documentation makes any sense, but considering this is still in dev,
that’s to be expected.

I’ll rewrite the documentation when I finish refactoring the code.

Modeler - 3D modeling in the browser

2011-06-08T00:00:00-07:00

Goals

3D modeling in the browser. No plugins, no programs to install. Just fire up a browser and off you go.

Status

[07-24-2011] Added in a directional and ambient light to the shader. Next up is point lighting.

[06-15-2011] Optimizations have been finished and merged into the master branch.
Next up is implementing a simple lighting model, and then work on setting up the interface to allow geometry to be
put into a scene.

[06-08-2011] I’m putting this demo page up because somebody on Github has asked to see a demo. This project is far
from nearing a state where you can call it a 3D modeling application. Right now, I have a basic renderer that can take
a scene made of some primitives and render it to screen. I’m working on optimizations because there’s currently a large
amount of overhead associated with getting objects to the GPU right now.
My goal is that once I’ve finished optimizing the core of the renderer, I can start designing a basic interface and
method of inputing geometry. Then I will perhaps release a stable version of the source.

Demo

Code

For the latest, bleeding edge code, you can go to Github and clone it locally.
There’s a terse readme that will describe how to get it up and running on your local computer.

There are no stable releases right now, as the project is very far from where it needs to be to live up to it’s goal.

Now On Jekyll

2011-05-27T00:00:00-07:00

I first started my blog in order to help myself learn. I figured that I would be motivated to write, and in order to fully explain things, I would force myself to do research and increase my knowledge on a given topic. So I set up a Wordpress blog, created a very simple theme and got started with it.

This was all good in theory, but in practice it didn’t quite work. This really bugged me, because I didn’t know why it didn’t work. I thought about it for a long time, and I think I’ve figured it out.

The reason it wasn’t working is because the way I think and do things is very different from the workflow of Wordpress. Wordpress is a very linear blogging system. Posts are displayed in the order they’re created, and if you want to do a series of detailed posts in multiple posts, you either need to do them one after the other, or you need to keep them as drafts until they’re all done.

I tend to work a little different. I like to do a lot of things at once, and nibble away at posts. I’ll write a little here and a little there, and generally take my time to produce content. This wasn’t working for me in Wordpress, and it was actually starting to make me feel bad.

So, I decided to change to a platform that’s a little more freestyle. I chose Jekyll because I decided to integrate my site with Github. Now I don’t have to worry about logging in to a web based control panel, because everything is handled with public/private key encryptions on Github, and it’s very easy to deploy to my sever with a post-commit hook that tells my server to do a git pull.

I’m also writing in textile now, which means that should I produce any content that’s worth publishing, converting it to TeX then to a PDF or something similar should be equally easy.

This is probably time for the obligatory “this is a work in progress” comment, and to say that things will be in flux for a while, at least until I get settled on a format/workflow that really works for me. I’ve been working with this for a while now offline, and it seems to be doing the trick, but there are still a few bugs to iron out.

You can also find all of my old posts still on the website, in my archives , however I couldn’t bring across all the comments, so to those of you who commented on my writing, thank you and I’m sorry.

Pivoting

2011-04-20T00:00:00-07:00

In start-up parlance, to pivot is to change the direction of your attack. Which makes it the perfect description for what I’m doing.

When I started this blog, I just wanted to build a name for myself out on the internet. I was aware that potential employers would probably be searching for my name, and I wanted to control the content that they found. I had no overall goals for the blog itself, other than what it would do for me.

Over time, it evolved into a place for me to share snippets of code and techniques that I’d found along the way. Each time I did something kind of cool, I’d write it up and post it online. While I hope that these snippets have helped people, and I know some of them have, I’ve decided that’s not really what I want to do with my blog anymore.

I’ve long held the belief that information channels in the human mind are serial. You’re either consuming information or you’re producing, but it’s very hard to do both at the same time. I’m a consumer, I always have been and I always will be. I’m fascinated by a whole bunch of different but loosely related things. I don’t have the time to write regularly while I’m trying to do all this cool stuff.

But there’s the rub: I like to write about what I learn. It helps order my thoughts and creates a reference document for me to refresh my memory from. It’s secondary to doing cool stuff, and a blog demands to be first choice when it comes to building audiences and producing quality content regularly.

I’m not well suited to the blog format of writing. I’d prefer to do something awesome, write it up and publish it, and disappear for another 6 months while I do something else awesome. And that’s exactly what I’m going to do.

Lately I’ve been working deep inside computer graphics, reading and learning and tinkering around in WebGL. I will be doing that for a while, and won’t be posting here much. But when I do, I’ll post all about the things I learn.

Between here and there, I will be migrating off Wordpress and onto Jekyll. These days I carry around a computing device of some kind that I can store files on, so web based access to content is no longer important to me. Jekyll will make the site faster, more secure and easier for me to change and deal with. I have no timeframe for this, and will publish none.

The Social Media Revolution

2011-02-15T00:00:00-08:00

I can’t remember exactly when I first started hearing about the so-called “Social Media revolution.” It was right when I was starting to really get into web development. It was easily at least 3 years ago, before Twitter had hit the mainstream like it has now. All I remember is that I didn’t buy into it.

I had been a member of a social network called deviantArt since 2001, and joined Facebook quickly after it opened it’s doors to people who weren’t in school. I had graduated when it reached Australia, and wasn’t able to create an account. I had interacted with people through an online media for a long time before I heard the phrases “social network” and “social media.” To me, all this talk from marketers and web designers about leveraging social media, claiming that social media was the way forward, was just that – talk, nothing but hot air.

I think today I can say that I understand the social media revolution. All it took was to get involved in creating a social network.

I have recently changed jobs to an Austin company that is busy building it’s business social network. Working as close as I am with their social network and learning about how they plan to leverage the community, I can see that I took the wrong end of the stick with regards to social media.

I’ve read a lot of criticism lately about Facebook, with critics saying that Facebook is a hollow way to interact with your friends. They say that it cheapens relationships, and waters down the meaning of ‘friend.’ This is the view I’d had of all social media in the past, and while it may or may not be a valid criticism of Facebook, it’s certainly not a valid criticism of social media.

I had a discussion today with a friend about the future of publishing. She’s in the publishing business, and is violently opposed to e-books and the effects they’re having on brick and mortar book stores. It was while I was explaining to her my vision of the future that I realised the value of social media. We were musing on the role of publishers in a primarily e-book formatted world where there was almost no hand selling done. She was worried about the authors that weren’t super stars, and how they would get eyes on their books in a world where you didn’t have covers to browse, and browsing had a greater friction.

I explained that it would be social media and social networks that would step in. Websites like Goodreads are a good start, where people share their opinions on books and list books they’ve read and want to read. You’d build a network of readers that you know, and know the tastes of, and that would provide the data you’d need to make decisions about new books.

It was then that I realised the true value of social networks. It’s a new way for applications to gather real, meaningful data in the most efficient way. By crowd sourcing data, you build a knowledge base in a relevant domain in a very hands off way. By leveraging this data, you can provide very personalised and useful functionality in applications. Rather than make assumptions about your visitors and users, you can obtain hard data and act upon it.

Safari and Firing Keypress Events with Backspace

2010-10-05T00:00:00-07:00

Whilst working on a project for a client that uses a lot of jQuery and ASP.NET AJAX, I found that the ASP.NET AjaxControlToolkit control MaskedEditExtender doesn’t quite work in Safari. The symptoms of the problem are the backspace and delete keys not working to clear the text in the mask.

A little too late for my project, there was a fix posted on the project’s Codeplex issue tracker (which I haven’t verified personally). It involves patching AjaxControlToolkit javascript in source to sniff specifically for Webkit browsers and compiling a new AjaxControlToolkit.dll.

Instead, I took the extenders out and replaced them with a custom jQuery date mask. I researched a few of the more popular jQuery plugins that do that, but found they didn’t quite work the way we wanted them to, so I had to roll my own.

Stupidly, I tested mostly in Firefox, and after a while got it working pretty well. I went to test it in Safari, and it didn’t work. I feared all the work I had done was for naught. I took a quick look in Safari’s javascript console and found that Safari wasn’t firing keypress events for the backspace key, which is what my plugin was listening for.

As it turns out, this was a known issue with Webkit browsers. I tested around and figured out that it was just the keypress event that wasn’t being fired. The keydown event was being fired fine. So I switched my plugin to listen to the keydown event instead of the keypress event, and that resolved the issue.

So if you want to support Webkit browsers and you’re doing key press detection for ‘special’ keys, use the keydown event instead of the keypress event. It will save you some frustration.

Evaluating JSON in Safari

2010-08-13T00:00:00-07:00

Just a quickie on parsing JSON strings in Safari.

I’m in the middle of a project developing a timesheet/rostering application, which uses a lot of Javascript. I have a series of web services that interact with jQuery. For reasons beyond the scope of this post, the web service returns a JSON string, which needs to be parsed into a JSON object, and then further processing is done on the object.

I had a bug where Safari was choking on the JSON string returned by my webservice, yet Firefox and IE were happy parsing it. As it turns out, my JSON string had a Javascript keyword in it; ‘break’.

Here is my JSON string (well, an example):

Safari was choking on the break in the above JSON string. When I wrapped the attribute in single quotes, like so:

it was happy.

You can replicate this by using the below code snippet to parse out your JSON string quickly in Safari’s debug window:

which should fail. If you add the single quotes around break though, it should work just fine. This also fails for other Javascript keywords:

fails. If you wrap if in single quotes, it works.

I think the take away lesson is to always wrap your object attributes in a JSON string in single quotes, otherwise Safari will choke on it.

Autostart a VPN in Windows XP/Vista

2010-03-10T00:00:00-08:00

Autostart a VPN in Windows XP/Vista

Just a quick one today, and it’s exactly what it says on the box.

I was unreasonably inconvenienced by the need to manually dial into my works VPN everytime I start my computer up. For some reason it really rubbed me the wrong way.

A few days ago, I finally decided to solve this niggling problem once and for all. Here are the steps you’ll need, assuming you already have the Windows VPN client configured for a VPN:

Save your authentication details in the connection
Set the VPN connection to not prompt for user details (Start → Connect To → right click on your VPN → Properties → Options → uncheck “Prompt for name and password”)
Create a .bat file somewhere safe, and put in it the following: rasdial "Name of your VPN Connection"
Create a shortcut to this .bar file
Put this shortcut into your startup folder

Now, the next time reboot, your VPN should start as soon as you get an internet connection.

ProxyBotLib

2010-02-19T00:00:00-08:00

A library for connecting a .NET based bot to the Starcraft Brood War API http://code.google.com/p/bwapi/. Contains source for the BWAPI socket communication dll and the .NET proxy bot.

Available from Github.

Created for use with the EIS Starcraft AI competition http://eis.ucsc.edu/StarCraftAICompetition

Based on http://breakablec.redirectme.net/svn/repos/trunk/StarProxyBot_net/ which is based on http://eis.ucsc.edu/StarCraftRemote

Getting Started

This library is intended to aid an external, .NET based AI bot to connect to the BWAPI socket. To get started, create a new console application which will be the base for your AI agent. Add the ProxyBotLib project to the solution, and add to the console application a reference to ProxyBotLib. There is a sample agent in ProxyBotLib.Tests that you should move to the console application. Create an instance of the agent, and create an instance of the ProxyBot, passing the agent to the constructor of the ProxyBot.

Example


[STAThread]
public static void Main(System.String[] args)
{
    StarCraftAgent agent = new StarCraftAgent();
    ProxyBot proxyBot = new ProxyBot(agent);

    try
    {
        proxyBot.start();
    }
    catch (SocketException e)
    {
        Console.Error.WriteLine(e.StackTrace);
        System.Environment.Exit(0);
    }
    catch (System.Exception e)
    {
        Console.Error.WriteLine(e.StackTrace)
    }
}

ASP.NET GridView with an ObjectDataSource

2009-10-26T00:00:00-07:00

Just a quick tip:

I got the following exception today:

If a data source does not return ICollection and cannot return the total row count, 
it cannot be used by the GridView to implement server-side paging.

If you’re trying to return an IEnumerable from your select method, try changing it to a List or an array. That should clear the problem right up.

Going Dark

2009-10-13T00:00:00-07:00

Nearly 12 months on from the start of my blog (the first post went up at the end of November 2008), I’m finding less and less time to do the quality kind of writing I have set out to do. I feel that, as I change, so too does my website need to change.

As much as this site is currently a programming blog, it’s also my electronic representation. The website shares my name, and is representative of me. There’s more to me than just programming. For a while I’ve tried blogging or writing about non-programming related topics on another domain, however I don’t feel this is fair to myself.

I guess the best way to describe myself is an aspiring polymath. I have an interest in a broad range of topics, notably programming/computer science, mathematics and art. This website doesn’t really represent that. I can’t maintain multiple websites to separate various areas of my life – I’m a single person with multiple facets, and I should have a single website, with multiple facets.

Additionally, I find myself with less and less time to devote to this kind of writing, as it slowly makes it’s way down to the bottom of my priority list. Currently I’m trying to rekindle my math education by going back to basics, learn Punjabi so I can impress the fiance’s parents, do several programming projects at once and get back into doing art regularly, and writing is a very far last.

So, all that lead up to say that I’m going dark, and will be overhauling the site sometime in the future. I’m going to change the format of the site so that it more accurately represents me as a whole, is better organised and has a nice format that allows me to post quick, smaller posts that can be filtered out when subscribing to RSS feed. I may or may not stick with Wordpress – I think I’ll probably start hacking away at Enki and do some funky stuff with wildcard subdomains or something.

All older posts will remain, as a few of my posts are rather popular (by more than 50% compared to the rest of the site) and I suspect they’re really helping people out.

Mario AI Competition 2009 - Getting Started

2009-08-25T00:00:00-07:00

Programming is fun. That’s why I decided it would be a good career for me. I love solving puzzles, and I love the concept of making computers, these mysterious boxes of my childhood, do things. However, when you finally get to working as a professional programmer, the types of projects you get to work on are often not as interesting as you’d like. This is why I am interested in AI. AI presents new and unique challenges, and techniques of approaching these challenges. I said in a previous post that AI was more commonplace than you’d think, but didn’t really follow it up with suggestions of where you can work on AI related programs.

I’ve recently stumbled on an interesting AI competition (before it got big with the video – I’ve been writing this post for about a month), based off of an open source Java project called Inifine Mario, called Mario AI Competition 2009. The competition is to create an AI agent that can navigate randomly generated Mario levels, pitting each agent against each other. The first round of this competition has already closed, however there is another round that closes September 3.

I won’t be attending the conferences nor will I be submitting agents to the competition. I will however work on a few agents, as this is probably the most fun application of AI that I’ve seen in a while, and it’s a small enough environment to enable me to get very familiar with it very quickly, and hence get into making solutions very quickly.

On the surface, this seems a trivial, niche problem. An agent that can navigate a video game level doesn’t really have a lot of diverse applications. However, it’s a great way to begin practicing some fundamental concepts of AI. The parameters of the competition don’t limit the techniques you can use to create the agent. In the video below, Robin Baumgarten is using A* path finding techniques.

However, A* is just the start, and is a fairly basic approach (though it works pretty well by the demos), and there are many more options, including machine learning and neural networks. Unfortunately, I won’t be covering any of that yet. The goal of this post is to get myself, and anyone else interested, up to speed on the environment, and the basics of creating an agent. I will be creating a very simple reactive agent that has no planning, and is quite flawed. However, you should be able to walk away with a firm grasp of how the environment works and what tools you have at your disposal.

Before I go on, a disclaimer is necessary: I haven’t worked with Java since my university days, so about 6 years or so. I will post some code, and that code will probably suck. You have been warned.

The Game Environment

The details on the code available from the competition website are fairly vague, so I’m posting this to perhaps help some people who are interested in getting into it, and also for my reference to help while working on it. Firstly, obviously, you’re going to have to download the code available on the competition website. The code is relatively stable at this point, however it was constantly being updated with fixes for bugs posted on the Google Group for the competition. These changes would be posted on the group, so I’d check it regularly, or grab it from Google Code with svn, and just update your repo regularly. Once you’ve downloaded it, open it in your IDE/editor of choice, and roll up your sleeves.

Firstly, I’m going to reference classes by their fully qualified class names; ie: ch.idsia.scenarios.Play, which references Play.java located in the src/ch/idsia/scenarios folder. This way you can play along at home.

According to the online documentation, you can fire up a run by typing
java ch.idsia.scenarios.Play
from within the “classes” directory. This will start a copy of the Infinite Mario game with a human player. To start with a pre written agent, type
java ch.idsia.scenarios.Play ch.idsia.ai.agents.ai.ForwardJumpingAgent
to start with an agent that will run forward and jump as soon as it can.

The ch.idsia.scenarios.Play class is a simple class that sets up the agent, whether it’s human controlled or automated, and then it sets some play environment variables and runs the application. If an argument is supplied, it will attempt to instantiate an instance of the class and pass it through to the play environment.

I won’t be covering the the details of the simulation code, as it’s all pretty logically separated and you don’t really need to know how to do that. Information is passed through to the agent through an implementation of the interface ch.idsia.mario.environments.Environment. This argument to the getAction function provides the agent with a serialised view of the terrain and the location of enemies, along with information about Mario. Basically, any information you can get by looking at the scene.

This information is provided in the form of a byte matrix, through several functions. observation.getLevelSceneObservation() will return a matrix with details of the terrain. It will also tell you what the type of the terrain is, such as a pipe or a one way platform. This detail is found in ch.idsia.mario.engine.LevelScene. You can see the number codes for the different types of terrain. It’s broken down into gaps, hard borders, half borders and flower pots.

The observation.getEnemiesObservation() is very similar to observation.getLevelSceneObservation(), except it addresses enemy locations. Again, you’ll also get the type of the enemy from the matrix in the form of an integer code, which you can find in ch.idsia.mario.engine.sprites.Sprite.

I’ve written a debugging function that will output both the enemy and terrain matricies to give you a code view of what’s going on. It’s interesting and enlightening to watch the code view of the simulation next to the simulation itself, and it will help us write code to fit our design. The function is as follows:

I put the above code into a function in the agent itself, and called the function from the getAction function of the agent, purely because I know this is going to get called once per tick. You can put it wherever you want to put it.

Creating a Dumb Agent

As I mentioned at the start of this post, I'm just going to start with creating a very simple, dumb agent that will attempt to traverse the level, and even then not get it right all the time for reasons I will cover. On the surface, Mario's tasks for navigating a stage without enemies is pretty straightforward. All he needs to do is to get himself around the level and jump over pits. However, sometimes Mario can find himself falling into a gap, or over-jumping his mark and jumping into a hole. So basically, we need to check if there's something in Mario's path that needs to be jumped over, or if there's a gap that we need to jump over. But, we can't just jump - we also need to check if jumping is going to put is into a gap and kill Mario, and if Mario runs off of where ever he is, he might fall into a hole. This would be fairly straight forward if we had a robust method of predicting where Mario's jumps will take him, but unfortunately we don't officially get this information. There is a movement algorithm in ch.idsia.mario.engine.sprites.Mario, which starts at the move method, however, not only is this not in the spirit of the competition, but more importantly, it's very hard to figure out, for me at least. I've not been able to reliably modify the movement code to act as a predictor of Mario's path if you plug-in how long to hold each key for. Hence, at this stage, we'll just be making Mario go right and try and jump over obstacles. Seems fairly simple. You'll see in the provided agents that the function getAction is the heart of the agent, and an instance of the Environment interface discussed before. This function is the work horse of your agent, as it will tell the simulation what the agent is going to do. Although the observation.getLevelSceneObservation() and observation.getEnemiesObservation() methods return the full view of the level, all the features are jumbled together. Later on, we'll need to know what's a cannon and what's a pipe, and what's raised ground, and maybe even what's a block we can punch. We'll need to know this because cannons shoot Bullet Bills and enemy flowers live in pipes, and these can appear at any time, and if Mario is near by, he's going to get hurt. I've created the following function to categorize the environment into pipes, cannons and pits:

The three variables are defined as private members of the agent, and calling this function will populate them with tile locations in the case of pipes and cannons, and tile columns in the case of pits. You don’t have to do this with such a simple agent – you can simply use similar techniques to parse over the whole level state.

I use this information to determine how far away obstacles are. At first I was going to make the distance between obstacles affect the jumping distance and height, however without an accurate way to determine where jumps are going to land, this can actually cause more harm than good. So I ignore it, and just use a fairly blunt approach.

Firstly, another helper function:

This function takes a Vector and will return the closes tile to Mario, depending on his direction. It's a very coarse way to determine the closes obstacle to Mario. Bear in mind that it doesn't recognise when obstacles are put close together, thus doesn't optimise Mario's jumping. The goal of the agent is to jump over the closest obstacle. That's it. Considering our obstacles are now in three different datastructures (cannons in one, pipes in another, and pits and raised terrain in the original byte array), we need to store the delta (distance between Mario and the closes obstacle) and update it only when we've found a smaller delta. Also, I want to keep the delta of any pits separate, as I'm going to have different rules for pits than other obstacles (because pits are the only thing that can kill Mario at this stage). To this end, I create two integer variables at the top of the getAction method. They are intitialized to 11 because this is where Mario is:

Here is the code to extract the delta of the nearest obstacle, and the delta of the nearest pit. Note that levelState is the results from a call to observation.getLevelSceneObservation:

Once we have the deltas, we can use this information to decide what to do. I mentioned above treating obstacle deltas different from jump deltas. This is an attempt to make Mario take smaller jumps when he can see a pit is after an obstacle. This is controlled by two instance members that keep track of jump height and jump length, called jumpHeight and jumpLength respectively. This is very hit and miss. Notice that Mario does not respond to anything more than 4 tiles away, and tiles that are behind him. This is to prevent him from going jump crazy:

Finally, the maintainJump method is to ensure we’re holding down the jump key for the optimal amount of time. It is also coded to provide rudimentary control over jump height and length, however this isn’t being taken advantage of.

The complete agent is at the bottom of this post for you to download and include in your project. Simply put it in the path src/timgittos, configure the ch.idsia.scenarios.Play class to have no enemies, with options.setPauseWorld(true), and run any level you want (passable result with difficulty 3). Then build the project and run it with java ch.idsia.scenarios.Play timgittos.BlogAgent.

As you will observe, the agent will make Mario go towards the right as fast as possible, jumping over obstacles as it meets them. For the most part, it works well enough. However, there are quite a few fatal flaws, and I will explain why it fails in this way.

Most obviously, the agent frequently falls down gaps. It doesn’t fall down all gaps – which would indicate that it’s not a failure in the gap detection, but rather something else. In fact, what’s going on is that the gaps that Mario tends to fall down are those that enter his field of consideration (4 tiles ahead of him) while he’s in the air. The agent makes no effort to check whether it’s jump will land Mario in a pit (since it can’t predict where Mario will land), and my previous efforts at trying to make the agent force Mario to the left when it detects he’s going to go down a pit have failed.

Mario will also fall down pits if there are multiple pits in a row. Again, this is because the agent doesn’t exert much control over the size and length of Mario’s jumps ,and so can’t pin point that it wants to land in the middle of the two pits, so it tends to overshoot the jump and fall down the second pit.

Most annoyingly, the agent will sometimes get stuck. If it reaches an obstacle, such as a cannon or a bit of wall or a pipe and jumps at the wrong angle, it will enter a weird wall jump loop, where it jumps, gets stuck on the obstacle, jumps off, jumps again, and gets stuck again. This will loop until there is no time. This is a side effect of the environment allowing wall jumps, which is cool when you can get the agent to make Mario jump out of a pit he’s falling into, but annoying when he gets stuck.

In any case, this agent is far from complete, and just serves to demonstrate how the simulation environment works, and how to interact with it. Once you’re clear how to work with the simulation, you can concentrate on building a useful agent, either by starting from scratch (like you would if you were going to use a machine learning approach), or by building on top of this base (for a determinate approach like A*).

Download: Mario AI Blog agent (.java)

Configuring webHttpBinding When Using WCF with JQuery

2009-06-24T00:00:00-07:00

Firstly, a disclaimer: I don’t have a lot of experience working with AJAX enabled WCF services, and from reading some of Rick Strahl’s posts on using JQuery with ASP.NET, I’m doing things in a really hackish and terrible manner. Hopefully my mistakes won’t impact the usefulness of this short tip.

When working with JQuery and AJAX enabled WCF services, I recently encountered the following error, through Firebug and Fiddler:



The maximum string content length quota (8192) has been exceeded while reading XML data. 

This quota may be increased by changing the 

MaxStringContentLength property on the XmlDictionaryReaderQuotas 

object used when creating the XML reader.

This is caused by WCF webHttpBinding default having fairly draconion limitations on XML message length and depth. This thread on MSDN helped diagnose the problem, however it didn’t do much to help me solve my particular problem. Ultimately, I stumbled upon the solution quite accidentally.

Firstly, as per the MSDN thread, you need to add the custom binding configuration underneath the configuration section:
[xml]

[/xml]

At first I thought this was a custom binding, and tried to replace the service endpoint binding to the custom binding defined above, however this was causing an “System.ServiceModel.ServiceActivationException” exception.

The above binding declaration is actually a configuration for the webHttpBinding. As such, you need to add the BindingConfiguration property onto your service endpoint, along side your binding declaration. This is as follows:
[xml]

[/xml]

This will allow you to send larger messages to your WCF services via AJAX, and get on with creating applications.

Going Camping with CouchDB On OS X Tiger

2009-06-12T00:00:00-07:00

With Snow Leopard being released at the end of September this year, Tiger is definitely starting to show it’s age. I’ve been putting off upgrading to Leopard for quite some time, not being able to justify the down time associated with upgrading an OS. This has had an unpleasant side effect of not being able to do things quite as easily as I want, and finding information is hard.

Due to the recommendations in the comments of my Ruby CMS article, I have decided to start playing with the Camping Ruby microframework backed by CouchDB. Getting Camping up and running was easy enough, and I managed to get some trivial functionality going. Camping uses SQLite for it’s database, which is fine if I wanted to massage my data into a relational form. However, I have models with optional attributes, and rather than making nullable database types, I want to leverage CouchDB’s schema-less, RESTful document storage. Each persisted object in my application will be available on a unique url, so CouchDB is a nice fit for what I want to do.

The Great Installation

I found this great article about getting Camping talking to CouchDB, and it seemed easy enough, so I decided to try it. Since I already had Camping working, all I needed was to get CouchDB installed on my Macbook. As much as I’m not scared of compiling applications from source, I’ve had issues in the past with OS X and compiling, so I decide to find a simple package or disk image to install. I found CouchDBX, however checking the requirements showed that it supports Leopard only.

With a little more research, I found out I had to use Macports to install CouchDB. Macports relies on XCode Tools which come available on the DVDs that came with OS X. If you haven’t previously installed XCode Tools, then you should install them before you install Macports. Something that is buried in a support ticket, however, is that Macports targets XCode tools 2.5. My XCode tools was something like 2.4.8. While I did manage to get Macports installed, the installation for CouchDB fails when it tries to build tk. If you, like me, have an older XCode Tools than 2.5, you’ll need to download 2.5, which you can find deep inside the Apple website. This does require an Apple Developer Connection account to get, so if you don’t have one, you’ll need to create one.

Installing CouchDB is as simple as issuing
[bash]
sudo port install couchdb
[/bash]
and Macports will take care of the rest. CouchDB lists it’s dependencies as Spidermonkey, Erlang and a few others, however each of those has dependencies, and each of those dependencies has dependencies, and it ends up taking quite a long time and downloading a fair few packages. The upside is that if you didn’t have Erlang previously installed, you do now. Erlang is something I’ve been wanting to take a look at.

Start The Server Before You Leap

While the article I linked to above about getting Camping and CouchDB talking is good, it’s not exactly the most verbose explanation especially if you haven’t read the documentation for CouchDB and prefer to just dive in. For those who are still a little unsure like I was about how exactly to do this, I’ll outline my approach below.

Before you get started writing any code at all, you need to start your CouchDB server. This is something that escaped me for the longest time, and when I finally twigged, it gave me a bit of grief. To start CouchDB, issue the following command:
[bash]
sudo couchdb
[/bash]
If you try this without escalating privilege, it will return an error "{"init terminating in do_boot",,[{couch_server_sup,start_server,1},{erl_eval,do_apply,5},{erl_eval,exprs,5}, {init,start_it,1},{init,start_em,1}]}}", which searching for will bring you to the CouchDB wiki page for error messages. This page will tell you the problem is an unavailable port. For me, at least, this is not true. CouchDB runs on port 5984 which as far as I know is not used for any system services or other software. The reason I was getting this error was that I wasn’t running it with enough privilege.

Once you get CouchDB started, you’ll notice it blocks the terminal. I don’t like to have too many windows open at once, so I’d prefer to have it run as a background process. Fortunately CouchDB will let you do that with a command line switch option, along with changing the location of the pid file. I’ll leave figuring out how you want to start it up to you.

Once you have CouchDB started, you’ll have access to a web-based administration panel called Futon. Futon is available to you at http://localhost:5984/_utils/, assuming you’re running CouchDB on your local host. The Futon utility will allow you to create databases and insert documents in preparation to test your connectivity with Camping.

Camping Time

There were two Ruby gems I had considered when deciding how to connect Ruby to CouchDB. I should point out that due to the RESTful nature of CouchDB, you strictly don’t need any Ruby gems and could roll your own fairly easily, if you wanted to. I didn’t want that level of control, personally. The two gems I considered were CouchRest and RelaxDB. CouchRest is a simple Ruby wrapper around the CouchDB REST API, whereas RelaxDB is more abstracted, bringing ActiveRecord-like functionality to CouchDB. While before I would have chosen RelaxDB, I’m intentionally trying to work a little closer to the raw APIs here, so I chose CouchRest.

You can install CouchRest through RubyGems:
[bash]
sudo gem install couchrest
[/bash]
however I found that the gem version wouldn’t work and kept throwing errors when I started my Camping application. To overcome this, I just cloned it from the GitHun repository and placed it in my Camping app directory and referenced it that way.

The first thing to do would be to create a normal Camping sample application, if you haven’t done already. For the purposes of this post, I’m going to use the “”http://camping.rubyforge.org/files/README.html">skeletal Camping blog" application used in the documentation, and edit that to work with CouchDB. I figure this will give everyone a relatively common base from which to start. Import CouchRest just below where the application imports Camping:
[ruby]
require ‘camping’
require ‘couchrest’ # or ‘couchrest/couchrest’ or similar if you’ve cloned from Github
[/ruby]

Given that the purpose of this article is to demonstrate connecting to CouchDB, and not the design of a framework around it, we can safely ignore defining a model for now, and rely on CouchDB as our model. So if you’re following along from the example application, you can safely delete the classes from Blog::Models module. We’re not going to delete the whole module, because of the create method.

The Camping create method that is run when the server starts up your Camping app. From the documentation, “This is a good place to check for database tables and create those tables to save users of your application from needing to manually set them up.” Instead, we’re going to use this method to set up CouchRest in our application:
[ruby]
module Blog::Models
def Blog.create
db_url = ‘http://localhost:5984/’
storage = CouchRest.database(“#{db_url}blog”)
Blog::Controllers::Index.set_storage(storage)
end
end
[/ruby]

Next, because we’re now calling a new method on the controller class, we need to modify that. Change the Blog::Controllers::Index class to the following:
[ruby]
module Blog::Controllers
class Index < R ‘/(\w+)’
def Index.set_storage(storage)
@storage = storage end def get(id) @post = @storage.get(‘posts/’ + id)
render :index
end
end
end
[/ruby]
What I’ve done here is given the controller class a static reference to my CouchDB database (from the create method). Then the controller was changed to respond to a regex, which is passed into the get method. We use the id passed in to retrieve a document from CouchDB, which we assign as an instance variable.

Lastly, we need to modify the Index function view to pull data from the CouchDB database:
[ruby]
def index
h1 @post[:title]
end
[/ruby]
This will output the title of the test document created at the start of the article.

If you haven’t already, start up Futon and create a database for the purposes of this demo. Call the database “blog”, and fill it with a test document with the id of “posts/test”, and at least a “title” property with the value “Test Post”, and any other properties you wish.

Start the Camping application with camping blog.rb, and point a browser to http://localhost:3301/test, and you should see “Test Post” in a header tag, rendered out to the browser, which means that Camping has successfully communicated with CouchDB.

I didn’t cover putting data into CouchDB, however you would do it in a similar vein, writing a post method inside your routes to create data and save it to CouchDB. From here, personally, I’m going to create some wrapper classes for requests and models and build up something which is a little DRYer, however as far as a demo, this is good enough.

My Best Guesses About Wolfram Alpha

2009-05-19T00:00:00-07:00

Following the “soft launch” of Wolfram Alpha a few days ago, I’ve been wondering exactly how Wolfram Alpha works. From the description of all the hype leading up to it, it seemed like a question answering application that is specialized in answering questions, as opposed to say Google, which is more into finding and presenting data, leaving the interpretation to humans. Now that it’s here, we can have a play around and see what it can do.

Firstly, I tried to ask Wolfram Alpha how it worked, and it just gave me a puzzled look. So I can only guess, and guess I shall.

The Wolfram Alpha website lays it all out on the table, with regards to what it’s all about. Wolfram Alpha’s goal “is to accept completely free-form input, and to serve as a knowledge engine” to answer search queries entered. From the very limited playing I’ve done, it seems pretty cool.

Following my move from Perth to Texas, I typed in “”http://www.wolframalpha.com/input/?i=austin+to+perth">Austin to Perth" into Wolfram Alpha just to see what it told me. I got back map, with a line drawn between the cities. I got the distance in miles between the two and the flight time. I got a side by side comparison of the local times, populations and approximate elevations.

Google however, delivered me what I was actually looking for, sort of. Maybe that’s just a difference in expectations and thinking.¹

It’s clear that Wolfram Alpha is pretty cool, and will do some awesome things with the data before it returns it back to you, but it doesn’t really help me figure out how it works. My thoughts are that Wolfram Alpha combines a large database of indexed knowledge in the form of a knowledge base and a powerful logical language, the language being Stephen Wolfram’s own Mathematica, naturally. As he describes it, Wolfram Alpha is the “killer-app” for Mathematica.

First, lets discuss the vast store of data available to Wolfram Alpha, most likely in the form of a knowledge base. A knowledge base is an information representation scheme designed to allow information to be operated on using logic. Information is stored in “sentences” in a knowledge representation language. The knowledge base allows logical agents, in this case the Wolfram Alpha application, to receive queries, and then search and analyse the knowledge base, performing logical inferences and information compounding, then collating it and returning the results. The logical agent does all the heavy lifting, but the very structure of the knowledge base helps the agent.

The heart of the logical agent is it’s knowledge representation language. It allows the agent to “reason” through sentences and make inferences in order to derive new facts. Proposition logic and First-order logic are both knowledge representation languages. Knowledge representation languages use syntax and semantics to define knowledge, where syntax outlines the structure of a language, and the semantics are the meaning.

Logic is a very mathematical concept, and mathematics can be seen as a kind of logic that operates on numbers. Mathematics has a syntax, that defines the infix notation of logical operators on operands, and the semantics are what those operators do. 1 + 1 = 2 is an example of a complex logical language, where the syntax defines that the + operator acts on each 1, and the = operator defines the result of the previous operation. The semantics define that the value of 1 + 1 is 2.

Mathematica, the heart of Wolfram Alpha, is a computational language, according to it’s Wikipedia page. It’s built on top of the Symbolic Manipulation Program, designed by both Chris A. Cole and Stephen Wolfram. The Symbolic Manipulation Program is a “computer algebra system”, which facilitates symbolic computation, allowing computers to operate on symbols and manipulate expressions instead of operating on their values, which sounds a heck of a lot like something that could be used to create a logic that can operate on a knowledge base.

Going back to logical agents and knowledge bases, there are a number of ways logical agents can extract and infer information from knowledge bases. The topic of knowledge based logical agents is a pretty vast one, and I couldn’t possibly explain it completely in a single post, even if I knew more than just a fraction of it, which I don’t. But I can summarize what I do understand, and how it applies to Wolfram Alpha.

As referred to often in the post so far, inference or entailment plays a large part of how a logical agent can extract “new” information from a knowledge base. Inference is deeply rooted in formal logic, and techniques have been developed to allow automated software processes to apply it to a knowledge base.

Logical entailment is the idea that a sentence “logically follows” another sentence. If a given sentence a is true, and the truth of sentence b depends on the truth of a, then b must be true, and also that if b is true, then logically a must also be true. This is useful if the knowledge base doesn’t contain the fact that one of a or b is true, but it does contain definition that the truth of b depends on the truth of a.

The knowledge base is designed to be a model of reality, and holds sentences about the world intended to describe it to a level of detail. Sentences can be as atomic as facts, such as “the sky is blue”, or can be logical sentences such as “if the sun is in the sky, it is not night”, which of course has exceptions (such as in certain seasons in the polar regions), which also need to be modeled in the knowledge base.

This is relevant because, with a finite model represented by the knowledge base, there are a finite number of entailment and inferences that can be made on the model, which means that a logical agent such as Wolfram Alpha can reduce the world to a finite search space, and can run a search over this space looking for information that follows on from the set of facts in the knowledge base.

Search techniques for searching the knowledge base are similar as search techniques in other AI based problems, such as constraint satisfaction problems and touring problems. These searching algorithms include backtracking and local search methods, such as hill climbing.

When searching this knowledge base, the logical agent needs to abide by a series of rules, known as inference rules, in order to guarantee the the knowledge it entails and infers is valid.

Firstly, the logical agent needs to be aware of the equivalence of two logical sentences. If two sentences are both true under the same model, such as the Wolfram Alpha knowledge base, then they are logically equivalent, and can be used to format facts in a different way to aid inference.

Secondly, the logical agent needs to be aware of the concept of validity. A sentence is valid if it is true in every model, which essentially means it’s a tautology and is always true. These tautologies are useful because they aid in validating inferences, where a infers b if a implies b is a tautology, where implication is such that b is true if and only if a is true. This can get a little confusing, and if you can, I’d suggest you read Chapter 7 in AI:AMA
.

Thirdly, it needs to ensure the sentence is satisfiable, which means it’s true in at least one model, which is basically just searching for inferences and determining that, for a given search space state, the inference being suggested is true.

The logical agent and inference/entailment from a knowledge base can be observed in Wolfram Alpha with a fairly simple query: “”http://www.wolframalpha.com/input/?i=red+%2B+yellow">red + yellow". In this query, the logical agent would probably hit the knowledge base and tell it that both red and yellow are true, meaning that we want to find information about those. It would then search for all sentences that are entailed or logical structures that mention the fact red or yellow, such as a sentence “orange is a mix of red and yellow”. It would then tell the knowledge base that this fact had been entailed, and tell it that orange is true. Then, when it finds the sentence “blue is complementary to orange”, it can add that to the record set. Obviously there will be other sentences in the knowledge base, and the agent will have to use a filtering algorithm to determine which sentences and facts are relevant to the query, otherwise it might return results that the user is not interested in.

To successfully parse the search query, it would also need a measure of natural language processing, so that it can convert a human-readable query into a machine readable query. This, combined with a large, extensive knowledge base, a fast logical language such as Mathematica and AI techniques for inference and entailment of knowledge mean that Wolfram Alpha can answer a wide range of questions that a simple indexed and categorised search engine couldn’t.

However that’s just my best guess. And keep in mind who I am: I’m just a young web developer with an interest in AI. I don’t actively participate in AI research, and I have no formal training. My guesses and musings are probably widely off the mark, and if anyone has any other ideas or corrections, clarifications or discussions, I’d love to hear them in the comments.

If you mistype a search query into Wolfram Alpha, curiously it won’t suggest a correction. Considering how relatively easy this task is (just use it’s Levenshtein Distance), I find it odd that it doesn’t support this.

Now Appearing In Austin, Texas

2009-04-26T00:00:00-07:00

This blog has gone dark over the last two or so weeks, but for a very good reason. On the 21^st of April, I flew from Perth, Western Australia to Austin, Texas, where I will be staying for the next 6 months. For those not acquainted with the trip, it’s half a world away at over 13,000km, for a total flying time of 29 hours not including layovers (for my trip, anyway).

I’ve been spending the last week settling down here in Austin, and the week before that preparing for the trip. I’m still suffering from some jet lag, and catching up on the last 8 months with my girlfriend, who I hadn’t seen since August 2008. I haven’t had the time nor the concentration required to write a blog post, and I haven’t touched my Google Reader account, which I can see has over 1,600 unread articles.

However, I do have some interesting posts coming up. I’m planning a response to an AI article that was linked to me in a comment, a more in depth look at the importance of searching by solving the 8-Queens problems in Python using some different search techniques, and a look at creating some graceful degradation control adapters for ASP.NET server controls that don’t work without Javascript.

So, don’t unsubscribe from my feed in your readers, the blog isn’t abandoned, life has just taken priority over it. When things settle down, I’ll start writing articles again.

Where Do We Draw The Line On Complexity?

2009-04-15T00:00:00-07:00

I’ve got a few posts planned about AI and HCI, however these require a lot of time to research and write code for, time that I don’t have given I’m flying to the US on the 21^st of April. So I apologise to people who saw my last AI article on Hacker News and Reddit and subscribed to my feed expecting more of the same. There will be more, I promise. I just need more time. For now, just some musings.

I’ve been thinking a lot lately about solving problems. I read a number of programming aggregators and startup blogs, and the term “solve a problem” keeps nagging at me. To be successful, at programming and business, you need to solve a problem. I’d love to eventually run a development company, but I don’t know what problem to solve. So, I consider the problem my current employer is solving.

I currently work for a web development company that is doing fairly well. We have a suite of products that we sell to our clients, and sell services related to those products. They’re doing well, so obviously, they must be solving a problem. So, from “client” point of view, the problem we solve is that of letting people who don’t know anything about websites build and run complex websites.

We have a CMS product that allows non web geeks manage websites. This includes writing new pages and editing content on existing pages, publishing news items, distributing these to an email list, managing uploaded files and inserting modules of dynamic content to their hearts desire. The modules we offer include contact forms, random image rotators, resume upload controls, auto-generating bread crumbs and menus, and so on. These modules aim to reduce the complexity of managing dynamic sites, so that ordinary people can do it.

On top of that, we do custom applications built on top of that CMS site. Clients have a site they run themselves with the CMS, but some also have dedicated applications with a separate interface. These are separate because they’re custom jobs. They provide functionality that is not available in the CMS (yet), or functionality that would be too complex to maintain using the CMS. So again, we’re reducing the complexity of running a custom application.

So, on first looks, we build websites and applications that non-geeks can use. But looking further, we manage complexity. We reduce the complexity for the client, so that the client can do difficult things with ease, and don’t have to know how it’s done, only that they can do it.

On the other hand, good programming is about managing complexity. That is, trying to keep your code as free from complexity as you can get away with while still doing the job. Complex code is buggy and unmaintainable.

Complexity exists, and it is immutable. Once you’ve simplified a task to the point that the only steps involved are those that accomplish that task, and that task cannot be accomplished without those steps, you have your complexity, and it isn’t going anywhere. The task cannot be made more simple, because to do that we’d have to leave out steps, which would not accomplish the task.

What we do from then on is delegate complexity, shift it around and make it other people’s problem. Take for example, the task of creating and publishing a blog post. Our software has tagging, categories, post titles and post content. Creating a post involves writing a post, giving it a title, adding tags, selecting categories and publishing it.

Breaking it down, we need to create a body, create a title, create all categories, create all tags, link the tags to the post, link the post to the categories and publish it. Each link has a display name and a URL slug, and each category has a display name and a URL slug. URL slugs cannot contain certain characters, however their display names can.

Now, we can delegate this complexity to the user, which will result in simple code. The user will be responsible for creating tags and categories, and giving them URL slugs that fit our rules, while the application will just take the data and store it, and retrieve it when asked. The user will be responsible for assigning tags to the post and the categories, and the application just stores it. This is obviously an unacceptable level of complexity for the user.

We could also delegate all the complexity to the application, making the user experience simple. The user just types in the tags they want, picks the categories, and the application will link the tags if they exist, create them if they don’t, automatically strip unwanted characters from URL slugs and hide a lot of the complexity. In more complicated cases, this will result in very complex code that will be bug prone.

So the question is, where do we draw the line? What balance of code complexity and user interface complexity is successful? I guess you could say “make it 50/50” and think that’s good enough, but I don’t agree. I think the balance is very contextual, and often leans in favour of code complexity. In simple examples like above, taking on all the complexity of the task in the code is a trivial thing and easily done. For nuclear reactor control software, things might not be straight forward.

This is the key to a successful software product/business, I think. Finding the right balance between complexity. If you put too much complexity on the user, user’s won’t be able to use it, and your software won’t sell, and the whole thing will bomb. If you put too much complexity on the software, it will be buggy and difficult to maintain, and will eat up development time and money, and possibly even end up costing more than it earns, and then it will bomb. That’s not even including the more personal aspects of programmer job satisfaction and sanity.

Success is finding the sweet spot when balancing complexity.

jQuery Context Menu Unbind Click Fix

2009-04-09T00:00:00-07:00

Updated on May 28, 2009, due to partial fix. The fix should now be a complete fix.
—
Apologies for the somewhat confusing title.
I’ve been doing a lot of jQuery work, replacing all the AJAX.NET crap in my project at work to speed the interface up. I’ve started using the awesome jQuery Context Menu plugin. However, I found it was also messing around with jsTree which I am using on the same page.

The problem is that the jQuery Context menu overzealously unbinds all click events from the document. This means that it’s going to break all your other Javascript that relies on clicking. Checking the documentation for jQuery’s unbind function, you can see that it accepts a function as a second parameter. This is the function that will be unbound if you pass that in as a parameter.
So, I fixed the jQuery Context Menu by changing the following:

In the main contextMenu function, near the end, just above the return statement, I added the following:
[javascript]
// External click event for document
function onDocumentClick(e) {
var menu = $(‘#’ + o.menu);
$(document).unbind(‘click’, onDocumentClick).unbind(‘keypress’);
$(menu).fadeOut(o.outSpeed);
return false;
}
[/javascript]
Next, I change the function that assigns the click listener to the document to assign the defined function, instead of an anonymous function. So, change:
[javascript]
// Hide bindings
setTimeout( function() { // Delay for Mozilla
$(document).click( function() {
$(document).unbind(‘click’).unbind(‘keypress’);
$(menu).fadeOut(o.outSpeed);
return false;
});
}, 0);
[/javascript]
to
[javascript]
// Hide bindings
setTimeout(function() { // Delay for Mozilla
$(document).click(onDocumentClick);
}, 0);
[/javascript]
Lastly, I remove all instances of:
[javascript]
$(document).unbind(‘click’);
[/javascript]

That’s it. That fixed the problem for me. You’ll notice I don’t bother with the keypress bindings. That’s because I’m not using them, so I’m not bothered. I’m assuming the fix for that will be a similar strategy, for those who are bothered.

I’ve uploaded my version for those who can’t get it working using the tips in this post, but remember the copyright remains with Cory S.N. LaViska over at A Beautiful Site.
jquery.contextMenu.js

Correcting 5 Misconceptions About AI

2009-04-07T00:00:00-07:00

For the longest time, I have been interested in artificial intelligence. The idea of computers that could make decisions and think independently fascinated me. Of course, I knew that AI wasn’t quite that advanced, but the idea still captivated me. However, the barrier to learning AI was too high. It was too complex and too academic. Just looking at the mathematical notation involved made my head spin.

I eventually took the plunge and convinced my family to buy me Artificial Intelligence: A Modern Approach for Christmas, and 12 months later, I actually started reading it. I’m still reading it, and will be the first to admit I don’t understand everything that is discussed, however there are a few things that I’m realising about AI.

It’s All About Searching
Searching is a constant in AI techniques. Problems are defined and solution spaces are created. Problems can be represented in a number of ways (graphs, trees, logic knowledge bases), however in the end, it always comes back to searching.

This is important because searching is easy. Searching is something that a lot of programmers already know, even if it’s only at a most basic, brute force level. We do searching all the time. We loop through arrays searching for values, we use regular expressions to match string patterns, we retrieve records from databases. We search.

At it’s simplest, you can search using brute force searching, iterating over all combinations and permutations of solutions looking for one that satisfies the problem, but beyond that, you can involve tricky heuristics to make optimal decisions about how to search. You can have local searches, which will pick a solution space and search it for local maximums, such as hill climbing, and searches that will find global minimums, such as simulated annealing. But it’s still search. It’s still something you can do.
It’s More Common Than You Think
AI is a hell of a lot more prevalent than most people realise. I didn’t think AI had much commercial application before I started learning about it, but luckily that didn’t dim my interest. For those who are interested, but holding back because they don’t see how it would benefit them, here’s some good news. AI techniques are used everywhere.

That international 4 city flight you booked used AI techniques. A constraint satisfaction problem solver took all the constraints about needing to be at this city by that time, flying on this airline for that much, and creating a plan for you. When Amazon recommends products you might be interested in, it calculates this with Bayesian networks and classifiers, a method of probabilistically linking a set of variables. Circuit design, product manufacturing, supply chain optimisation, all of these things use techniques that AI use. They’re not the sole domain of AI, but learning AI will cause you to learn these too.
You Can Use It Today
Whatever you’re working on, you can probably use AI techniques in it. Even some of the more exotic sounding techniques like neural networks can be of use to you. Self healing databases? Hell yeah. Even Bayesian classifiers to catalog and categorise products, heuristic searches to mine data in databases, hierarchical task planners to plan that holiday or manage that Gantt chart.

Can you use it anywhere? No. Your simple CRUD app probably won’t benefit from a wizz-bang heuristic search. But if you’re doing anything that involves large amounts of data, interacting with people, predicting trends and recognising patterns, you can use it.
It’s In Demand
You may have heard of the Netflix Prize. Guess what? That’s AI. Google is the biggest search engine around, and index billions upon billions of pages on the internet, and can get you relevant results to a question in a matter of seconds. That’s one hell of a big knowledge base, and one smart search algorithm. Amazon sell products all over the world, and aggressively upsell and cross sell. I get emails about related products I might like based on my wishlist and purchase history, and they’re actually pretty accurate.

Also, computer games. Enough said.

AI skills are in demand. Not huge demand, but probably more that you would have guessed. These skills are hugely profitable in the right hands, and big companies want to extract every single little morsel of useful information about your browsing, shopping, eating, travelling, viewing and reading habits in order to market to you more effectively. Now that sounds a little creepy to me, but if that doesn’t bug you, more power.
There’s a Lot of Information Out There
AI isn’t some weirdo niche science topic. There’s actually quite a lot of information out there, once you start going down the rabbit hole. “AI: A Modern Approach” cites hundreds of papers and books. There’s thousands of websites out there on the subject. There are many academic papers that are made available for free online. There are communities, like AIGameDev, dedicated to spreading that delicious knowledge.

I think the hardest part about finding information is getting the terminology. It’s pretty dense when you first get into it, especially when talking about acyclic directed graphs, and your idea of a graph was like mine was about a year ago, namely a few bars on a 2D Cartesian axis. But once you’ve got a foot in the door of the lingo, it can become pretty accessible, and information starts becoming more bountiful. That foot in the door can be either a good, basic website, or in my case, a university level textbook designed to introduce people to AI.

AI is a big field, full of fascinating and interesting concepts and techniques, and it’s a young field that’s still full of potential. It’s not as complex or confusing as film and television would have you think. That’s not to say it’s a walk in the park, as I stated earlier, I’m probably running a 70% rate of understanding what I’m reading, but I’m managing. And if I can manage, so can you. So if you’re interested, there’s no better time to start than now.

A CMS in Ruby on Rails, and Why I Stopped

2009-04-06T00:00:00-07:00

For the last couple of months I have been writing a series of posts describing a personal Ruby on Rails based CMS. I have been writing tutorial style posts outlining what I was doing, and why I was doing it. Don’t bother trying to look for those posts, because I’ve archived them.

This decision was pretty easy after I slowed down and reviewed the situation objectively for a few minutes. That clarity, coupled with a few truths that hit home while reading the source of a few other Rails applications pretty much sealed the deal.

The next post in the series was going to be an overview of another Ruby CMS project, BrowserCMS. I saw a video from RailsConf about this project, and recognised a lot of their goals as coinciding with mine. So I was going to poke through their code, see how they’ve done things, compare it to how I did the same things, or was planning to do them.

While I was reading through their source, it occurred to me just how much I don’t get Rails. I have a bit of a poke around with scaffolding and get familiar enough with the generators and I decide that I’m ready to tell people how do create a CMS in Ruby, because I’ve nearly finished creating a CMS in ASP.NET.

It’s clear to me, now, how silly that was.

Rails isn’t just a framework for Ruby, it’s a whole change in paradigm. Intellectually, I know Rails is “opinionated software”, however I don’t think I understood what that really means. I tried to make my code as flexible and configurable as possible, and I was struggling with all but the most basic CRUD tasks.

So, first I realised I wasn’t ready to tell anyone how to do anything in Rails.

But I have a series of about 5 posts doing just that. What do I do with those? Do I continue on, plugging away at learning while trying to instruct? I decided the answer to that depended on what I had achieved with my posts. What was the value of them?

Then I realised that I had covered very little other than simple CRUD. Sure, I had some unusual object relations, like trees and self referential comments, and I implemented some business logic like compiling pages into templates, however the total sum of the non-CRUD related content could have fit into 1 post. So I spent 4 posts blathering away at how to achieve the same task as running script/scaffold.

What’s worse is that I realised I was back in the rut of creating a CMS. How on earth did I do that again, after stating loudly and proudly that I don’t even like programming websites.? Well, I told myself, you are planning on using this on your own sites, your many, many online business ideas. Sometimes you have to do the same old thing to earn money. Which is true, if I had done anything of worth, but I hadn’t, I was a long winded scaffold script. I got carried away in the joy of learning a new language/framework (which isn’t a bad thing), and fell into the familiar territory of doing what I always do (which is a bad thing).

So, now I realise that I’m not only trying to teach people something I don’t understand, I’m trying to teach them how to do something I don’t even like doing.

That’s stupid.

I’ve archived the posts. I may revisit, as I still have grand ideas of what a CMS should be, but for now I’m shelving the whole thing. Luckily I have such a small readership (read: none) at this stage, nobody will be affected. For that I’m grateful.

And yet, through all this stupidity, I have learnt a few things of value.

I’ve learnt that Ruby on Rails is more complex than I thought, and will hit the books again to pick up some more advanced techniques.

I’ve learnt that I’m scared to push myself in programming. This revelation is a pointy one. I love programming, it’s my job, it’s my hobby and it’s my passion. The fact that I’m scared to push myself to innovate, hiding behind the excuse that I’m not smart enough or I’m not creative enough is double edged. On one hand, it’s sad that I’m not as ambitious as I thought. On the other, it’s great that I know now, so that I can get stuck into remedying that.

I’ve also learnt a lot about blogging. Those posts of mine weren’t really providing much value. I don’t have many readers because I’m not saying anything new, and I’m not showing anybody cool things they can’t find in a hundred other blogs. I also didn’t have much of a personal voice, and was writing them like I would a textbook, which is missing the point of a blog. It’s supposed to be informal, and I’m supposed to show my personality. So, I’ve found my voice, while realising that I’m not providing value. Another pointy idea, but ultimately good, because that too is something I can work on.

So, inevitably, I have to question the value of this post. What could this post provide to someone who stumbles across this website? Well, a few things.

Firstly, self awareness is a great thing to possess as a programmer. If you know where your weaknesses are, you can train in them, and get better. But that’s not enough, you also need to know what you’re afraid of, so you can recognise that you don’t even know that it’s a weakness. That fear hides the existence of the things you’re not good of, and that’s a major roadblock to improving.

And lastly, if you don’t have anything to add to the conversation, don’t say anything. The whole internet is a conversation, and I’ve just been babbling to myself in a corner the whole time. If you want to contribute, add your own thoughts, your own interpretation on subjects that are well known. Go into new levels of detail on old ideas and technologies. Introduce new ideas or technology, or modify existing ones. Contribute, don’t just talk for the sake of talking.

Visual Studio 2008 Deletes LINQ DBML Designer File

2009-04-01T00:00:00-07:00

Do you spend hours wrangling with your “Interactive” Development Environment, trying to prevent it from deleting your boiler plate .designer file for your LINQ DBML? Do you get baffled watching Visual Studio delete said file from your software version control system, and then struggle to get the two back into sync?

Then you might be encountering this bug right here. The reason for this post is because this bug seems very hard to find information on in Google. So hopefully I can raise some awareness, and at least have it pop up on a Google search.

Typical symptoms are the designer file for the DBML being deleted when the DBML is updated. If you’re also using source control, Visual Studio will attempt to delete it from your source control at the same time. Renaming the DBML file will cause it to regenerate, however it can cause major headaches when combined with source control, removing it, adding it, pending delete actions hidden in a project you thought you had unchecked out.

The solution is the suitably moronic action of moving all your using statements inside your namespace declaration. A co-worker found this solution in this MSDN forum thread. Once you move your usings, Visual Studio happily stops deleting your designer file, and you can finally get back to work programming instead of fighting your tools.

In Defense of the Jerk

2009-03-29T00:00:00-07:00

Not just any jerk, but the jerk who knows his stuff. The technically strong, socially weak programmer who does not play well with others.

During a recent employee review, I was told that I need to work on a few areas, namely the way I communicate with my co-workers, and my tendencies to shoot down ideas without supplying alternatives. I was also told that my technical proficiency was more than sufficient.

The technically capable but socially awkward programmer is a cliche in every day society, and the rogue programmer is a cliche in development teams. Seth Godin’s post, and another one that cropped up in Hacker News reminded me of this, and made me think. I realised that, to some extend, I am that jerk.

The point of this isn’t to toot my own horn, rather to try to offer an explanation on behalf of all well-meaning jerks in software development teams. Now, I’m not talking about those jerk jerks, who code maze-like code to secure themselves a job, those who are needlessly rude and abrasive, and those that ignore the other members of the team to the detriment of the whole project.

I’m talking about the jerks who are otherwise good employees. We’re not trying to sabotage the project, to exert our will over the project, to make anyone feel bad or insufficient.

We just care about the code.

At least, I do. I care about what I’m doing. I care about the project. I want my code to be the best code I’ve ever written, I want this project to be the most successful project the company has. I own my code, and take pride in it.

When somebody suggests something that I know won’t work, that will negatively affect the quality of the code, I freak out, somewhat. The first thing on my mind is to shoot down this idea, because I don’t want it reducing the quality of the project.

If my manager is planning on putting another programmer on the project with me, and I don’t believe they’re quite up to standard, I’m going to try to limit the damage they do to the application. I’m going to try and push them to work in a relatively isolated corner of the application. Unfortunately, I know this is a bad team work based attitude, however I can’t help it.

Now, I’m not defending jerks. Being a jerk is a bad thing, I know this. I agree with what my boss said, and agree that I need to work on these areas. However, instantly firing the jerk, if they’re a well meaning jerk, is not a good idea, because you’ll lose someone who is passionate about what they do, and constantly striving to improve them.

Instead, just try to work things through, and soften the edges of the jerk.

Parsing ASP.NET pages with SGMLParser

2009-03-09T00:00:00-07:00

I’m going to take a short break in my Ruby CMS series to post something I encountered at work.

During my development of the CMS at work, I’ve had to deal with parsing HTML content in order to compile page content into tags. This involves being able to replace certain elements of a page with other elements. At first I tried to do this with regular expressions, however this didn’t turn out too well when it came to dealing with the inconsistencies in legacy sites running on the current, older CMS. Next, I tried parsing the pages as XDocuments, which worked ok as long as I was parsing well formed pages. As soon as it hit a malformed page, however, it died in a fiery burst of exceptions.

Then I looked at SGMLParser, and it seemed like it was my savior. It parsed SGML, of which HTML is a subset, and it auto corrected malformed content, and would handle all the inconsistencies of life, in use HTML, and it would allow me to parse it into an XDocument so I can manipulate nodes. However, even SGMLParser had it’s own problems: it wouldn’t handle ASP.NET server tags very well, which was a problem.

We provide “plug in” functionality to CMS sites by the way of ASP.NET server controls. You build your functionality, stick the server control files into your site, drop the binary into the bin folder and insert the server control tags into your page. Fire it up, and it will appear and function. However, when running pages with server control tags through the SGMLParser, it wouldn’t recognise the namespaces, and would strip them, completely breaking them.

This was unsatisfactory, as we were planning on using a similar sort of set up to perform the same thing in the new CMS. So, I hit Google, looking for ways to get around this. There’s not a lot of information out there about it, other than “SGML parses SGML, not ASP.NET, which isn’t valid SGML” which was exceedingly unhelpful, because I already know.

I peeked into the source of SGMLReader to see if maybe I could remove the functionality that stripped out unknown namespaces. Sure, this would probably defeat the purpose of using SGMLParser, but it would help me out in this specific project. Unfortunately, the codebase is rather complicated and I really didn’t want to dig in and spend hours on something I wasn’t sure was even going to work.

I saw that the project has a custom HTML dtd, so I considered briefly writing a dtd for ASP.NET. However, while I was thinking of all the different permutations of server tags, especially when you can specify your own namespaces and tag names and attributes, I quickly decided that wasn’t suitable either.

In the end, and I believe this is honestly the only way to do it, I ended up pre-processing my content, wrapping ASP.NET server tags within <![CDATA[ ]]> tags. I noticed that SGMLParser was wrapping my older <% %> ASP style tags in this fashion, and leaving them unmolested. After I parse it into the XDocument, do my manipulations and pull it back out as the desired content, I run a post-process through it, removing the <![CDATA[ ]]> tags that were added in the pre-process. After, I’m left with my content as it went in, with the modifications done through the compiling process.

Of course, I do the pre-processing and post-processing with a regular expression:
[code language=“html”]
</?[\w]+:[^>]*/?>
[/code]
which I think is kind of funny, in a way. I can never seem to escape regular expressions.

ASP.NET Ajax, FCKEditor and Firebug

2009-02-12T00:00:00-08:00

Today at work I had the pleasure of dealing with a functionality bug in our new CMS that is written in ASP.NET. Our CMS uses FCKEditor for the rich text editor, and we’re using a whole gang of ASP.NET Ajax stuff for the interface. Specifically, we’re using a TabContainer with user controls inside each tab.

The CMS is designed in the way that most CMS’s are – we have 2 major components. Page objects contain the content data of a page, so text, HTML meta data, etc. Template objects contain templates – that is, HTML files with areas where you insert the page content, similar to how Dreamweaver does it’s templates for you.

When you publish a page/site, the CMS compiles the content into the template, then saves that as a file. When you’re editing or creating a page in the admin interface, the application reads the content areas available in the current template you have selected for that page, and creates an FCKEditor dialog for it.

Because you might not know how the content you’re writing fits into the template you’re going to use, we provide a preview function. This preview function will read in the content of the FCKEditor dialogs, create a temporary page object, set the src of an iframe to our preview page, which takes the page objects and feed it to a preview function which will compile the page and return the string, which we dump to the output stream of the preview page. We then fire up the iframe inside an ASP.NET popup extender, for a nice modal preview.

This all worked fine, until we got the tab container involved.

In order to streamline the work flow and reduce the page refreshes on postbacks, we decided to put the content in a tab container, with different parts of the page in different tabs. When we did this, we noticed that when the preview button did a partial postback, it reloaded the FCKEditor dialogs from the database, obliterating the changes we made to the page (if any), or just displaying nothing for the content if it was a new page.

This was just on my computer.

On a co-workers computer, it worked perfectly as intended, despite the fact we were both working from the same source, in the same IDE, running it in the same browser. What gives?

After poking around on both computers and trying the application in different browsers, we concluded that it doesn’t work only in my Firefox – IE was fine on my computer, and all browsers were fine on his. Acting on a hunch, I disabled Firebug for my Firefox, because I noticed my co-worker didn’t have Firebug installed.

The application started working again.

I don’t know why this happens, and why Firebug should be interfering with the Javascript in an obtrusive way, or even which Javascript it’s interfering with. I don’t know if Firebug was screwing with FCKEditor or ASP.NET Ajax. So, this post is partially to put this info out there, in the hopes that someone else can answer for me.

It’s also partially to say, if you’re seeing odd behavior that seems to be cropping up inconsistently across machines running Firefox, try disabling Firebug. Since being done by Firebug, I’ve decided to leave it off during all development, and thinking back, I wonder how many other Javascript bugs I’ve fought with that were caused by Firebug, and not the code.

Consistent Designs Across Browsers

2009-02-08T00:00:00-08:00

Firstly, a caveat: I am not a designer. I am a server side programmer who dabbles in web design and development. I do not know CSS as well as someone who designs websites for a living would. So take this advice with a grain of salt.

Today @RealtorPaul asked why his site wasn’t displaying right in Firefox, when it was displaying fine in IE. This is a common enough occurrence in web design, and it’s due to the fact that different browser vendors use different render engines, and each render engine has it’s own share of bugs.

Bugs are qualified by measuring against a set of standards laid down by the W3C as a target for render engines. Among the various browsers, IE typically has the longest history of the worst standards support around, with IE 6 being the #1 criminal, and admittedly IE 7 is much better, but still flawed.

When users develop a HTML interface that they check primarily against IE, testing how it looks in IE, etc, they’ll often get a nasty shock when they check in a Gecko (Firefox, etc) browser, as their designs fall apart and generally look horrible.

While the ideal way to trouble shoot these problems is to go over your CSS code with a fine tooth comb and understand how all the various rules are working, and understand how all the browsers render those rules, that’s not very practical. Luckily, the 80/20 rule tends to come into play here, meaning the largest problems between browsers are caused by a small selection of things. Here is a list of things you can check against:

Do you have a valid doctype in your HTML code? A valid doctype will look like this:
```
<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01//EN” 
```
```
“http://www.w3.org/TR/html4/strict.dtd”>
```
You can find a list of available doctypes at the W3C website. I personally recommend the HTML 4.01 doctype over the XHTML doctypes, for reasons that deserve a topic of their own. To use a doctype, put it as the first thing in every HTML page in your website.

Are you using a lot of padding and margins? One of the differences between Firefox and IE (just to name two) that most people hit is the difference in the box model. IE renders it’s box model incorrectly, and as a result, can cause a lot of grief when using a lot of padding and margins.

Are you using properties that do not have 100% support in all browsers? Some CSS features are not implemented completely in all browsers, and their support is patchy at best. You can find a list of these CSS features at quirksmode.org.

Are you floating a lot of elements? Floating elements removes them from the regular flow of the page, and as a result, can have some funky results on your design. Floating elements can be awesome when you know how to use it, but can be confusing as hell when you don’t. Make sure you know what you’re doing when you float stuff.

Are you changing the flow of elements with the “display” property? Certain elements are block level elements (they sit on their own line, and push elements beside them down) and some are inline elements (they happily co-exist in the middle of other elements). If you’re changing how some elements display, be aware that other properties (I’m looking at you, “width” and “height”) don’t work on inline elements. Know what happens when you change how things are displayed.

Those are the CSS concepts that get me the most. Many problems are solved just by adding a valid doctype to your page, however if you’re still finding you’re having problems, give the other items on the list a look.

This list is far from exhaustive, nor is it even very in depth. However, it’s a good place to start looking, and it might point you in the right direction. With the state of the browser market as it is, debugging CSS is as much an art as creating the design for a site is.

When debugging CSS, you might want to start with just bare bones HTML, and slowly add rules as you go, and isolate that way which rules are the ones that are messing everything up. Also, keep in mind that CSS is cascading – which means you need to put your more specific rules at the bottom of your stylesheet, general rules at the top, otherwise your general rules will override your specific rules.

The best way I’ve found to debug CSS is to incrementally apply styles, and use a tool like Firebug to turn rules on and off dynamically, so you can see what happens. The most important thing to remember is that even experienced developers have to deal with browser incompatibility. If you find you’re struggling, keep at it, and don’t lose heart. It’s all part of designing a website.

Apps Hungarian is Just Good Naming

2009-02-06T00:00:00-08:00

Application Hungarian is just good variable naming convention, but worse, because it’s needlessly concise, and hard to read at a glance. It also comes from an environment that is growing more and more obsolete. More on that in a bit.

Firstly, clarification is needed as to the definition of Application Hungarian notation, as opposed to Systems Hungarian. All of this is relatively useless, however, if you are in the same situation I was in a few years back and don’t know what Hungarian notation even is.

Hungarian notation is a variable and function naming convention where you add either prefixes or suffixes to names. What these prefixes/suffixes mean depends on what type of Hungarian notation you’re using. Systems Hungarian is the method of adding information about the type of the value of a variable, or a return from a function. For example, a string that represents a name would be called “strName” using Systems Hungarian. Applications Hungarian is where you add information about the semantic meaning of the value of a variable.If this is a little foreign, that’s because most people think Systems Hungarian when they think about Hungarian notation.

In Making Wrong Code Look Wrong, which is what inspired this post, Joel Spoelsky outlined exactly what Applications Hungarian notation is, and why it’s so useful. He outlines that in Applications Hungarian, you add information about the semantic value of a variable/method return. To illustrate, he demonstrates that you can use Applications Hungarian to differentiate safe and unsafe strings in a web application environment. He uses the prefix ‘s’ to define a “safe” string, that is safe against XSS attacks (ie: A html encoded string). He uses the ‘us’ prefix to define an “unsafe” string, that is a string read directly from user input that may contain potentially dangerous code.

Spolsky also demonstrates using the notation to make wrong code long wrong. That is, by combining prefixes on methods, based on their return types, you can use the names as a sort of litmus test. So if the return prefix of a function specifies it returns a ‘us’ or unsafe string, and you assign it to a ‘s’ or supposedly safe function, this is clearly a logic bug, and looks wrong.

I think this is great, and it’s something I’ve never thought of, but my question is, how is it different from properly descriptive variable naming, aside from it’s somewhat obscure brevity?

The virtues of clear, descriptive names in programming have been sung again and again. If you make your variables and method names descriptive enough, your code becomes somewhat self documenting. You capture the intention and meaning in your code when you use variables like “customerFirstName” and “formatAddress”. You look at those names and you can immediately see the intention behind the code.

I see a huge overlap between the best practice of descriptive variable naming and Spolsky’s intention behind his use of Apps Hungarian, so much so that I don’t see a difference between the two, with relation to their purported goals. Apps Hungarian is more terse, and more obscure, and has somewhat of a learning curve if you’re not familiar with the nomenclature of the system. This, to me, seems like a needless barrier to understanding.

Am I missing something? Why is Apps Hungarian better than regular, descriptive and intelligent variable naming? I can’t see any benefit to using Apps Hungarian explicitly, and to my understanding, Apps Hungarian is just a more terse method of good variable naming.

Pixel Perfection is Impossible

2009-02-03T00:00:00-08:00

This post is an elaboration of a comment that I left on a post about CSS frameworks. I agree wholeheartedly with Joren’s position on CSS frameworks after having used 960gs for the layout of this site (at the time of posting this).. As I mentioned in my reply to Joren’s post, I used the framework to try to cut down the stress I feel when I try to make things line up properly and that most certainly didn’t work as intended.

Specifically, I have a little widget that shows my most recent tweet on the front page, and I’m using a cute Twitter bird vector from DarkMotion.com as the background for this element. If you are viewing this post in IE, Chrome on a small resolution, and probably Opera and Safari, the bird is probably sitting obnoxiously below the recent post bar, getting in the way of content.

This little bird has given me so much grief in the design of this site, that I’ve thrown my hands up in despair and given up. The reason it’s plagued me so is the way 960gs automatically floats everything for it’s grid system. If you want to work outside the grid system, even a little bit, the framework makes you pay with blood.

I love the bird, I love showing my most recent tweet. I will not remove it. However, I can’t claim to be a serious developer, whilst still allowing obvious display bugs on the site, and I can’t bring myself to use a third-party theme to represent my personal blog. It just seems wrong.

In Joren’s post, there is an excellent comment defending frameworks, which makes mention that Joren’s blog has a 3 pixel difference in margins of the content, between the header and the footer. While I acknowledge that this wasn’t the author’s main point, it brings up something that I’ve never understood in web design, and the mentality of many web designers, both new to design and coming from print design.

A web page is a fluid medium. Web designers advocate abandoning the pixel for the em, citing greater flexibility and fluidity. So, at some level, they recognise this. However, people still insist on making designs that rely on pixel perfect precision positioning across all major browser vendors, which is where the need for CSS frameworks and reset stylesheets come from.

Web browsers are products competing in a market, and they have different ways of rendering CSS, and they have their own unique quirks. We know this, as well. Beyond glaring CSS interpretation bugs and discrepancies in box models, they have unique margins and padding on elements, and sometimes these only differ by a few pixels.

Why is this a problem?

Why do these people feel the need to contort CSS, torture it into burying these differences, into displaying the same across each browser. There are far too many permutations of resolution and browser, not to mention whether or not someone has their browser full screened (I don’t) to try to enforce this pixel perfect design.

Embrace the differences. Embrace the fact that your margins may not look identical. Recognise that at the design stage, and design your sites to compensate for this. Don’t split images into different elements if they’re intended to fit together seamlessly. Find another way. Don’t stress if the margin between your content and your header is 3 pixels bigger on IE than it is in Firefox. As long as the general communication goals of your design work across all browsers, and it doesn’t look like a train wreck, be happy.

I know all of this is easier said than done. I’m a server side programmer, not a CSS guru or a designer. However, I think it’s a worthy to keep in mind while designing. Don’t fight the diversity, embrace it.

C# Interface Method Gotcha When Inheriting

2009-02-02T00:00:00-08:00

I noticed some interesting behavior from C# yesterday at work. Truth be told, I’ve noticed this in the past, but I’ve only figured out what’s causing it today.

The behavior is this: when you inherit from a class that implements an interface, calling a hidden/overriden method from an object of the inheriting class that has been upcast to the interface will result in a call the the inherited function.

Ok, so that probably made no sense at all, which is why I will explain it, but not before a warning. I’m not sure if this is intended behavior, and I’m not sure if this is something I’m doing wrong. If someone can point me in the direction of an explanation or a correction, I would be very grateful.

On to the explanation.

Take a sample, trivial application that has widgets. These widgets just print messages out to the console. We have an interface, IWidget, which forms the contract for all widgets:
Next, we have a generic widget class, which we use for most widgets. This is called GenericWidget
Next, we have a generic widget class, which we use for most widgets. This is called GenericWidget:

And finally, we have a specific type of widget that does something different, called SpecificWidget:
Now, we want to run some tests on our widgets, to see what’s going on. First, we’ll test the widgets themselves. Running:
will output:
Doing something in GenericWidget Doing something else in GenericWidget Doing something in SpecificWidget Doing something else in SpecificWidget
Which is exactly what we expected to see. Test has passed. Next, lets say we have a function that we want to pass widgets to, but we don't know what kind of widgets we will be passing, only that they are widgets. So we pass them as widgets, but upcast them to IWidget, and call the methods on them from the interface. For example:
which will give the following output:

Doing something in GenericWidget
Doing something else in GenericWidget

Doing something in GenericWidget
Doing something else in GenericWidget

Wait, that’s not right. The specificUpcast should call the method on SpecificWidget, shouldn’t it? At least, that’s my expected behavior. Just to prove there’s not something wrong with our specificUpcast:
will yield:
Doing something in SpecificWidget Doing something else in SpecificWidget
will yield:

Doing something in SpecificWidget
Doing something else in SpecificWidget

which is our expected output all along.

If someone can explain this to me, or point me to a better method to upcast, then please do so. I’m finding a lot of my code needs to check for specific types in order to call the proper method, and it seems clunky and awkward. I’m sure I’m doing something wrong, I’m just not sure what.

As usual, you can find the source code here: Interface Upcasting Inherited Classes Gotcha

Using Twitter to Gather Information

2009-01-30T00:00:00-08:00

I’ve mentioned briefly the virtues I see in Twitter when I discussed how to implement a project in 3 hours. Now I want to expand on how to use Twitter to gather information. I mentioned in that the key to utilising Twitter to gather information was to follow the right kinds of people. However, you’ll find that when you start following more than 100 people, things get a little hectic.

Every programmer is more effective with a solid selection of tools, and Twitter is no different. TweetDeck is the best Twitter desktop client I’ve used, and it’s an AIR app, so it runs on all major operating systems. Most Twitter clients have a single stream that Tweets come in through, and everything gets lumped together. TweetDeck’s strongest feature, for the purposes of leveraging Twitter to gather information, is the option of splitting your stream into groups.

TweetDeck allows you to put people you follow into groups, and have their tweets appear in a different window. The notification alert will also show this segregation. In addition to splitting your followers, you can specify windows that will feed you the results of searches, using the Twitter search operators outlined here.

The search operators and TweetDeck are the engine of our information gathering machine. Using the search operators you can follow the public stream and cherry pick Tweets that contain information you want. You can look for specific phrases, specific hashtags, tweets after a certain date and tweets with links.

For example, I use use a search for “artificial intelligence” with links to find people who tweet interesting links concerning artificial intelligence, which is a subject I’m highly interested in. I can run several of these filters in different windows at the same time, and grok the whole public stream. No longer am I restricted to listening only to those that I follow. Of course, that’s not to say I no longer follow people. If someone pops up multiple times in my filters, I’ll follow them to be sure not to miss a single tweet from them.

This method, however, isn’t flawless. If you look too narrowly, you won’t find any tweets. Also, when you finally do find tweets, even by trying to pick out key phrases/keywords and links, there will be a significant signal to noise ratio. My search for AI topics often lead to students linking university class websites and time tables, which is something I’m obviously not interested in. Often people who pop up in searches all the time turn out to have a high noise to signal ratio.

Having said that, while there are drawbacks, the ability to monitor the public stream as well as the people you follow, and sift out tweets that have a higher likelihood of being relevant is a powerful thing, and will often connect you to bits of information you would have never found otherwise. That’s the power of Twitter, and that’s why I love Twitter.

3 Hours from Concept To Implementation With Ruby

2009-01-27T00:00:00-08:00

Although I’m still relatively new to it, I’m a big fan of Twitter. However, not for the social media aspects of it. I view Twitter as an excellent method of gathering information, as long as you follow the right kinds of people. By the right kinds of people, I mean people who tweet interesting links they find online. Simply follow people who are interested or involved in the same subjects that you’re interested in, and they will feed you information over time, in a nice steady flow.

I’m very much interested in AI, and AI as it applies to games. I am a fee paying member of Alex J. Champandard’s AIGameDev and I follow him on Twitter. While this is great, his flow of information isn’t fast enough for me. So I set to Twitter to search for people who are interested in AI and game development, when I found the @playwitter account, and the associated website. As you can see from the @playwitter tweet, they’re not yet fully functional. I didn’t really want to wait, and I didn’t really want to follow all those people on my own. So I decided to come up with an intermediary solution.

The concept is a Twitter bot that will read in an RSS feed and tweet the entries. I decided to use Ruby, as I haven’t done any significant programming in Ruby before. All I knew was the basic syntax that I read from the Pickaxe book.

First, I hit Google looking for a Ruby RSS parser library. Oh! It turns out Ruby has one built into the language. So I read a few websites on how to do that, and it seems pretty straight forward. So I grab the feed over at Playwitter and start pulling it down with my Ruby script. The quick script I wrote in 10 minutes worked like a charm.

The next part was to tweet the entries. I looked for a Twitter library and settled on the Twitter gem. I installed the gem, and this took me a while to get it working as a library, but get it working I did. I was able to send tweets from an automated script.

It took me about half an hour to wire these together and before I knew it, I was done. However, it was fairly crude, and I found out when I tried to deploy it to my server that it wouldn’t make the grade. I set about refactoring and upgrading the code and trying to get it run. 3 hours later, it was complete, and it was working.

In the end, I implemented the idea in 3 hours, with the following features:

YAML config file for defining Twitter account details and RSS feeds to tweet from.

Timestamp based polling of the RSS feeds, storing only updates new since the last poll.

Tweeting with added hashtag, defined in the YAML with the feed

Deployment as a Ruby Gem

Details of the project are the subject of another post, and when that project is a little mature, I will create that post.

From concept to deployment on a live site, with a basic knowledge of Ruby only, in 3 hours. That’s a fantastic result that I’ve never experienced in another language, compiled or not. It was fun, it was fast, and I felt the freedom of PHP with the benefit of a well implemented OO system.

Man, I love Ruby.

Frameworks Make Reading New Code Hard

2009-01-24T00:00:00-08:00

In an effort to increase my knowledge of both Ruby and Rails, I have been keeping my eyes open for interesting Ruby/Rails apps to peek at the source code of. Whilst looking at @j_stirk’s website, I noticed it was running on Radiant CMS, a Ruby CMS. So, I grabbed a copy of the source code.

Whilst I was having a peek at the source, I began to think that I was in a little over my head. I managed to muddle my way through the config/routes.rb file and figure out (with judicious use of Google) what requests were being directed to what controllers. The problems started happening when I hit the controller, and started seeing filters and symbols and statements that I didn’t know where to go next to find out about.

At first I thought it was to do with the fact that I don’t really know Ruby. I know enough to recognise it, and muddle through basic syntax, but I don’t know any tricks, any coding conventions and the nuances of Ruby programming. However, upon reflecting on my dilemma, I realised this isn’t something that was restricted to Ruby, Rails and Radiant CMS.

I remember last year looking into Symfony, before deciding that PHP was too god-awful ugly to waste my time on. I recall that too had a fairly high learning curve, and looking through an existing Symfony app, it was very hard to figure out what exactly was going on. There was much API browsing.

A few years ago when I first learnt ASP.NET, I was in a similar situation. Server tags and user controls and page events and assemblies were all very new and very confusing to this ex-PHP & ASP 3.0 developer. I stormed through a book on ASP.NET and was thrown head first into a contracting gig before catching my stride again.

I love frameworks. Ever since I heard about this thing called “Rails” a few years back, and realised there were a few similar frameworks written in PHP, I’ve been in love with frameworks. And I’ve always learnt them from the ground up, creating my own application. Last night was the first time I’ve ever tried to learn a framework from an application.

And it’s hard.

While frameworks increase programmer productivity and make maintenance easier for programmers who already are in the know, they make things really hard for a new maintainer who is not familiar with the code to dive in and figure out what’s going on. Not only do they have to learn the individual nuances of the programmer who wrote the application, they also have to figure out how the framework works.

Reconciling YAGNI With Reversibility

2009-01-21T00:00:00-08:00

Yesterday I started reading Andrew Hunt’s The Pragmatic Programmer, which has been sitting around waiting to be read for at least several months. Every programmer I talk to says that it’s a book that will really stimulate growth as a programmer, and I certainly need to grow.

Already several of the things the author has said have rung true, and I can see many of the scenarios he’s described as having happened, or nearly happened, in a few of the projects I myself has been involved with. Which is exactly what has piqued this post.

Hunt outlines the need for what he calls reversibility. He states that there are critical decisions to be made in each project, and each of these involves a commitment that often isn’t easily changed, such as committing to a type of database, or committing to a design pattern.

He goes on to describe the need for a Schrödinger’s Cat approach to software design. The basis is the Schrödinger’s Cat theory which illustrates quantum superposition – where at the point of a decision, multiple dimensions spawn off and you don’t know which dimension you’re in until the decision is observed.

Hunt argues that we should design code to be flexible enough to allow as many of the “possible dimensions” as possible. What he means by this is to allow for these critical decisions to be changed, with minimal impact on the code, hence the term reversibility.

To do this, we should code for possibilities. We should always keep in mind what might happen, and design our software so that we can accommodate the change. This flies directly into the face of another principle of programming, You Ain’t Gonna Need It (YAGNI), and the general belief that the more code you write, the more opportunity there is to introduce bugs in code (something Hunt himself mentions).

YAGNI outlines that you shouldn’t write code you don’t need, and cites several reasons why, and coupled along with the idea of writing less code is better, this is something I believe. However Hunt’s Reversibility idea is in almost direct opposition – he advocates writing code “just in case.”

Can these two ideas be reconciled?

I believe they can, and it’s an approach I’ve used in the past. I’ve found that it’s possible to quickly and safely recognise that there is the possibility of a change by writing interfaces and method stubs for new functionality, and have them throw not-implemented exceptions.

This way, you acknowledge that a decision might be changed and have already got the application hooks to hook into it, but you haven’t wasted time implementing something that may not come to pass. Your software will build, and at the existing functionality won’t be broken while you wait to implement these new changes.

This seems like a trivial thing to do, however it can really streamline the process in my experience.

AI Application Programming - Book Review

2009-01-18T00:00:00-08:00

I’m spending a lot of my time lately reading about AI, both game related, business application related and academia related. Having recently completed “AI Application Programming” by M. Tim Jones (Charles River Media, 2003, First Edition), I have decided to review it in the context of my current situation.

I am new to the field of AI, and my previous reading has been limited to sporadic Wikipedia research on concepts as I come across them. This book covers a lot of material that I haven’t read about before, but it also covers some material I have. This allows me to evaluate the book as both someone with prior knowledge, and someone with no knowledge.

Firstly, the book was a fairly broad overview on integrating aspects of artificial intelligence into application development. Therefore it was no surprise that a majority of the AI concepts discussed were optimization oriented. The book provided an overview of the history of AI, then it covered simulated annealing, adaptive resonance theory, ant algorithms/ant colony optimization, neural networks, genetic algorithms, a chapter on using some of the techniques described to run artificial life simulations, rules based systems, fuzzy logic, bigrams/Markov chains, agent based software and a wrap up the future of AI.

Each chapter is fairly formulaic. It starts with an overview of the theory of the subject for that chapter, and the presentation of any relevant formula. Then a basic example is covered, without code, in order to show how the theory being covered can be applied. Then a specific example with C source is covered, with a detailed explanation of what’s going on. I largely glossed over the source, as I don’t really have much familiarity with C, so cannot comment on the quality of the source.

Overall I have mixed feelings about the book. A lot of the topics have domain specific language, such as referring to parts of algorithms as genes and candidate algorithms as chromosomes in genetic algorithms, and I feel the author sticks to these to the detriment of comprehension of the topic. For example, the author was discussing “energy” and “temperature” with relation to simulated annealing, without outlining that it’s goal was to narrow the search space for a solution to a given problem.

Another detracting factor was the numerous errors in diagrams, equations and the text. These errors can be attributed to a variety of sources, from poor copying jobs on some of the diagrams to bad editing. One particularly annoying error was the diagram showing how a NOT logic gate could be constructed using a single neuron neural network – the diagram showed an input bias of 1, with a weight of 1 on the input, claiming that the output will always be the inverse of the input, by the equation output = input * input weight + bias.
An input of 0 into this equation will indeed output a 1, however an input 1 will yield 2, which is incorrect. The correct diagram should have a input weight of -1, which will yield a correct answer with both the 0 and 1 inputs. These errors hindered the understanding of the topic.

However, it’s not all bad news. From my personal reading, I had always struggled with how the back propagation algorithm in neural networks worked, and this book managed to successfully explain it. A lot of the other topics, such as fuzzy logic and the rules based system were also well presented and relatively straight forward.

From reading this book, I feel I have a solid enough understanding of the basics of the topics covered that I could successfully go out and perform my own, more in depth research and succeed fairly well, as well as integrate a few of the more rudimentary features of these approaches into an application.

How To Run Your Own Webserver

2009-01-14T00:00:00-08:00

For some time, I’ve run my own web server from the comfort of my own home. I made this decision due to the fact that I wanted more control over my server, and I wanted to run as many web development languages side by side as I could, and mainly because I wanted to run SVN. Before I started hosting my own websites, I had a sketchy knowledge of how the DNS works, and how to go about hosting your own websites on a Linux operating system. I also had minimal Linux administration skills.

There are a few good reasons for hosting your own website:

No artificial caps on bandwidth and hard disk usage. You pay for what you use, and if you need more, you buy more.

Total control over your hosting environment. If you want a language installed, install it. If you want to run a certain version of Rails, run it. It’s your server.

Experience. Hosting your own websites on your own server can give you a lot of experience with systems administration on a server operating system.

Cost. You have complete control over how much everything costs, and you know exactly where your money is going. You can spend as much or as little as you wanted.

How Do You Do It?

First, it helps to get an idea of what you really want. Do you want to run a huge corporate intranet with load balancing and proxy servers, or do you just want a small server to host personal sites and tinker? Is your budget limitless, or are you already living on ramen for dinner 5 nights a week? Do you want to host proprietary languages like Cold Fusion or ASP.NET, or will a Linux/Apache install satisfy you?

Personally, I was only interested in hosting personal sites, and doing it cheaply was my utmost concern. This is what I will focus on, as this is what I have experience in. So, what I was looking for was a relatively easy solution that was above all cheap.

1. Get Your Hardware

Before you can start, you need to have hardware to put your server on, and if you already don’t have it, appropriate networking gear to support multiple computers accessing the same internet connection (if you want to use a personal computer as well).

As your end goal is a web server, this server preferably needs to be up 24/7, which means whatever hardware you choose to run it on will essentially cease to exist with regards to usage. Most of the time, hopefully, you’ll never need to do much work on the server itself, only transferring data to and from it.

I already had my networking gear, and I commandeered an old desktop computer for my server. It was a Pentium IV 3.0GHz with 2GB of RAM. I found in the year or so I ran the server that my memory usage didn’t ever go above ~400mb. I also had a 120GB hard disk in there. This computer used to serve as my old gaming workstation, however I don’t play games much these days, and I bought a laptop that was more powerful.

Cost: Free

2. Get Your Software

I chose to run CentOS 5 as my Linux distribution. My choice was admittedly relatively arbitrary, however I was relatively happy with the choice. I installed the OS and included only the packages that I knew I needed – that meant no xserver, and no GUI. I was going to administrate this server via ssh on my laptop. I then updated the OS and installed all the required software.

I immediately recognised that it would be hard to individually install and hook up everything that I wanted to run, and decided to run a web-server software package to help. I eventually settled on Webmin after a few false starts, and Webmin proved to be very user friendly and relatively powerful. If I was doing the same thing again, I would be relatively comfortable doing it all individually without Webmin, but it was Webmin that provided me with a safety net while learning.

Cost: Free

3. Get Connected

I was already running the biggest Internet providing plan that my ISP offered. As I live in Australia, we have to live with usage caps on our Internet plans. Mine was 20GB download during peak traffic, 40GB download during off-peak, and unmetered upload. This was perfect for hosting a server, as most of my traffic was upload, once I got everything installed.

However, you do need more than just an Internet connection to get a server online, you also need a static IP address. Technically you can do it with a dynamic IP and a dynamic DNS service, however that was a level of complexity I didn’t have the patience to deal with. So I put a static IP on my account as well.

Cost: $10/month for the static IP, Internet was free because I was using the connection anyway

4. Get Hosted

This is the final step to getting your server ready to host websites. So far, you have a server with the software installed, and you have an Internet connection and a static IP. You can type your static IP in a browser and get your Webmin’s default landing page (if your router supports NAT loopback, which mine didn’t). To get your web server attached to a domain name, you first must register the domain name, then point it to nameservers that run a DNS server.

You could run the DNS server on the same machine, or a different machine, but that was all too complicated for me. I instead chose to get a hosted DNS solution with Nettica, and have Nettica manage my name servers. Then it was simply a matter of pointing my domains to the Nettica nameservers, pointing my Nettica entries to my server IP, and add the virtual servers with Webmin, letting it take care of configuring Apache for named virtual hosting.

Cost: $50/year

So that’s it. For about $170/year, I could host my own server and serve as many websites as I had room for on the Internet. I had complete control over the server, and I could install what I wanted, when I wanted.

I don’t run the server now, as I have recently moved to a location where I cannot justify it, but overall I found the experience very rewarding. Sure, you can get cheaper shared hosting, but there’s nothing like deciding you want to install, say, SVN and just installing it, and having it up and ready in 10 minutes for no charge.

PHP Has An Identity Crisis

2009-01-11T00:00:00-08:00

I have been using PHP for quie a while. I first learnt PHP 4 when I was 18-19, building a dynamic art gallery type site for my drawing attempts. I thought it was wonderful that I could programmatically display new images without having to update the HTML file. I also used PHP for my final year project in university, and by the time I graduated, I was quite proficient in it.

However, as I slowly got more and more interested in programming, and the principles of programming, I learn more and more languages, and learnt OOP practices that I never applied to PHP, simply because I was self taught, and at the time PHP wasn’t pushing itself as an OOP language.

However, times change, and the PHP community tends to push the fact that PHP is an OOP language. Firstly, this isn’t entirely accurate. PHP is a language that supports OOP, however it isn’t an OOP language. There is no string object – I cannot take a substring of a string by calling a method on the string variable. Instead I must use a global function substr() to do it. That’s not OOP, it’s procedural wrapped in OOP.

However, PHP does support OOP. You can define custom classes, you can create objects and you can call methods on that object. In a hostile world full of more OOP languages like Ruby and Python that are gaining traction in the web development world, PHP must push more and more it’s OOP support. If you talk with serious developers in the world of PHP, they will insist that although PHP is not inherently an OOP language, it’s close enough.

Today I found out that from PHP has introduced in PHP 5.3 the GOTO statement.

For those of you who are unaware of the specifics of the GOTO function, this post, also the post that I learnt this fact from, outlines it. While experienced programmers know enough to avoid the GOTO statement, new programmers may not, and PHP can be abused enough already without the GOTO statement.

So, what is it PHP? Are you an OOP language, or are you procedural? The PHP community pushes it’s support for OOP, and then it introduces a control statement that characterises the worst of procedural code. PHP needs to clarify it’s future as a language, and decide whether to push itself as an OOP language or as a procedural language.

Encapsulation in Python

2009-01-03T00:00:00-08:00

Or, “I see London, I see France, I see Python’s underpants”

I come from a primarily C# background, where I have fairly tight control over how visible my properties and methods are. I can choose to make them private to the class, protected to the class and its children, internal to the assembly or public for everything.

In my course of learning Python, I’ve discovered awesome things like docstrings, multiple inheritance and sequence unpacking. However, I’ve also been shocked and made more than a little uncomfortable by the realisation that Python doesn’t implement encapsulation. I don’t trust other people not to abuse access to methods that I’ve intended to be private – I’ve seen too much bad code for that. While I know there are ways to get around this, I don’t feel I should have to perform code gymnastics to implement what I feel is an essential part of an OO language.

Another thing that makes me cringe a little about Python is the need to pass in the self parameter for all object methods. I realise that this is required to differentiate between an instance method and a class/static method, however I just can’t shake the idea that it seems a little clunky, even though I know it’s no different from writing a static at the start of my function definition.

However, to wrap up the last two weeks, I feel confident in saying that from what I’ve seen I like Ruby more than I like Python. That’s not to say these are bad languages; I first learnt web based programming with PHP, and I’m sure that I’m going to leave PHP in the dust for one of these two languages. I will also disclose that I did not learn Python 3.0, and haven’t really looked into it whatsoever, so if 3.0 changes some of the stuff here, forgive me.

Having said that, I will investigate both languages more, and definitely work in both more. I’ve found PHP doesn’t do it for me anymore, I’ve seen a better side of programming where I don’t have to live with ugly warts in my languages, and PHP is ugly. Long live Python and Ruby.

Don't Get the Wrong Degree

2009-01-03T00:00:00-08:00

I recently read an interesting post that popped up in my feed reeder on Saturday night, on a subject that strikes very close to home. Obviously I am not in the exact same situation; I have a degree.

But I have the wrong degree.

The Software Engineering degree I studied was very heavy on the management side of software engineering, and light on the actual implementation side of programming. I don’t know if this is common to SE degrees, however I found this was the case with mine.

I share Daniel’s love and thirst for information, and have a very strong drive to learn as much about everything as I can. So, on the surface, the dilemma of not having the right degree seems fairly harmless. Daniel describes the phenomena of “perception is reality” – people perceive that having a degree is better than not having a degree. So I guess I have a head start in that aspect. I have the piece of paper, I don’t have to deal with these negative perceptions.

Instead, I had to deal with the mistaken belief that I was more competent than I was.

I have never worked in a large company. The company I’m with now is the largest company I’ve ever been with, and we only have 4 developers, including myself. I’ve always worked with smaller companies, that either only dabble in programming, or were start-ups. It wasn’t until I looked at a job posting at a larger company that I realised that I may have made a huge, 3 year long mistake.

The job posting was your standard outline of positional requirements and expected experience and education, but it also had a puzzle attached. You had to complete the puzzle, in your language of choice, and submit the code along with your resume for consideration. This was in late 2006. I can say now that it was a simple graph problem, finding the minimal spanning tree of any given graph. Back then, however, I thought it was just an odd puzzle.

I didn’t know this was a class of problem. I didn’t know this was rooted in mathematical theory, I didn’t know there were algorithms for solving this. I charged head first into solving the puzzle blindly. I ended up with a 90% complete solution that came very close to Prim’s algorithm. I submitted my crippled solution, and naturally didn’t get the position. Later, someone pointed out what class of problem it was, and I was off searching for it.

That’s when it hit me.

That’s when I found out how little I knew about my craft.

Since that day, I’ve regretted every year in that software engineering degree, every year I learnt things that I wasn’t interested in (management) that I could have spent doing computer science. If I could afford it, and if I could afford the time off, I would go back, start fresh and do a computer science degree. However, the more I learn, the more this desire fades. But there is not a day that I do not strive to fill the gaps in my knowledge myself.

I’m not bashing Software Engineering. I know it was my fault for not properly researching the course material offered, I know that I could have gotten what I missed from another institution. The only reason I know this, however, is because I learnt enough about the industry to know what I was missing, and subsequently, know what I needed. And that’s not something every potential high school graduate looking to get into programming will know.

It’s not enough to get a degree – you have to make sure you get the right degree, from the right place. Unfortunately, that generally takes more experience to judge than you have right out of high-school.

Passing Parameters in Actionscript

2008-12-28T00:00:00-08:00

While in the process of trying to learn Python, I decided it would be a good idea to attempt to learn some AI and AI related concepts at the same time using the PyGame framework, as advised by AIGameDev.

For a while, I’ve had this really nice steering demo/white paper in my Delicious account, something that I’ve meant to try implementing myself. Because this was entirely new territory, and I know my physics/math isn’t up to scratch, I decided to try to implement some of the behaviors outlined in the previous paper in Actionscript 3.0 first, then when I got the hang of it, port it to Python.

After about 8 hours or so, I had finally puzzled out the seek/flee behavior, and tried to put together a demo as in the above page, when I hit a strange bug. If I put the seek behavior vehicle on the stage on it’s own, it performed correctly. If I placed the flee behavior vehicle on the stage on it’s own, it performed correctly. If I had both on the stage at once, they freaked out and opposed one another, and the two vehicles often got caught in a state of equilibrium, their velocities canceling each other out.

It seemed as if my little vehicle views were sharing the same vehicle model, and the two different behaviors were acting on the same vehicle model. Which didn’t make any sense, considering they were two separate instances of the same class.

After a lot of bug testing and fiddling around, I finally realise I had been caught by the way Actionscript passes parameters into functions/constructors: unless you’re passing a primitive data type, Actionscript passes by reference.

I was instantiating my vehicles with the same velocity and starting position, and I was using arrays to pass in this information into the constructors, little knowing that the actual array each class was manipulating was the same array.
You can easily bypass this by importing

mx.utils.ObjectUtil

and using the

ObjectUtil.copy

method (remembering to cast it back to your desired data type, in my case an array).
So, if you find your instances seem to be sharing private variables they shouldn’t be, check your parameters and make sure you’re not passing things by reference to multiple instances and manipulating them.

Ruby Wrap Up

2008-12-25T00:00:00-08:00

Today marks the last day of my Ruby portion of my Ruby/Python Bootcamp. Unfortunately with the Christmas and related Christmas stresses, and an impending move, I didn’t get to spend a lot of time with the language, beyond the fundamentals.

I did a dumb thing, and started to try to get a website up and going on Rails 2.2. Rails is a great framework, although I’ve found the learning curve beyond your basic scaffolding and MVC set up to be fairly high. I made extensive use of this Rails API guide and it certainly helped a lot, as did the Ruby on Rails guides portal. The reason this was as dumb idea had nothing to do with Rails or Ruby, and everything to do with the fact I hate making websites.

Seriously, I’m on holiday. I should be staying away from websites for a while.

So, I didn’t end up doing much on the website I promised I’d show, and there’s not really anything to show, yet. I did manage to set up an excellent workflow with SVN and my web-host, which will eliminate the need for an FTP client, and Ruby did help me complete my partial understanding of RESTful design.

So, I walk away after a week of Ruby with a rudimentary knowledge of Ruby syntax, which is enough to let me read Ruby code and fill in the gaps myself, a stronger knowledge of RESTful design and a much smarter development workflow.

Thanks, Ruby.

So, tomorrow, or tonight, I’ll kick off Python, and I’ll also see if I can’t use it while investigating a few other programming related interests, like OpenGL programming or some AI stuff, if I can figure it out. Hopefully I’ll be able to get as much out of Python as I got out of Ruby.

First Impressions Of Ruby

2008-12-20T00:00:00-08:00

I like it.

A lot.

But I always knew I would. I’m so far impressed with how much effort Ruby goes to at making itself understood at a casual glance, and just how easy it is to write self documenting code. Writing code that’s free of braces and parenthesis is refreshing, and it’s nice to know the safety blanket is there (with regards to parenthesis for functions, conditional statements, etc) is there if I need it.

I started last night by flicking through Why’s (Poignant) Guide, and found it pretty good for the basics. I quickly picked up the general concepts and basic syntax fast, and Why’s Guide was pretty whimsical and kept things interesting. However I quickly bored of the absurdity in chapter 5 where the majority of its content is fluff.

I tried switching to SaphireSteel’s The Book of Ruby, however right at the start when the author stated:

if (subtotal < 0.0) then subtotal = 0.0 end

Putting everything on one line like this adds nothing to the clarity of the code, which is why I prefer to avoid it

I knew that this book would not help me. I already know many languages that require simple statements like that to be spread over multiple lines. I want a language to do this:

[code language=“ruby”]subtotal = 0.0 if subtotal < 0.0[/code]

Hi, Ruby.

Then I browsed over to Ruby in 20 Minutes and quickly flicked through the pages, and it concreted my knowledge. I like iterators, I like respond_to?, I like how everything seems to make sense. I also am pleased to see how many concepts map onto similar things in C#. Modules are like namespaces, but better. attr_accessor is like { get; set;}. attr_reader is like {get; private set;}.

I feel I’m ready to go find some code in the wild and attempt to read it. I’ll also see if I can come up with a post that maps Ruby concepts to C# concepts for other C# programmers interested in Ruby (and with IronRuby, there’s no reason why you shouldn’t be).

Ruby & Python Bootcamp

2008-12-19T00:00:00-08:00

It’s common advice in the programming industry to learn one new language every year to stay on top of things. It’s something I honestly believe in as well. Unfortunately I can’t say I’ve learnt a new language this year.

Last year, I learnt Actionscript 3.0, which is different enough from Actionscript 2.0 to be called a new language. I did this because of work, I did it in December and I had to do it fast. That worked pretty well for me. I got thrown in the deep end and had to learn or drown.

This year, with this being my last day at work for 2 weeks, I’m going to do the same thing, but I’m going to make it a little more interesting. I consider myself a reasonably competent programmer, and fairly solid in my knowledge of OOP paradigms. I think I can learn a language pretty quick. So, during my holidays, I’m going to:

See how fast I really can learn a language at least to the point where I know what to search for online and can find my own way around reasonably confidently.

See just how easily various concepts from different languages transfer across syntax

Build some stuff I’ve been meaning to build for a while but kept putting off

With that in mind, this year I’m going to learn both Ruby and Python in 2 weeks, dedicating a week to both languages. In the process of learning these languages, I will also build a base for 2 websites for 2 of my domains that I have been meaning to build. I won’t spend any time designing them, just building the code.

So, over the next 2 weeks, the majority of posts on here will be reflecting my thoughts on Ruby and Python, and linking to resources that I plan to use in my learning, with a final post being the unveiling of the websites I manage to build.

Wish me luck!

Wireframe Your Interfaces First

2008-12-17T00:00:00-08:00

As I’ve mentioned in a past post, I’m doing a rebuild of the CMS here at work and I’ve reached the point where the internals are done, and now I have to create a user interface for the application.

Now, in the past I have worked a variety of jobs and in those jobs a variety of roles. One of my jobs saw me as a web developer, like now, but with a difference: I was the only web developer.

I was responsible for quoting, requirements analysis, planning, design, development, testing, debugging, deployment and maintenance. If there’s only one thing I learned there, it was that web development is more than HTML and Javascript and a server side language, and a freelance web developer needs to know more than just programming and design.

What I really found hard was the design part.

That is, until I read somewhere that design is visual communication. Just like any other form of communication, you need to have a point, something to say. However, that point can very easily get lost in the minutiae of designing, of making sure something looks good.

I’ve found that wireframing is essential. You use the wireframe to establish the point of the page, the information that a page needs to contain, free of it’s appearance. You use the wireframe to tweak the structure, to experiment with different work flows. When you’re done, you go over the top and start designing.

Wireframing has enabled me to quickly build a general structure for a user interface, concentrating on the information and tasks that interface needs to perform.

I wireframe with Balsamiq, which I’ve found to be an excellent tool. You can try it out indefinitely on their site, fully functional, and all it costs is pop-up every 5 minutes asking you to buy it. I’m recommending we buy at least one copy for work, and I recommend you check it out if you want to make effective applications.

Learning Mathematics

2008-12-14T00:00:00-08:00

Although I’m proud of my education and work experience thus far, the most important thing I have come to realise is where the vast gaps in my education are. A little too late did I realise that the degree I really wanted was Computer Science, and instead I studied Software Engineering.

If you need someone to analyse a complex problem and break it down into it’s components, I can do that. If you need someone to manage a project and make sure your resources are optimised, I’m your man.

However, during my degree, we only breifly touched on mathematics and algorithms. If I recall correctly, we covered some basic boolean logic and very basically touched on sets. We didn’t really get into the nitty gritty stuff that I’ve seen CompSci graduates talk about.

However, I’m not the kind of person who would shrug “Oh well” and go about my business – I’m taking it upon myself to learn in my own time.

I don’t know how other people learn. Although I’ve done a little reading into it, I’m still trying to come to terms with how I learn. While trying to study mathematics, I’ve realised I have a tendency to explore various elements of a topic in depth – I tend to dive into the intricacies of a concept, then go back to the shallow level and move on to a new concept.

However, I’ve found that this is very difficult to do with mathematics. All of the higher level concepts rely on lower level concepts, and there is much cross referencing. I might be looking into Euler’s Totient function, which will lead me to the concept of coprimes, which will lead me to rings, which are contrasted to groups, which were referenced back in the totient function! What’s worse is all of these topics, especially the more abstractable rings and groups, extend past the real number systems, which I haven’t even considered yet.

I’ve found the best way to learn mathematics is to go broad and shallow, pick up the basic concept of all related concepts, then slowly work your way down. It results in a kind of net of understanding that isn’t complete, but allows a person to easily recognise holes, and more intuitively link concepts together.

Learning methods and methods of thinking are both subjects that fascinate me, and I’ll probably have a deeper look into it when I get some time. I think these topics have a vast impact one what kind of knowledge people can learn easily, and can account for people having a “knack” for something.

Compile a User Control as a DLL

2008-12-07T00:00:00-08:00

At work, I’m redeveloping the old, ASP 3.0 CMS application and replacing it with a shiny new .NET 3.5 implementation. The software is designed to be run as a virtual directory from all websites, and thus shares the same from installation to installation.

The old CMS is a mutant. It started as an ASP 3.0 application, and then had extra bits made of .NET 1.0 & .NET 2.0 tacked on to it, much in the same manner that Frankenstein’s monster was created. The core ASP 3.0 application handled the page/news creation and publishing, and served as the interface.

The additions were mostly in the form of user controls (.ascx files) that were placed in the content for a page that needed one. These user controls took care of things like random image rotators, contact forms, bread crumb menus, etc. Various sites used a various sub-section of a pool of controls.

The modus operandi with the current system is that each installation has it’s own collection of controls which are inserted into pages by us on behalf of the client, because it involves putting ASP.NET markup into the content areas.

I’ve decided this isn’t such a great idea, and as such, I’m centralising the user controls as a library, seperate from the CMS, so that each site accesses the single pool of controls, and if a client leaves, it will be relatively simple to recompile a new library with the controls they use.

Anyway, that’s the back story. Essentially what I need to do is compile a whole load of .ascx files into a dll, and load them into pages. I’ve spent all morning looking on Google for tips on how to do this. And frankly the results were less than helpful, however I have a history of not reading documentation properly.

What I found out you need to do, is to add a class library project to your solution, and add the .ascx file as per normal. However, you need to do several steps to get this working properly:

Go to the properties of your .ascx file and change the build action to Embedded Resource.

From your control declaration on the .ascx file, delete AutoEventWireup. We need to wire these things up ourselves. Personally I cleared it of everything except the language attribute.

In the old code behind (now unattached class file) for the .ascx, you need to override the OnLoad event handler, and put the following code:
[sourcecode language=“csharp”]
string content = String.Empty;
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), “example.ascx”);
using (StreamReader reader = new StreamReader(stream))
{
content = reader.ReadToEnd();
}
Control userControl = Page.ParseControl(content);
this.Controls.Add(control);
[/sourcecode]
This source will use reflection to open the currently executing dll (in this case, our .ascx library) and find the content for the .ascx, parse it as a new control and add it to the currently executing context.

For every control on the .ascx, in our now orphaned .ascx.cs you need to declare a private/protected variable of the same time, with the same variable name as the ID on the control (for sanity’s sake). You need to find this control in our newly loaded .ascx and assign a reference:
[sourcecode language=“csharp”]
labelInAscx = (Label)control.FindControl(“labelInAscx”);
[/sourcecode]

The above two steps is exactly what the AutoWireUp attribute on the control declaration does for you. We do it manually because we have to use reflection to extract the content of the ascx file, which is compiled into our dll.

After taking these steps, compile your project, and in another project, on a regular aspx page, register the assembly and use as you would any normal .ascx and hopefully the content will render out fine.

Compile .ascx as DLL solution for Visual Studio 2008

0.999... = 1 Is Important

2008-12-04T00:00:00-08:00

Before I get into this, I am not a mathematician. I’m not even an amateur. I’m just a guy who barely passed high school math 7 years ago, and who is interested in learning more.

It’s a generally accepted (though not completely) fact that 0.999… = 1. I’m not going to go into proofs, however if you need to see for yourself, you can find some at the Wikipedia article for 0.999… And I’m not going to debate or even acknowledge that people disagree, because that’s not the point of this post.

The point is, that 0.999… = 1 is an important concept that demonstrates the abstraction of the numeral from the number. The people who see 0.999… = 1 and can’t believe it, I believe, haven’t adequately realised there is a difference between a number and a numeral.

A numeral is a symbol that represents a number – that’s all it is. It is, of itself, inherently useless. The numeral doesn’t mean anything without the number. However, a number itself has meaning, no matter what numeral you use to represent it. This is what’s going on with 0.999… = 1.

The reason this distinction is important is one of advancement in mathematics, specifically in algebra and all other relatively abstract fields. When you realise that 1, the numeral, represents the number 1, and 0.999… the numeral, can also represent the number 1, you realise that 4/4 is also a valid numeral for the number 1. Then, it’s just a very small step to understanding that x can represent the number 1, and that in the equation 2x + y = 5, y also represents a number, and we need to find out that number.

Although the example I gave is trivial, I believe it’s an important concept to grasp, and it’s a concept many people don’t grasp.

Adobe AIR 1.5 Update Framework

2008-12-03T00:00:00-08:00

Lately I’ve been working on a small Adobe AIR application, and one of the last things I had to do for this application was build in auto-update functionality. So, naturally, I hit the all knowing sage with my question, and found many blog posts referencing the official Adobe AIR Update Framework, an additional swc library you can download and include in your project.

Last night I found out that this framework has been rolled into the latest AIR 1.5 SDK, so I checked my version and downloaded the update. My experience with the Flex SDK told me I’d have to find the SDK path in Flex Builder and point it to my new SDK to get the auto-update goodness.

This, however, was not the case – there was no variable. So I searched more online for the answers to my question, and finally found some official Adobe documentation. After a quick browse through, I deemed this useless. I still could not find how to get access to the ApplicationUpdaterUI class.

Eventually I re-read that documentation, and a section that I thought was incorrectly copied from the old update framework download actually held the key.

You still need to copy the swc library to your project.

Only, the swc is in the AIR SDK package, not available as a separate download. Having copied the library to my project, I then had access to the auto-update goodness, but no thanks to Adobe’s confusing documentation.

Interconnectivity of Media

2008-11-27T00:00:00-08:00

On the 27th of November, 2008, terrorists attacked Mumbai, India. They hit several places and killed 80 people (at the time of this post), and wounding many more.

I first heard about this through MSN via my girlfriend, who sent me a news link. Twitter lit up, several tweets about people’s reactions to the news, and with one of those tweets, a link to live CNN footage streaming online direct from Mumbai. A quick look on Google trends showed that the news of the events in India have circled the globe in less than 24 hours.

I saw this as well during the US Presidential elections, and it was even more intense. Twitter was non-stop tweeting about the various speeches and states, every major international news site had a streaming video and up to date Flash based maps for voting, and Google trends was all about the election and Prop 8. I was watching live footage of Obama’s and McCain’s speeches, and footage from Kenya.

I felt it then, and I feel it now: overwhelming awe.

The growth of the internet since 1983, away from a purely academic/military network with text only media, to today with streaming video and interactive content, has truly made our world a global community.

Working day to day on the internet, creating websites to further the individual causes of various people, it’s easy to lose site of how awesome the internet really is, and how interconnected everything is these days.

It’s nice to be able to take a step back.

Wordpress Or Roll Your Own

2008-11-26T00:00:00-08:00

Laziness is a good quality for a programmer to have. Code reuse is smart, it’s fast and efficient, and leads to less bugs (depending on how popular the code you use is).

I know this.

I’ve known this since university. Do I do it? I’m starting to, I’m slowly learning it. This is relevant, because prior to setting up Wordpress on my server, I developed roughly 4 version of my own PHP blogging platform. Two of them were relatively usable though still buggy, and 2 of them never made it past the full execution stack stage.

Now, when I phrase it like this, it doesn’t seem so bad, but I was constantly referencing Wordpress admin screen shots and had installs of Wordpress, Joomla and Drupal to pick and choose interface elements and functionality that I liked from these software applications.

I had planned to start from scratch and slowly build up the featureset of my application to match those of the more popular open source applications. And to get experience I planned to use these applications… but only in a sandbox, which was not publicly accessible.

At the same time as trying to develop, in my own time, my own blogging/CMS solution, I’m upgrading the CMS we use at work. This upgrade is a complete rewrite, migrating the funcitonality from ASP Classic to ASP.NET. This involves designing and developing, on my own, a fully functioning CMS system with support for page editing and a news section.

So I was spending all time at work during the day creating an ASP.NET CMS, then coming home at the end of the day to fire up Zend Studio and do the exact same thing in PHP. I was reluctant to program, and the application was stalling, and I wasn’t blogging.

And the worst, I wasn’t aware of why I was stalling, and why I didn’t want to work on it. I would spend my time at home goofing off, watching movies and chatting to friends. At least I had the intelligence to sit down and design a theme for my blog, once the code was finished. But I still wasn’t developing the blog engine, and the whole process became this big elephant in the room that I was trying to ignore, blocking the doorway to me finally starting to do something I’ve been wanting to do for a while.

I didn’t realise the lunacy of what I was doing until I stepped back and started programming something else entirely unrelated to both PHP and blogs. Once I had done so I realised a shocking truth: I don’t even like programming websites.

At least, not in my own time.

Programming blog engines and CMSes isn’t something I want to spend all my time doing. I want to work on other projects, push the boundaries of my own knowledge – but the blog/CMS thing is a rut that I’ve fallen into. Been there, done that, I know the problem well and I know the solution well.

So, something to take away from my experience is this:

Unless your business/hobby/passion is writing blog engines, just use an off the shelf one. Your time is better spent actually blogging than writing a blog engine. You learn more, it’s generally more interesting, and you’re creating content sooner.

And isn’t content what it’s all about in the end?

Why Blog?

2008-11-25T00:00:00-08:00

Or to put it another way, why you should care about this blog.

Just in setting this blog up, I’ve learnt many things, many things that I can share with people. Is this why I’m choosing to blog? Partially. But the really compelling reason is learning.

I’ve often heard it said that if you want to learn more about something, teach it. Through experiences on online forums, helping people with code, I find that this is a true statement. However, teaching in a classroom is beyond me – both in terms of time and in terms of relative skill levels. So I’m turning to the internet, a blog, to write about and share my experiences. Not because I think I’m qualified to teach anyone, but because I’m not.

So, we come back to the question, “who is this guy, and why should I listen to him?”

I’m a 24 year old developer currently living in Perth, Western Australia. I have a Bachelor of Science (Software Engineering) that I obtained from the Edith Cowan University. I have been working in the field of programming since late 2005. I have worked as a debugger/maintenance programmer for a desktop application for a now gone Perth startup, I have worked as a one-stop web development shop for a small company that also doesn’t exist, and am currently a backend developer for a web development company.

But none of that is important.

I have worked in Actionscript 2.0, Director Lingo, ASP 3.0, PHP, ASP.NET (C#) and Actionscript 3.0, all in major projects. I have worked extensively with MySQL, PostgreSQL and SQL Server. I have developed both desktop applications and web applications, as well as web services and desktop Windows services. I am familiar with Windows OSes, OS X and Linux based systems. I can adequately administrate both IIS and Apache servers.

None of that is important either.

What is important is that I have made mistakes. A lot of mistakes. About 10 years worth of mistakes. From those mistakes, I have learnt a lot, and I have clear goals in life.
I have made lifestyle mistakes, scholastic mistakes, career mistakes and mistakes in programming. I have tanked a couple of large projects, and have sabotaged my own efforts at starting and maintaining a small business.

From these mistakes comes a passion for correcting what I can – and to do that, I have to learn. I have to upgrade my skills, I have to grow as a person. I intend to do that by writing about them. Both to sort my own thoughts out, and to recieve feedback and learn from that feedback.

That’s why you should listen to me. And tell me when I’m wrong, and tell me when I’m being stupid and tell me when I am getting it right.

I want to learn everything I can, and while learning, hopefully give something back.

Estimation	Quotient	Mean
1	\(\frac{2}{1} = 2\)	1.5
1.5	\(\frac{2}{1.5} = 1.333\)	1.4167
1.4167	\(\frac{2}{1.4167} = 1.4118\)	1.4142
1.4142	..	..