Products, the Universe and Everything

Products, the Universe and Everythinghttp://www.riverblade.co.uk/blog.phpRiverblade's products, and the technologies we encounter along the wayen-usLintProject Pro 2.0.10.19 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_08_01_archive.xml#641225497036332368#641225497036332368

Corrected the parsing of RuntimeLibrary definitions in Visual C++ 2010 project (.vcxproj) files [VS2010] [from Visual Lint 2.5.4.136].

Speeded up the parsing of Visual Studio 2010 C++ project (.vcxproj) files further [VS2010] [from Visual Lint 2.5.4.136].

When a Visual C++ 2010 project (.vcxproj) file is parsed, the contents of each configuration are no longer read automatically. Instead, they are loaded on demand when the contents of the configuration is requested, which can significantly speed up the loading of complex projects [VS2010] [from Visual Lint 2.5.4.136].

Corrected the analysis results parser to strip leading and trailing whitespace from source file pathnames [also in Visual Lint 2.5.4.136].

Added support for the Visual C++ CL environment variable. Any compiler options contained in this variable will now be reflected in the contents of project indirect files [VS2002-VS2010] [from Visual Lint 2.5.4.136].

Added support for forced include project properties in Visual C++ 2002-2010 project (.vcproj and .vcxproj) files [VS2002-VS2010] [from Visual Lint 2.5.4.136].

Desensitised the Visual C++ project (.vcproj) file parser to doubled path delimiters in folder paths used to load inherited property sheet (.vsprops) files [VS2002-VS2008] [from Visual Lint 2.5.4.136].

The operating system version information written to the application logfile now includes the name of the OS rather than just the OS version number [from Visual Lint 2.5.4.136].

Corrected the analysis results parser to strip leading and trailing whitespace from source file pathnames [from Visual Lint 2.5.4.136].

]]> Visual Lint 2.5.4.136 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_08_01_archive.xml#641225497036332367#641225497036332367

When a Visual C++ 2010 project (.vcxproj) file is parsed, the contents of each configuration are no longer read automatically. Instead, they are loaded on demand when the contents of the configuration is requested, which can significantly speed up the loading of complex projects [VS2010].

Corrected the analysis results parser to strip leading and trailing whitespace from source file pathnames.

Added support for the Visual C++ CL environment variable. Any compiler options contained in this variable will now be reflected in the contents of project indirect files [VS2002-VS2010].

Added support for the Visual C++ INCLUDE environment variable. If Visual Studio is invoked with the /UseEnv option, the contents of this variable will be written by Visual Lint Enterprise Edition as -i directives to all new project indirect files. Note that for this to work correctly, a custom std.lnt file which does NOT specify the global include folder configuration must be used for the solution concerned [VS2002-VS2010] [Visual Lint Enterprise Edition].

Added support for forced include project properties in Visual C++ 2002-2010 project (.vcproj and .vcxproj) files [VS2002-VS2010].

Desensitised the Visual C++ project (.vcproj) file parser to doubled path delimiters in folder paths used to load inherited property sheet (.vsprops) files [VS2002-VS2008].

The operating system version information written to the Status View now includes the name of the OS rather than just the OS version number.

Fixed issues in the parsing of RuntimeLibrary properties within Visual C++ 2010 (.vcxproj) project files [VS2010].

Revised the project loading sequence to avoid reading project files a second time to generate project indirect files. Note that this optimisation has an effect only when a new project indirect file needs to be written.

]]> Visual Lint 2.5.3.134 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_07_01_archive.xml#641225497036332366#641225497036332366

Added a workaround for a bug in Visual Studio 2010 RTM which prevents pages being reliably displayed in the IDE internal browser [VS2010].

Fixed a potential crash in the parsing of Visual Studio 2010 C++ project (.vcxproj) files.

Speeded up the parsing of Visual Studio 2010 C++ project (.vcxproj) files slightly. Note that further optimisation of the parsing of VS2010 projects should follow in a subsequent build [VS2010].

Added workarounds for various bugs in the automation interfaces of Visual Studio 2010 [VS2010].

Corrected a bug in the "PC-lint" Options page affecting some Visual Studio 2010 installations [VS2010].

Inherited property sheets specified using system environment variables are now parsed correctly in Visual C++ project files [VS2002-VS2008].

If a filename in a Visual C++ project contains environment variables, it will now be expanded when the file is parsed [VS2002-VS2008].

Corrected a bug in the parsing of .vcproj project files which prevented a project from overriding a for loop compliance setting inherited from a property sheet (.vsprops) file [VS2002-VS2008].

Added -vm to the analysis command line so that the PC-lint module header ("--- Module: ()" - required to support whole project analysis) is always present in the analysis results, even if -v is present in the analysis configuration.

Updated the theme in the installer Updates Wizard to match the main installation.

]]> LintProject Pro 2.0.9.18 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_07_01_archive.xml#641225497036332365#641225497036332365

Added basic support for the CppCheck analysis tool. In consequence, the /folder option now saves PC-lint and CppCheck settings independently.

Corrected a bug which caused incorrect report links to be generated if the output folder contained at least one period (".").

Speeded up the parsing of Visual Studio 2010 C++ project (.vcxproj) files slightly. Note that further optimisation of the parsing of VS2010 projects should follow in a subsequent build [VS2010] [from Visual Lint 2.5.3.134].

