The BDP-S350 supports true 1080p output and is compatible with Dolby TrueHD. Unlike the majority of the previous generation of blu-ray players, the BDP-S350 features an Ethernet connection to enable BD-Live features as well as firmware upgrades. Another cool feature on the BDP-S350 is the USB port for BD-Live external memory.

Have you ever confronted compiler or linker errors while building a Intel(R) Threading Building Blocks (TBB) based application with Microsoft* Visual Studio*? What was the problem there? Perhaps the path to the TBB headers was absent? Or TBB libraries were not added to the project settings? Or maybe different TBB versions were mixed? Have you ever thought it would be great to have a tool that could configure Visual Studio projects to use TBB by the single press of a button, so you would avoid all that annoying errors?

The great news for you: such a tool already exists and available at the ‘Downloads | Extras' page under ‘msvs_plugin' link. This tool, the TBB integration plug-in, provides a simple mechanism to set up the use of TBB in Microsoft* Visual C++* projects. The plug-in adds the TBB paths into Visual C++ project settings and properly specifies the TBB libraries to link with. It works with all Visual Studio versions that TBB supports, namely Visual Studio 2003, 2005 and 2008, but keep in mind that the tool doesn't work with Visual Studio Express Editions because those don't support add-in projects.

At first you should install the plug-in. Although it requires going through a set of installation steps the process is very simple. For Visual Studio 2005 copying the plug-in files into ‘My Documents\Visual Studio 2005\Addins' folder is enough; similarly for Visual Studio 2008. Looks simple, doesn't it? For Visual Studio 2003 several additional installation steps are required but it is also easy. Detailed installation instructions can be found in Readme.txt that is part of the plug-in package.

Well, now, after the plug-in has been successfully installed you can integrate TBB into your Visual C++ projects by one click, or switch between TBB versions easily. For that right-click on the project item in the Solution Explorer and open the "Use Intel(R) TBB" sub-menu in the project context menu as shown at Figure 1.

Figure 1. A sample of “Use Intel(R) TBB” sub-menu

In this sub-menu you will see a list of the TBB versions that can be used in your projects. This list is created on basis of the plug-in configuration file called paths.xml which is also a part of the plug-in package. On Figure 2 below you can see an example of the configuration file. By the way, exactly this sample is provided with the plug-in and it corresponds to the sub-menu displayed on Figure 1 above.

Figure 2. A sample of paths.xml file

As far as you can see from Figure 2 two TBB versions are specified in the XML file by default: TBB 2.0 and TBB 2.1. Correspondingly, the integration sub-menu has two items. We fully rely on the information provided by the user because it would be difficult to track all open-source TBB packages on a machine and determine where they are installed. If necessary, you can specify more TBB versions by adding new <TBB> tags to the configuration file. A <TBB> tag has several sub-tags. Generally, you need to specify all these sub-tags; otherwise the corresponding paths will not be added to your projects. You might however omit ‘mode="64"' tags if you only work with 32-bit applications, and vice versa. One more thing that I would like to note: if you use variables like $(TBB21_INSTALL_DIR) above, then don't forget to add them to your Windows* environment.  

However let's return to our example. As you maybe already noticed, the text ‘TBB 2.0' displayed in the TBB integration sub-menu matches the ‘version_name' attribute from the XML file. The name can be any string that you like. But why is TBB 2.0 disabled? The reason is quite simple: the folder specified under <TBB_INCLUDE_DIR> tag doesn't exist, which must be means that TBB 2.0 is not installed; so, it doesn't make sense to integrate this TBB version.

Along with the fact that the plug-in is easy-to-install and easy-to-use it can be also easily switched off: you just need to deselect it in the ‘Tool | Add-in Manager' menu (Figure 3).

Figure 3. Add-in Manager menu

So, here I introduced you the tool that simplifies setting a Visual C++ project to use Intel(R) Threading Building Blocks. Hope that it will be useful for you in your work with TBB and that you will like it. Your feedbacks will be very much appreciated and will allow us to improve the plug-in. Please, don't hesitate to provide us your opinion about it.

I love reading case studies of teams that shake up "business as usual" and reinvent their world.  It inspires me to be open to the possibilities of such change.

If you are involved at all in software engineering, check out this blog entry by the Songbird development team as it shows their shift from the traditional waterfall model to Agile methods.

There are some good ideas here, some of which might be adoptable to your own work.

The traditional waterfall model has taken a huge number of deadly arrows over the course of my little lifetime in tech:

