You can use Visual Studio (C++, C# and VB.NET supported) and get quite interesting results.

Here are a series of links below which will help you get started.

1. Download and install the Kinect SDK
2. Download and install Quickstart Samples and Slides (zip file)
3. Understanding the Kinect hardware
4. Setting up your Dev Environment
5. Understanding the basics of skeletal tracking using the Kinect sensor
6. Understanding camera fundamentals
7. Understanding the audio fundamentals
8. Playing with the Coding4Fun Kinect toolkit and seeing how one can build cool apps such as:
• Kinect Paint (which uses skeleton tracking)
• Kinect Mouse which uses your hands as the mouse cursor

Keep and eye out on the Coding4Fun Kinect blog.

I have never bought a UPS until now and don’t have any experience with it – what are the things that I need to consider? I will have the following equipment running which will need to be powered up for about 15 minutes:

• 4 Desktops (including a MCE and WHS)
• Two 17” LCD Monitors
• A set of powered Speakers (optional)
• Few switches
• KVM Switch
• VOIP Phone
• Wireless Router
• DSL Modem

Would it make sense to buy a few smaller UPS’s instead of one big one? Which is a good one? How much wattage/capacity should I look to get? Can one get second-hand ones – are they recommended? Does the UPS required any maintenance or are they maintenance free these days?

Of all the machines, the WHS is one of the most critical ones. Is there any UPS’s which work well with some Add-Ins? I am interested in WHS shutting down in an orderly fashion so as to save all the data whenever the UPS battery gets low (in case for some reason the generators don’t kick in).

I also wanted to know if there is any opensource (or not too expensive), network management or network analyser for a ZigBee network? Essentially I want to be able to programatically view network and node information on the ZigBee network (e.g. S/N ratio, signal strength, etc.) – something similar to Ember’s Insight Desktop which shows the details I am interested in. I could not find anything specific and would be interested in getting ideas.

The Cray XMT does this by switching among 128 concurrent threads. As the XMT supports more than 8000 CPUs, if one needs to maximize throughput the developer must provide at least 128 threads per CPU, With 8K CPUs you are looking at over 1,024,000 threads! Needless to say, with such large number of threads, it is extremely important to get thread management implemented correctly – without that the system won’t be able to scale and even deadlock.

Another factor is the application design specifically the parallel programming models (including the recursive threaded models) and resource management to be able to successfully handle resource exhaustion.

If this is an area of interest then you should check out the likes of OpenMP, Parallel Extension to .NET 4 (which include PLINQ and TPL), CCR, etc.

Underpinning all of this of course is Amdahl’s law which one should be comfortable with; including its relation to the law of diminishing returns.

I wonder, where I can I get some time on a Cray XMT? I can also settle for a Cray CX1 – anyone willing to donate some money to a poor geek to help with this?

• parser_optimization="complexity"
• allow_early_termination="true"
• early_terminate_optional_fields="true"

This got me thinking more and wanting to understand what does changing these attributes mean under the covers. Below is what I found out on each of these.

On parser_optimization:

• Setting the parser_optimization to complex essentially generates a more complicated grammar (it uses both a top down and bottom up parsing); this grammar is then used to parse the FF.
• The complicated grammar is better when parsing records with more optional nested options – however it still cannot handle all the layout conditions and can still break in some situations.
• And given the runtime is doing more things, this will be slower than the other option called ‘speed’ (yeah no kidding Sherlock!).
  • The reason the ‘speed’ option is faster is because it uses top-down parsing only.
• In addition you should also set lookahead_depth to zero (more on this below) to avoid validation failures (against a schema) when there are many optional nodes in the same group/record.

Changing the lookahead_depth itself is trivial but you need to be a little more aware of what this means:

• This essentially tells the parser when making a parsing prediction how far ahead to look in the token stream.
• Setting this to Zero essentially means ‘infinite lookahead’ which in turn means more memory will be consumed.
• Depending on how busy your BizTalk servers are and how much memory pressure you already experience processing various files (and their sizes), this might be an issue.

Basically, the FF parser is a streaming parser and implemented as a leftmost derivation which takes in a CFG. Essentially when we change the lookahead_depth to zero we change do not restrict this and the parser can recognize tokens using DFA perhaps (of course we don’t know the real implementation).

For those old school like me, and have played with yacc – that is a LL(1) parser – essentially parse the grammar with one token lookahead.

On allow_early_termination="true":

• When working with FF’s BizTalk expects that every line is of the same length (either because of the data contained padded with spaces). However if it finds a newline (CR + LF) character then it breaks and you get an error something along the lines of “Unexpected data found while looking for: \r\n”.
• Adding the allow_early_termination setting helps fix this. Read more here.
• Also note that only the right-most positional field is allowed to early terminate.

Lastly, the early_terminate_optional_fields attribute enables early termination of optional trailing fields. A couple of points to note on this:

• If your schema does not have this annotation and you open that in the BizTalk editor, then it will automatically add this annotation explicitly and set it to the default value of False.
• This only takes affect if you also have the allow_early_termination annotation set to True.
• More details on this here.

And in case you were wondering this is a supported option by Microsoft as shown in this KB article.

1. Modify the file /etc/apt/sources.list (make sure you run it via sudo something like: sudo gedit /etc/apt/sources.list)
2. Add the following two lines in the end and save the file:
1. deb http://openscenegraph.dachary.org/packaging-farm/openscenegraph/gnulinux/debian/unstable/src ./
2. deb-src http://openscenegraph.dachary.org/packaging-farm/openscenegraph/gnulinux/debian/unstable/src ./ 
3. Run in the terminal: sudo apt-get update
4. And finally run: sudo apt-get install openscenegraph

Grrr … b**tards!

Here is the scenario:

Say I have a remote controlled aircraft (a mini helicopter) which among other things has a camera fitted which is filming over a certain area. I use a training set and somehow “train” the camera to look for certain objects and recognise data points of that object and learn it to recognize that object (for example a human in Pink). Now once this is trained, if the helicopter is over another area and recording I want it to be able to recognise these pre-trained images in that video feed and do something if something is found (e.g. a human in pink).

The closest “CSI” analogy I can think of is – the facial recognition which they show to be iterating through hundreds of photos comparing data points (which of course as we all know this is mostly fiction – but that is a discussion point for another day).

So the question:

What does it take to compare objects in video feeds? I am not really interested in knowing how to “train” and find a pink human – but rather how to reliably and possibly quickly (within reason of course) compare and see if two are the same of the pattern. This should also reduce the false positives – e.g. a pink table might look like a human in pink with the environmental factors (shadows, sunlight, rain, angle of camera, etc.). I have read a little online but don’t have any experience in the subject.

Has anyone done this (or something similar) in the past or have any pointers for me?

If an event source does not exist, it is automatically created. The creation of the event source is a privileged operation and requires elevated privileges (a.k.a admin privileges) which of course might not always be possible if running a web application.

The easiest way to create this event source is via a reg file. An example is below (credit goes to my colleague Dominic to provide me the original sample).

Note: you need all the lines below including the “Windows Registry Editor Version 5.00”.

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\Application\YOUR-APPLICATION-NAME-GOES-HERE]