Inherited property sheets specified using system environment variables are now parsed correctly in Visual C++ project files [VS2002-VS2008] [from Visual Lint 2.5.3.134].

If a filename in a Visual C++ project contains environment variables, it will now be expanded when the file is parsed [VS2002-VS2008] [from Visual Lint 2.5.3.134].

Corrected a bug in the parsing of .vcproj project files which prevented a project from overriding a for loop compliance setting inherited from a property sheet (.vsprops) file [VS2002-VS2008] [from Visual Lint 2.5.3.134].

Corrected "PC-Lint" to "PC-lint" throughout.

This is a significant release as (with the exception of Visual TICS, which is a bit of a special case) this is the first time we have added support for any additional analysis tools to one of our mainstream products. If the addition of CppCheck support to LintProject Professional proves to be of benefit to our customers, support for it is also likely to be added to Visual Lint in due course. ]]> LintProject Pro 2.0.8.16 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_06_01_archive.xml#641225497036332364#641225497036332364

Modified the project indirect file writer to automatically generate "-save -e686" directives if a bracket is found within an include folder specification. This avoids erroneous occurences of Warning 686 ("Option 'String' is suspicious because of...\") when PC-lint encounters an include directive containing brackets in a project.lnt file [from Visual Lint 2.5.2.131].

Improved the parsing of .vcxproj (VS2010) project files to support changes to the structure of .vcxproj files between VS2010 RC and RTM [from Visual Lint 2.5.2.131].

Added information on the version of PC-lint being used to the banner displayed when analysis starts. Analysis reports also now show this information.

Paths containing ampersands are now quoted before use in the same way as those containing spaces.

Text written to logfiles should now have consistent line endings

]]> Visual Lint 2.5.2.131 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_06_01_archive.xml#641225497036332363#641225497036332363

Corrected a bug which was preventing analysis tasks from being reliably aborted when a file was saved. This fixes a file locking issue in the IDE [VS2005/2008/2010].

Modified the Configuration Wizard and project indirect file writer to automatically generate "-save -e686" directives if a bracket is found within an include folder specification. This avoids erroneous occurences of Warning 686 ("Option 'String' is suspicious because of...\") when PC-lint encounters an include directive containing brackets.

Improved the parsing of vcxproj (VS2010) project files to support changes to the structure of .vcxproj files between VS2010 RC and RTM.

Fixed a crash which occurred if an incorrectly formed command line was written to the Status View.

If an MSXML4 installation is not detected, an error message is now written to the Status View.

Minor updates to the Getting Started Guide.

]]> Code Editor Markers in Visual Linthttp://www.riverblade.co.uk/blog.php?archive=2010_04_01_archive.xml#641225497036332362#641225497036332362 Basic markers implemented in the Visual Studio 2008 code editor.

Basic markers implemented in the Visual Studio 2008 code editor.

Hovering over a marker will of course yield a tooltip which describes its meaning:

Hovering over a marker will yield a tooltip which describes its meaning.

There are some interesting subtleties involved with doing this. For example, many lint issues report their line number as the line at which the effort of the issue makes itself felt, rather than where the code fragment that causes it is. In such cases, a corresponding "Reference/Location cited in prior message" issue will locate the offending bit of code. In marker terms, this means that the marker which actually locates the problem may be a generic location marker, and therefore not as helpful as it could be. Our approach to this is to attempt to highlight the code fragment which actually caused to the issue, as you can see in the following screenshot:

Highlighting the offending symbol in the code itself.

Ultimately, we want to make these interactive by adding a context menu which will allow the user to suppress (or even fix!) a specific issue directly from the code editor. That said, we feel that this is a good starting point for the development of a set of potentially very complex functionality. ]]> Visual Lint for Eclipse/CDThttp://www.riverblade.co.uk/blog.php?archive=2010_04_01_archive.xml#5726593726598725393#5726593726598725393

We expect to be able to make development builds of Visual Lint for Eclipse available to Visual Lint beta testers during the summer. ]]> ACCU Conference 2010http://www.riverblade.co.uk/blog.php?archive=2010_04_01_archive.xml#5726593726598725392#5726593726598725392 As we arrived on Tuesday afternoon we had a bit of time to relax before things really got going (which they did in the evening, with seventeen of us descending on a restaurant in town and then monopolising the hotel bar afterwards...).

Day 1 - Wednesday This morning after dropping off our gear in the exhibitors area we joined a friend for breakfast and then headed down to set up our stand (an activity which almost always holds a few unexpected last minute surprises). The Evolution of Scrum (Jeff Sutherland - Keynote) This was the first session of the conference proper, and as such the main conference room was packed to the gills. As we were delayed by setting up the stand we ended up right at the back of the room, so I couldn't see the slides particularly well, but fortunately that wasn't a problem for this session. Jeff gave an interesting overview of the history of Scrum and its core principles, before doing the same with Lean Software Development and then going on to give examples of how Scrum and Lean have fared in environments where their success has been directly measured by comparison with traditional approaches (a notable example being a CMMI Level 5 company which was sufficiently impressed by the achievements of Scrum teams that they started bidding Scrum projects at 50% of the cost of the waterfall equivalent). I've not worked on a Scrum team myself so I don't have an informed view of its advantages and disadvantages relative to other agile processes. It is however beyond doubt that it can be very effective, but that to be so the organisation must embrace not only the mechanisms of Scrum but also its core principles. That of course requires that the organisation must not only change itself, but also must welcome that change. Unfortunately experience tells us that far too many organisations struggle to do that. Using Concurrency in the Real World (Anthony Williams)