• The book Microsoft Secrets shows that in the early 90s, Microsoft couldn't manage their humongous Office projects with the traditional model and went to an "synch and stabilize" model to get things under control.
• Practices on the Internet have created an implicit demand that every downloadable software project will have both a stable version and the latest development version available for download. This doesn't work with the traditional waterfall model, because development builds for the waterfall model are not guaranteed to work.
• Back in my old Sequent days, working on the OS, we always had the standard that "you never break the build" but we never put our weekly builds out on the Internet for just anyone to download. I'm incredibly impressed with the stability and quality of bi-weekly builds of huge projects like OpenSolaris. For most purposes, you could probably take one of those builds and chances are, be quite happy with it.
• Yet, many famous and hugely profitable software enterprises seem to run on the waterfall model from all external evidence. I don't need to mention these.

By the way, Songbird is a fine open source music service / desktop media player. It's like a marriage of iTunes and Firefox. Worth a look. Screenshot below.

Fortunately for all the people who don't work for Intel and might want to enter, there are some new articles in the wiki from Intel engineers that you can start adding to.  For example, we've started publishing some internal information like "Connecting Wirelessly from a MID" and "Linux Profiling on MID".   More are on the way.

We're also trying something by taking some content that was planned for a PDF formatted "white paper" and putting it in the MID Wiki instead.  Now it will be easier for us to keep up to date in addition to getting input from people who find it the content helpful.  Loc Nguyen was the first to give this a try with his information on using the D-Bus message bus.  Feedback (and contributions) are welcome!

Hopefully some of this helps give you ideas on where to contribute to the MID Wiki.  And if you just don't like money, you can certainly contribute for the glory of it all!

Click to play

This week's show is only 30 minutes long and weighs about 28MB (it’s a 128kbps MP3). You can download the file directly, listen using the streaming player above, or (BEST OPTION!!1!) subscribe to the Bit Stories podcast feed in your favorite podcast aggregator (like iTunes). If you subscribe to the feed, you’ll get each show delivered automatically as it becomes available - probably once a week or so, with the occasional bonus video or audio segment thrown in for fun. Plus, we’ll love you forever if you subscribe! :-)

Here are some free form notes from today's show:

• Yet Another Audio Setup

• Embarrassing Confession: We recorded the last two shows using the built-in mic on my MacBook Pro, instead of the elaborate mixer/condenser mic that we have set up. Because I'm an idiot. The saving grace? It sounded pretty darn good! :-)
• Have developers let the Tablet PC community down?
• Brian paved and reinstalled Windows XP on his Samsung Q1 UMPC
• Why XP instead of Vista? Not quite enough horsepower.
• Josh has done the same thing (gone back and forth between XP and Vista) on his Asus R2H UMPC
• Speaking of mobile device operating systems... Moblin.org
• What the heck IS Moblin? Is it an OS?
• Moblin is a stack of tools to help create OSes and applications for Mobile Internet Devices. It's sponsored by Intel, and hosted by Intel Software Network
• Ubuntu Mobile Edition (UME) sneak peak is out there, if you have a Samsung Q1 Ultra
• Brian feels that he won't be able to use a Linux-based MID because of the lack of mature ink/handwriting input support
• It's really hard to do an ink interface well
• Will Atom-based devices ever have the horsepower to do handwriting well? Is this a hardware or a software problem?
• Do open source projects do better when there's a common, widespread demand and need for the result (like a web browser)? Do enough people in the open source community need and/or want good ink and handwriting support to motivate them to write it? Would enough people use it and care about it to make it worth their time?
• Since Mobile Internet Devices are all about the Internet, having a good browser is going to be essential.
• Windows versus Linux on these small, pocketable internet devices.
• In general, lack of UI "polish" in Linux applications is a deterrent for non-geeks to adopt it.
• Brian's "essential" applications on his Samsung Q1: Microsoft Office, Firefox, and Microsoft Money
• Is Firefox the exception to the "Linux applications don't have a good interface/user experience" stereotype?
• How easy is it going to be to "install any app you want" on the upcoming Linux MIDs?
• The challenges of adapting applications to devices on smaller screen.
• UMPCScrollBar - a great little app that lets you scroll windows around the smaller UMPC screen, so you can get to the "Install" and "OK" buttons that get pushed off the bottom of the screen.
• Intel Software Network's mobility community makes tons of resources, tools, and smart people available for people writing applications for these devices. Take advantage of us!
• Without great software, Intel products are just a bunch of really tiny hot plates. :-)
• Have we discovered the REAL reason Intel has chosen not to deploy Windows Vista? Is it because NetMeeting is no longer there? Microsoft stopped distributing NetMeeting in 1998 - TEN YEARS AGO. But Intel lives and breathes NetMeeting - old habits die hard. (Update after the show: according to Wikipedia, Microsoft released a hotfix that allows you to download and install NetMeeting on Vista. Guess we were wrong! ;-) )
• Macs do Screen Sharing, based on VNC, but there's NO way on a Mac to participate in a NetMeeting call, because it's a closed, proprietary Microsoft protocol.
• Google Docs is GREAT for live collaboration.
• PowerPoint is a great presentation tool, but it is NOT a collaboration tool! It gets abused WAY too often. PowerPoint abuse starts early - Brian's 7th grade son is already doing it!
• New recording time - Wednesday morning instead of Friday afternoon. Hope this gets the show out faster, and Josh and Brian perkier.
• Josh's morning voice - he's not a morning person. Brian gets up at 5:30 AM.
• Stuff we didn't get to this week: Brian dips his toes into the world of Twitter and FriendFeed, and next week is iPhone 3G day! Come stand in line with us!

