ArtinSoft's Blogs

ASP.NET & Web Standards

Fzoufaly — Fri, 09 May 2008 22:38:00 GMT

Aggiorno is an add-in for Visual Studio 2005/2008 that can swallow horrible non-validating markup and help you make an ASP.NET site web standards compliant with little effort. With Aggiorno web developers can improve their ASP.NET or HTML sites by making them comply with the latest web standards and incorporating the latest technology trends. This will immediately mean increased productivity and immediate business value. Beta 1 has just been released, so you might want to give it a try and send some...(read more)

A note on Visual Studio Team System 2008

jpena — Wed, 07 May 2008 00:42:00 GMT

Last March I attended the Microsoft Inner Circle conference in Bellevue, WA, in which they presented the 2008 version of Visual Studio Team System. This was my first view of VSTS, and I was impressed by some of the features they included to help developers in tasks such as gathering statistics on their source code, writing and executing unit tests, and looking for potential performance bottlenecks.

We were also introduced to Visual Studio Testing Edition, which contains a set of tools to help QA teams automate tasks such as tracking and managing stabilization processes, controlling code churn and performing load tests.

From a tester’s or developer’s perspective, I have no doubt that VSTS is going to be a great tool; however, I think it still needs to extend its support for Project Management tasks, as well as database design and requirements elicitation, documentation and tracking. We were told that many of these features will be included in the next version of VSTS, code named “Rosario”.

More information on VSTS can be found at http://msdn.microsoft.com/en-us/teamsystem/default.aspx

VB Runtime NOT in next Windows

Fzoufaly — Wed, 30 Apr 2008 19:44:00 GMT

Here is an excerpt from an article that Greg DeMichillie wrote on Directions on Microsoft April Edition: "The planned follow-on release to Windows Vista, code-named Windows 7, will not include the Visual Basic 6.0 (VB 6) runtime libraries, Microsoft has begun informing customers. This sets a timeframe for the final end of support for the runtime." As we have informed on several occasion in this Blog, Microsoft is performing all the normal steps to retire a technology from market. Visual...(read more)

ActiveX Controls in .NET and the Enabled bug

Mrojas — Fri, 18 Apr 2008 18:04:00 GMT

We found and interesting bug during a migration. The issue was that when there was an iteration through the controls in the forms, and you set the Enabled property, the property didn't get set.

After some research my friend Olman found this workaroung

foreach(Control c in Controls)
{
ctrl.Enabled = true;
if (ctrl is AxHost) ((AxHost)ctrl).Enabled = true;
}

Install Assembly in GAC with C#

Mrojas — Wed, 09 Apr 2008 16:42:00 GMT

Do you want to create a program to install your assembly in the GAC using C#. Well if you had that requirement or you are just curious, here is how.

I read these three articles:

Demystifying the .NET Global Assembly Cache

GAC API Interface

Undocumented Fusion

What I wanted just a straight answer of how to do it. Well here is how:

using System;

using System.Collections.Generic;

using System.Text;

using System.GAC;

//// Artinsoft

//// Author: Mauricio Rojas orellabac@gmail.com mrojas@artinsoft.com

//// This program uses the undocumented GAC API to perform a simple install of an assembly in the GAC

namespace AddAssemblyToGAC

    class Program

        static void Main(string[] args)

            // Create an FUSION_INSTALL_REFERENCE struct and fill it with data

            FUSION_INSTALL_REFERENCE[] installReference = new FUSION_INSTALL_REFERENCE[1];

            installReference[0].dwFlags = 0;

            // Using opaque scheme here

            installReference[0].guidScheme = System.GAC.AssemblyCache.FUSION_REFCOUNT_OPAQUE_STRING_GUID;

            installReference[0].szIdentifier = "My Pretty Aplication Identifier";

            installReference[0].szNonCannonicalData= "My other info";

            // Get an IAssemblyCache interface

            IAssemblyCache pCache = AssemblyCache.CreateAssemblyCache();

            String AssemblyFilePath = args[0];

            if (!System.IO.File.Exists(AssemblyFilePath))

                Console.WriteLine("Hey! Please use a valid path to an assembly, assembly was not found!");

            int result = pCache.InstallAssembly(0, AssemblyFilePath,installReference);

            Console.WriteLine("Process returned " + result);

            Console.WriteLine("Done!");