Anthony is the author of the Boost threading library, and an authority on the new threading capabilities of C++ 0x. In this session he talked about the (by now well understood) difficulties with designing multithreaded software before going on to describe core principles (e.g. carefully considering which data must be shared and avoiding hidden dependencies, singletons and globals) to apply in order to write simpler, more effective concurrent applications. Among the simple but interesting techniques Anthony described were the use of a SynchronizedValue template class to wrap a value type with its own lock (reassuringly, this is a technique we already use extensively in our own code, albeit under a different name) and a templated DataFlowVariable type which executes operations in terms of tasks and can be used to produce scalable codebases very easily. The latter in particular is something I think we could learn from when we next review the way we use tasks in our codebases. He then went on to describe how new C++ 0x threading features such as futures (which provide a simple way of executing a task and waiting for a result to become available) and std::async (which automatically scales the number of threads spawned to the capabilities of the hardware) can also assist. Googletest and Googlemock C++ libraries (Seb Rose) This session was (like the previous one) packed out. A notable late arrival who didn't get a seat was Kevlin Henney - which is almost karma, given how packed his sessions at the Conference usually are! Googletest is an xUnit unit test framework developed to support the development of the Chrome browser. Like most C++ unit test frameworks, Googlemock is macro based and has only a console runner, which can be configured via command line options. One nice touch is that the pass/fail output is colour-coded. Seb demonstrated running test fixtures within Visual Studio,with test results directed to the output window. In this environment double clicking on a failure message in the Output Window opens the source at the failing test as you would expect. One quirk is that exceptions must be explicitly tested for, whereas most xUnit test frameworks will automatically fail the tests if an unexpected exception occurs. Under Windows, the option -gtest_catch_exceptions overcomes this limitation. The mocking framework Googlemock is a templated framework based on jMock and using tr1::tuple. Interestingly it does not require Googletest, but should work with any test framework. Because of its template nature, it does however impose a significant compilation time penalty. Quite reasonably, it can only mock virtual methods. It does however look quite flexible - allowing (for example) a test to define sequences of expected calls and parameters into a mock, and in what order. The C++ 0x Standard Library (Nicolai Josuttus)

This was a detailed in study of the new features in the C++ 0x Standard Library, including all of the things you would expect - initialiser lists, new containers, auto variables, tuples, r-value references, move constructors etc. The new version of the C++ standard introduces so many changes that even a detailed study can only just scratch the surface, and there is certainly too much for me to even begin to do justice to it in a mere blog post. If you are planning to move your codebase to C++ 0x in even the medium term I can only suggest that it would be a good idea to start familiarising yourself with the changes (and their implications and the resultant opportunities) as soon as you can. Sponsors Reception Following the session there was an hour long break before the Sponsor's Reception at 6:30pm, which is as ever our chance to showcase our products, answer enquiries and and make some new contacts over a glass or two of wine. This year we have quite a bit of new stuff to showcase so we have a lot to talk about.

Thence to the bar, of course.... Day 2 - Thursday After the reception yesterday afternoon we packed down the equipment from our stand and congregated with other delegates in the bar for discourse (and of course, beer). In due course, a trip to Chutney's Indian Restaurant in town was proposed, taxis were booked and we continued our discourse over a curry and (of course) more beer. After we returned those unfortunate enough to wander into the hotel bar and stay into the early hours of the morning were of course fated to join the ranks of "The Lakosed" and hence were distinctly wobbly this morning. Hello! I'll Be Your Tester Today (James Bach - Keynote) I have a feeling that this when we come to the end of this year's ACCU Conference a significant proportion of delegates will have this pinned down as their most memorable session. Certainly, this was the funniest one I've been for a while. James' started out with a simple question, and an equally simple (but brutally honest) answer: Question: What do testers do that's special and different from developers? Answer: We break stuff (or more accurately: you broke it when you wrote it, and we just found you out!) He then went on the give a very humorous description of the role and mindset of a consultant tester, using (among other things the dropped calculator example). His delivery was infectiously funny and as a result we spent most of the time laughing. His captioned re-interpretation of The Towering Inferno (reproduced below) gives a small insight into how he sees the tester's craft:

One interesting observation was that with the advent of agile software development, development teams effectively got so fed up with the process people (who are the same people that testers have been fighting for years) that they fired their testers. Automated functional testing is one of James' big beefs with the software industry. He eloquently demonstrated that human based testing offers something that an automated test just cannot - for example intuition, and thinking "outside the box". Automated systems just can't do that - which is why they excel at unit level testing, and fail miserably at end-user testing. Most importantly, they cannot offer communication and feedback to developers in the same way as human testers. He then went on a very funny excursion through some of the techniques testers may use, notably the "Click Frenzy", the "Shoe Test" (any test consistent with pounding on a keyboard with a shoe!), and "Branching and Backtracking". One important point made was that testing is a heuristic activity encompassing a teachable set of skills. It's not just "playing around". Untrained testers immediately start writing test cases, based on assumptions they aren't aware of and don't even know how to think through. Quote of the session "I'm testing outside the specification because the specification is a rumour." Genemodulabstraxibilicity (Steve Love) "The feeling that it's just too difficult" This session was a discussion of code and design smells, and the problems they can lead to - all ably illustrated by quotes from Edserger Dijkstra, Terry GIlliam et all. Before starting that discussion, however, Steve observed that when we code, we strive for an often conflicting set of goals (maintainability, etc etc) and that in doing so we often sacrifice simplicity. If however we instead strive for simplicity the rest will generally follow. The classical corporate response to such smells is of course to lay down a rigid set of rules which proscribe certain constructs or structures. Unfortunately, this all too often becomes a dogma in its own right, with the original meaning being lost. For example, one C++ coding standard I encountered early in my own career contained the edict "Do not use multiple inheritance" (on the grounds that it was a powerful technique which was likely to be cause maintenance headaches for inexperienced developers) which today seems quite ludicrous. I wonder if that rule has been removed yet, or whether the company in question is still insisting that developers blindly follow it, despite having long forgotten why the rule was written in the first place...? Worse, the sheer number of design and code smells (of which Steve could only mention a limited number, even in a 90 minute session) makes such a proscriptive approach even more unrealistic. So, rather than issue such proclamations, would it not be better to encourage developers to actually think for themselves and make their own informed judgements instead? We are, after all, supposed to be software professionals. Stood at the bottom of a Mountain looking up (Pete Goodliffe)

Pete Goodliffe: Stood at the Bottom of a Mountain, Looking Up.

This session dealt with learning and learning curves. The "mountain" in the session title refers to the mass of "stuff" we know we don't know when we join a new project. As software development is a knowledge profession, it requires that we constantly learn. However, learning (or more accurately being aware of how little we actually know about an as yet unfamiliar subject) can be frightening. Learning is difficult, and becomes harder as systems and technologies become more and more complex. It's a tough problem, but one we have to face if we are to succeed in our profession. At the end of the day it is our own responsibility to keep learning and evolve our understanding and knowledge. Moral of this session: Always question what you're learning, and why. Beware of the obvious, and continually question your preconceptions and prejudices. TDD at the System Scale (Steve Freeman & Nat Price) Steve Freeman and Nat Price are the authors of Object Oriented Software Guided By Tests, and this session promised to be an interesting one. In most projects, developers who practice test driven development do so on small functional blocks (classes, functions etc.) and then try to glue them together to form a meaningful system. By contrast, this session described the presenters' experience in applying TDD principles to a financial system at system level (i.e. a "system-test first" test driven development). That's a very ambitious goal. One way to do this is to interface directly to a domain model (which by definition does not include the external interfaces) within the application. As such, it requires that the application be structured in such a way as to make such testing practical - i.e. that the high level design of the application - rather than just individual components of it - be amenable to automated test. Hence a system level TDD approach may also require system level decisions to be made at an earlier stage than would be normal in a traditional TDD project. As such, this can be a scary concept to some organisations since it forces them to make and commit to such decisions early.

In addition to the obvious design constraints, there are some real practical difficulties (asynchronous behaviour being an obvious one) to overcome in doing this sort of testing. Nevertheless, they seem to have managed it. I must admit I did like their concept of using audit events as an alternative to logging. ]]> Introducing Visual TICShttp://www.riverblade.co.uk/blog.php?archive=2010_04_01_archive.xml#8314655171728252546#8314655171728252546Tiobe (the vendor behind the ClockSharp C# static analysis tool) with a view to us producing a Visual Studio add-in for their TICS framework. TICS is a rule based layer which abstracts software quality tools from multiple vendors and provides configuration and analysis results in a standard format. In effect, it is another integration tool - albeit one which provides a command line interface rather than a graphical user interface. Supported analysis tools include such diverse products as Tiobe ClockSharp and Microsoft FxCop for C# and Parasoft C++ Test, GrammaTech CodeSonar and Programming Research QA C++ for C/C++. Tiobe saw us as a vendor with proven experience of Visual Studio Extensibility and wanted us to produce a more full-featured add-in than their own in-house add-in product. Although we initially planned to write something custom from scratch, when we studied the requirements it become obvious that the best way to meet them was to produce a custom version of Visual Lint which interfaces to TICS rather than PC-lint. As we had previously done some exploratory work on integrating other analysis tools (notably FxCop), most of the hooks we needed to do this were already in place, so much of it was a case of turning off functionality which was not required and rebranding. There were a handful of surprises, but nothing too major. The result is a product called "Visual TICS", of which two development builds have so far been delivered to Tiobe for evaluation and feedback:

Visual TICS currently supports C/C++ and C# projects and uses the Visual Lint core engine and displays to schedule analysis tasks and present analysis results in exactly the same way as Visual Lint. If you have already used Visual Lint, you would find the user interface to be both familiar and consistent. Rather than the conventional perpetual licences we use for Visual Lint, Tiobe plan to offer Visual TICS as an optional component of TICS site licence subscription packages. As such, it will not be appearing in our online store, so any sales enquiries must be directed to Tiobe. We are however of course happy to answer any licencing or technical questions any of our customers may have about it. ]]> LintProject Pro 2.0.7.15 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_04_01_archive.xml#7272048260144145769#7272048260144145769

