STEP 1: Make a directory called temp\. Let’s put it on the Desktop.

STEP 2: Put the Quicktime movie you’d like to convert in the new temp\ directory.

STEP 3: Download a 32-bit version of ffmpeg from here: http://ffmpeg.zeranoe.com/builds/win32/static/. Decompress the 7z file. You may need to download and install 7-zip if you don’t already have it: http://www.7-zip.org/download.html. The result should look something like this:

STEP 4: Open a command prompt by navigating to Start Menu > Run.

STEP 5: Type cmd and press Enter.

STEP 6: cd to the temp\ directory on the Desktop.

STEP 7: Run the ffmpegcommand replacing quicktime.mov with your movie file and replace quicktime.avi with your desired output file:

ffmpeg -i aoeu.mov aoeu.avi

Here is an example:

Press ENTER and you have successfully converted your file to the AVI format!

What does it do?

Vi (pronounced vee-eye) is a text editor. It allows you to edit files interactively and visually see the changes at the same time.

The original Vi is a modal editor consisting of two modes: normal mode and insert mode. In normal mode, keystrokes are interpreted as commands (i.e. – “j” moves down one line and “k” moves up one line). In insert mode, keystrokes are typed directly into the file being edited. Many of the text editor applications we are familiar with consist of only a single insert mode: Microsoft Word, Notepad, Wordpad, and even the email editor web applications (i.e. – Gmail).

What does it not do?

The original Vi text editor does not format the text in your files. Bold, italics, underlining, font size, font color (the list goes on) are not features of Vi. Vi does not do spell-checking. Vi does not do any syntax highlighting for programming languages like Perl, Python, etc.

As over 30 years have gone by since vi was created, many clones have been created: Stevie, Elvis, nvi and Vim, just to name a few. Many of these clones have plug-ins that support spell-check, syntax highlighting, and much more.

Where does it come from?

Vi is the visual mode of  a line editor called ex.

However, it all started with ed which is a UNIX command line editor for teletypes. ed was written by Ken Thompson in 1971. In February 1976, George Coulouris modified Thompson’s code and created em editor which is designed for display terminals. Bill Joy and Chuck Haley then took em, modified it to create en, and then modified that to create ex.

In October 1977, vi was born from the mind of Bill Joy. It was officially released as the visual mode of ex 1.1 in the first BSD Unix release in March 1978. Seeing the popularity of the visual mode, ex 2.0  included a short-cut to go directly to the visual mode by using the command vi.

When should you run it?

Anytime you need to edit a text file, vi can be run. For example, to edit help.txt, type: vi help.txt. Vi will launch and display the contents of help.txt.It is important to avoid the use of vi in the presence of an adamant EMACS user (especially Church of EMACS members). The possibility of being insulted, attacked or even becoming the target of an evangelistic conversion process are all within the realm of reality. In all seriousness, the vi vs. EMACS debate is an on-going rivalry that will likely have no end. Caveat emptor…

Next Steps

Check out some of the references below for more information about vi and its family of clones. If Vi gives you a warm fuzzy feeling, make sure to check out Vim … the de facto Vi clone these days. It even has a great support for Windows!

References

Wikipedia – Vi
http://en.wikipedia.org/wiki/Vi

The Vi Lovers Home Page
http://thomer.com/vi/vi.html

Wikipedia – Ed (text editor)
http://en.wikipedia.org/wiki/Ed_(text_editor)

Vim, The Editor
http://vim.sourceforge.net/

An Introduction to Display Editing with Vi
http://docs.freebsd.org/44doc/usd/12.vi/paper.html

Wikipedia – Editor War
http://en.wikipedia.org/wiki/Editor_war

I looked around on the Internet and didn’t find a simple, no frills unit test framework for PowerShell that leveraged Hamcrest matchers. So I wrote one! Being relatively new to PowerShell, I probably haven’t leveraged common PowerShell idioms. Hopefully, it’s easy enough to modify and tailor to your project. This is my first shot at it. Comments and suggestions are welcome!

Official PSHamcrest Page:
http://rayli.net/blog/pshamcrest

Codeplex Page:
http://pshamcrest.codeplex.com/

Latest release:
http://pshamcrest.codeplex.com/releases

Browse the latest source code:
http://pshamcrest.codeplex.com/SourceControl/BrowseLatest

Things you’ll need:

1. Second computer with a CD or DVD drive.
2. USB drive that has enough capacity to store the CD/DVD contents.