And here's the complete source code for this application: DOWNLOAD SOURCE CODE AND BINARIES

April 8th 2008 and the end of Visual Basic 6 Support

Fzoufaly — Tue, 08 Apr 2008 21:04:00 GMT

The date has arrived Visual Basic 6 leaves Extended support today.

Rob Helm recently wrote on "Directions on Microsoft": "Some organizations will let support lapse on the VB6 development environment, gambling that any serious problems in the VB6 environment has already been discovered" Additionally, Rob adds: "... organizations remaining loyal to VB6 applications will have to make increasingly heroic efforts to keep those applications running as their IT environments change."

Organizations that GAMBLE with their business continuity, IT professionals that need to make HEROIC efforts to keep applications running! Don't you believe that maintaining an IT organization supporting a business is already enough of an effort to add to the mix unsupported applications?

Do you plan to be a GAMBLING HERO or is it about time to consider ways out of Visual Basic 6?

Well this might be just the right time. ArtinSoft is about to release a new version of the Visual Basic Upgrade companion. The effort required to migrate has been reduced even further and it now makes more sense than ever to automatically upgrade your applications to C# or VB.NET.

Have you been procrastinating the decision to move? Act now!!

VBUC 2.0 Feature Spotlight: Migration Profiles

Jaguilar — Tue, 08 Apr 2008 14:39:00 GMT

One of the new features of the Visual Basic Upgrade Companion version 2.0 is the support for Migration Profiles. These profiles give you control over which translations to use for a particular migration, improving the quality of the generated code and applying only the conversions desired (for example, for specific third party components). ...(read more)

Birth pangs to ease your .NET migration pains: ArtinSoft’s Visual Basic Upgrade Companion v2.0 is born!

enassar — Tue, 08 Apr 2008 01:04:00 GMT

I mentioned a few days ago that ArtinSoft was about to release a new version of its VB to .NET migration product. Well, today it is official: finally, the Visual Basic Upgrade Companion v2.0 has been released! After an incredible amount of work (kudos to everyone involved), the tool now includes a series of enhancements basically aimed towards increasing the generated code quality and the overall automation of the upgrade process, allowing to reduce even further the manual effort required to convert and compile your VB6 code to VB.NET or C#.

These are just some of the new features and improvements included in this version of ArtinSoft’s Visual Basic Upgrade Companion (VBUC):

Upgrade Manager: The VBUC v2.0 now sports a dashing GUI and Command Line interface that improves the user experience. Incorporating a screen to set up migration profiles, it allows selecting and applying only those features you require for a specific conversion.
Support for conversion of multi-project applications.
Migration of mixed ASP and VB6 code to ASP.NET and VB.Net or C#.
Individual conversion patterns designed to improve the migration of a large amount of diverse specific language patterns.
Conversion of unstructured to structured code, reducing the presence of spaghetti code and improving code maintainability and evolution. This includes the transformation of frequently used patterns related to error handling. For example, the VBUC recognizes “On Error Goto” and “On Error Resume Next” constructs patterns and replace them with the .NET “Try-Catch” structure. It also performs “Goto” removals.
Improved typing system, which provides additional information to assign more accurate target types to existing VB6 variables, functions, fields, parameters, etc.
Improved Array migration, such as conversion of non-zero-based arrays and re-dimensioning of arrays.
C# specific generation enhancements: declarations and typing, events declaration and invocation, error handling, conversion of modules to classes, indexer properties, case sensitive corrections, brackets generation for array access, variable initialization generation, and much more.
Migration of ADO to ADO.NET using .NET Common Interfaces.
Support for converting many new 3rd-party components such as SSDataWidgets SSDBGrid, TrueDBList80, Janus Grid, TX Text Control, ActiveToolBars, ActiveTabs, ActiveBar 1 and 2, etc.
New helper classes that offer frequently used VB6 functionality that is either unavailable in .NET and/or that is encapsulated for the sake of readability.
Automatic stub generation of no-maps as a proven strategy to manage overall remaining effort towards successful compilation of upgraded code.
And much more!