Corrected a bug in the parsing of .vcproj project files introduced in the previous build [VS2002-VS2008].

Updated the theme of the installer to match that used in the Visual Lint installer.

Minor updates to the readme file packaged within the installer.

]]> LintProject Pro 2.0.6.14 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_04_01_archive.xml#2518861849975288295#2518861849975288295The following changes are included in this build:

Trailing backslashes on intermediate folder paths are now filtered out before generating the PC-lint command line. This is necessary as PC-lint will raise an erroneous warning 686 and abort analysis when presented with a directive of the form -i"FolderName\".

$(NoInherit) and $(Inherit) macros found within Visual Studio project files and property sheets should now be correctly processed [VS2002-VS2008] [from Visual Lint 2.5.1.128].

$(NoInherit) or $(Inherit) macros found in project settings are now stripped from generated project.lnt files [from Visual Lint 2.5.1.128].

For Loop compliance is now correctly defined when specified in a Visual Studio property sheet (.vsprops) file [VS2002-VS2008] [from Visual Lint 2.5.1.128].

MsBuild property sheet user macros are now correctly processed [VS2010] [from Visual Lint 2.5.1.128].

Added support for MSBuild properties (e.g. MSBuildToolsPath) introduced in the VS2010 RC [VS2010] [from Visual Lint 2.5.1.128].

Property sheets specified as relative filenames in a .vcxproj project file are now parsed correctly [VS2010] [from Visual Lint 2.5.1.128].

Corrected a bug in the parsing of MSBuild project files which do not explicitly specify the name of a project [VS2010] [from Visual Lint 2.5.1.128].

VS2010 project file properties (e.g. UseOfATL and UseofMFC) which have been renamed by Microsoft between VS2010 B2 and RC are now correctly loaded [VS2010 RC] [from Visual Lint 2.5.1.128].

Added support for the IntDir, OutDir and ConfigurationType properties in .vcxproj project files [VS2010] [from Visual Lint 2.5.1.128].

Corrected a bug in the handling of user macros within Visual Studio property sheet (.vsprops) files [VS2002-VS2008] [from Visual Lint 2.5.0.127].

Added limited support for the $(TargetDir) variable within project configurations by aliasing it to $(OutDir) [VS2002-VS2008] [from Visual Lint 2.5.0.127].

Corrected a bug in the project file reader which caused Visual Studio inherited property sheet (.vsprops) files referenced via relative paths of the form "\foldername\filename.ext" to be located incorrectly [from Visual Lint 2.5.0.125].

Updated the PC-lint 9 message database to include changes (messages 83 and 457) and new messages (1084-1085, 1096-1111 and 1574) included in the updated msg.txt file for PC-lint 9.00d [from Visual Lint 2.0.10.124].

]]> Visual Lint 2.5.0.127 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_02_01_archive.xml#7630978041276126204#7630978041276126204This is the first public Visual Lint 2.5 build, so there is a somewhat longer changelist than usual:

General

Added support for Visual Studio 2010. Note that as a result of some rather nasty regressions in the Visual Studio 2010 automation interfaces (even at Beta 2) this support is not yet complete and further changes are expected to be required once the Visual Studio 2010 RTM build is available.

Revised the add-in startup/connection sequence and add-in menubar configuration mechanism for compatibility with Visual Studio 2010 (these changes should be transparent to the user).

Removed support for Visual Lint Free Edition. Available product editions in Visual Lint 2.5 are Standard, Professional and Enterprise Editions.

Issue category export files generated by Visual Lint are now formatted in a human readable form [Visual Lint Professional and Enterprise Editions].

Project specific analysis configuration (.vloptions) files are now formatted in a human readable form [Visual Lint Enterprise Edition].

For diagnostic purposes, the contents of the "Visual Lint Status"pane in the Output Window are now logged to the folder CSIDL_COMMON_APPDATA\Riverblade\Visual Lint. Logfiles are automatically deleted after 30 days.

User Interface

When licence key data is pasted into the first (registered user) edit control in the Registration Key Dialog, it is now parsed to determine if the data extends over multiple lines. If so, the second non-empty line of text is automatically entered into the licence key control.

Added a "Host IDE/toolchain" drop list to the "PC-lint" options page. Although this is always disabled when hosted in most environments, it will soon be required to support multi-targetting in Visual Studio 2010, as well as for some non-Visual Studio environments.

Added a "View History" button to the Analysis Status Display. Minor improvements to the corresponding "View Analysis History" context menu command.

Added a "Do not ask me again" option to product edition prompts in registered installations and to the Manual Analysis save prompt.

The elapsed time indicator on the Manual Analysis Dialog is now hidden until the first update.

The confirmation text shown after a key is entered now shows the actual name of the host, not just "Visual Studio".

Removed the old "one click activate" display option in the Analysis Status Display.

Corrected the file filters used for the File Open dialogs in the Advanced Solution Configuration dialog.

A Visual Lint icon is now displayed in the Visual Studio splash screen [Visual Studio 2002/2003/2005/2008 only].

Corrected "PC-Lint" to "PC-lint" throughout.

Renamed the "Visual C++" options page to "PC-lint" for clarity.

Analysis

Added support for "Post Analysis" Events to the Advanced Solution Configuration dialog. When enabled, the specified application will be run when the analysis of a solution completes. This setting is defined on a per solution basis and persisted to the corresponding .vloptions file stored in the solution folder.

