It's been twelve years since the last release of the "non-.NET" version of Visual Basic and five years since support was terminated. But there's still room in the toolspace for new products.
This month eXontrol released their eXCalendar, eXEdit and three other OCX controls (all part of their eXsuite package). Also this month, BCL Technologies released easyPDF SDK for "any language that supports COM objects." And Korzh.com released EasyQuery.Ax, a COM/ActiveX extension to their Easy Query product line.
All of these products are available in .NET versions (or are part of a product line that includes .NET versions). But what's interesting is that these product announcements all featured COM/ActiveX/OCX implementations. I made a very good living from Visual Basic 6 for a long time and, while I'm not currently developing in it, it's a testament to the power of the tool that it (and its COM brethren) still provide a market for tool developers.
Posted by Peter Vogel on 12/01/2010 at 10:00 AM6 comments
This is a continuation of
the interview I had with Blair Symes (marketing manager for Flexera Software) about InstallShield. In this part of the interview, I wanted to ask about what the company's product does for its customers now and what they expect to deliver.
Peter Vogel: What do you see InstallShield doing for your customers?
Blair Symes: We want to make it easy for developers to handle even the most complex installation requirements with minimum effort for desktop, web, server, and mobile applications. So automated tools and wizards and easy-to-use project views are important to keep installation authoring simple while cutting down development time. But we also include advanced features to give developers complete control of installation behavior as well as the look, feel, and functionality of installer dialog boxes. We also support the entire application lifecycle by making it easy to create updates and patches. That includes ensuring that the applications uninstall smoothly without aggravating end users.
P: Where is InstallShield going? Where do you want to take the product?
B: Many of our changes are driven by our customers changing software practices. Many software companies follow Agile Software Development best practices by building their installations from the beginning and continuously integrating them with their product builds. InstallShield Standalone Build licenses enable developers to follow Agile Software Development best practices by automating and integrating installation builds with their product builds.
Customers are also asking us for support for distributed development and deployment of installation packages. We currently provide tools like InstallShield Collaboration, Pre-requisites editor and MSI chaining to support this. But we're also looking to enhance and provide a more robust solution to support these needs and, in turn, provide a richer installation experience.
P: What do you see as the biggest change in the environment?
B: More and more software vendors providing their applications to customers as Microsoft App-V packages. It's a shift comparable to what happened with Windows Installer (MSI) ten years ago when the industry moved from script-based installs to MSI installs but this time the shift is to application virtualization. Software companies are having to provide their applications both virtual packages and traditional MSI packages. InstallShield makes that easy. When you build a traditional MSI project, InstallShield can simultaneously build it as an App-V package. It can also automatically convert your legacy MSIs to App-V packages. InstallShield handles all the conversion work, so there's no learning curve for developers new to application virtualization.
Posted by Peter Vogel on 11/30/2010 at 1:53 PM1 comments
It's often interesting to find out how a company sees itself. I recently asked Blair Symes, marketing manager for Flexera Software, how the company views its product and customers. We
reviewed Flexera's InstallShield in the November issue of Visual Studio Magazine.
Peter Vogel: From your point of view, what is InstallShield?
Blair Symes: InstallShield is the gold standard for building Windows software installations (and has been for over 20 years). InstallShield gives developers a flawless localized installation experience for their software, keeping their end users happy and support costs down.
P: Who are your target customers?
B: The target audience for InstallShield is software developers working for software vendors that sell applications commercially and developers working for enterprises (in any industry) or government agencies that develop custom applications for their organizations.
P: Those are big categories.
B: We break them down into two different roles. We distinguish between "Setup authors" (also known as "release engineers," "build engineers," or "software developers") and "Development/Configuration managers." Both groups are risk averse: They want a reliable process that guarantees a successful installation. The first group -- the setup authors -- also want the software installation creation process to take as little time as possible (and require as little effort as possible). They're working on tight schedules and budgets and don't want to have to learn a new tool on each development cycle.
The second group -- development/configuration managers -- are typically managing multiple projects with no time for mistakes and release dates that must be kept. So they're interested in managing their resources efficiently and ensuring collaboration. Reliability and predictability within a project schedule matters to them.
Posted by Peter Vogel on 11/29/2010 at 6:03 AM0 comments
Continuing my
exploration of Flexera Software InstallShield, it would be irresponsible of me not to mention some of the additional tools that come with the InstallShield package. While InstallShield doesn't have all of the tools that, for instance, Wise provides there is some overlap.
You can read my reviews of InstallShield and Wise Package Studio here.
InstallShield includes two tools that you can use from the Installation Designer to support those installation packages that need more than the Wizards that Visual Studio provides. There's a dynamic scanner that analyzes an application as it runs and determines what DLLs it actually uses. This helps ensure that you include all the necessary components in your installation package (and specify all the appropriate dependencies among those components). There's also a static scanner that, analyzes the files in your project (EXEs, DLLs, OCXs) to find the dependencies embedded in them and adds those dependencies to your installation package.
Not integrated into the Installation Designer are a number of tools for analyzing MSI files (Windows installation packages). An MSI Diff tool compares two MSIs and highlights differences, answering the question, "What are the real differences between these two versions of our product?" Two other tools support modifying a few of the attributes on some of the standard dialog boxes that InstallShield uses.
Posted by Peter Vogel on 11/21/2010 at 4:34 PM0 comments
Deploying an application is only half the battle -- probably less, in fact. You also have to set up the environment that the application will run in. A huge part of setting up that environment is ensuring that the database the application will work with has all the changes made to it that the application requires. As changes accrue in the development system, how do you ensure that those changes are made to the production system before your new application starts? You
could count on developers remembering and reporting all of the changes they make. You
could have a risky way of ensuring all changes to the database structure are tracked. But I repeat myself.
Red-Gate's newest offering, SQL Source Control, deals with your changes to your database the same way that you deal with changes to your code: Through source control. At least that's their plan. As I said in my last blog post (Next Up: Designing Databases), in the December issue of Visual Studio Magazine we're looking at one of our readers' favorite design-time tools for databases (ERWin). We're also going to look what could be a key tool for getting those designs into production: Red Gate's SQL Source Control.
Posted by Peter Vogel on 11/19/2010 at 12:43 PM0 comments
In the November issue of Visual Studio Magazine, I
reviewed a pair of Windows installation and deployment packages--Flexera Software InstallShield and Wise Package Studio. Today I'll dive a little deeper in InstallShield.
InstallShield actually provides you with two interfaces for creating deployment packages. One is integrated with Visual Studio. The other is the standalone InstallShield 2011. This interface allows you to choose between a wide variety of project types. These include a number of Wizards (including one for Visual Basic 6) and a ClickOnce deployment project.
However, when the Wizards aren't enough, you'll need to use one of the InstallScript projects. Typically, you'll use an InstallScript project when you want to take control of the installation user interface or when there are tasks that you need to perform after your software package is installed (and, occasionally, before installing your package). While using InstallScript isn't for the faint of heart, InstallShield does go a long way towards managing the process.
For instance, if you select the most "free-form" of the InstallScript projects, the base InstallScriptProject, InstallShield presents the project to you in the Installation Designer, a treeview that organizes the components of the installation package. It's not a Wizard (there's no attempt to walk you through the steps) but the treeview does structure the tasks you need to perform.
The first step, for instance, is to define the "Features" that make up your deployment package. As you add features, a dialog (available from the Feature's property sheet) allows you to create dependencies between features (i.e. don't install this feature without this other feature). Each feature has a set of events associated with it, listed in its Properties Window, that you can tie InstallScript code to.
Further down in the Installation Designer you can write your InstallScript functions that you can tie to your events. The UI isn't as slick as I might like. There's no way to create the skeleton of a function from the Properties Window of a feature as you can when adding event handlers in Visual Studio, for instance. This necessitates some bouncing back and forth in the TreeView between the script node and the features node. But the InstallScript editor is more than just an implementation of Notepad and includes, for instance, IntelliSense-like support.
As I said, InstallScript isn't for the faint of heart (and C programmers will feel more at home with InstallScript than Visual Basic programmers will), but the InstallShield UI goes a long way to managing the complexity.
Posted by Peter Vogel on 11/18/2010 at 4:54 AM0 comments
I tell new developers (all anxious to write the bestest, fastest code they can) that they're worrying about the wrong thing. The most important thing is to get their database design right.
If you get the database design right then everything else will be easy; if you get the database design wrong... then make sure you're paid by the hour. In December, we're going to review one of the top vote getters in the database category of this year's VSM Readers Choice Awards: CA Technologies' ERWin Data Modeler.
We expect a lot from our database design tools: That they support whatever notation we're using, that their output be compatible with whatever database we're using, that we be able to share the designs that we create with the tool with all of the stakeholders in our development, that it integrate with our development toolset. And, of course, that they actually help us get the database design right.
These days there's a more important question: In a world of Object Relational Modeling tools (like Visual Studio's Entity Framework, to name one) is their still a spot in the toolspace for ERWin?
Posted by Peter Vogel on 11/17/2010 at 11:47 AM0 comments
We
reviewed Aspose.PDF recently, looking at its ability to create PDF documents from .NET applications. Aspose actually has two related PDF products, Aspose.PDF and Aspose.PDF.Kit, however in a bid to ease complexity, the company is thinking about merging the two products some time before the end of the year.
Posted by Peter Vogel on 10/26/2010 at 9:57 AM0 comments
Test Driven Development must be important: Vendors are releasing tools just to support parts of the TDD process. JetBrains -- which makes
ReSharper -- has just released a new code coverage add-in for Visual Studio 2005 to 2010. It's called dotCover and highlights code covered by unit tests. It works with a variety of unit test frameworks and has a console front end that allows it to integrate with continuous integration processes.
Posted by Peter Vogel on 10/26/2010 at 9:28 AM0 comments
When you think about it, a reviewer like me has a lot of effrontery. Fundamentally, I call up software vendors and ask them to send me a free copy of their software. Often the vendor does just that, while a few vendors suggest that I download the evaluation copy of their product from their Web site.
I explain to those vendors who point me at their evaluation copy that I'm uncomfortable with reviewing anything but the exact same bits that a real developer gets. I'm keenly interested in seeing what the "real" installation process is like and what, if any, issues are raised by the company's licensing strategy. In addition, I live in fear of criticizing some aspect of a product and have it turn out that I was looking at some limitation built into the "evaluation" version and not present in the "real" bits.
Most vendors are comfortable with providing a free version. After all, having me download software doesn't explicitly cost them anything and, at most, they are only losing the profit they might have made had I purchased the software myself.
Some vendors are not. For instance, we look at the latest versions of the InstallShield and Wise installation and deployment tools in the upcoming November issue of Visual Studio Magazine. InstallShield was steadfast in that they do not provide free software to anyone under any circumstances. If I wanted to review the product, I was going to have to review the evaluation version available on their Web site. I don't think that I've misled any readers as a result of doing that, but please let me know if there's something in the InstallShield review that isn't accurate because I was using an evaluation version.
I simply wasn't able to get a response from Wise despite several e-mails to the company and to their public relations firm. I mention this because (perhaps unfairly) I use this as a measure of how well the company responds to requests.
When I first started reviewing software in the late 80s, I would often test the company's technical support by asking a question. This was only a reasonable test if the person processing the request didn't realize that I was reviewing the software. That's not possible any more, so I usually measure a company's responsiveness by how quickly they get back to me from the start of the review process to the end. I recognize that these companies know that this review is part of their marketing process, so it's not a great measure of the organization's responsiveness. However, Wise is unique in simply not responding at all. I'm not sure what that tells me about the company.
Does anyone out there use the Wise installer? How has the company dealt with you when you've had an issue with their software?
Posted by Peter Vogel on 10/21/2010 at 12:07 PM0 comments
One of the things that I like about object models is consistency. If I learn one object, I hope that I can leverage that knowledge when working with other objects. I also like it if the object model that I'm working with is compatible with the .NET object model. Aspose.PDF, which I
reviewed in the September issue of Visual Studio Magazine is like that.
For instance, with Aspose.PDF if I want to create a document with some text, I first create a Pdf object, create a Section and add the Section to the Pdf's Sections collection. I then create a Text object and add the Text to the Section's Paragraphs collection (I can add a Text object to the Paragraphs collection because Text inherits from Paragraph). Right at the start you can see the consistency between how a Section is added to the Pdf object and the Text is added to the Section.
The code looks like this (and you can see the repetition):
Dim doc As Pdf = New Pdf()
Dim sec As New Section()
doc.Sections.Add(sec)
Dim txt As Text = New Text("A curve")
sec.Paragraphs.Add(txt)
This is exactly the way that I expect objects-with-collections to work, so I'm a happy camper.
While I like collections, I also appreciate shortcuts. Aspose, for instance, allows me to create a Section and add it to the Pdf object by using an inconsistent version of the Add method that accepts no parameters:
Dim sec As Section = doc.Sections.Add()
I'm comfortable with using this shortcut because I believe that a developer reading this code would understand what the code was doing.
There's a second shortcut that I can use to create a Section and add it to the Pdf object. I can pass a Pdf object to the Section as I create it:
Dim sec As New Section(doc)
I'm less comfortable with this shortcut because I don't think it's obvious what's going on here. In fact, a developer with knowledge of the Decorator pattern might assume that's what's happening here (and it's not, by the way).
But these are all shortcuts and I'm free to ignore them to stick with the standard objects-with-collections coding.
Now what happens when I create a document with a graphic? The pattern is the same but I create a Graph object and add it to the Section's Paragraphs collection (a Graph inherits from Paragraph, just like a Text object does). So that code looks like this:
Dim gph As Graph = New Graph(sec1, 100, 400)
sec.Paragraphs.Add(gph)
I can build up a Graph by creating Shapes and adding them to the Graph's Shapes collection in a way very similar to the way I added Texts and Graphs to Sections. This example creates a Curve (using an array of positions) and adds it to the Graph object:
Dim pos () As Single = New Single() {0, 0, 200, 80, 300, 40, 350, 90}
Dim crv As Curve = New Curve(graph1, posArr)
gph.Shapes.Add(crv)
However, I have to admit, the number of parameters required to create a curve makes creating a graphic out of shapes more than a little intimidating. Ignoring that though, I appreciate the care that went into the Aspose.PDF object model.
Posted by Peter Vogel on 10/15/2010 at 7:37 AM0 comments
I spend so much time talking about how I feel let down by the documentation provided with the software that I review that it would be churlish not to comment on a company that does it right. So here it is:
Aspose.Pdf does it right.
I reviewed Aspose.Pdf for the September issue of Visual Studio Magazine, and one thing that impressed me was the product's documentation and help. Aspose provides a Help file that breaks down into two main sections. First, there is a Getting Started section that provides an overview of the package and what it does. The very first sentence provides what's often missing in these packages: a succinct description of what the product does in terms of "why you'd want to use it":
Aspose.Pdf for .NET is a .NET Component built to ease the job of developers to create PDF documents ranging from simple to complex on the fly programmatically.
The second section is a programmer's guide that provides detailed information on using Aspose. This section is in several parts. The first sections are introductions that assume you're not familiar with the basic technologies used by the package and provide essential background information. You're free to skip over these sections, of course, if you are familiar with the information.
The next part section is "scenario based:" it walks a developer through the basics of creating a "Hello, World" application with Aspose.PDF. This would probably be where most programmers would get started -- skipping the background material to see if they can get something working.
Aspose.PDF is smart enough to continue in that mode, organizing the information in the next few parts around typical scenarios. Rather than dumping the reader into an alphabetical list of classes and methods, information is organized by what developers would want to do: "Working with Sections," "Working with Images" and so on.
Aspose.Pdf has recognized that the typical developer question when starting to work with a product is not, "How do I use this class?" Instead, most developers want to ask the question, "How do I accomplish this task?" These parts don't consist of a hunk of code that you have to figure out. Instead, you get an overview of what the solution looks like, followed by the code you need.
Once you've gotten up to speed in Aspose.Pdf and have moved on to the point where you are asking "How do I use class ???', there's a an API reference that answers those questions.
It's just nice to see documentation done right. And darned unusual, also.
Posted by Peter Vogel on 10/08/2010 at 6:44 AM3 comments