For more info, you can visit ArtinSoft’s website, and let us know about your specific migration requirements.

Visual Basic Upgrade Companion 2.0 - The tool you have been waiting for

Jaguilar — Mon, 07 Apr 2008 22:25:00 GMT

The Visual Basic Upgrade Companion version 2.0 was released today! The VBUC2.0 is a considerable improvement over previous versions of the Companion....(read more)

So Long VB6, and Thanks for all the Fish

Jaguilar — Mon, 07 Apr 2008 18:41:00 GMT

I may be a little late to the obituary, but VB6 support is finally, officially, irrefutably gone. The IDE, as stated in Microsoft's Product Life-Cycle guidelines, "... will no longer be supported starting March 2008". We will miss you VB6......(read more)

Useful MSBuild Custom Tasks

Mrojas — Thu, 03 Apr 2008 19:48:00 GMT

I present here the implementation of some useful tasks
In Artinsoft we perform massive migrations of VB6 code to VB.Net
and C#.

And sometimes after migration there are customizations to be
performed on the code, to add new functionality or to set certain new
properties.

The idea was to provide a couple of very simple and puntual MSBuildTask
to illustrate how easy it is to create custom tasks and to provide a starting
point to create new one.

You can freely use this code, just keep this comments and remember this is just
a sample code. There are not warranties. ;) And i made it a rush I know it could have
been written better

Artinsoft
mrojas@artinsoft.com

The implemented tasks are:

RemoveCOMReference	Removes COMReferences from your project. COM references are for when you are using things thru Interop
FixOutputPath	Resets the output paths to bin\Release and bin\Debug
AddProjectReference	Add a reference to another project. A nice feature is that it generates RelativePaths the way Visual Studio does
AddSimpleReference	Add a reference to a very simple references like the ones you add when you click Add Reference and add System.EnterpriseServices
ChangeCurrentBuildSetting	This can be used for a lot of things. For example to turn on or off the RegisterForComInterop setting To set conditional compilation variables To set debug info to pdbonly The sky is the limit jeje

The following is a sample project file

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<!-- make sure that the Assembly is in a place where msbuild can find it, a simple way is just to put it

in the same directory of your .proj file -->

<UsingTask TaskName="SomeUsefulTasks.MSBuild.RemoveCOMReference"    
  AssemblyFile="SomeUsefulTasks.dll"/>

<UsingTask TaskName="SomeUsefulTasks.MSBuild.FixOutputPath"         
  AssemblyFile="SomeUsefulTasks.dll"/>

<UsingTask TaskName="SomeUsefulTasks.MSBuild.AddProjectReference"   
  AssemblyFile="SomeUsefulTasks.dll"/>

<UsingTask TaskName="SomeUsefulTasks.MSBuild.AddSimpleReference"    
  AssemblyFile="SomeUsefulTasks.dll"/>

<UsingTask TaskName="SomeUsefulTasks.MSBuild.ChangeProjectBuildSetting"    
  AssemblyFile="SomeUsefulTasks.dll"/>

   <ItemGroup>

    <VSProjects Include="$(Start)\**\*.*proj" />

  </ItemGroup>

<!--

Run with 
MSBUILD SampleProject.proj /target:COMReference /p:Start="C:\MyCode"

-->

  <Target Name="COMReference">

    <RemoveCOMReference SourceFiles="@(VSProjects)" ComReferenceName="MSXML2" />

  </Target>

<!--

Adds a project reference

Run with