When a Visual C++ project file is parsed, the default settings for for-loop compliance (false for VS2002/2003; true for VS2005 and later) and C++ exceptions (always true) are now set correctly.

For loop compliance settings are now read from project files and written to the corresponding project indirect files directly where possible. As a result, the "for loop compliance" option on the "Command Line" page is now used only when Visual Lint has been configured to allow PC-lint to write project indirect files.

Added limited support for the $(TargetDir) variable within project configurations by aliasing it to $(OutDir) [VS2002-VS2008].

Minor corrections to the analysis results parser.

The scheduler no longer attempts to populate the analysis queue if an analysis tool has not yet been defined.

Analysis tasks (and in particular IncrediBuild analysis tasks, which often deal with high volumes of data) now respond to shutdown requests faster.

The IncrediBuild post-task analysis results processing timeout can now be configured via a registry entry (HKCU\Software\Riverblade\Visual Lint\Settings\Analysis\IncrediBuild).

Added "tuning" options relating to analysis (both IncrediBuild and local) to the "Diagnostic" options page.

Installer

Corrected a bug in the code used in the installer to detect whether a trial licence is available.

Added Visual Studio 2010 Beta 2 to the list of supported IDEs in the readme file packaged within the installer.

Added Windows 7 to the list of supported operating systems in the installer Readme text and Getting Stated Guide.

Various minor updates to the Getting Started Guide.

The Visual Lint installer now adds a shortcut to the Getting Started Guide to the Start Menu.

When an expired trial installation is uninstalled, an uninstallation feedback page is now displayed.

Trial started/ended and Uninstall feedback request pages are now opened with a query string giving details of the product/OS version etc.

Corrected a bug in the remove commands sequence during uninstallation.

Reports

Minor revisions to the stylesheets used to generate HTML reports.

Changes to the method used to generate file and project reports during Incredibuild analysis, for efficiency.

Added the name of the licenced user to the footer of generated reports.

Bug Fixes

Corrected a crash which could occur on IDE shutdown if reports had been generated during a session. The crash was caused by a COM threading model related bug in a third party component (TeeChart.ocx) [Visual Lint Enterprise Edition].

Fixed a potential crash when a project is unloaded.

When a project is added to or removed from the workspace in Visual C++ 6.0 or eMbedded Visual C++ 4.0, the displays and analysis queue are now updated correctly when the workspace file is saved.

If a single project is loaded without a solution under Visual Studio .NET 2002 or later, the active project configuration will now be loaded correctly.

The "Projects" droplist in the Analysis Status Display now correctly updates the icon of a project when its"Enable Background Analysis" property is toggled.

The Analysis Status Display is now correctly populated by the solution load task if an analysis tool has not yet been defined.

Analysis Status Display context menu commands which are not functional while a project is loading are now disabled if such a project is selected.

Corrected the visual display of the droplists in the Analysis Results and Analysis History displays (the text '--- All projects ---' was previously being cut into mid-way by the current analysis status of the project).

Visual Lint now uses a single COM container interface to support all IDEs. In consequence, when registered from the "Customize" dialog in Visual C++ 6.0 or eMbedded Visual C++ 4.0, the other COM interfaces within the add-in will no longer be listed in the dialog as possible add-ins (this is a workaround for a bug in legacy versions of Visual Studio) [VC6/eVC4].

The "Use IncrediBuild" command handler no longer unnecessarily checks whether xgconsole (the IncrediBuild XGE interfaces console interface) is available when switching to local analysis tasks.

Corrected a bug which affected the analysis of projects with names containing illegal filesystem characters.

Corrected a bug in the handling of user macros within Visual Studio property sheet (.vsprops) files [VS2002-VS2008].

Corrected a bug in the handling of solution files located by UNC paths.

Corrected a bug in the VS2010 integration which was preventing the Visual Lint toolbar from being displayed by default the first time the IDE is loaded after installation [VS2010].

Corrected a bug affecting the "one .vloptions file per project" option in the Advanced Solution Configuration Dialog [Visual Lint Enterprise Edition].

]]> Visual Lint 2.0.10.124 has been releasedhttp://www.riverblade.co.uk/blog.php?archive=2010_01_01_archive.xml#4588682274617078871#4588682274617078871The following changes are included:

Corrected a bug in the project file reader which caused Visual Studio inherited property sheet (.vsprops) files referenced via relative paths of the form "\foldername\filename.ext" to be located incorrectly.

Added support for the new "ShowSourceInOutput" attribute introduced in IncrediBuild 3.50 in the XGE XML interfaces used by Visual Lint to perform grid analysis tasks.As the introduction of this new attribute is a breaking change (omitting it results in changed behaviour which prevents Visual Lint from cross referencing analysis results for individual tasks back to the initiating objects), this change is required if grid analysis is to be run with IncrediBuild 3.50 onwards.

Corrected a bug in the IncrediBuild interfacing task which could cause no threads to be allocated for analysis results processing on single core machines.

Updated the PC-lint 9 message database to include changes (messages 83 and 457) and new messages (1084-1085, 1096-1111 and 1574) included in the updated msg.txt file for PC-lint 9.00d.