You’ll need a computer with a CD or DVD drive that can read your Office 2010 installation CD/DVD. Here’s what you do:

1. Using the second computer, copy the contents of the CD/DVD to your USB drive.
2. A trial version of Office came with my Acer Aspire One netbook. To get as clean an installation as possible, I uninstalled Office from my netbook first.
3. Plug the USB drive into your netbook.
4. Run the Office Setup file from your USB drive.
5. Make sure you have the product key.
6. Install, activate and enjoy your Office 2010 Professional installation!

I’m running a Lenovo Thinkpad W500, Windows 7 64-bit and Firefox 5. To get Firefox scrolling working, I updated the UltraNav driver. Previously, I was running v13.2.4.12 (Jul-14-2009). Updating it to v15.3.6.0 (May-5-2011) and rebooting fixed the scrolling. Hopefully, it works for you, too.

The UltraNav driver for Windows 7 (32-bit, 64-bit), Vista (32-bit, 64-bit) and XP (32-bit, 64-bit) can be found on the Lenovo Support site.

The process for opening OneNote notebooks that weren’t created on your phone is a bit awkward, but once you get used to it, it only takes the minute or so to login to SkyDrive and off you go! The basic idea is to navigate to your document in SkyDrive and open your OneNote notebook from there.

1. In your Windows Phone 7 browser, navigate to http://skydrive.live.com. If you’re using IE, make sure your “Website preference” is set to “Mobile version.”
2. In SkyDrive, navigate to the OneNote document you’d like to open on your mobile device and click on it.
3. And that’s all there is! The OneNote document is now imported onto your phone.

The Kensington Orbit Trackball with Scroll Ring is as simple and practical as it gets. Without repeating my review, you can check it out on Amazon: Raymond Li’s review of Kensington Orbit Trackball with Scroll Ring.

What is particle swarm optimization?

Particle swarm optimization (PSO) is an algorithm whose goal is to find the optimal solution for a problem.

Give me an example.

Let’s say the problem you’re attempting to solve is x*x + y*y = 0. Potential solutions to this problem consist of (x,y) pairs. Any (x,y) pair could be a potential solution:

• (1,3)
• (4,2)
• (5,9)

In PSO, a potential solution is represented by a particle. Therefore, a particle with the values (1,3) represents the potential solution (1,3). If x and y are coordinates on an x-y coordinate system, the particle with the values (1,3) would be positioned at x=1 and y=3. If the particle moves to x=4 and y=2, it now represents a different potential solution, namely (4,2).

Each time the particle moves to a different position, it uses its (x,y) values and plugs them into the problem (x*x+y*y=0) to see if it gets 0. If not, it moves to another location which represents yet another potential solution. If more than one of these particles is moving around looking for potential solutions, we get a particle swarm. Particle swarms moving around in this manner are searching for the optimal solution to the problem.

This seems like random guesswork. How does the particle swarm find the right solution?

The short answer is that each particle’s movement is not completely random. Particles are influenced by their personal experience and the experience of the entire swarm. Due to these influences, the swarm tends to converge on the optimal solution.

What is a particle’s personal experience?

Every particle remembers the best solution it has come across in its own personal experience. As the particle moves from position to position, it plugs them into the problem and gets a result. The closer this result is to 0, the closer it is to the optimal or “right” solution. When the particle encounters a solution that is more optimal than the solution currently in its memory, the new solution replaces the older, less optimal solution in the particle’s memory.

Cool… so what’s the experience of the entire swarm?

When a particle moves to a different position, not only is the new solution compared with the particle’s memory, the solution is compared with the swarm’s memory. If the new solution is more optimal than the current solution in the swarm’s memory, the new solution replaces the less optimal solution in the swarm’s memory. In addition to each particle remembering the single most optimal solution it’s found so far, the swarm also remembers the single most optimal solution found so far.

How do these experiences influence the particle’s movement?

The actual mechanics of how the particle is influenced will be explained in another post. Despite the particle flying around randomly, it has a tendency to be pulled in the direction of its best personal solution as well as the swarm’s best solution.

But how does it find the best solution?

There is no guarantee that it finds the best solution.

The particles are randomly searching all solutions with a tendency to be pulled in the direction of the best solution it’s found and the best solution found by the swarm. This tendency makes the swarm focus its search in relatively promising regions in hopes of finding a better solution.