MSBUILD SampleProject.proj /target:AddProjectReference /p:Start="C:\MyCode" /p:ProjectPath="C:\MyCode\MyNewSuperProject\Project1.csproj"

-->

   <Target Name="AddProjectReference">

      <AddProjectReference SourceFiles="@(VSProjects)"  AbsolutePathToProject="$(ProjectPath)"/>

   </Target>

<!-- 
Adds a reference to a standard assembly

Run with

MSBUILD SampleProject.proj /target:AddSimpleReference /p:Start="C:\MyCode" /p:Reference="System.EnterpriseServices"

-->

<Target Name="AddSimpleReference">

      <AddSimpleReference SourceFiles="@(VSProjects)" Reference="$(Reference)" />

</Target>

<!-- 
Resets the OutputPaths to .\bin\Debug and .\bin\Release

Run with

MSBUILD SampleProject.proj /target:FixOutput /p:Start="C:\MyCode" /p:Reference="System.EnterpriseServices"

-->

<Target Name="FixOutput">

    <FixOutputPath SourceFiles="@(VSProjects)"  />

</Target>

<!--

Adds a reference to a standard assembly

There are several options here for example to set the project debug info to pdb-only do this:

Run with

MSBUILD SampleProject.proj /target:ChangeSettingToPDBOnly /p:Start="C:\MyCode"

Or run with

MSBUILD SampleProject.proj /target:ChangeSettingAddAConstant /p:Start="C:\MyCode"

Or run with

MSBUILD SampleProject.proj /target:SettingComInterop /p:Start="C:\MyCode"

-->

<Target Name="ChangeSettingToPDBOnly">

      <ChangeProjectBuildSetting

          SourceFiles="@(VSProjects)"

          ConfigurationType="All"

          Setting="DebugType"

          NewValue="pdbonly" />

</Target>

<Target Name="ChangeSettingAddAConstant">

      <ChangeProjectBuildSetting

          SourceFiles="@(VSProjects)"

          ConfigurationType="All"

          Setting="DefineConstants"

          NewValue="MYNEWVAL"

          Add="True"/>

</Target>

<Target Name="SettingComInterop">

      <ChangeProjectBuildSetting

          SourceFiles="@(VSProjects)"

          ConfigurationType="All"

          Setting="RegisterForComInterop"

         NewValue="true" />

</Target>

</Project>

DOWNLOAD CODE AND BINARIES

Get Relative Path

Mrojas — Thu, 03 Apr 2008 15:24:00 GMT

I had the requirement of creating a MSBuild custom task that opens a .csproj
adds a reference to another project.

The problem I faced is that references in VisualStudio are generated as relative paths,
so I needed something to help me generate relative paths.

After some Googleing I finally found this code. It was in a long forum discussion
and was posted by a guy named something like Marcin Grzabski. And here it is for posterity.

        private static string EvaluateRelativePath(string mainDirPath, string absoluteFilePath)

            string[]

            firstPathParts =

             mainDirPath.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);

            string[]

            secondPathParts =

             absoluteFilePath.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);

            int sameCounter = 0;

            for (int i = 0; i < Math.Min(firstPathParts.Length,secondPathParts.Length); i++)

                if (

                !firstPathParts[i].ToLower().Equals(secondPathParts[i].ToLower()))

                    break;

                sameCounter++;

            if (sameCounter == 0)

                return absoluteFilePath;

            string newPath = String.Empty;

            for (int i = sameCounter; i < firstPathParts.Length; i++)

                if (i > sameCounter)

                    newPath += Path.DirectorySeparatorChar;

                newPath += "..";

            if (newPath.Length == 0)

                newPath = ".";

            for (int i = sameCounter; i < secondPathParts.Length; i++)

                newPath += Path.DirectorySeparatorChar;

                newPath += secondPathParts[i];

            return newPath;

And to use is just do somelines like:

            String test = EvaluateRelativePath(@"E:\Source_Code\Code\ProjectsGroup1\Project1", @"E:\Source_Code\Code\ProjecstGroup2\Project2");

