Today, over ten years later, I found an interesting series of articles on MSDN written by Scott Mitchell where he discusses data structures using C# 2.0. Visual Studio 2005 uses the 2.0 version of the language, whereas Visual Studio 2008 uses version 3.0; that said though, the articles will be useful for developers using either version of the C# programming language.

Gaining a solid understanding, or refreshing an existing understanding, of data structures will improve the code you write to solve every day programming problems and I would encourage anyone programming on the .net platform to check these articles out.

 I am working with some of the brightest folks here at Intel, our subject matter experts and architects, such as Clay Breshears, Michael Wrinn, Bob Chesebrough and Tim Mattson (amongst others).  I will also be working closely with the indomitable Wolfgang Rosenberg, manager of the Intel Academic Community. 

My job is to reach out to educators and researchers around the world, to connect them with Intel experts and to help foster development of a curriculum to educate the next generation of programmers and engineers on the newest compute platforms.

Hopefully, this blog will go a long way to opening up channels of communication 

We have a number of events and initiatives planned for this year. 

We have already started our monthly Academic Community Curriculum Webinar Series.  During these webinars, we discuss the newest curriculum topics.  It is a great way to speak directly with our course architects.  I moderate the series and I very much look forward to speaking with you there soon.

The next in the series is on May 15 on multi-core design patterns.  Please Register below.

 Register or view past event here.

------------------------------------------

We are creating quite a few short videos supporting our academic efforts.

 I'm in the process now of filming a series on threading topics with an emphasis on game development and visual computing.  So far only the first title on Optimizing for DirectX is posted, but the rest will be available soon.

Is this type of content useful?  Are there better ways to scale out our knowledge and build conversation?  I'd like to hear that from you.

 I've asked around internally as to how folks like to consume information.  As you might imagine, there were a wide-range of responses.  Tim Mattson just rolled his eyes when I started to talk about videos and webinars.  While he is a great presenter, his own preference is to just download the PowerPoint or code and have done with it.

Others, myself included, prefer a richer content set.  For me, nothing beats the immediacy of a live event.  That is one reason we have our monthly webinars.  I am also quite interested in convening smaller conversations, perhaps using something like Communicator or Live Meeting, to discuss specific topics or curriculum ideas.  Let me know by responding to this blog.

 ---------------------------------------------

Finally, I've become very interested in different forms of new media.  I'm often available on Twitter -find me as @psteinb.

I am the owner of the Intel Software Second Life Island. 

IM me on Second Life as Peretz Stine.

Check out our launch video.

Over the last year, we ran an event series on our Second Life island dedicated to engaging engineers and professionals around the world in conversation on this unique environment.  That program, sadly, is ended, but you can still view much of it here:

Are you interested in meeting on Second Life or other virtual worlds?  It can be arranged.

 Well that's enough for now -you have you orders -tell me how best to foster dialogue.  I'll be working as hard as I can, but you are the whole point.  Let's start the conversation.

First, ...2014?  I'd love to know what is going to be happening by the end of this year, let alone six years out.   That's an Internet Eternity, especially in this product area.  How old is  your cellphone, smartphone, or favorite tech toy? Would you have really envisioned how you use it two years ago?  Four?

Second, there are too many wild cards in the cast of characters.  Apple, Google, Asus, Microsoft, and even... what's their name again... oh yeah, Intel, might have a plan or two up their sleeve in this time frame, and any one of them could send things scrambling in a new direction.  Apple wrenched the phone world sideways with the iPhone, and Asus launched a whole new market with the Eee PC.  Google has Android cooking and never fails to keep developers amused with new forays, and good ol' Microsoft may be sometimes slow to the party, but they always show up with an entourage.

Third, the article claims the "proven advantages of the ARM ecosystem in mobile devices will eventually outweigh those of the Intel platform."  I've talked to a lot of people inside and outside Intel who develop for these devices, and the fragmentation of the existing ecosystems drives many of them nuts.   One of the great things about moblin is that is provides an compliance base across devices so you can reduce testing and reach more target systems, even running on multiple form factors like MIDs and netbooks.

ARM has an impressive part of the market right now in MID and ultra mobile devices without a doubt.  The iPhone alone tips the balance quite nicely.  I just don't see how anyone watching this industry, and who has looked at Atom and Intel's plans for it, could do anything but chuckle at any six-year prediction around MIDs other than it is going to be one crazy ride.

I guess Microsoft didn't evangelize this conference much outside of the UK. It would be interesting for Microsoft to hold such a conference here in the United States also.

Unfortunately, the only way to get the source code for the .NET Framework was within Visual Studio 2008 and that wouldn't get you all of the source code. With the NetMassDownloader, available on CodePlex, you can now download all of the available source code!!!

