January 2004 - Posts

.NET Framework install failing
31 January 04 02:01 PM | MikeD

Though I haven't encountered this problem (yet) I wanted to keep this link around in case I run into it with our clients...

Microsoft.Net Framework 1.1 setup has ended prematurely

Filed under:
SOA/OO/WS
30 January 04 08:55 PM | MikeD

Great post about the basic premises of SOA:

·        Business systems are autonomous. They evolve independently of each other. They protect their internal state. For example, most enterprises use Siebel for CRM, Peoplesoft for HRMS and SAP for others.

·        Corollary 1- Heterogeneity is the reality.

·        Corollary 2 – Loose coupling is necessary for interaction between these systems. Otherwise, a change in one system (like upgrade) will have serious consequence on other systems.

·        This one is little bit controversial. Business systems don’t trust each other and hence doesn’t support Atomic transactions.

 

He goes on to talk about using distributed objects technologies like COM or CORBA rather than SOAP/XML/WS-* stuff - possible, but you lose the “loosely coupled” nature using distributed objects instead of the SOAP/XML stuff.

Pretty much sums up what Joel has had in his head for at least two or three years, its a shame I didn't tune into the IJH* factor earlier (and he keeps reminding me).

And Rod, in case you're reading this, “Long Live WIS!“ (poke, poke)

Mike

*IJH = “In Joel's Head” - a phenomena where the requirements and design of a project is complete in Joel's brain before the rest of the team can even begin user interviews and formal requirements gathering. Successful projects with Joel usually involve a requirements gathering process somewhat akin to a frontal lobotomy to extract from Joel what is self-evident to Joel. On a somewhat disturbing note, recently Joel has been referring to another part of his anatomy where he pulls stuff out of, and I'm not sure I'm looking forward to tuning in to the IJA factor on the next project.

Filed under:
How cold is it?
29 January 04 09:42 AM | MikeD

It's so cold here in Manitoba that one of the towns nearby had its natural gas supply line freeze up:

Temperatures took a nosedive Wednesday night; the mercury fell to the dreaded –40 C and with the wind chill, it felt like –52 C.

Residents of Stonewall, just north of Winnipeg, are especially feeling the cold. Mayor Ross Thompson says the main distribution line from Centra Gas is frozen, so natural gas is not flowing to furnaces in town.

About 1,150 Stonewall customers are without heat, including the local hospital. Manitoba Hydro, which owns Centra Gas, is working on the problem, but it could be six hours or more before the flow of gas is restored.

Mayor Thompson's own pilot light has gone out; he has this advice for Stonewall residents: "People should turn their taps on. Let the water drip through the taps so it doesn't freeze up. Use candles. Use electrical heating devices if they have them.".

Filed under:
SQL Server Reporting Services - playing with the released bits
28 January 04 09:51 PM | MikeD | 1 comment(s)

In feedback of my previous blog, Thomas asked:

Mike - I remember some review of this thing talking about it not being programmable with C# or VB.NET. Did you see anything in regards to that?

Yes and no...

You work with report definitions in VS.NET - there are new project templates for building reports.