//This will genearate something like ..\..\ProjectGroup2\Project2

VB6 is dead. Long live .NET

enassar — Tue, 01 Apr 2008 21:00:00 GMT

Well, not exactly. But official support for Visual Basic 6.0 has certainly ended, as I’ve mentioned on previous posts. VB 6 has been used by millions of people all over the world to develop applications ranging from thousands to millions of lines of code. It’s definitely time to move those significant organizational investments to .NET, and appropriately ArtinSoft is about to launch a new enhanced version of its VB to .NET migration product (Visual Basic Upgrade Companion). Stay tuned for details…

Jay Roxe on VB to .NET migration motivations and benefits

enassar — Tue, 25 Mar 2008 22:21:00 GMT

Browsing through some of the good old VB to .NET migration resources I’ve accumulated through all these years, I rediscovered a Dr. Dobb’s interview by Scott Swigart with Jay Roxe. Among other things, they talked about the motivations for migrating from Visual Basic 6.0 to the .NET platform, either to VB.NET or C#, and some of the benefits of the new environment.

Putting aside the VB6 support end concerns, he describes the lifecycle of any application as one of the motivations for a .NET upgrade: “The application has reached a point where the code has grown beyond its original scope, and it's time to rewrite the application anyways, and it just makes sense to transition to the latest development platform at the same time”. Other incentives relate directly to the .NET Framework’s new functionality and development capabilities, and that’s where the benefits come under the spotlight. For instance, he mentions that “We're also seeing, particularly for some of our Web customers, that when they took a VB6/ASP application, and moved it to a VB.NET/ASP.NET application, it was 300 percent more scalable, and they got 200 percent more throughput from the application”.

Roxe also explains how the ClickOnce technology solves the DLL Hell issue by providing better deployment and management, checking the prerequisites availability before installing the application itself, with the option of setting up version checking and without impact to any other applications on the machine. There’s also the possibility of deploying a COM component with an application without having to register it, allowing multiple side-by-side installations of that component without conflicts.

Finally, he responds to the questions around choosing the programming language (VB.NET or C#) once you decide to move to the .NET platform, adding some advice around VB to .NET migrations and pointing some of the available resources. You can read the whole article here, and if you have a VB to .NET migration project in your hands or want to share any experience you’ve had with such upgrades, I’d definitely love to hear about it.

Upcoming VB Webcasts

Jaguilar — Wed, 05 Mar 2008 15:42:00 GMT

Beth Massi, Program Manager on the Visual Studio Community Team, will be doing a series of webcasts on Visual Basic 9. They will be mostly about the new features of VB9, including one about LINQ in VB that I am particularly interested in. Another one of them deals specifically with Visual Basic 6.0 to .NET migrations, called Live From Redmond: Migrating Your Visual Basic 6 Investments to .NET. If you haven't yet considered moving your VB6 application to the .NET Framework, this may be a good place to start....(read more)

Pretty Printers / Format Code / for C# VB.NET

Mrojas — Tue, 04 Mar 2008 20:49:00 GMT

In my past life I spent a few eons writing Java code. And it wasn't bad. We had nice tools like Jalopy! that allowed us to have
code in a very standard way.

And I missed that. I've been looking around for something similar but I havent found anything like that :(

Until I found a great post from Chris Eargle, he improved the original solution from Kelvinpinch

Well here's the code.

Public Sub FormatSolution()
     Dim sol As Solution = DTE.Solution
     For i As Integer = 1 To sol.Projects.Count
          FormatProject(sol.Projects.Item(i))
     Next
End Sub

Private Sub FormatProject(ByVal proj as Project)

     For i As Integer = 1 To proj.ProjectItems.Count
          FormatProjectItem(proj.ProjectItems.Item(i))
     Next
End Sub

Private Sub FormatProjectItem(ByVal projectItem As ProjectItem)

     If projectItem.Kind = Constants.vsProjectItemKindPhysicalFile Then

          If projectItem.Name.LastIndexOf(".cs") = projectItem.Name.Length - 3 Then
               Dim window As Window = projectItem.Open(Constants.vsViewKindCode)
               window.Activate()
               projectItem.Document.DTE.ExecuteCommand("Edit.FormatDocument")
               window.Close(vsSaveChanges.vsSaveChangesYes)
          End If
     End If

'Be sure to format all of the ProjectItems.
     If Not projectItem.ProjectItems Is Nothing Then
          For i As Integer = 1 To projectItem.ProjectItems.Count
               FormatProjectItem(projectItem.ProjectItems.Item(i))
          Next
     End If

'Format the SubProject if it exists.

     If Not projectItem.SubProject Is Nothing Then
          FormatProject(projectItem.SubProject)
     End If
End Sub

To use it perform the following steps:

Go to the VS IDE Tools Option
Then Select the Macros option and select Macros IDE...
This will open the macros IDE
In the Macros IDE navigate to the Module1, and Insert the code

To run the Macro go to Tools\Macros\Macro Explorer

And select FormatAll :)