It’s possible for a swarm to converge on a non-optimal solution too quickly before getting a chance to search the rest of the solutions. Balancing the weight of influence from both personal and swarm experience is one of the most important factors for the swarm converging on the optimal solution.

Where can I find more information about PSO?

If you’re looking for the paper that started it all, here’s the original paper from Kennedy and Eberhart: Particle Swarm Optimization.

A really good tutorial on the basics of PSO: PSO Tutorial.

Maybe you want to see PSO in action: Source Code Library: Particle Swarm Optimisation (PSO).

Wikipedia’s take on PSO: Particle swarm optimization.

After incorporating binary serialization into a C# application that loaded data from an Excel spreadsheet, I was able to get a 33% decrease in execution time by caching the generated object into a binary file. It’s a quick-and-dirty way to get a speed increase especially when you’re loading a lot of external data that changes, but doesn’t change frequently.

The first step for serializing a class into a binary file is to mark the class as Serializable.

[Serializable]
public class YourClass
{
	// your class definition.
}

Now that your class is ready to be serialized, you can use ObjectSerializer. The ObjectSerializer class below allows anyone to serialize an object into a binary file. Serializing or de-serializing a class marked with the [Serializable] attribute takes no more than 3 lines of C# code.

public class ObjectSerializer<T>
{
	protected IFormatter iformatter;

	public ObjectSerializer()
	{
		this.iformatter = new BinaryFormatter();
	}

	public T GetSerializedObject(string filename)
	{
		if (File.Exists(filename))
		{
			Stream inStream = new FileStream(
				filename,
				FileMode.Open,
				FileAccess.Read,
				FileShare.Read);
			T obj = (T)this.iformatter.Deserialize(inStream);
			inStream.Close();
			return obj;
		}
		return default(T);
	}

	public void SaveSerializedObject(T obj, string filename)
	{
		Stream outStream = new FileStream(
			filename,
			FileMode.Create,
			FileAccess.Write,
			FileShare.None);
		this.iformatter.Serialize(outStream, obj);
		outStream.Close();
	}
}

To serialize an object using ObjectSerializer, first instantiate the ObjectSerializer class. Then use the SaveSerialziedObject() method to serialize the object.

YourClass yourObject = new YourClass();
ObjectSerializer<YourClass> objSerializer =
	new ObjectSerializer<YourClass>();

// serializes yourClass to SomeFilename.bin.
objSerializer.SaveSerializedObject(yourObject, "SomeFilename.bin");

To deserialize the binary file generated from the previous operation, instantiate the ObjectSerializer class. Then use the GetSerializedObject() method to retrieve the original object.

ObjectSerializer<YourClass> objSerializer =
	new ObjectSerializer<YourClass>();

// deserializes yourClass from SomeFilename.bin.
YourClass yourObjectFromFile =
	objSerializer.GetSerializedObject("SomeFilename.bin");

And there you have it… quick-and-dirty binary serialization in C#!

• 10F ≈ -10C
• 32F = 0C (melting point of water)
• 40F ≈ 4C
• 70F ≈ 20C
• 100F ≈ 40C

Converting Fahrenheit to Celsius

1. Take your Fahrenheit temperature, and subtract 32 from it. Let’s say the temperature is 50F. Our result is then 50 – 32 = 18.
2. Multiply the result by 5. In our example, we do the multiplication and get 18 x 5 = 90.
3. Divide the result by 9 to get our final Celsius result, 90 ÷ 9 = 10C.

Fahrenheit to Celsius formula: (F-32) x 5 ÷ 9 = C

Convert Celsius to Fahrenheit

1. Take your Celsius temperature, and multiply by 9. Let’s say the temperature is 25C. Our result is then 25 x 9 = 225.
2. Divide the result by 5. In our example, we do the division and get 225 ÷ 5 = 45.
3. Add 32 to the result to get our final Fahrenheit result, 45 + 32 = 77.

Celsius to Fahrenheit formula: C x 9 ÷ 5 + 32 = F

Why is -40F = -40C?

Oddly enough, -40F is not colder than -40C. Yes, they are both really cold, but they are also exactly the same temperature. Let’s use the formulas from above and try it out.

Convert -40F to Celsius

1. (F-32) x 5 ÷ 9
2. (-40-32) x 5 ÷ 9
3. -72 x 5 ÷ 9 = -40

Convert -40C to Fahrenheit

1. (C x 9 ÷ 5) + 32
2. (-40 x 9 ÷ 5) + 32
3. -72 + 32 = -40

Exactly the same!