The VS.NET integration consists of a visual designer for the RDF file, which is in pure XML format. The RDF gets published to the Report Server (via http) and available to clients by navigating to the report server website (http://localhost/ReportServer). There is no "code view" when working in a report project, except for the XML view of the RDF. Its not like an ASP.NET page, there is no VB.NET or C# code-behind file for the report.

Ok, so can I program a report through a C# or VB.NET project? Uh, well, kinda the same answer - yes and no. When I created a new C# project and went to add a reference, there was no Microsoft.ReportingService object space listed in the GAC. I did browse to the assemblies in C:\Program Files\Microsoft SQL Server\MSSQL\Reporting Services\ReportServer\bin\ and added a reference to ReportingServicesLibrary.dll (there was a ton of other assemblies there too, this seemed like the most likely candidate. The object browser shows a bunch of classes in the namespaces Microsoft.ReportingServices.Library and Microsoft.ReportingServices.Library.Soap. I'm not sure that is where I would start if I wanted to program these things.

More useful was adding a web reference to http://localhost/ReportServer/ReportService.asmx - the WSDL shows this:

"ReportingService" Description

Documentation

The Reporting Services Web Service enables you to manage a report server and its contents including server settings, security, reports, subscriptions, and data sources.

Methods

  • CancelBatch()
  • CancelJob(JobID As string) As boolean
  • CreateBatch() As string
  • CreateDataDrivenSubscription(Report As stringExtensionSettings As ExtensionSettingsDataRetrievalPlan As DataRetrievalPlanDescription As stringEventType As stringMatchData As stringParameters As ArrayOfParameterValueOrFieldReference) As string
  • CreateDataSource(DataSource As stringParent As stringOverwrite As booleanDefinition As DataSourceDefinitionProperties As ArrayOfProperty)
  • CreateFolder(Folder As stringParent As stringProperties As ArrayOfProperty)
  • CreateLinkedReport(Report As stringParent As stringLink As stringProperties As ArrayOfProperty)
  • CreateReport(Report As stringParent As stringOverwrite As booleanDefinition As base64BinaryProperties As ArrayOfProperty) As ArrayOfWarning
  • CreateReportHistorySnapshot(Report As string) As string
  • CreateResource(Resource As stringParent As stringOverwrite As booleanContents As base64BinaryMimeType As stringProperties As ArrayOfProperty)
  • CreateRole(Name As stringDescription As stringTasks As ArrayOfTask)
  • CreateSchedule(Name As stringScheduleDefinition As ScheduleDefinition) As string
  • CreateSubscription(Report As stringExtensionSettings As ExtensionSettingsDescription As stringEventType As stringMatchData As stringParameters As ArrayOfParameterValue) As string
  • DeleteItem(Item As string)
  • DeleteReportHistorySnapshot(Report As stringHistoryID As string)
  • DeleteRole(Name As string)
  • DeleteSchedule(ScheduleID As string)
  • DeleteSubscription(SubscriptionID As string)
  • DisableDataSource(DataSource As string)
  • EnableDataSource(DataSource As string)
  • ExecuteBatch()
  • FindItems(Folder As stringBooleanOperator As BooleanOperatorEnumConditions As ArrayOfSearchCondition) As ArrayOfCatalogItem
  • FireEvent(EventType As stringEventData As string)
  • FlushCache(Report As string)
  • GetCacheOptions(Report As string) As boolean
  • GetDataDrivenSubscriptionProperties(DataDrivenSubscriptionID As string) As string
  • GetDataSourceContents(DataSource As string) As DataSourceDefinition
  • GetExecutionOptions(Report As string) As ExecutionSettingEnum
  • GetExtensionSettings(Extension As string) As ArrayOfExtensionParameter
  • GetItemType(Item As string) As ItemTypeEnum
  • GetPermissions(Item As string) As ArrayOfString3
  • GetPolicies(Item As string) As ArrayOfPolicy
  • GetProperties(Item As stringProperties As ArrayOfProperty) As ArrayOfProperty
  • GetRenderResource(Format As stringDeviceInfo As string) As base64Binary
  • GetReportDataSourcePrompts(Report As string) As ArrayOfDataSourcePrompt
  • GetReportDataSources(Report As string) As ArrayOfDataSource
  • GetReportDefinition(Report As string) As base64Binary
  • GetReportHistoryLimit(Report As string) As int
  • GetReportHistoryOptions(Report As string) As boolean
  • GetReportLink(Report As string) As string
  • GetReportParameters(Report As stringHistoryID As stringForRendering As booleanValues As ArrayOfParameterValueCredentials As ArrayOfDataSourceCredentials) As ArrayOfReportParameter
  • GetResourceContents(Resource As string) As base64Binary
  • GetRoleProperties(Name As string) As ArrayOfTask
  • GetScheduleProperties(ScheduleID As string) As Schedule
  • GetSubscriptionProperties(SubscriptionID As string) As string
  • GetSystemPermissions() As ArrayOfString3
  • GetSystemPolicies() As ArrayOfPolicy
  • GetSystemProperties(Properties As ArrayOfProperty) As ArrayOfProperty
  • InheritParentSecurity(Item As string)
  • ListChildren(Item As stringRecursive As boolean) As ArrayOfCatalogItem
  • ListEvents() As ArrayOfEvent
  • ListExtensions(ExtensionType As ExtensionTypeEnum) As ArrayOfExtension
  • ListJobs() As ArrayOfJob
  • ListLinkedReports(Report As string) As ArrayOfCatalogItem
  • ListReportHistory(Report As string) As ArrayOfReportHistorySnapshot
  • ListReportsUsingDataSource(DataSource As string) As ArrayOfCatalogItem
  • ListRoles() As ArrayOfRole
  • ListScheduledReports(ScheduleID As string) As ArrayOfCatalogItem
  • ListSchedules() As ArrayOfSchedule
  • ListSecureMethods() As ArrayOfString
  • ListSubscriptions(Report As stringOwner As string) As ArrayOfSubscription
  • ListSubscriptionsUsingDataSource(DataSource As string) As ArrayOfSubscription
  • ListSystemRoles() As ArrayOfRole
  • ListSystemTasks() As ArrayOfTask
  • ListTasks() As ArrayOfTask
  • Logoff()
  • LogonUser(userName As stringpassword As stringauthority As string)
  • MoveItem(Item As stringTarget As string)
  • PauseSchedule(ScheduleID As string)
  • PrepareQuery(DataSource As DataSourceDataSet As DataSetDefinition) As DataSetDefinition
  • Render(Report As stringFormat As stringHistoryID As stringDeviceInfo As stringParameters As ArrayOfParameterValueCredentials As ArrayOfDataSourceCredentialsShowHideToggle As string) As base64Binary
  • RenderStream(Report As stringFormat As stringStreamID As stringHistoryID As stringDeviceInfo As stringParameters As ArrayOfParameterValue) As base64Binary
  • ResumeSchedule(ScheduleID As string)
  • SetCacheOptions(Report As stringCacheReport As boolean)
  • SetDataDrivenSubscriptionProperties(DataDrivenSubscriptionID As stringExtensionSettings As ExtensionSettingsDataRetrievalPlan As DataRetrievalPlanDescription As stringEventType As stringMatchData As stringParameters As ArrayOfParameterValueOrFieldReference)
  • SetDataSourceContents(DataSource As stringDefinition As DataSourceDefinition)
  • SetExecutionOptions(Report As stringExecutionSetting As ExecutionSettingEnum)
  • SetPolicies(Item As stringPolicies As ArrayOfPolicy)
  • SetProperties(Item As stringProperties As ArrayOfProperty)
  • SetReportDataSources(Report As stringDataSources As ArrayOfDataSource)
  • SetReportDefinition(Report As stringDefinition As base64Binary) As ArrayOfWarning
  • SetReportHistoryLimit(Report As stringUseSystem As booleanHistoryLimit As int)
  • SetReportHistoryOptions(Report As stringEnableManualSnapshotCreation As booleanKeepExecutionSnapshots As boolean)
  • SetReportLink(Report As stringLink As string)
  • SetReportParameters(Report As stringParameters As ArrayOfReportParameter)
  • SetResourceContents(Resource As stringContents As base64BinaryMimeType As string)
  • SetRoleProperties(Name As stringDescription As stringTasks As ArrayOfTask)
  • SetScheduleProperties(Name As stringScheduleID As stringScheduleDefinition As ScheduleDefinition)
  • SetSubscriptionProperties(SubscriptionID As stringExtensionSettings As ExtensionSettingsDescription As stringEventType As stringMatchData As stringParameters As ArrayOfParameterValue)
  • SetSystemPolicies(Policies As ArrayOfPolicy)
  • SetSystemProperties(Properties As ArrayOfProperty)
  • UpdateReportExecutionSnapshot(Report As string)
  • ValidateExtensionSettings(Extension As stringParameterValues As ArrayOfParameterValueOrFieldReference) As ArrayOfExtensionParameter

This is likely where I would start to programmatically create reports.

Anyway, the first report I tried was a matrix report (like an Access cross-tab). The wizard was pretty straight forward, but I've done cross-tabs before using Access, so I knew what to expect I guess. It turned out that I used Guids as the row and column headers, which was something it didn't like (gave a runtime error), because I didn't know how to add the lookup tables to the query (in the wizard). Once I modified the datasource and joined in the lookup tables, then I was able to use the descriptive column rather than the Guid as the row header and column header. Actually figuring out what property sheets allowed me to do that was tougher - I was getting compile errors and double-clicking on the task didn't bring up any property sheet. Eventually I was able to get it, and ran the report, and got some good results. With drill-down.

And then it hung. Not sure why or what exactly happened, but VS.NET wouldn't shut down. Anyway, when I fired it back up again, it worked no problem. So it could have been me.

So far, I like it.

Mike

Joel Spolsky needs a comment feed...
28 January 04 05:30 PM | MikeD | 2 comment(s)

Reading Joel's blog entry “Please Sir, may I have a linker?” today, and it sparked a memory of a tool that the Joel I work for mentioned a while ago...

http://www.remotesoft.com

Salamander .NET Native Compiler
Compile .NET assemblies (IL) to native code, run without .NET Framework...
Part 1: Salamander .NET Linker and Mini-Deployment Tool
- Link assemblies together, deploy without whole Framework installation

I went to add this comment to the other Joel's blog, and he doesn't have a comment area. Anyway, I think this is what he is after. Maybe Joel reads my blog?

Filed under:
.NET Reality Check...
28 January 04 05:16 PM | MikeD | 2 comment(s)

I agree with Frans Bouma that there is a significant amount of hype around Whidbey, Yukon, Longhorn, etc, and it isn't all that useful for what we do today.

However, I think the work of the Prescriptive Architecture Group and the Patterns and Practices are good examples of non-trivial documentation and code that works with today's release bits. The PAG is working on today's problems and with today's bits.

The application blocks have been a tremendous help in many ways for applications and corporate frameworks we are developing for our clients.

http://www.microsoft.com/resources/practices/

I still find the discussion of the new stuff interesting, and I try to keep up so that when it becomes real bits, I have less to learn, and when I am building stuff today, I can think about how the nextGen stuff will be built, and design todays stuff in anticipation of that (to some degree). I find myself learning a bit more of the .NET Framework on each project I work on. And it has only been about six months since the last VB6 project I worked on.

SOA, for example, doesn't mean that I have to use Indigo. I can do SOA today, building framework pieces and components in a similar fashion to how Indigo is doing it. Those guys have already done a bunch of the design for me, so why wouldn't I leverage that? When Indigo arrives, I can adapt my pieces to use it instead of the “roll-your-own” that I built.

Mike

An interesting stat: there are about 28,000 method calls in the Win32 API, and about 184,000 method calls in the .NET Framework.

Filed under:
SQL Server Reporting Services
27 January 04 03:34 PM | MikeD | 1 comment(s)

SQL Server Reporting Services has been released, but the download is for a time-bombed 120 evaluation version.

Cool things:

  • importing Access reports.
  • scheduled execution of reports
  • subscriptions to reports
  • various output types: html, xml, pdf, text, rtf, xls
  • Visual Studio IDE integration
  • XML report definition format (patent pending? :) )
  • web service/soap api