"EventMessageFile"=hex(2):43,00,3a,00,5c,00,57,00,49,00,4e,00,44,00,4f,00,57,\

  00,53,00,5c,00,4d,00,69,00,63,00,72,00,6f,00,73,00,6f,00,66,00,74,00,2e,00,\

  4e,00,45,00,54,00,5c,00,46,00,72,00,61,00,6d,00,65,00,77,00,6f,00,72,00,6b,\

  00,5c,00,76,00,32,00,2e,00,30,00,2e,00,35,00,30,00,37,00,32,00,37,00,5c,00,\

  45,00,76,00,65,00,6e,00,74,00,4c,00,6f,00,67,00,4d,00,65,00,73,00,73,00,61,\

  00,67,00,65,00,73,00,2e,00,64,00,6c,00,6c,00,00,00

So here is a tip to get you to upgrade without doing a complete fresh install where you “fool” the installer in thinking you have a different version to allow you to upgrade.

You need to do the following steps, before inserting the Windows DVD

1. Go to, Start, Run: and type: regedit.exe
2. Go to HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion
3. Change the key: ProductName from "Windows 7  Enterprise” to “Windows 7 Business” or to “Windows 7 Ultimate”
4. Change the key: EditionID from "Enterprise" to “Business” or to “Ultimate”
5. Do not restart!
6. Now insert Windows DVD and start upgrading (the option Upgrade will not be graded out anymore)

Of course you will need the appropriate licences and still need to activate, etc.

*Sigh* I hate disc failures.

Prelude> foldr (+) 0 [1..100]
5050
Prelude> foldl (+) 0 [1..100]
5050
Prelude> foldl (+) 0 [1..1000]
500500
Prelude> foldl (+) 0 [1..10000]
50005000
Prelude> foldl (+) 0 [1..100000]
5000050000
Prelude> foldl (+) 0 [1..1000000]
*** Exception: stack overflow

On the other hand, foldl' while similar to foldl does not build up on thunks and in real world programs is probably more useful.

Prelude> :module +Data.List
Prelude Data.List> foldl' (+) 0 [1..1000000]
500000500000
Prelude Data.List> foldl' (+) 0 [1..1000000]
500000500000
Prelude Data.List> foldl' (+) 0 [1..10000000]
50000005000000