Note that this is likely to be the final Visual Lint 2.0 build as a Visual Lint 2.5 release candidate is currently being tested. As Visual Lint 2.5 will accept Visual Lint 2.0 licences directly existing v2.0 licences can be used without modification.

]]> Breaking change in IncrediBuild 3.50 RChttp://www.riverblade.co.uk/blog.php?archive=2010_01_01_archive.xml#680094685629494562#680094685629494562Just after Christmas we discovered a breaking change in IncrediBuild 3.50 RC (released on 24th December) which affects the Visual Lint/IncrediBuild integration. As this behaviour was not present in the 3.50 beta, we unfortunately weren't aware of it until a customer stumbled on it during the holiday.

Fortunately the original (pre 3.50) behaviour can be reinstated by adding the attribute "ShowSourceInOutput" to the generated XML configuration file used to instruct xgconsole (the IncrediBuild console grid engine) to initiate the analysis. Visual Lint has now been modified to add this attribute when running with IncrediBuild 3.50 or later, so if you are affected by this issue (which manifests as an "IncrediBuild analysis failed" task dialog shown after the analysis completes) you can download an updated build from:

http://www.riverblade.co.uk/products/visual_lint/downloads/VisualLintAddinSetup.exe

[Update: Replaced link with one to the latest formal build which incorporates this change]

]]> All Quiet on the ResOrg Front? Not Exactly...http://www.riverblade.co.uk/blog.php?archive=2009_12_01_archive.xml#167079027684252005#167079027684252005When I first released ResOrg 1.2 to CodeProject back in 2001, I had no idea how useful (or otherwise) other developers would find it. All I knew was that for me it helped with a real pain point. Quite frankly, I was thoroughly sick of converting resource.h files to spreadsheets and back just to identify conflicts and renumber resource IDs.

The standalone ResOrg application then grew to include a Visual C++ 6.0 add-in and then to support a rudimentary form of multi-file analysis. When Visual Studio .NET 2002 was released, Nick Hodapp (then the Visual C++ Product Manager) contacted a number of other add-in authors and I and offered us all free copies of the new version in exchange for us porting our code to the new version. ResOrg.NET (as it was termed was basically the same as ResOrg, but added a simple toolwindow which allowed you to view and edit the properties of a single resource symbol file:

The ResOrg.NET 1.x toolwindow. With hindsight, this was rather limited in scope - the new Symbol Files Display (keep reading...) is far more capable.

As the automation model of VS2002 was very different (and far more complex) than that of VC6 that port was a little painful, to say the least; ResOrg ended up with two builds and two installers - one for VC6, and one for VS2002 onwards. Although the VC6 version hasn't been updated in ages (v1.6.1 was released in December 2004) various breaking changes in subsequent Visual Studio versions meant minor updates to ResOrg.NET have continued sporadically ever since.

For example, when Visual Studio 2005 was released, it proved to be completely allergic to the MFC ActiveX control used to implement the ResOrg.NET toolwindow, and I was forced to convert it to an ATL only implementation in v1.6.2.2. That then caused yet more issues when Visual Studio 2008 was released, as it proved to be incompatible with ATL windowing code built with versions of Visual Studio prior to Visual Studio 2005*. As the ResOrg.NET code was by then built with Visual Studio .NET 2003, the logical thing to do was port the code to Visual Studio 2008.

* When Visual Studio 2008 came out it was released as a process with Data Execution Prevention (DEP) enabled. In consequence, any add-ins for VS2008 which use ATL for user interface code (which ResOrg 1.x does for its toolwindow) and which were built with ATL 7.1 or earlier will not run in VS2008 since these versions of ATL use a technique for message thunking which triggers DEP and shuts down the process. Although this was corrected in ATL 8, it does mean that add-ins for VS2008 onwards must be built with later versions of Visual Studio (this same issue caused us to shift the builds for Visual Lint from VS2003 to VS2008).

It was at that point that things went quite horribly wrong. ResOrg 1.x is an MFC based codebase, and unfortunately the versions of MFC shipped since Visual Studio 2005 come with extra baggage (specifically SXS activation runtime checks*) not present in previous versions. Murphy's Law being what it is, although the app itself worked OK the new code would crash randomly in the add-in, and we were unable to identify a workaround. As a result the port failed and the build was reverted to VS2003 - but obviously without VS2008 support.

* Look up STATUS_SXS_EARLY_DEACTIVATION and STATUS_SXS_INVALID_DEACTIVATION for details. It's a very poorly documented area, unfortunately.

Although we have since released some minor fixes there it has largely lain since. Almost.

When we discovered the SXS issue and realised that we had hit a brick wall it became obvious that a radical rethink was in order. Several months earlier we had started the process of reimplementing the whole product in ATL/WTL (which Visual Lint uses, so we know it works well with VS2008), and although that process was making steady progress the amount to time we were able to give to it until then had been quite limited. By the time we discovered the SXS issue the core functionality was in place but the new version (by now designated ResOrg 2.0) didn't yet have a usable user interface.

That in itself proved to be a major undertaking, and as we are having to fit in work on it around Visual Lint development (itself quite intensive at the moment as we've a major release for that scheduled for January) it tends to be a bit of a side project. However, it is now sufficiently advanced that it is now about time we started talking about what we've been up to. All being well, we aim to be able to release a public build by the time VS2010 is released in March. We're not at beta yet, but not a huge distance from it.

The first ResOrg 2.0 release will offer an equivalent level of functionality to 1.6, but we are taking the opportunity to refresh the displays a little. The ResOrg 2.0 add-in will include two toolwindows - one a Symbols Display comparable to the previous version (although it is now a docking window rather than a popup frame), and the second a higher level "Symbol Files" display which shows the status of all projects/symbol files at all times. This display is effectively a more usable superset of the ResOrg.NET toolwindow in 1.x, and although it is currently still being developed, the screenshot below should give you a flavour of how it will look:

The ResOrg 2.0 add-in, running within Visual Studio 2008

ResOrg 2.0 also includes the standalone application as previously. At the moment it looks rather like its predecessor, but the intention is to replace the "Workspace" docking view with the contents of the "Symbol Files" toolwindow shown above when it is completed:

The ResOrg 2.0 application as it currently stands. The workspace view on the left will soon be replaced by a docked 'Symbol Files' Display equivalent to that in the add-in.

The ResOrg 2.0 app is itself largely complete (the only major bits missing are multi-file conflict checking and a rework of the "projects" display to match the new "Symbol Files" toolwindow in the add-in), and the add-in itself is about half way done. Support for the new Visual C++ .vcxproj project file format (a major change in itself - .vcxproj files look nothing like their predecessors) is already in place, courtesy of Visual Lint.

The plan is to have at least a beta of it by the time Visual Studio 2010 is formally launched in March. We hope that the new version will meet the expectations of existing users of ResOrg 2.0. We're working quite hard to make sure we don't lose any functionality in moving the code from MFC to WTL, and we are hopeful that the end result will be well worth waiting for.

]]> So what's happening with Visual Studio 2010 support, then?http://www.riverblade.co.uk/blog.php?archive=2009_12_01_archive.xml#8661764171249015022#8661764171249015022Last night we had an enquiry asking whether Visual Lint supports Visual Studio 2010 Beta 2 (a very good question). As we last blogged about this subject back in June (see Visual Studio 2010 Support for Visual Lint and LintProject Professional) and a lot has happened since then I thought it was about time for an update.