Drawback:

  • MSDE is not an option. Doesn't appear to be even something you can buy for MSDE. (To clarify - you can use MSDE for data sources, but the reporting services database for metadata cannot be hosted by MSDE)

Mike

Regional Directors
23 January 04 04:46 PM | MikeD | 1 comment(s)

Now I know two Regional Directors : Joel Semeniuk (my boss), and Derek Hatchard - a good friend of mine, former co-worker at ImagiNET and now in New Brunswick.

Very deserving...

(Hmmm, what can I get from them by sucking up in this way?)

Xen and the Art of Objects and Data
21 January 04 06:55 PM | MikeD

Erik Meijer from Microsoft Research is working on a new CLR language that incorporates C#, XML, and relational data.

I first read about it in an Extreme Tech article, which had this little code snippet:

public class book {
    sequence{
      string title;
      choice{
        sequence{ editor editor; }+;
        sequence{ author author; }+;
        }
      string publisher;
      int price;
    }
    attribute int year;
  }

Looks a lot like C#, right? The sequence, choice, and attribute keywords are from XML usage (in XSD) and the + means “One or More“ (there is also ? for optional, and * for zero or more). There is also parts of the syntax that allows for iterating over collections using a type of query.

book* OldBooks =
      bib.book[it.publisher == "Addison-Wesley" && it.year > 1991];

In the above example, it is an implicit iterator and publisher and year are attributes of the items in the collection.

From Harry Piersons blog:

Note, this is the opposite approach from tools like O/R mappers and XSD.exe which attempt to hide the differences from the programmer. We've seen a similar evolution in the way we think about invoking objects across the network. Tools like DCOM and .NET Remoting attempt to hide the RPC and make it appear as a local call. But as the thinking evolves, tools like Indigo is designed to make the boundaries across apps and machines explicit. Initial thoughts on data access were to make it all look like objects (i.e. O/R mapping). But as the thinking evolves, maybe we need to make the boundaries between objects and data explicit (and easy) as well.

See also: Unifying Tables, Objects, and Documents (Erik's paper)

SQL Server Reporting Services
21 January 04 05:14 PM | MikeD | 4 comment(s)

I'm a long-time Access developer, and when I saw SQL Server Reporting Services, I was quite interested.

I can't see anything on the website about pricing though - will it be a free downloadable? Anyone know?

 

More Posts Next page »