And last but not least if you want to runit from the command line just do:

devenv /command "Macros.MyMacros.Module1.FormalAll" MyProject.csproj or

devenv /command "Macros.MyMacros.Module1.FormalAll" MySol.sln or

Upgrade a VB6 Application Incrementally: The Interop Forms Toolkit

Jaguilar — Mon, 03 Mar 2008 11:19:00 GMT

If you're still waiting to upgrade your VB6 applications to the .NET Framework, maybe the Interop Toolkit will help you to make a decision and get started with the process....(read more)

Killing open Terminal Services sessions remotely

Jaguilar — Fri, 29 Feb 2008 17:22:00 GMT

How to use two relatively obscure command line tools to remotely close a Terminal Services session....(read more)

Windows Server 2008 released

Jaguilar — Thu, 28 Feb 2008 16:54:00 GMT

A quick post to tell everyone that the day finally came: Windows Server 2008 was released today. it includes two technologies in particular that I think will be revolutionary: Hyper-V and RemoteApp....(read more)

ActiveX exceptions when running in .NET

Mrojas — Tue, 05 Feb 2008 15:11:00 GMT

During migration to C# or .NET it is easier to keep the same ActiveX.
The VBCompanion does a great work in migrating the ActiveX control using the .NET ActiveX wrappings and fixing all method calls.
Sadly sometimes those ActiveX do not work properly in .NET.

Well we have good news.
Recently my friend Jose David (who we keep bothering because he is now
a Project Manager and now he only programs in MS Excel and MS Project, I added the MS by his request :P) fixed a curious bug
we had with an aplication we migrated from VB6 to C#.

The thing is that the aplication had an ActiveX control with a strange runtime behaviour.
We migrated the application keeping the ActiveX control and in most ocasions it worked ok.

But randomly it started throwing exceptions.

During the testing he discovered that if he repeated the steps slowly the bug did not reproduced.

So his idea was that it was due a garbage collection issue. And SURPRINSINLY he was right :P

He added this:

System.GC.Collect();
System.GC.WaitForPendingFinalizers();

And the application started to work.

It seems like some of the COM objects needed a little more time for releasing all references :)

IsMissing migration in VB.NET or C#

Mrojas — Mon, 04 Feb 2008 22:43:00 GMT

Recently we added some support for migrating the IsMissing function to VB.NEt or C#

The thing is. In VB6 the IsMissing Function is TRUE only if you have something like:

Public Sub Foo(Optional str)

Where you dont specify the variable type, or if you have

Public Sub Foo(Optional str as Variant)

And is IsMissing is FALSE for any other case. Including Optional variables whose definition type is not Variant.

So let's see some examples to illustrate the idea:

Example 1:

Public Sub Foo(str, a As Integer, b As Integer, Optional c As Integer)
    MsgBox (str & "Foo Is missing a " & IsMissing(a))
    MsgBox (str & "Foo Is missing b " & IsMissing(b))
    MsgBox (str & "Foo Is missing c " & IsMissing(c))