The short version is that "They changed too much,* and it doesn't really work very well yet, but we will have something out early next year regardless".

* At least as far as the internal interfaces go - the bugs we tend to find in a new version of Visual Studio are not generally the ones you will encounter if you actually use it to compile code.

The long version is, well, quite long - so please bear with me while I elaborate.

First of all, if you are interested in the sort of issues we face when a new version of Visual Studio is approaching release you could do far worse than to take a look at Carlos Quintero's blog. Carlos is the author of MZ-Tools, and one of the most prolific add-in authors out there when it comes to identifying, reporting (and blogging about) issues in the automation interfaces for new versions of the IDE.

Some time ago I realised that Visual Studio releases broadly come in two flavours - the ones where Microsoft try to change everything (e.g. Visual C++ 5.0, Visual Studio .NET 2002 and Visual Studio 2005) and those where they consolidate the changes in the previous release (e.g Visual C++ 6.0, Visual Studio .NET 2003 and Visual Studio 2008). Visual Studio 2010 - which sports not only a new and vastly more complex C++ project file format (.vcxproj) but also a new intellisense engine and WPF based editing environment - was always destined to be in the former camp.

In short, we were expecting this release to be a bit of a pain from an integrator's perspective, and - although we'd love to have been proved wrong here - we've unfortunately been dead right on that. When Beta 1 landed, it was effectively unusable from an add-in perspective (even Visual Studio 2005 Beta 1 didn't quite manage that feat) and although we were able to do some groundwork towards supporting the new IDE, it wasn't something we were happy to release, even to our beta testers.

Furthermore, because of the volume of changes that were obviously going to be needed to support Visual Studio 2010 we had to take the decision to only implement VS2010 support in our development branch (i.e. in Visual Lint 2.5) and as a result Visual Lint 2.0 does not (and will not) support it (that's the bad news; the good news comes at the end).

What's interesting is that the previous CTPs (none of which had the new editor) worked fine with our development versions, so I'm pretty convinced that the breaks we saw in Beta 2 were entirely down to the new editor implementation. We filed our bug reports, crossed our fingers and hoped Beta 2 would resolve these issues.

For some of them it did - and we now have internal builds of Visual Lint which basically work in VS2010:

Visual Lint 2.5 running in VS2010 Beta 2

The one glaring problem remaining is menu/toolbar interfacing (one of the areas badly affected by the new editor) which is still thoroughly broken in Beta 2. Although we've been experimenting with moving the menu/toolbar interfacing for this IDE from the add-in to an associated VSPackage (the deepest and most complex level of integration available in Visual Studio) that's still not entirely satisfactory - but we are making progress so we may end up going that way anyway, despite the additional complexity it introduces.

The good news bit: Although our beta testers already have builds of Visual Lint 2.5 with VS2010 support, since we are planning to release Visual Lint 2.5 early next year the Visual Studio 2010 integration will become publicly available then. Visual Lint 2.0 will be a free update to existing Visual Lint 2.0 customers as it will accept existing v2.0 licence keys directly.

So, we will certainly have something out well in advance of the Visual Studio 2010 launch in March. How complete the Visual Lint (and ResOrg, but more of that later) integration for Visual Studio 2010 is depends on what Microsoft are able to deliver post-Beta 2, of course.

]]>