I am getting behind in my blogging: I missed the second day of the eScience event, took most of Friday off and went camping with my family. What a beautiful weekend!
Here is the start of my (short) wrap-up to the event.
I think this is a reasonable place for them to focus: there certainly is a market for this pre-packaged hardware / software solution.
Patrick Hogan showed off the work his group is doing at NASA: World Wind. Think Virtual Earth and Google Earth packaged in a slick smart client layered with scientific data fetched from data warehouses from around the world. Check it out here: http://worldwind.arc.nasa.gov/download.html
He really wowed the audience with:
And more, all in a zoomable 3d view off the earth.
Plus a version of it is available for Windows Mobile!
Probably the most impressive part was that it was all done in one year by one programmer straight out of college. That says a lot about the productivity one can achieve with the Microsoft tools (it is all .NET and DirectX).
Apparently the CEO of Google praised the NASA group for the accomplishment. It took them 30 programmer years to achieve the same result.
Dan Werthimer talked a bit about SETI@Home and BOINC.
This is a very well-known project run from my alma-mater.
He talked about several ways over time that people have tried (or suggested trying) to tell extra-terrestrial life that we are here. None of these were funded. He makes the point that there was no funding until Voyager, which he called “Porno in space”. If you don’t get this, look for the plaque on the side of Voyager (or recall V’ger).
His whole talk was pretty amusing. A mix of SETI science and humor.
Tags: grid
David Lifka leads the Cornell Theory Center (i.e., the CTC). If you are (still) questioning the viability of Windows for cluster computing, you should check out the work they have done. They offer a free workshop – I went last year. Interesting content plus you get to check out their visualization cave!
He spoke about what they do there and more of the story: Windows, IIS, SQL Server, Web services, Visual Studio, . . . All together this makes an excellent platform for computing.
David brought up the problem with network load balancing (NLB) applied to distributed computing. It is transaction based. If transactions/second go down, then the server is loaded higher. Long running tasks (e.g., a large BLAST search) will have a low t/s resulting in more tasks assigned to that machine. Then you get a grinding halt. This approach works well for short transaction-based requests (think Web-sites) and poorly for computation-intense applications.
He brings this up for a good reason: many people think that application distribution can be achieved by simply implementing NLB across a set of Web servers. The answer, as is often the case, is: “well, under some circumstances, maybe.”
He also uses an alternate to the term “grid”: “Heterogeneous Wide Area Distributed Computing”. Meaning, a Grid that isn’t necessarily based on Globus.
Marty Humphrey directs the group that builds WSRF.NET.
WSRF.NET is both an alternative to the Globus reference implementation (built on Java / Tomcat) and a toolkit for developing WSRF-compatible Web services using ASP.NET. See this paper for a good overview of WSRF/WSRF.NET (note that isn’t the purpose of this paper, but it does it just the same).
The grid-standards community owe these UV guys a big thanks for taking the standards and building an alternate implementation – further validating the standards work. This proves (again) that the standard can be implemented, that it is functional, that it works and is not biased towards a specific language, application server, or OS. Of course, the implementation also provides feedback into future standards efforts.
It also validates a basic tenet of our approach: .NET is a terrific platform for distributed computing.
A great challenge for this industry is to take the excellent work done by computer scientists (and other domain experts) to solve these greatly hard problems and distill them down into something that is accessible to/by “normal” people to solve their real problems.
The standards are definitely helping make this a reality, but the tools built on these standards will really make the difference.
Robert Scoble posted some things he would consider when evaluating an acquiring company. I read his post with interest as in the past I was actively involved in the sale of a company I cofounded.
He asks if anyone else has any good advice for entrepreneurs considering a sale.
Here’s mine – I’m sure this isn’t complete, but it is a start:
My motivation for some of these questions comes from my own experience. For example, we were bought to give credibility in a new market as well as to infuse our entrepreneurial spirit across the greater company to affect more ASP-related business. We had a brand, products, and credibility that supported the acquisition. But when it came down to it, we were bought by a “numbers” company. What mattered more than anything else was that we hit our revenue targets. Strangely enough, receipts, costs, and cash, didn’t really matter. Just revenues.
That said, our acquisition was a success by the most important measure: that company (Energy Interactive) and the core personnel (outside of the founding executives) continues to this day as a somewhat independent group, selling the same / similar products into the same industry.
Now, I don’t mean to imply by any of my suggestions that I believe that these criteria particularly apply to Microsoft; however, I do think it is a good thing for the entrepreneur to investigate these (and many other) issues when evaluating an acquisition.
Tags: acquisition
Here at the Microsoft eScience event – my special thanks to the organizers. Apparently I wasn’t registered! No problem – they will get me a badge during the break.
Jim Gray kicked off the event with a historical view of science – that we have now gone into the era of data analysis. This is clearly the case in many different scientific domains: the sheer amount of measurements being taken, collected, and stored is phenomenal. Analyzing this data.
He described how on a 15-20M astronomy project (I think he was talking about the Sloan Digital Sky Survey (http://Skyserver.sdss.org), up to a 1/2 of that is spent on software development. This doesn’t count the programming done by the astronomers! Certainly, some of this software development includes that related to the science, but most of it is the development of an entire distributed computing system to support this one project.
His point: the tools aren’t good enough yet. I agree that this is true across the grid/distributed computing domain. There is too much computer science and IT skill necessary to build and maintain these systems. We are trying to make this easier in our own domain.
I hadn’t heard Jim‘s pragmatic side: He talked a bit about how we computer scientists need to engage the domain experts in science:
Replace “domain experts in science“ with customer, and Jim Gray sounds like a sales manager! Maybe we can get him hawking the Digipede Network!
Here is a trick that I found while looking at ways to handle .NET 2.0 while continuing to support .NET 1.1. The obvious way to support both is to build with VS2003 and use application configuration to direct the loader to prefer .NET 2.0 if available:
<?xml version="1.0"?>
<configuration>
<startup>
<supportedruntime version="v2.0.50727">
</supportedruntime><supportedruntime version="v1.1.4322">
</supportedruntime></startup>
</configuration>
creates a new assembly that is bound to the CLR that ILMerge is running. Of course, it is stripped of its strong naming key and signcode key; so you have to deal with this seperately. The good thing is, though, that all of your resources (both managed and Win32) are in your resulting PE.
Of course, you can use ildasm and ilasm to do this too, but it takes more steps (or at least more attention to the arguments) to get the intended result.
The other night we were performing tests of the Digipede Network on .NET 2.0 Beta 2 and came across an unexpected failure. The failing code instantiated a FileInfo object with the fileName argument of a nonexistent file. Then the code read the Attributes property. This resulted in the following exception / stack trace:
Unhandled Exception:
System.IO.FileNotFoundException:
Could not find file 'xxxxx'.
File name: 'xxxxx'
at System.IO.__Error.WinIOError(Int32 errorCode, String maybeFullPath
at System.IO.FileSystemInfo.get_Attributes()
The code was supposed to read Attributes only if Exists was true. This was clearly a logic error, but my first question was: “How does this ever work?” As I didn’t have time to look into it further, I just went ahead and fixed the problem.
Today I tested this code again in .NET 1.1 and found that Attributes returns a default value (all bits on) even when the file cannot be found. I looked this up in the BreakingChanges.chm (that hasn’t been updated since May) and found no reference to this change in behavior.
I decided to test it again on .NET 2.0 Beta 2 (v2.0.50215) and confirmed again that I get the above exception. This appears to be an unintentional breaking change to Beta 2.
Then I tried it with the .NET 2.0 RC (v2.0.50727, the one from the Visual Studio 2005 RC that was handed out at PDC05). This time it worked just like it did in .NET 1.1.
So, the problem came and went.
I figure that the Beta 2 behavior was reasonable; however, the CLR team apparently (and, I think, correctly) prefers compatibility.
Here is the code sample I used to test this out:
using System;
using System.IO;
namespace FileInfoTest {
///
/// Summary description for Class1.
///
internal class FileInfoTest {
///
/// The main entry point for the application.
///
[STAThread]
private static void Main(string[] args) {
// check arg length
if (args.Length != 1) {
Console.WriteLine("Usage: FileInfoTest file");
return;
}
// get FileInfo
FileInfo fileInfo = new FileInfo(args[0]);
Console.WriteLine("Exists:\t{0}", fileInfo.Exists);
Console.WriteLine("Directory:\t{0}", fileInfo.DirectoryName);
Console.WriteLine("Name:\t{0}", fileInfo.Name);
Console.WriteLine("Attributes:\t{0}", fileInfo.Attributes);
Console.WriteLine("LastAccessTime:\t{0}", fileInfo.LastAccessTime);
Console.WriteLine("LastWriteTime:\t{0}", fileInfo.LastWriteTime);
}
}
}
I talked with David Holladay at PDC05 (i.e., DOC | HOLLADAY). Today he published the interview here.
I talk a bit about what Digipede does and what makes our product different from other Grid offerings out there. I also talk a little bit about the background of my team and what got us interested in this market space. At least I think that is what talked about — I haven’t watched the interview myself!
FriendFeed Status
About me
Main feed
Email subscriptions