End Sub

It occurs that IsMissing is really FALSE in all cases. So it is equivalent to:

Public Sub Foo(str, a As Integer, b As Integer, Optional c As Integer)
    MsgBox (str & "Foo Is missing a " & false)
    MsgBox (str & "Foo Is missing b " & false)
    MsgBox (str & "Foo Is missing c " & false)
End Sub

Example 2:

Public Sub Goo(str, a As Integer, b As Integer, Optional c As Object, Optional d As Byte, Optional e)
    MsgBox (str & "Goo Is missing a" & IsMissing(a))
    MsgBox (str & "Goo Is missing b" & IsMissing(b))
    MsgBox (str & "Goo Is missing c" & IsMissing(c))
    MsgBox (str & "Goo Is missing d" & IsMissing(d))
    MsgBox (str & "Goo Is missing e" & IsMissing(e))
End Sub

All cases EXCEPT "e" are equivalent to FALSE

Public Sub Goo(str, a As Integer, b As Integer, Optional c As Object, Optional d As Byte, Optional e)
    MsgBox (str & "Goo Is missing a" & false)
    MsgBox (str & "Goo Is missing b" & false)
    MsgBox (str & "Goo Is missing c" & false)
    MsgBox (str & "Goo Is missing d" & false)
    MsgBox (str & "Goo Is missing e" & IsMissing(e))
End Sub

So if you are migrating your VB6 Code to C# put attention to these little details it can save you a lot of time.And remember that this is just one feature of VBCompanion tool ;)

Internet Explorer Runtime Error Do you Wish to Debug?

Mrojas — Mon, 04 Feb 2008 22:37:00 GMT

Hi, for several months I lived with an extremely unconfortable bug.
On some pages IE will display an alert dialog indicating

Error
A Runtime Error has occurred.
Do you wish to Debug?
Line: blablabla
Error: blablalba

Well finally I looked in google and found this: http://support.microsoft.com/kb/822521

So if anybody had to live with this bug like me, I hope this helps him

Opening Projects Migrated with the VB Upgrade Companion on Visual Studio 2008

Jaguilar — Thu, 31 Jan 2008 01:29:00 GMT

Now that Visual Studio 2008 is available, you might wonder what will happen with the Visual Studio 2005 projects generated with the current version of the VB Upgrade Companion (VBUC). For starters, it is worth mentioning that Visual Studio 2008 fully supports projects created in the .NET Framework 2.0, like the ones generated with the VBUC. The newer version of the .NET Framework (3.0, shipped with Vista, and 3.5, shipped with VS2008) keep the same core version of the CLR (2.0) as before, with very few minor changes. There are no compatibility or breaking changes like when upgrading from versions 1.1 to 2.0 of the .NET Framework. When you open a VS2005 project in VS2008, you are greeted with the new Visual Studio Conversion Wizard ...(read more)

Countdown to Extinction

Jaguilar — Fri, 25 Jan 2008 14:32:00 GMT

.... and so we reached 2008. This may seem like any other "average" year - the price of gas keeps going up, everybody talks about global warming, and will be an election year in the US (so we have one more reason to stop watching TV). However, for a large group of IT departments around the world, 2008 is a BIG year. 2008 is the year when Microsoft officially kills support for Visual Basic 6.0....(read more)

The curtain unveils – Aggiorno is out!

enassar — Tue, 15 Jan 2008 16:56:00 GMT

Since 2007, a team of ArtinSoft’s experts has been working on a tool that helps automate a lot of actions commonly performed by web developers, increasing their productivity and resulting in more efficient pages. The outcome is Aggiorno, an expandable plug-in for Visual Studio that produces SEO friendly, XHTML compliant, CSS styled HTML and ASP.NET, which eases enormously the task of delivering web standards compliant web sites. Based on a unique pattern detection and transformation engine, Aggiorno’s beta version is currently available on a by-invitation-only basis, so register now and get early access to this revolutionary product!