If, like me, you find yourself debugging some fairly advanced issues on the .NET platform you might also consider reading Debugging Microsoft .NET 2.0 Applications by John Robbins. Given that the .NET Framework's 3.0 and 3.5 are merely extensions of the .NET Framework 2.0, the CLR remains at version 2.0 even in these newer frameworks, the book is still very applicable.

System.DirectoryServices.AccountManagement

Within this assembly are some types that simplify many tasks that have taken considerably more code to achieve in previous versions of the .NET Framework, or have simply been unreliable in previous versions.

To illustrate this lets consider the a scenario where we must determine the domain groups to which a particular user belongs. We first must establish an instance of the PrincipalContext class that encapsulates the server or domain against which other operations will be performed and in this example we use the ContextType enumeration to specify that we are dealing with a domain.

PrincipalContext context = new PrincipalContext(ContextType.Domain);

We'll next need to establish an instance of the UserPrincipal class representing the domain user whom we wish to determine the group membership of.

UserPrincipal userPrincipal = UserPrincipal.FindByIdentity(context, "aperson");

With the UserPrincipal instance we can now discover the groups to which the user belongs simply by calling the GetGroups() method which will return us an instance of the PrincipalSearchResult<Principal> generic collection class.

PrincipalSearchResult<Principal>
groupPrincipals = userPrincipal.GetGroups();

If you've ever previously programmed against an LDAP based directory using Microsoft .NET then you may notice the absence of an LDAP path in the above code. LDAP paths had a tendency to be fairly volatile objects as the directory to which it relates is maintained over time. Therefore, using these new classes in the System.DirectoryServices.AccountManagement assembly, we can write more maintainable code that is less likely to be affected by changes within the domain structure which could break older code that relied upon fixed LDAP paths.

Finally, the groups can be iterated over using the C# foreach loop as shown here.


foreach (Principal principal in groupPrincipals)
  Console.WriteLine(principal.Name);


Interestingly, if you're still using Visual Studio 2005, this new assembly can simply be added to as a reference because the .NET Framework version 3.5 is in effect an extension of the .NET Framework 2.0.

Only slightly less known is Knuth's series of books The Art of Computer Programming (TAOCP). Planned as a seven-volume set, the first three volumes were published in the 1970s and were considered "required reading" by most everyone studying computer science. In college, I was especially taken with Knuth's use of an invented computer architecture called MIX, as it was a mixture of several well-known (at the time) architectures, and like some other college students of the era, I wrote an extended MIX interpreter, (mine was in IBM System\370 Assembler in two boxes of punch cards), that I oh-so-cleverly called XIM.

My XIM implemented not only the standard MIX instruction set, but also added all of the architectural extensions Knuth described in the volumes, such as floating point and I/O. In the mid-70s, I wrote Knuth a letter describing XIM and asking, as an aside, when we might expect to see volume 4 published. I received a thoughtful and courteous reply, saying, essentially, not to hold my breath! Sadly, my only copy of XIM perished in an apartment fire.

Knuth since has rewritten and revised TAOCP volumes 1-3 multiple times, trying to keep it relevant for the times. (Algorithms for efficient sorting of data stored on magnetic tapes are probably not as useful as they once were.) What I missed, though, was the start, in 2005, of the publication of parts of TAOCP Volume 4! Still a work in progress, Knuth has published "Fascicles", sets of chapters from the book. Fascicles 1-4 are out, and Fascicle 0 has just been released.

What? Oh, yeah. The interview. Knuth has been an advocate of what he calls Literate Programming, which if I understand it correctly, has one write programs that are designed to be read by humans so that they can understand what the program is supposed to do. I'm all in favor of this, as a long time advocate of writing understandable code and letting the compiler handle the optimization.

Knuth also expressed disdain for "unit tests", saying "lots of time is wasted on activities that I simply never need to perform or even think about. Nothing needs to be 'mocked up.'" He also takes CPU manufacturers to task for moving to multicore:

... it looks more or less like the hardware designers have run out of ideas, and that they’re trying to pass the blame for the future demise of Moore’s Law to the software writers by giving us machines that work faster only on a few key benchmarks! I won’t be surprised at all if the whole multithreading idea turns out to be a flop, worse than the [Itanium] approach that was supposed to be so terrific—until it turned out that the wished-for compilers were basically impossible to write.
...
I know that important applications for parallelism exist—rendering graphics, breaking codes, scanning images, simulating physical and biological processes, etc. But all these applications require dedicated code and special-purpose techniques, which will need to be changed substantially every few years.

Well, some at Intel would take issue with that! It is certainly true that multithreading requires a different way of approaching algorithms, and there's a lot of progress in making threading easier, but there's lots more work to do.

Knuth has also revised the 1960s-era MIX, creating MMIX, a more modern 64-bit architecture.

Finally, I note that Knuth still plans to complete the seven-volume set of TAOCP. I'll look forward to that!