The show is picking up steam - we're hitting our stride, and cranking them out. Many, many thanks to our listeners - we love you guys! We love connecting with people through the show, and getting to know who's listening. But the only way we can do that is if you talk to us, so leave a comment, email us, or find some other way to say "hi", and let us know what you think of the show! :-)

Setup of Hyper-V is as simple as adding an additional role to Windows Server 2008 and the following screen shots describe the process in detail. After using the RTM version I can say that it definitely has some increased performance over previous versions and appears to have performance benefits over some other virtualization technologies that I have used in the past.

You'll see in the series of 21 screen shots below that the creation of a new virtual machine and the management of the virtual machine is very simple although I was a little disappointed in the fact that only 16-bit graphics are available within the virtual machine regardless of the underlying graphics hardware on the host computer. Microsoft points out though that 32-bit graphics is not a requirement for many server scenarios and so 16-bit graphics is adequate although I would hope that in the next version there would be support for 32-bit graphics within the virtual machines. The final screen shot shows Windows Server 2008 running within a Hyper-V virtual machine.

Specifically, the comment that "Sequential programming is really hard" got me to thinking about thousands of talking Barbie dolls that once caused an uproar with her comment that "Math is hard."  I thought up comments about checking Prof. Tanenbaum for a drawstring between his shoulder blades.  (Shame on me; no, really.)  Then, I read the rest of his comments about how software is still pretty fragile and causes system crashes with an alarming frequency.  The second part of Tanenbaum's sentence about parallel programming being a step beyond that was sobering.

I'm not sure how I feel about sequential programming as a difficult activity.  We've moved beyond methods and technologies that had their productivity drawbacks, like patch cords, assembly language, punch cards, and rigidly formatted source lines.  Even so, I often think that in our quest to make programming easier or more reliable, we've heaped new methods and technologies on ourselves that can easily complicate things more than previous things have been.

If our current programming methods, models, and environments are complex enough that we can't write software to be much more reliable than a broken watch, then what will it be like when we try to wedge parallel programming and all those attendant complexities into those same methods, models, and environments?  This is what I took to be Prof. Tanenbaum's point in his quoted comments.  (And I renew my humility at his sagacity.)

What about chucking out all the flotsam and detritus we've accumulated over the last 40 years of programming and start with something new, something that starts at square [0] with parallel thought processes?  First: if you thought this, please hit yourself with a rolled up newspaper for me.  Second: realize that starting fresh may ultimately be a good choice and allow us to focus on the problems of parallelism and overcome the failings of current methods, but it's tough to get entrenched methods replaced by untried technologies.  Besides, who wants to take all the time required to completely rewire our modes of thinking and teaching, when they can get by with the mostly status quo?  Or the status quo with some parallelism wedged in a few slots?

Prof. Patterson summed it up well with, "In order for parallelism to succeed, it has to result in better productivity, efficiency, and accuracy."  For better or for worse, "market forces" will drive a winner in the parallel programming arena.  Will it be the best solution?  Maybe, but I don't think Prof. Tanenbaum will be holding his breath.  It certainly won't be the only solution we see in our near future.

Firefox and Firebug add-on developer tool make undestanding JavaScript's document.location much easier.

Here at the Intel Software Network (ISN) we have quite a few AJAX based services (Feedback, Email A Friend, Login/Logout, Polling, Rating, Commenting) that can be dropped into any and all of our 40-50 web sites by placement HTML elements with specific ID's.  Each common service is also written to support localization.  You can check out some of these functions in the button bar of the following pages US, China and Russia ISN Landing Pages.  Just load the pages and look for the icon bar at the top right of the page.

Most of thes services require that we pass the URL back to the server to gets back data.  When passing a URL as a querystring parameter encoding it correctly is important to prevent unwanted side effects.  For instance some of our fist passes at adding a Comment Service to pages resulted in differnet sets of comments getting returned when the querystring varied.

So lets take a peek into the Firebug DOM tab and see what document.location brings.

As you can see everything is nice and easy to get at here.

Here is some sample HTML code that you can save and run on your own local machine and see each of these variables at work. Try adding QueryString parameters (and/or even add a full properly encoded URL on the end.)  My most complex resulting output was http://localhost/locationtest.htm?a=1&b=2&target=http%3A%2F%2Flocalhost%2Flocationtest.htm%3Fa%3D1%26b%3D2

[
<html>
<head>
	<title>Document Location and encodeURIComponent()</title>
	<script>
		var thisURL = document.location.protocol
+ "//" + document.location.host
+ (document.location.port.length >0 ? ":"+document.location.port : "")
+ document.location.pathname;
		var thisFull = document.location.protocol
+ "//" + document.location.host
+ (document.location.port.length >0 ? ":"+document.location.port : "")
+ document.location.pathname
+ document.location.search;
	</script>
</head>
<body>

<pre>

Tools - Firefox and Firebug

document.location = <script>document.write(document.location);</script>
document.location.href = <script>document.write(document.location.href);</script>
document.protocol = <script>document.write(document.location.protocol);</script>
document.location.host = <script>document.write(document.location.host);</script>
document.location.port = <script>document.write(document.location.port);</script>
document.location.pathname = <script>document.write(document.location.pathname);</script>
document.location.search = <script>document.write(document.location.search);</script>
document.location.hash = <script>document.write(document.location.hash);</script>

This is not the base URL for this page.
var notBaseURL = "<script>document.write(document.location);</script>";

The base URL is -
var thisURL = "<script>document.write(thisURL);</script>";

The base URL plus parameters -
var thisFull = "<script>document.write(thisFull);</script>";

Say you want to call an AJAX service and you want to pass this URL correctly.
I would consider that for a service call in most instance like getting Tags for this page
Or getting Comments for this page you would only way the base URL.
"<script>document.write(thisURL);</script>";

To make an HTML call and pass another URL you need to use the JavaScript method
encodeURIComponent() = "<script>document.write(encodeURIComponent(thisURL));</script>";

So your final call to your service URL for passing thisURL would be something like this example.
<script>document.write(thisURL + "?target=" + encodeURIComponent(thisURL));</script>

Or with your querystring parameters it would be like so.
<script>document.write(thisFull + "&target=" + encodeURIComponent(thisFull));</script>

Dont include document.location.hash in your call to your service as it can cause issues down the road.

</pre>
</body>

</html>
]

Here is the output from the above HTML

It might seem very simple and you might say why bother but the end result are cool.  Take for example out Coment Service.  For this we need only the base url and not all the extra parameters.  If you were to take the extra search parameters for Comment retrieval then you would get one set of results and without the search parameters another set of data.  All our Content Deliver pages allow for Comments, take A Library Based Approach to Threading for Performance for example (drive to the bottom of the page to see the add a comment option.)  The resulting call that populates the return data set comes from this page call (post page load)

http://softwarecommunity.intel.com/isn/home/CommonServices.ashx?F=GetCommentsJSON&P1=http%3A%2F%2Fsoftwarecommunity.intel.com%2Farticles%2Feng%2F3816.htm&P2=&_=1215014917424

The packaged JSON data set uses JSONP for the callback pattern and thus to populate the page data.

Simple but very cool!

Cheers

Kevin Pirkl

I implemented a subset of task_group in TBB as a header tbb/task_group.h: 37 lines of C++ and 5 preprocessor lines.   It's a small subset.

• It does not support task_handle. 
• The exception/cancellation model is still TBB's. 
• wait() returns void, not task_group_status, since the blog does not detail task_group_status. 

But nonetheless, I think some TBB users will find this minimal form useful.  For example, it's enough of task_group to write the quicksort in Molloy's post.

The code for header follows my signature.  I'd be interested to hear how useful it is.

- Arch

#ifndef __TBB_task_group_H
#define __TBB_task_group_H

#include "tbb/task.h"

namespace tbb {

class task_group;

namespace internal {

// Suppress gratuitous warnings from icc 11.0 when lambda expressions are used in instances of function_task.
#pragma warning(disable: 588)

template<typename Function>
class function_task: public task {
    Function my_func;
    /*override*/ task* execute() {
        my_func();
        return NULL;
    }
public:
    function_task( Function& f ) : my_func(f) {}
};

} // namespace internal

class task_group: internal::no_copy {
private:
    empty_task* root;
public:
    task_group() {
        root = new(task::allocate_root()) empty_task;
        root->set_ref_count(1);
    }
    ~task_group() {
        if( root->ref_count() )
            root->wait_for_all();
        root->destroy(*root);
    }
    template<typename Function>
    void run( Function f ) {
        task& self = task::self();
        self.spawn(*new( self.allocate_additional_child_of( *root )) internal::function_task<Function>(f) );
    }
    void wait() {
        root->wait_for_all();
    }
};

} // namespace tbb

#endif /* __TBB_task_group_H */