Products, the Universe and Everything

The Riverblade Developer's Blog

Beth demonstrating Visual Lint at the ACCU Conference 2008  Anna taking part in a discussion panel at the European Software Conference 2007 

Welcome to our developer's blog. We hope that this forum provides an insight into us, our products and how we develop them. Please feel free to write to us if you have anything to add to any of the posts here.

Current Entries | Archives |

Visual Lint has been released
Monday, January 5, 2015

This is a recommended maintenance update for Visual Lint 4.5. The following changes are included:

  • Added support for Keil uVision 4 projects to VisualLintGui and VisualLintConsole.
  • Fixed a bug in the handling of analysis configurations by VisualLintGui and VisualLintConsole.
  • Fixed a bug which could cause a file open operation to fail within the Visual Studio plug-in.
  • Fixed a bug which could cause files which are excluded from analysis (or files within projects which are excluded from analysis) to be included in background analysis when a file is saved.
  • Various minor optimisations to the solution loading process.
  • The "Delete Analysis Results" and "Start Background Analysis" commands are now disabled until the solution has finished loading.
  • Corrected the URL of the "more information" link on the "Analysis" Options page.

Posted by Anna at 11:11 | Get Link


Visual Lint has been released
Monday, November 24, 2014

This is a maintenance update for Visual Lint 4.5. The following changes are included:

  • Fixed a bug in the generation of PC-lint analysis command lines for files analysed with the -pch option.
  • When a PC-lint analysis task corresponding to a PCH generation file (e.g. stdafx.cpp) starts, the corresponding PCH object (.lph) file is now explicitly deleted before PC-lint is invoked.
  • Fixed a bug which was preventing custom PC-lint issue categories from being loaded correctly.
  • Fixed a bug in the VisualLintGui code editor "Open Referenced File" context menu command which could cause header files referenced via project additional include folder properties to fail to be located.
  • Fixed a bug which prevented header files from being analysed with the Google C++ Style Checker (
  • Adjusted the priority and timing of IncrediBuild analysis results parsing tasks.
  • Improved the handling of IncrediBuild analysis tasks in VisualLintConsole.
  • Added details of PC-lint 9.00l messages 29, 94, 169, 330, 486, 488, 489, 491, 1112, 1113, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1723, 1751, 9063, 9064 and 9067-9166 to the PC-lint 9.0 message database. Also updated the entries for 165, 170, 312, 435, 436, 516, 665, 686, 690, 836, 838, 845, 905, 967, 1096, 1102, 1104, 1111, 1119, 1417, 1419, 9011, 9022, 9033 and 9066.
  • Updated various PC-lint indirect files as a result of the public release of PC-lint 9.00l.
  • The titlebar captions of the Registration Key dialog and VisualLintGui main window now include the major/minor version of the product.

Posted by Anna at 10:58 | Get Link


How Visual Lint parses projects and makefiles
Thursday, November 6, 2014

Code analysis tools can require a lot of configuration to be useful. Whilst some (e.g. Vera++ or need very little configuration to make use if effectively, others such as PC-lint (and even, to a lesser extent, CppCheck) may need to be fed pretty much the same configuration as the compiler itself to be useful. As a result the command lines you need to use with some analysis tools are pretty complex in practice (which is of course a disincentive to using them, and so where Visual Lint comes in. But I digress...).

In fact, more capable code analysis tools may need to be given even more information than the compiler iteself to generate meaningful results - for example they may need to be configured with the built-in preprocessor settings of the compiler itself. In a PC-lint analysis configuration, this is part of the job compiler indirect files such as co-msc110.lnt do.

As a result of the above, a product such as Visual Lint which effectively acts as a "front end" to complex (and almost infinitely configurable) code analysis tools like PC-lint needs to care about the details of how your compiler actually sees your code every bit as much as the analysis tool itself does.

What this means in practice is that Visual Lint needs be able to determine the properties of each project it sees and understand how they are affected by the properties of project platforms, configurations and whatever compiler(s) a project uses. When it generates an analysis command line, it may need to reflect those properties so that the analysis tool sees the details of the preprocessor symbols, include folders etc. each file in the project would normally be compiled with - including not only the properties exposed in the corresponding project or makefile, but also built-in symbols etc. normally provided by the corresponding compiler.

That's a lot of data to get right, and inevitably sometimes there will be edge cases where don't quite get it right the first time. It goes without saying that if you find one of those edge cases - please tell us!

So, background waffle over - in this post I'm going to talk about one of the things Visual Lint does - parsing project files to identify (among other things) the preprocessor symbols and include folders for each file in order to be able to reflect this information in the analysis tool configuration.

When analysing with CppCheck, preprocessor and include folder data read in this way can be included on the generated command line as -D and -I directives. Although we could do the same with PC-lint, it is generally better to write the preprocessor and include folder configuration to an indirect ("project.lnt") file which also includes details of which implementation (.c, .cpp, .cxx etc.) files are included in the project -as well as any other project specific options. For example:

// Generated by Visual Lint from file: SourceVersioner_vs90.vcproj
// -dConfiguration=Release|Win32

-si4 -sp4                     // Platform = "Win32"
+ffb                          // ForceConformanceInForLoopScope = "TRUE"
-D_UNICODE;UNICODE            // CharacterSet = "1"
-DWIN32;NDEBUG;_CONSOLE       // PreprocessorDefinitions = "WIN32;NDEBUG;_CONSOLE"
-D_CPPRTTI                    // RuntimeTypeInfo = "TRUE"
-D_MT                         // RuntimeLibrary = "0"
                              // AdditionalIncludeDirectories = ..\Include"
-save -e686                   //
  -i"..\Include"              //
-restore                      //
                              // SystemIncludeDirectories = "
                              //   F:\Projects\Libraries\boost\boost_1_55_0;
                              //   C:\Program Files (x86)\
                              //       Microsoft Visual Studio 9.0\VC\include;

                              //   C:\Program Files (x86)\
                              //       Microsoft Visual Studio 9.0\VC\atlmfc\include;

                              //   C:\Program Files\
                              //       Microsoft SDKs\Windows\v6.0A\include;

                              //   F:\Projects\Libraries\Wtl\8.1\Include"
-save -e686                   //
 +libdir("C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include")
 +libdir("C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\atlmfc\include")
 +libdir("C:\Program Files\Microsoft SDKs\Windows\v6.0A\include")
 +libdir("C:\Program Files\Microsoft SDKs\Windows\v6.0A\include")
 -i"C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include"
 -i"C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\atlmfc\include"
 -i"C:\Program Files\Microsoft SDKs\Windows\v6.0A\include"
-restore                      //
SourceVersioner.cpp           // RelativePath = "SourceVersioner.cpp"
SourceVersionerImpl.cpp       // RelativePath = "SourceVersionerImpl.cpp"
stdafx.cpp                    // RelativePath = "stdafx.cpp"
Shared\FileUtils.cpp          // RelativePath = "Shared\FileUtils.cpp"
Shared\FileVersioner.cpp      // RelativePath = "Shared\FileVersioner.cpp"
Shared\PathUtils.cpp          // RelativePath = "Shared\PathUtils.cpp"
                              // RelativePath = "Shared\ProjectConfiguration.cpp"
Shared\ProjectFileReader.cpp  // RelativePath = "Shared\ProjectFileReader.cpp"
Shared\SolutionFileReader.cpp // RelativePath = "Shared\SolutionFileReader.cpp"
Shared\SplitPath.cpp          // RelativePath = "Shared\SplitPath.cpp"
Shared\StringUtils.cpp        // RelativePath = "Shared\StringUtils.cpp"
Shared\XmlUtils.cpp           // RelativePath = "Shared\XmlUtils.cpp"

A file like this is written for every project configuration we analyse, but the mechanism used to actually read the configuration data from projects varies slightly depending on the project type and structure.

In the case of the Visual Studio 2002, 2003, 2005 and 2008 .vcproj files Visual Lint was originally designed to work with, this is straightforward as the project file contains virtually all of the information needed in a simple to read, declarative form. Hence to parse a .vcproj file we simply load its contents into an XML DOM object and query the properties in a straightforward manner. Built-in preprocessor symbols such as _CPPUNWIND are defined by reading the corresponding properties (EnableExceptions in the case above) or inferred from the active platform etc.

Similarly, for Visual C++ 6.0 and eMbedded Visual C++ 4.0 project files we just parse the compiler command lines in the .dsp or .vcp file directly. This is pretty straightforward as well as although .dsp and .vcp files are really makefiles they have a very predictable structure. Some other development environments (e.g. Green Hills MULTI, CodeVisionAVR) have bespoke project file formats which are generally easy to parse using conventional techniques.

Visual Studio 2010, 2012 and 2013 .vcxproj project files are far more tricky, as the MSBuild XML format they use is effectively a scripting language rather than a declarative format. To load them, we effectively have to execute them (but obviously without running the commands they contain).

As you can imagine this is rather tricky! We basically had to write a complete MSBuild parsing engine* for this task, which effectively executes the MSBuild script in memory with defined parameters to identifiy its detailed properties.

* Although there are MSBuild APIs which could conceivably help, there are implemented in managed code - which we can't use in a plug-in environment due to .NET framework versioning restrictions. Instead, our MSBuild parsing engine is written natively in C++.

To work out the parameters to apply to the MSBuild script, we prescan the contents of the .vcxproj file to identify the configurations and platforms available. Once we have those, we can run the script in memory and inspect the properties it generates for the required build configuration. This process is also used with CodeGear C++ and Atmel Studio projects, both of which are MSBuild based.

Eclipse projects (.project and .cproject files) are also XML based and are not too difficult to parse, but whereas it is straightforward to work out how things are defined in a .vcproj file, Eclipse project files are much less clearly defined and more variable (not surprising as they effectively represent serialised Java object data).

To make matters worse, each compiler toolchain can have its own sub-format, so things can change in very subtle ways between based projects for different Eclipse based environments such as Eclipse/CDT, QNX Momentics and CodeWarrior. In addition, Eclipse C/C++ projects come in two flavours - managed builder and makefile.

Of the two, managed builder projects are easy to deal with - for example to determine the built-in settings of the compiler in a managed builder we read the scanner (*.sc) file produced by the IDE when it builds the project, and add that data to the configuration data we have been able to read from the project file.

The scanner (.sc) file is a simple XML file located within the Eclipse workspace .metadata folder. Here's an extract to give you an idea what it looks like:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?scdStore version="2"?>
<scannerInfo id="org.eclipse.cdt.make.core.discoveredScannerInfo">
<instance id="cdt.managedbuild.config.gnu.mingw.exe.debug.116390618;
<collector id="org.eclipse.cdt.make.core.PerProjectSICollector">
<includePath path="c:\mingw\bin\../lib/gcc/mingw32/4.5.2/include/c++"/>
<includePath path="c:\mingw\bin\../lib/gcc/mingw32/4.5.2/include/c++/mingw32"/>
<includePath path="c:\mingw\bin\../lib/gcc/mingw32/4.5.2/include/c++/backward"/>
<includePath path="c:\mingw\bin\../lib/gcc/mingw32/4.5.2/../../../../include"/>
<includePath path="c:\mingw\bin\../lib/gcc/mingw32/4.5.2/include"/>
<includePath path="c:\mingw\bin\../lib/gcc/mingw32/4.5.2/include-fixed"/>
<definedSymbol symbol="__STDC__=1"/>
<definedSymbol symbol="__cplusplus=1"/>
<definedSymbol symbol="__STDC_HOSTED__=1"/>
<definedSymbol symbol="__GNUC__=4"/>
<definedSymbol symbol="__GNUC_MINOR__=5"/>
<definedSymbol symbol="__GNUC_PATCHLEVEL__=2"/>
<definedSymbol symbol="__GNUG__=4"/>
<definedSymbol symbol="__SIZE_TYPE__=unsigned int"/>

Unfortunately scanner files are not generated for makefile projects, and the enclosing project files do not give details of the preprocessor symbols and include folders needed to analyse them. So how do we do it?

The answer is similar to the way we load MSBuild projects - by running the makefile without executing the commands within. In this case however the make tools themselves can (fortunately!) lend a hand, as both NMake and GNU Make have an option which runs the makefile and echoes the commands which would be executed without actually running them. For NMake this is /n and GNU Make -n or --just-print.

The /B (NMake) -B (GNU Make) switch can also be used to ensure that all targets are executed regardless of the build status of the project (otherwise we wouldn't be able to read anything if the project build was up to date).

If we run a makefile with these switches and capture the output we can then parse the compiler command lines themselves and extract preprocessor symbols etc. from it. As so many compilers have similar command line switches for things like preprocessor symbols and include folders this is generally a pretty straightforward matter. Many variants of GCC also have command line options which can report details of built-in preprocessor symbols and system include folders, which we can obviously make use of - so the fact that many embedded C/C++ compilers today are based on GCC is very useful indeed.

There's a lot of detail I've not covered here, but I hope you get the general idea. It follows from the above that adding support for new project file types to Visual Lint is generally not difficult - provided we have access to representative project files and (preferably) a test installation of the IDE in question. If there is a project file type you would like us to look at, please tell us.

Posted by Anna at 12:32 | Get Link


PC-lint 9.00l has been released
Wednesday, October 29, 2014

Gimpel have just released PC-lint 9.00l - which looks to be a pretty important update to PC-lint 9.0 over the previous build (9.00k). You can download patch itself and updated versions of the corresponding support files from the PC-lint 9.0 patch page.

This update significantly improves MISRA and C++ 11 support, so if you are using MISRA, have C++ 11 code or are using Visual Studio 2012 onwards this is very much a recommended update.

Some C++ 14 features (e.g. binary literals and digit separators) are also now supported if the -A(C++2014) option is active. Details of the major changes included in the patch are available at, from which the relevant extracts are reproduced below:

          * This patch contains significantly enhanced support for MISRA
            C3 (MISRA C 2012).  A number of new messages to support MISRA
            C3 have been added and the au-misra3.lnt author file has been
            updated accordingly.  We now provide some level of support
            for all but 3 of the decidable rules and 4 of the undecidable
            rules, with full support being provided for the vast majority
            of the rules.

          * We have broken out the 1960/1963 diagnostics (used to support
            MISRA C++) into individual messages to provide a greater level
            of control and flexibility, especially with regards to message
            suppression.  The 1960/1963 messages will continue to be
            supported for backwards compatibility.  A new author file,
            au-misra-cpp-alt.lnt, can be used to take advantage of the
            new messages in place of the 1960/1963 messages.

          * We have improved support for MISRA C 2004, namely with regards
            to rules #8.8, #6.2, and #8.9.

          * We have improved support for MISRA C++, namely with regards to
            rules #7-3-1, #9-6-2, and #9-6-4,

          * We now provide significantly improved support for VS2012
            through an updated co-msc110.lnt file, available on our
            patches page.

          * Patch 9.00L introduces support for range-based for statements,
            the 'final' class specifier, standard layout types, improved
            handling of null pointer constants, significantly improved
            handling of C++11 core language features used in Visual Studio
            2012 headers.  As with other C++ 2011 features, these are
            available using the option: -A(C++2011).

          * We now support binary literals and digit separators from
            C++14.  These features are available using the option:

          * We now support the use of message numbers and patterns with
            the +efreeze/-efreeze and ++efreeze options.  For example,
            ++efreeze(534) will prevent later-appearing options from
            suppressing message 534 without affecting the frozen status
            of other messages.

          * We now support C11's _Static_assert (when using -A(C2011)).

          * The Program Info facility now includes flags for indicating
            when a function has been declared with the final or override
            specifiers and when a class has been declared with final.

          * Multiple '-deprecate()' options can now be used to combine
            deprecation messages. Such joined messages appear separated
            by commas.  For example:

              -deprecate(function, printf, Directive #2SFH)
              -deprecate(function, printf, Recommendation #LCD1C)

            would result in

              Warning 586: variable 'printf' is deprecated. Directive
                     #2SFH, Recommendation #LCD1C

            whenever 'printf()' is called.


          We have decided to disable strong type deduction as it was
          responsible for incorrect type deduction in certain cases that did
          not involve strong types.  This feature will be revisited in a
          future release.

Full details of the bugfixes also included in the patch (the contents are too long to list here!) are available at

Note that from our own experience running beta versions of this update some additional suppression directives for warnings 1509 and 1510 may be required to prevent unnecessary warnings being generated by classes derived from those within frameworks such as ATL and WTL.

We are in the process of updating our own indirect files to include appropriate suppression directives, but if you find you need assistance with specific occurances (or have suppression directives you think we should include in our files) please let us know.

As the update also adds quite a few new PC-lint messages we will also be updating the PC-lint message database installed with the next Visual Lint build (

Posted by Anna at 17:20 | Get Link


Visual Lint has been released
Monday, October 6, 2014

This is a maintenance update for Visual Lint 4.5. The following changes are included:

  • Fixed a bug which could cause the Visual Studio plug-in to miss changes to the active project configuration.
  • Added a status message to the Visual Studio plug-in to identify when the active configuration has changed.
  • Fixed a bug which could cause system include folders to be read incorrectly from Visual Studio 2012/13 projects which use the Intel C++ Compiler.
  • Fixed a bug in VisualLintGui which was preventing accelerators from being translated correctly by the main frame window when no MDI windows were open.
  • Various updates to the helpfile.

Posted by Anna at 11:29 | Get Link


Online Abuse - a statement
Monday, September 15, 2014

On Friday we became aware of the following abusive tweet directed at our founder Anna:

Abusive tweet screenshot

Needless to say we were taken aback that anyone would direct such abuse at any of our staff, though given the nastiness directed recently towards some women in the games sector and and some of the incidents documented by Everyday Sexism perhaps we should not have been surprised that it would happen sooner or later. We note that they were too cowardly to write under their own name, but did so anonymously.

Riverblade is a small business, and the wellbeing of our staff is very important to us. We value people not for how much they fit in, but for who they are and what they are capable of. We don't discriminate, and won't judge.

We will however call out bigotry and bullying whenever we see it - hence this statement.

Shortly after Anna drew attention to the tweet we received a phone call from one of the organisers of Agile on the Beach (whose conference hashtag the abuser had posted on) expressing their horror and asking if there was anything they could do. We told them not to worry, but that we would issue a statement and report the user account in question (both of which we have done). Others have also expressed their support via various channels, and for that we are very grateful.

We are also very well aware that this incident absolutely pales into insignificance next to the nastiness that some women in our industry (notably Zoe Quinn) have recently been subjected to. Nevertheless, the principle is the same - this is not acceptable behaviour and we will not let it go unnoticed.

We know that the fact that the abuser hid behind an anonymous account makes it less likely we'll ever be able to confront them directly, but that doesn't change anything. The anonymous account the abuser used is included in the Level 2 blocks within The Block Bot, so if you are the target of online abuse we recommend you consider making use of it. Also, make sure you have support you can call on - please don't suffer alone.

Finally, a message for the abuser. If you can't be bothered to grow up, at least try to use your brain and realise that you can easily turn off the blog feed in Visual Lint from the Options Displays page.

On second thoughts don't bother - we don't want people like you as a customer. Go away until you learn to treat people with respect.

Posted by Admin at 14:59 | Get Link


Agile on the Beach 2014 - #agileotb
Thursday, September 4, 2014

This week we are exhibiting at the Agile on the Beach Conference in Falmouth.

Agile on the Beach

If you weren't able to make it here, a glance at the #agileotb Tweet stream for the event should give a feel for the event:

I will be presenting a lunchtime session titled "Agile Warning Policies" just after lunch. Slides will be uploaded here soonish!

Posted by Anna at 11:19 | Get Link


Agile Warning Policies on the Beach
Tuesday, September 2, 2014

We're going to the Beach. Are you...?

Our founder Anna is presenting a talk titled "Agile Warning Policies" at the Agile on the Beach conference this Thursday lunchtime. If you are going to the conference, we'll see you there!

If you want to follow the conference on Twitter, the hashtag to watch is #AgileOTB.

Posted by Anna at 22:19 | Get Link


Visual Lint has been released
Friday, July 25, 2014

This is a maintenance update for Visual Lint 4.5. The following changes are included:

  • Added support for the analysis of Atmel Studio 6.2 projects.
  • Added support for the analysis of Altera Nios II EDS Eclipse projects.
  • Added support for the analysis of NVidia CUDU C/C++ files (i.e. those with .cu and .cuh file extensions).
  • If a Visual Studio PCH generation file (e.g. stdafx.cpp) is excluded from analysis, a per-file analysis of the project will automatically fall back on non-PCH analysis.
  • If the generation of a PC-lint .lph (precompiled header object) file fails the remaining files within that project will now be analysed using non-PCH analysis.
  • When a property (e.g. preprocessor symbols) within a Visual Studio project is changed the Visual Studio plug-in will now detect the change when the project file is saved.
  • The _TCHARMapping property is now read when parsing CodeGear C++ projects.
  • Fixed a potential bug in the display state of toolwindows within the Visual Studio plug-in during the startup of the IDE.
  • Fixed an intermittent crash which could occur when the "Global Display Filter" context menu commands in the displays were executed.
  • Updated the company office address in the helpfile.

Posted by Anna at 16:58 | Get Link


Office Move
Friday, July 4, 2014

We have finally moved! Our new office is located within Platinum House - a serviced office complex in central Bournemouth, located less than 300 metres from the beach (very convenient for ice cream, sunbathing and surfing, if any of them are your thing).

Our new office is within Platinum House in central Bournemouth

Cool location aside, Platinum House (formerly the Kingshott Business Centre) has the usual officey things like a reception with comfy chairs, photocopiers, meeting rooms and (most importantly for any tech outfit) free coffee.

Our new registered office address is:

    Platinum House
    23 Hinton Road
    Dorset BH1 2EF
    United Kingdom

The change should be transparent, but please ensure that any purchase orders you place with us in the future reference the new address rather than the old one. Needless to say, any snail mail should also be sent to the new address.

Posted by Anna at 16:34 | Get Link


Visual Studio "14" CTP - good news, and bad news
Thursday, July 3, 2014

Microsoft have just released a Community Technical Preview (CTP) of Visual Studio "14" (the next version of Visual Studio), so naturally we have been taking a look.

Visual Studio '14' CTP

At first glance, the changes are incremental (which is surely a good thing for the developer community after the UI fiasco of the Visual Studio 2012 release). Of particular note are the changes to Visual C++ and the "C" runtime library - see Visual Studio "14" CTP and C Runtime (CRT) Features, Fixes, and Breaking Changes in Visual Studio 14 CTP1.

However, there is (for us, at least) one very significant change - Visual Studio "14" does not support add-ins, which will prevent many third party plugins from loading - including (unfortunately) both ResOrg and Visual Lint. As a result, we are currently undertaking a feasibility study to determine how much work is required in order to port the Visual Lint and ResOrg plug-ins from the add-in format to the VSPackage format (a lower level but far more flexible type of plug-in which is still supported by VS14).

Needless to say this is a major effort which introduces significant risk and additional complexity (we still have to maintain both add-ins for compatibility with earlier versions of Visual Studio...), but fortunately it is one we have already done some preparatory work towards. It is however a major distraction from other things we planned to do this year (thanks Microsoft!) so no doubt that will have consequences elseware in our development efforts. On the plus side, moving to the VSPackage format will eventually make supporting Atmel Studio (which uses the Visual Studio shell) somewhat easier.

You can get an idea of the sort of changes required to convert an add-in to a VSPackage from the blog post Strategies migrating from Visual Studio add-ins to packages. The fact that the Visual Studio automation interfaces (which are used by add-ins) are still (for now, at least) fully functional in a VSPackage environment helps, but in the long term moving away from them will probably be a good idea as Carlos suggests in the blogpost linked to above. However, for now that is unnecessary change and therefore undesirable.

I can't speak for other vendors but I can say that we started looking at this in detail as soon as we had the CTP installed a month ago. In the time since then we have been able to prototype a new ResOrg VSPackage which is almost fully functional and is helping us to identify and mitigate risk areas. There is still a lot of work to do before this can be released, but so far the signs are good.

Once ResOrg has been dealt with we hope to be able to port Visual Lint in the same manner (though as a more complex codebase it will probably take significantly longer to address). Either way, we hope to have the work complete by the Autumn.

In the meantime, ResOrg can load Visual Studio "14" projects already, and we have already made the changes necessary to allow development builds of Visual Lint to analyse Visual Studio "14" projects in VisualLintGui and VisualLintConsole. These changes are minor and can easily be merged back into the release (v4.5) branch as soon as needed.

The bottom line? Based upon previous Visual Studio releases we do not expect Visual Studio "14" to be publicly released in RTM (Release to Manufacturing) form until at least the end of the year. By then, we would hope that we will also have production ready builds of the ResOrg and Visual Lint plug-ins which are fully compatible with the new version of the IDE.

But it's still completely unnecessary work. Thanks, Microsoft.

Posted by Anna at 10:48 | Get Link


Business of Software Conference Europe
Wednesday, July 2, 2014

Kathy Sierra on 'Motivation Matters' at Business of Software Europe

Our founder Anna attended the Business of Software Europe Conference in Cambridge last week, and it was quite something indeed.

Although the Business of Software Conference has been running for several years in the USA, this is the first year an event has been held in Europe (and what better a place than Cambridge?). The conference covered everything from live Python telephony to the psychology of the internet and the organisation and management of sales teams, so it was pretty diverse.

If you are interested in more than just coding, this is an event we can strongly recommend. Photos and videos from the conference should be online soon, so if you are interested please stay tuned.

Posted by Anna at 10:34 | Get Link


ACCU Conference 2014 retrospective
Monday, May 19, 2014

Another year passes, and with it another ACCU Conference.* As ever we came away exhausted but energised with a bunch of new ideas, inspirations and suggestions from those we'd met at the conference....and then needed quite a while to recover. I can't speak for others, but I certainly found it was quite a while before I felt fully back into the swing of things afterwards.

This year was the second year the conference had been at the Bristol Marriott, so there were fewer uncertainties and things went ever so slightly more smoothly than last year (and this time we had a better idea where all the best restaurants and pubs were...).

We arrived on Monday afternoon, but couldn't start setting up our stand (which this year was conveniently packed into flight cases rather than the rag-tag collection of plastic boxes we've used in the past) until Tuesday as there was another event running in the venue.

As Beth and I were both booked on to the C++ 11 preconference session that day (the idea being to use it as a refresher on some of the parts of C++ 11 we're not using yet) We set up our stand before breakfast the following morning.

Setting up our stand before breakfast on Wednesday morning

Each day generally started with a keynote at 9:30am, for which all 420 delegates (minus those who were too badly hungover, no doubt!) gathered in the largest of the conference rooms.

The remainder of the day was filled with four tracks of predominantly 90 minute sessions, culminating in an hour of lightning talks at 6am before the festivities started in the evening.

If you have never been to an ACCU Conference before, the following selection of photos will hopefully give you a feel for the event.

This year Beth and I did Nico Josuttis C++ 11 Preconference session

Nico Josuttis' C++ 11 preconference session

The main hallway during one of its busier periods

The main hallway during one of its busier periods

ACCU 2014 delegates (all 420 of them!) assemble for a keynote

ACCU 2014 delegates (all 420 of them) assemble for a keynote. The room is actually much bigger than you can see here - there is another screen to the right.

The Bloomberg Lounge (with free bar!) was back on Wednesday and Thursday evenings this year, and once again had a selection of retro gaming machines

Jim Hague - He's Not the Messiah

Jim Hague on Cinema and Myths of Leadership

Jon Jagger introducing Dan North's keynote

Jon Jagger (the Conference Chair) introducing Dan North's keynote

Dan North on why Agile doesn't scale - and what you can do about it

Dan North on why Agile doesn't scale - and what you can do about it

Continuous Delivery with Legacy Code

Dan Swain and Leon Hewitt's Continuous Delivery with Legacy Code session

The C++ Pub Quiz
The C++ Pub Quiz

Olve Maudal's C++ Pub Quiz was as popular as ever!

Lightning Talks

The programme each day concluded with an hour of Lightning Talks at 6pm. This is Thaddaeus Frogley on "The Graphics Pipeline".

Didier Verner - Biological Realms in Computer Science

Didier Verner's "Biological Realms in Computer Science" keynote

Phil Nash - Mens sana in corpore sano

Phil Nash presented a very thought provoking session on health and fitness which was especially relevant for us sedentary office workers

For once, Kevlin Henney didnnot talking about singletons for once

Kevlin Henney's talk was "Immutability FTW!", but he still managed to sneak a Singleton in!

More photos, videos, tweets and slides from the conference are also available on the ACCU 2014 Eventifier page. We hope to see you at next year's Conference!

* it was actually 6 weeks ago...Douglas would be proud.

Posted by Anna at 13:16 | Get Link


Visual Lint has been released
Monday, May 12, 2014

This is a maintenance update for Visual Lint 4.5. The following changes are included:

  • When a Visual Studio solution is loaded, its version is now determined by the projects within it rather than its own version fields. This is necessary as in some cases when Visual Studio 2012/2013 converts a solution it does not update the version of the solution file.
  • Fixed a bug in the Analysis Results Display which caused analysis results to remain displayed after a "Delete Analysis Results" operation.
  • When VisualLintGui reloads a file in response to an external change any code editor markers will now also be reloaded.
  • The current selection will now be preserved when VisualLintGui reloads a file in response to an external change.
  • If the configuration to analyse is not specified on the command line, VisualLintConsole will now choose one.
  • Fixed a project naming bug in the Green Hills project file parser.

Posted by Anna at 10:38 | Get Link


Visual Lint has been released
Monday, Mar 31, 2014

This is a maintenance update for Visual Lint 4.5. The following changes are included:

  • When a Visual Studio solution is loaded, its version is now determined by the projects within it rather than its own version fields. This is necessary as in some cases when Visual Studio 2012/2013 converts a solution it does not update the version of the solution file.
  • If a Visual Studio solution contains projects for other versions of Visual Studio (e.g. a VS2013 solution with VS2012 and VS2010 projects), the version of each project will now be taken into account when determining which PC-lint indirect files to use.
  • The "Configure for" combobox in the Config Wizard "Analysis Tools" page and Options Dialog "PC-lint" page is no longer read-only in the Visual Studio and Eclipse plug-ins.
  • Fixed an analysis results caching issue which could affect memory usage in solutions/workspaces with a large volume of analysis results.
  • Added support for Green Hills project files with nested subprojects.
  • Fixed a potential crash when Visual Lint was turned "On" in the Visual Studio or Eclipse plug-ins via the "Product Enable" command on the toolbar.
  • Corrected the text of the VisualLintConsole help screen (the documentation for /excludeproject was missing a delimiter).
  • Added statusbar prompts and tooltips respectively to those VisualLintGui main menu and toolbar commands respectively which did not have them.
  • Updated the VisualLintConsole copyright notice.

Posted by Anna at 10:24 | Get Link


Visual Lint has been released
Friday, February 21, 2013

This is a maintenance update for Visual Lint 4.5. The following changes are included:

  • Added an "Open " command to the VisualLintGui code editor context menu.
  • Added "Copy Full Path" and "Open Containing Folder" commands to the Analysis Status Display context menu.
  • Added an accelerator for the "Perform Manual Analysis" command in the Analysis Status Display context menu.
  • The "Copy to clipboard" and "View Analysis History" commands in the Analysis Status Display context menu are now correctly disabled when no solution is open.
  • Removed the erroneous "Display Filter | Show only issues with this ID" command from the Analysis Status Display context menu.
  • When the active display filter is changed any code editor markers present in open source files will now be refreshed.
  • The "MISRA Rule" column in the Analysis Results Display is now (correctly) available in Visual Lint Professional Edition and above.
  • The Visual Studio and Eclipse plug-ins now monitor files within the loaded solution/workspace in the same way as VisualLintGui.
  • When a solution/workspace is loaded, the path which will be monitored for subsequent file changes now takes into account the locations of the projects within it.
  • Removed the "Detect externally changed files" option from the VisualLintGui "Editor" Options page. This behaviour is now always enabled.
  • When VisualLintConsole determines that the analysis of a solution/workspace has been completed, it will now wait until any project include dependency tasks have completed before exiting to ensure that any files which should be marked as stale will also be reanalysed.
  • Fixed a bug which prevented the Message Lookup Display from being configured correctly in x64 builds of the Eclipse plug-in.
  • VisualLintGui now declares itself as DPI aware to prevent DPI virtualization.
  • Fixed a bug which was causing the "Auto-select Project" checkbox in the Analysis Status Display to be incorrectly sized in Visual Studio 2010, 2012 or 2013 on systems with a high DPI setting.
  • Corrected the title of the "Visual Lint 4.5" help topic to "What's new in Visual Lint 4.5?".
  • Corrected the text of the "What's New" help topic.

Posted by Anna at 10:19 | Get Link


Visual Lint 4.5 has been released
Saturday, January 18, 2014

Visual Lint 4.5 is the latest version of Visual Lint, superseding Visual Lint 4.0. As a minor update, it will also accept existing per-user Visual Lint 4.0 licences; Visual Lint 1.x, 2.x and 3.x licences must however be upgraded to work with this version.


Host Environments:
  • The Eclipse plug-in now shows the correct version in the "About Eclipse Platform Plug-ins" dialog within the IDE.
  • Renamed the Eclipse plug-in file (formerly com.riverblade.visuallint.jar) to differentiate between 32 bit (com.riverblade.visuallint.win32_x86.jar) and 64 bit (com.riverblade.visuallint.win32_x86_64.jar) builds.
  • Added support for Green Hills MULTI projects to VisualLintGui and VisualLintConsole.
  • Added support for the analysis of Analog Devices VisualDSP++ 4.0/5.0 projects to VisualLintGui and VisualLintConsole.
  • The Eclipse plug-in now writes status text to the Status Bar where appropriate.
  • When a project file within the solution/workspace source tree is changed externally, VisualLintGui will now prompt to reload it. If VisualLintGui is minimised it will flash its window on the taskbar and delay showing the prompt(s) until it is restored.
  • Accelerated the loading of Eclipse workspaces.
  • The readme and licence files within the installer now show the full build version (e.g. "") rather than just the major/minor version.
  • Tweaked the layout of PC-lint include folder (-i) and library folder (+libdir) directives within generated project indirect ("project.lnt") files for improved readability.
  • The Analysis Status Display "Delete Analysis Results" command no longer regenerates the analysis queue. As a result, any active analysis tasks not directly affected by the operation will no longer be interrupted.
  • The FxCop /gac ("Search Global Assembly Cache for missing references") option is now enabled on the FxCop command line by default. If required, it can be disabled from the new FxCop Configuration Dialog.
User Interface:
  • Added a "Show only issues with this ID" command to the Analysis Results Display context menu.
  • Added "Show all issues with this ID", "Hide all issues with this ID" and "Reset Display Filter" context menu commands to the Analysis Statistics Display context menu.
  • Duplicated analysis issues are now always filtered out. Removed the "Filter out duplicated issues" option on the Options Dialog Displays page in consequence.
  • Added optional "Rule" columns (shown or hidden via context menu commands in the two displays) to the Analysis Results and Statistics Displays for use with PC-lint MISRA analysis. Note that the contents of these columns will only be populated when the solution/workspace is reanalysed - thereafter the mapping between PC-lint message no. and MISRA rules will be cached in the registry.
  • When the Configuration Wizard is used to configure for PC-lint analysis, the new "Rule" columns in the Analysis Results and Statistics Displays are shown or hidden depending upon whether one of the MISRA indirect files (au-misra.lnt etc.) is referenced within the PC-lint analysis configuration.
  • Category issue assignments can now be changed while a solution/workspace is open.
  • Added an "Ignore issues in system header files" option to the CppCheck Analysis Configuration Dialog.
  • When the Eclipse plug-in is started it now correctly prompts to run the Configuration Wizard if necessary.
  • Double clicking on the name of an indirect file in the Configuration Wizard PC-lint library configuration or PC-lint author recommended checks pages now correctly selects or deselects it.
  • The "Find" control within the VisualLintGui "Find/Replace" dialog is now pre-filled with the selected text (or, if there is no selection, the word nearest the cursor) within the code editor.
  • Added an optional "Rule" column to file analysis reports for use with PC-lint MISRA analysis. Note that this column will only be shown if the solution/workspace is reanalysed if the MISRA "Rule" column is shown in the Analysis Results and Statistics Displays.
  • Added support for PC-lint MISRA rules to CSV and user defined exported data formats (the latter via the new $(Rule) variable).
Bug Fixes:
  • Reduced the memory usage of VisualLintConsole when the /exportformat switch is used to export large data sets.
  • Fixed a dialog parenting issue in the Eclipse plug-in.
  • The "Back" button in the Configuration Wizard "PC-lint Warning Level" page now correctly returns to the "PC-lint author recommended checks" page.
  • The variable $(SolutionExt) is now expanded while parsing Visual C# (.csproj) project files.

Posted by Anna at 12:37 | Get Link


ResOrg has been released
Thursday, December 19, 2013

This is a maintenance update for ResOrg 2.0. The following changes are included:

  • Added support for Visual Studio 2010 and 2012 themes. Toolwindow colour settings are now automatically refreshed after a new theme is activated via the Theme|<name> (VS2010) or Tools|Change Color Theme (VS2012) theme editor commands.

    Note that changing the active theme via other commands in the theme editor may not result in the new theme being acted upon, as internal theme editor commands do not source events visible to third party plug-ins.
  • Added support for Visual Studio 2013.
  • If the user attempts to open file or solution which no longer exists via one of the ResOrgApp MRU lists, an error message is now displayed and the orphaned item removed.
  • Added MDI tabs to ResOrgApp.

Posted by Anna at 14:41 | Get Link


Agile on the Beach 2013 - photoblog
Thursday, September 19, 2013

The third Agile on the Beach conference was held on Tremough Campus, Penryn (near Falmouth in Cornwall) on 5th and 6th September 2013. As last year, the event attracted not only tech businesses, but also non-tech organisations (e.g. a legal practice and a university department) who are applying the principles of agile software development to run processes and workflows within their own organisations. Done well, agile thinking and principles can be applied to just about any workflow - it doesn't have to be about software.

This years conference was a great success by any metric. It sold out several times (with the organisers somehow managing to squeeze in more places each time as more people kept trying to register...) and that was certainly reflected in the energy visible at the event. I think in the end there were something like 170 delegates, which is a big increase on last year and compares very favourably with the 350-400 or so you can expect at the (far more established) ACCU Conference which we also take part in.

As others are writing far more eloquently than I about the detail of some of the sessions presented at the conference, I'm going to present more of a visual overview of the event - call it a photoblog post, if you like.

The conference was scheduled for Thursday and Friday, so we arrived from Bournemouth on Wednesday afternoon, car fully laden with demo stuff for the Riverblade stand (if you've seen us at the ACCU Conference you'll know the drill).

After some initial niggles (mainly down to uncertainties about the details of the newly installed automated car park barrier system on the Campus, it has to be said) we were all set up by 6pm or so. While Beth went over to sort out our accommodation (see the pictures below) I retired to the bar to work on my Code Analysis in an Agile World session for Thursday lunchtime.

Conference delegates were housed in student accommodation on the campus, which kept costs far lower than using hotels

Conference delegates were housed in student accommodation on the campus, which kept accommodation costs down

A typical room on the campus

A typical room on the campus. There was also a shared kitchen down the hall (which we didn't use much as breakfast was laid on in the campus restaurant)

Pizza and beer then followed as the evening warmed up. Sadly they didn't have any real ale on the bar (apparently they don't stock it until term starts) but Guinness, Addlestones and Crabbies were all available to lubricate the pizza.

Registration the following morning was the usual mix of delegates milling around, renewing acquaintances, examining the stands and (more importantly) hoovering up the caffeine.

Registration time is coffee time!

Registration time is coffee time!

Our stand at Agile on the Beach 2013

Our stand at Agile on the Beach 2013

When everyone piled into the main auditorium for Dan North's opening keynote it started to become obvious how many delegates were here:

A full house for Dan North, as Allan Kelly welcomes everyone to the conference.

A full house for Dan North, as Allan Kelly welcomes everyone to the conference

Dan's "Software Craftsmanship" keynote [Slides] [Video pt 1] [Video pt 2] was (as expected) awesome. The central theme was a discussion of the concept of mastery and how it relates to software development.

One of the slides from Dan North's keynote.

One of the slides from Dan North's keynote

Steve Parks has posted a detailed write-up of Dan's talk at

After the break, I headed into Jim Barritt's "Why you need to learn Clojure, right now" [Video], which despite not being as hands-on as I expected I found very interesting. For some reason the thought of trying to write an Eclipse plug-in in Clojure appeals...

Jim Barritt presenting 'Why you need to learn Clojure, right now'.

Jim Barritt presenting "Why you need to learn Clojure, right now"

Afterwards a late morning break provided essential re-caffeination opportunities before the sessions resumed.

When they did, I put my Business Hat (for those who don't know me that's the purple one with the floppy ears) on and joined the folks in the main auditorium for Allan Kelly's "Do It Right, Then Do the Right Thing" [Slides] [Video], which turned the management adage of "Do the right thing, then do it right" on it's head and illustrated the point with a selection of nasty looking weaponry (I know it's retro of me but I still prefer a halberd...).

Allan Kelly presenting 'Do It Right, Then Do the Right Thing'.

Allan Kelly presenting "Do It Right, Then Do the Right Thing"

Lunch (which could also be accurately described as a mega-sandwich session) followed, then then it was my turn to present a sponsored 30 minute session titled "Code Analysis in an Agile World" [Slides] [Video].

Although a sponsored session, the content was completely generic - I wasn't there to do a product pitch (in fact, I'm pretty sure I didn't even mention any of our products by name). The idea was to look at how code analysis tools are typically used in "traditional" team environments, why this is suboptimal, and how agile teams can do better. The concepts presented build on the techniques described in the "Effective Code Analysis" booklet we distribute at conferences.

The central issues covered were:

  • How to make analysis practical in continuous integration scenarios
  • Why you should also put analysis tools in the hands of developers rather than just on a centralised server
  • How you can use pre-commit hooks to make it less likely that developers will commit code which may degrade the quality of the codebase
  • How to define (and more importantly, evolve) warning policies to reflect changes in priorities or the quality of a codebase.

I wound up the presentation by presenting some principles for Agile Code Analysis (see the slides), which I hope isn't too presumptuous of me!

Anna-Jayne Metcalfe presenting 'Code Analysis in an Agile World' at Agile on the Beach 2013

Anna-Jayne Metcalfe of Riverblade presenting "Code Analysis in an Agile World" at Agile on the Beach 2013
(photo by Toby Weller; reproduced by kind permission of the Conference organisers)

Despite the nerves I was feeling immediately beforehand, I'm very happy with the way the session went. It's a huge subject so I could barely scratch the surface in 30 minutes, but I hope delegates found the material I presented useful. The room was packed (that was unexpected!) so there was clearly an appetite for the subject among the conference delegates.

I was however very surprised at how few delegates in the audience had any experience of code analysis tools (I asked them to put their hands up at the beginning). Clearly as an industry we are still not doing enough to make code analysis tools accessible and affordable - or indeed in educating developers to use them. That's a real shame, and reflects poorly on us all.

After lunch Rachel Davies presented "The Art of Slicing and User Stories" [Slides] [Video], which was interesting and hands on, and then it was time for another break, following which Chris O'Dell presented "Continuous Delivery at 7digital - an Experience Report" [Slides] [Video], which provided enlightenment, dinosaur skeletons, an always useful motto ("Keep Calm and Ctrl-Z") and the occasional Mexican Wave.

From personal experience deployment is one big, horrible #fail area in far too many organisations, so it was good to hear an upbeat discussion on the subject.

Chris O'Dell presenting 'Continuous Delivery at 7digital - an Experience Report'.

Chris O'Dell presenting "Continuous Delivery at 7digital - an Experience Report"

The main sessions on day 1 completed for me with Michael Rawling's "eXtreme User eXperience" [Slides] [Video] which described how a team melded user experience (UX) design with extreme programming (XP).

Michael Rawling presenting 'eXtreme User eXperience'.

Michael Rawling presenting "eXtreme User eXperience"

After the main tracks ended for the day, everyone filed back into the main auditorium for the Lightning Talks [Video].

For me the one which stood out was Allan Kelly's rant at the news that the UK Department of Work and Pensions (DWP) has mucked up their "flagship" Universal Credit project, and are blaming the fact that it was an "agile" project for the failure.

If in doubt, blame agile rather than the real culprits

If in doubt, blame agile rather than the real culprits (while wasting massive amounts of taxpayers money, of course)

Better commentators than I have blogged about this (agile...? a project with 1000 people...?), but personally, it's clear to me that the DWP couldn't manage it's way out of a paper bag, and wouldn't understand what agile meant even even if we pounded it into their thick skulls with a large lumphammer (iteratively, of course). #fail indeed.

After that excitement, it was time for the Beach Party (without which the conference would just be "Agile near the Beach"). The organisers had shuttle buses running from the campus to Falmouth beach with beer, food, beach games and live music laid on.

The Agile on the Beach Party gets underway

The Agile on the Beach Party gets underway

Ping Pong on the Beach

Ping Pong on the Beach

Jenga on the Beach

Jenga on the Beach

Beer on the Beach, courtesy of Atlassian

Beer on the Beach, courtesy of Atlassian

And that was it for day 1. Day 2 kicked off with Gabriel Steinhardt's keynote on Market-driven Product Management, which was arguably the most controversial session of the conference:

Gabriel Steinhardt presenting his 'Market-driven Product Management' keynote.

Gabriel Steinhardt presenting his "Market-driven Product Management" keynote

Rather than go into the arguments here, I'll point you at a blogpost by Gabriel in which he describes his experience at the conference, and some of the issues he raised. I found it useful, anyway.

Next up was Rich Quick on "Bringing Agile to a £2bn company", in which he described his experiences single-handedly re-inventing the methods his employer used for their software development. This was a brilliant example of Fearless Change - you just can't succeed in this within an organisation unless you are very sure of your ground and build the right relationships with others.

This was a very popular session, so I ended up sitting on the floor at the side of the room (hence the viewpoint in the photo below):

Rich Quick presenting 'Bringing Agile to a £2bn company'.

Rich Quick presenting "Bringing Agile to a £2bn company"

After the break, Martin Rowe's "Scrum: Easy to Understand, But Difficult to Do" [Slides] [Video] described introducing agile principles to an academic organisation (the phrase herding cats springs to mind), and then it was time for more the second part of the sandwichfest.

After lunch Beth and I both headed for Judith Andresen's "Company Culture Under Pressure" [Slides] [Video], in which she described how the dynamics of groups change with size, and techniques which can be used to overcome the communication difficulties which bedevil larger organisations. Her key recommendation was that no group should be larger than 8 people.

Judith Andresen presenting 'Company Culture Under Pressure'.

Judith Andresen presenting "Company Culture Under Pressure"

Next up were Wouter Lagerweij & Ciaran O'Neill presenting "The 'Just Do It' approach to Change Management" [Slides] [Video]:

Wouter Lagerweij presenting 'The 'Just Do It' approach to Change Management'.

Wouter Lagerweij presenting "The 'Just Do It' approach to Change Management" with Ciaran O'Neill

'OK, we're doing it. Now what?'.

"OK, we're doing it. Now what?"

That was the final session of this year's conference, so afterwards it was back into the main auditorium for some very upbeat closing thoughts from the conference organisers. What a couple of days!

On Friday evening there was a gathering for sponsors and speakers at the Wheelhouse, a quite simply amazing shellfish restaurant in Falmouth. Our thanks to Toby Parkins for organising this memorable conclusion to this year's event.

Agile in the Wheelhouse.

Agile in the Wheelhouse

I'm normally a bit squeamish about shellfish, but this was something else entirely. If I had to pick a favourite dish, the mussels in chilli would win hands down!

Beth and I spent the following day exploring the coastal path around Falmouth (I won't bore you with the details, save to suggest that if you go to the conference next year do take the time to wander up to Swanpool and try the ice cream...) and generally winding down. As last year, we rounded up our visit to Cornwall with a conference retrospective over fish & chips from Mariners, a fabulous chippie we discovered in Penryn last year. This year we even remembered to bring the Worcestershire Sauce (if you've never tried it it goes great with fish & chips) and accompanied the meal with a bottle of bubbly...

Riverblade's conference retrospective

Riverblade's conference retrospective was served with line caught Haddock & Chips from Mariners

As a postscript there has since been talk (prompted by my tweeting the above photo) of the Friday night pizza being supplanted by fish & chips next year - cross your fingers!

To sum up: it was a great conference, and here's hoping that Agile on the Beach goes from strength to strength in the future. For more information, please see the links below:

Finally, if you would like to read even more about this year's Agile on the Beach, Chris O'Dell has written a couple of quite detailed blog posts describing her experiences at the conference:

There are links to other blog posts on the Agile on the Beach website at

Agile on the Beach 2013 Speakers and Sponsors

Agile on the Beach 2013 Speakers & Sponsors
(photo by Toby Weller; reproduced by kind permission of the Conference organisers)

Agile on the Beach 2014 is scheduled for Thursday 4th and Friday 5th September 2014. We hope to see you there!

Posted by Anna at 12:52 | Get Link


Agile on the Beach 2013 - #agileotb
Tuesday, September 3, 2013

Agile on the Beach

We are exhibiting at the Agile on the Beach Conference in Falmouth this week (the photo above is from the Beach Party at last year's event).

I'll post some more pictures and info in due course, but in the meantime a glance at the #agileotb Twitter feed should give a feel for the event:

I should be doing a lunchtime session titled "Code Analysis in an Agile World" on Thursday.

Posted by Anna at 21:49 | Get Link


Visual Studio 2013 Preview released
Monday, Jul 1, 2013

Despite Visual Studio 2012 being less than a year old, Microsoft released a preview build of its successor last week at the //build/ conference to coincide with the preview of Windows 8.1.

Normally when a new version of Visual Studio reaches beta we have to make lots of changes to adapt to regressions and interface changes within the new version. In that respect Visual Studio 2012 was no different - adapting to the new IDE theming alone took several months. Visual Studio 2010 was even worse - as well as having to adapt to major changes to the project system some of the underlying command bar interfaces we use were fundamentally broken at RTM.

However, given the short timescale (at least in Visual Studio terms) between Visual Studio 2012 and 2013, the changes in the IDE itself are minimal - as are (therefore) the changes to Visual Lint itself.

In fact, once we had a Visual Studio 2013 Preview build installed in a VM on Thursday morning it only took a few hours to work through the changes - and everything was checked in by Friday afternoon:

A development build of Visual Lint running within Visual Studio 2013 preview

A development build of Visual Lint running within the Visual Studio 2013 preview

As a result I'm happy to be able to say that preliminary suport for Visual Studio 2013 will shortly be released in Visual Lint

This build will also include draft PC-lint indirect files for Visual Studio 2013 - once these have been shaken down we will obviously submit them to Gimpel for distribution via the PC-lint 9.0 patch page.

If you want to try the new version of the IDE, Visual Studio 2013 preview downloads are available at

Posted by Anna at 12:38 | Get Link


LintProject Pro has been released
Friday, Jun 7, 2013

This is a maintenance update for LintProject Pro 2.5. The following changes are included:

  • Added support for makefiles where the compiler location is explicitly specified rather than located via the system path [from Visual Lint].
  • Built-in compiler preprocessor symbols are now automatically included in the analysis configuration for makefile projects using GCC based compilers [from Visual Lint].
  • Fixed a bug in the Visual Studio 2010/2012 project (.vcxproj) file parser which affected project files which use $(MSBuildProjectDirectory) to reference the location of an external property (.props) file [from Visual Lint].
  • Fixed a bug which could prevent details of system includes for GNU makefile projects from being written to generated PC-lint project indirect files [from Visual Lint].
  • Updated the documentation for PC-lint messages 166, 510, 516, 829, 1009, 1085, 1962 and 1963 [from Visual Lint].
  • Added documentation for PC-lint message 142 ("case constant 'String' used previously in this switch") [from Visual Lint].
  • LintProjectPro can now export analysis results data in user defined formats specified using an external configuration file [from Visual Lint].
  • Duplicated analysis issues are now filtered out from the data written to export files written using the /exportfile switch [from Visual Lint].
  • Various modifications for compatibility with solutions (e.g. the WDK "Toaster" sample) in which two projects share the same name [from Visual Lint].
  • Fixed a bug in the querying of available CppCheck analysis issues via the --errorlist switch [from Visual Lint].
  • Relative pathnames within Cppheck and PC-lint analysis issues are now expanded to fully qualified pathnames for inclusion in reports and file exports.

Posted by Anna at 12:57 | Get Link


Visual Lint and Windows Driver Kit (WDK) projects
Tuesday, April 02, 2013

We have recently been working with Don Burn on PC-lint analysis of Windows Driver Kit (WDK) projects, and he has written an interesting article on the subject titled "Another Look at Lint" in the March-April 2013 issue of the NT Insider.

Within the article you will find the following rather complementary passage:

Finally the ultimate tool for using PC-lint with the WDK is Riverblade's Visual Lint. This is a third party tool providing an integrated package that works inside VS2012. The tool is an add-on to PC-lint which you must still purchase. The capabilities include background analysis of the project, coded display listings that - like Visual Studio - clicking on the error takes you to the line to edit and provides easy lookup of the description of the errors. The latest version of Visual Lint ( is required for use with the WDK. The tool has a minor bug that if there are two subprojects with the same name, such as filter in the Toaster sample, one needs to be renamed for analysis to work. A fix is in the works.

To use Visual Lint with the WDK choose LintLdx.lnt as the standard lint configuration file for the tool. There is a 30-day free trial of Visual Lint available so if you are considering PC-lint, take a look at what Visual Lint can add to the experience. I expect to be using it for much of my work.

Our thanks to Don Burn for his patience while we worked through the issues raised by the analysis of WDK projects. As a postscript, a fix for the bug he refers to above has already been checked in and should become available in the next public Visual Lint build (most likely

Posted by Anna at 16:29 | Get Link


Visual Lint 4.0 has been released
Tuesday, January 8, 2013

Well, it's done - the first public build of Visual Lint 4.0 was uploaded to our website this morning:

As of today, Visual Lint 4.0 replaces Visual Lint 3.5 as the current supported Visual Lint version. Customers with active priority support, floating and site licence subscriptions should already have received updated licence keys for the new version, and upgrades for Visual Lint 1.x, 2.x and 3.x per user licences should become available in our online store shortly. Pricing is unchanged from the previous version.

If you have purchased any full per-user Visual Lint licences since early October, your licence keys are already v4.x compatible so can start using the new version of the software right now without any need to upgrade. If you have purchased any upgrade licences during the same period, you will shortly receive new Visual Lint 4.x compatible licence keys.

Full details of the changes in this version are as follows:


Host Environments:
  • Added the standalone Visual Lint application (VisualLintGui) to the installer as an optional component. In addition to the project types supported by the existing Visual Studio or Eclipse plug-ins, VisualLintGui can also analyse projects for environments such as CodeGear C++ Builder for which a dedicated Visual Lint plug-in is not currently available.
  • Added support for x64 builds of Eclipse to the Eclipse plug-in.
  • Added support for Visual Studio 2012 themes to the Visual Studio plug-in.
  • Added support for Atmel Studio 6 to the Visual Studio plug-in. Note that the plug-in is not yet registered with this development environment by the installer, so this must be done manually. Atmel Studio 6 projects can also be analysed using both VisualLintConsole and VisualLintGui.
  • Added support for CodeGear C++ Builder XE3 (.cbproj) project files.
  • Added the ability to install a licence key from a (Unicode or ANSI) text file containing the new licence key during the installation process. This allows licence keys containing non-ANSI characters to be deployed during a silent installation.
  • Removed the obsolete "Getting Started Guide".
  • Added several custom PC-lint indirect files (including support files for CodeGear C++ Builder, Atmel/AVR Studio and the library "tuning" indirect file lib-rb-win32.lnt) and their dependencies to the installer. Generated PC-lint command lines automatically include a -i directive referencing this folder, so you should not need to copy the installed files to your PC-lint installation folder to make use of them.
  • Visual Lint now includes a subset of the indirect files from the PC-lint distribution by kind permission of Gimpel Software. Visual Lint injects a -i directive for the folder containing these files onto the command line, so that any indirect files not present within your PC-lint installation will be found there instead. To override the behaviour of any file within this folder, save a customised copy within your PC-lint installation and PC-lint will use it in preference.
  • Updated the manifest in the installer to fix the "This program may not have installed correctly" Windows 7 bug and specify that administrative privileges are required for installation.
  • Split the Configuration Wizard "Select Files" page into separate pages for std.lnt and options.lnt.
  • Changed the default extension for Solution/Project Analysis Configuration (.vloptions) files to .vlconfig. Where a .vloptions file already exists, it will of course be used in preference for backward compatibility.
  • Added the ability to read project settings from NMake and GNU Make makefiles embedded with within Eclipse or Visual Studio projects using Microsoft, Intel or GCC based compilers. If it is not possible to read these properties (e.g. if the makefile requires components which are not available), they will be read from the parent project file where possible instead. [Eclipse, VS2002/2003/2005/2008/2010/2012]
  • Added support for preprocessor undefines in Eclipse/CDT project (.cproject) files.
  • Generated PC-lint analysis command lines now include a -i directive for the "lnt" folder within the PC-lint installation folder (which contains the indirect files supplied with PC-lint) as well as the root folder. As a result, indirect files located within this folder will no longer be copied to the parent folder when selected for use in a std.lnt file via the Configuration Wizard.
  • Added the Configuration Wizard "PC-lint Warning Level" page to allow the PC-lint warning level (-w<n>) to use in newly created std.lnt files to be defined.
  • Replaced the Configuration Wizard "Select PC-lint Configuration Files" page with dedicated pages for compiler, library and author options indirect files.
  • Added a mechanism to allow the Configuration Wizard to determine which PC-lint indirect files should be included by default within new std.lnt files created by the wizard. The selection is context sensitive based on the project type.
  • PC-lint std.lnt indirect files generated by the Configuration Wizard now include comments to describe the purpose of what each directive within the file.
  • The Configuration Wizard now offers a default filename for new PC-lint std.lnt files.
  • Visual Lint now sets the priority of background analysis tasks directly rather than relying solely on the command line options of the corresponding analysis tool to do so. As a result, analysis tasks for tools such as CppCheck (which do not have a -background or equivalent option) now correctly run at a lower priority than previously, making the IDE more responsive.
  • Optimised the analysis of files with a large volume of analysis results.
  • When a project with a precompiled header file located outside of the project root is analysed using PC-lint, a -i directive for the folder containing it is now automatically included on the generated command line. This allows PC-lint to correctly locate the precompiled header file.
  • Project (e.g. "$(ConfigName)") and system (e.g. "%HOMEDRIVE%") environment variables can now be used in custom analysis options.
  • The source file pathnames reported in PC-lint per-project analysis are now fully qualified rather than relative pathnames.
User Interface:
  • The About Box now shows the build platform (x86 or x64) as well as the build version.
  • Added the ability to enable/disable inline highlighting of code elements referenced in reported analysis issues as well as customise the colours used. Note that: 1) enabling/disabling inline highlighting will not currently take effect in a given editor window until it has been reopened, and 2) changes in the colours will not currently take effect until the environment is restarted. [VS2002/2003/2005/2008/2010/2012] [Visual Lint Enterprise Edition]
  • Visual Lint 4.0 builds now show the corresponding version of the Visual Lint online help following installation.
  • Updated the icon for the "View Analysis History" button in the Analysis Status Display to reflect that used for the Analysis History Display.
  • Added command bitmaps to menus where appropriate.
  • Updated the appearance of selected items within the Displays, Options and Configuration Wizard. This change takes effect when Visual Lint is run on themed Windows Vista/Server 2008/7 systems; on unthemed, Windows Server 2003 and Windows XP systems the previous appearance is still used.
  • Icons in the analysis results shown within the Analysis Results Display are now greyed along with the text while the analyis of a displayed file is in progress.
  • "Stale" and "Incomplete" projects/files are now shown in the Analysis Status Display with greyscale icons to match the text colour.
  • Tweaked the category icons used in the displays slightly. Also updated the default icons and colour scheme for Internal and Fatal Error issues.
  • The background of icons in list controls (e.g. in the Analysis Status Display) is now painted to match the row background colour when running with visual styles under Windows Vista or later.
  • Added the ability to display analysis trends to the Analysis Status Display. The trends available include: since last analysis, over a specified time interval and since a specified date.
  • Updated the contents of Analysis Status Display infotips to include details of the issue IDs identified and changes in the number of issues.
  • Added infotips to the Analysis History Display giving details of changes in the number of issues in each analysis results set as well as details of the issue IDs identified.
  • The text and background colour of rows within the Analysis History Display history list now matches those used within the other displays.
  • Removed the "unchanged" and "no issues" trend icons from the Analysis History Display for consistency with the trend icons in the Analysis Status Display.
  • Added "Copy Infotip Text" commands to the Analysis Status, Results and History Display context menus to allow the text displayed when hovering over the list control to be copied to the clipboard.
  • VisualLintConsole now appends a "(+/-x)" suffix to the text displayed when the analysis of a file or project completes if the issue count has changed since the previous analysis.
  • The button controls within the Analysis Status and Results Displays now paint their backgrounds correctly after a theme or system colour change.
  • The contents of Analysis Status Display infotips are now truncated at 80 characters per line to prevent unintended line wrapping.
  • Added an option to determine whether Visual Lint should use the colour scheme of the host IDE where possible. The option is enabled in Visual Studio 2005 onwards. [VS2005/2008/2010/2012]
  • Added a "Configure for..." combobox to the Config Wizard "Analysis Tools" page to allow users of VisualLintGui to select the toolchain they wish to configure it for. The new controls are hidden when Visual Lint is hosted within Visual Studio, Eclipse etc.
  • Renamed the "Order" column in the Analysis Status Display as "No.".
  • If an explicit selection has not been made in the Analysis Results Display (e.g. via the "File" combobox) the analysis results for the first file in the current project will be displayed.
  • The Analysis Results Display now greys issue text and icons for stale files.
  • Removed unnecessary updates of the "File" combobox in the Analysis Results Display.
  • Revised the titles of several Configuration Wizard pages for consistency.
  • Added an option to the "Displays" options page to allow new blog posts on the Riverblade website to be automatically displayed (using the internal browser in the environment where possible) when Visual Lint starts. The schedule is programmable, with the default check for new posts being every 7 days.
  • Added "Select All" and "Select None" commands to the Analysis Results Display context menu.
  • Added keyboard shortcuts to "Select All" (Ctrl+A) and "Select None" (Esc) commands in the Analysis Status, Results and Statistics Display context menus.
  • Added "Select All" (Ctrl+A) and "Select None" (Esc) commands to the Analysis History Display context menu.
Bug Fixes:
  • Fixed a bug in the marker implementation which manifested in a "An exception has been encountered. This may be caused by an extension" message box when hosted in Visual Studio 2012 RC.
  • The "Background Analysis" command in the Visual Studio Solution Explorer now acts on all selected items rather than just the first one.
  • Fixed a bug which could case a "Warning: Unable to queue file for analysis" message to appear in the Status View when background analysis was enabled on a file which had up to date analysis results.
  • The Analysis Results Display "All files" view now excludes analysis results for files which are stale or excluded unless the corresponding "Include stale/excluded files within analysis metrics" option is active.
  • Fixed a bug in the Visual Studio plug-in which could cause the platform of the active solution configuration to be read incorrectly if the configuration contained active projects of more than one platform. [VS2005/2008/2010/2012]
  • Modified the startup sequence of the Visual Studio plug-in when hosted in Visual Studio 2005 or 2008 to match that used in later versions rather than that used in Visual Studio .NET 2002 and 2003.
  • Fixed a bug which could cause the contents of the Analysis Results Display to be refreshed incorrectly when an issue in a header file was double clicked.
  • When a CodeGear C++ (.cbproj) project file is parsed, the "Base" configuration (if any) is now hidden so that it cannot be used as an analysis target.
  • If the host IDE for a particular version of a CodeGear C++ (.cbproj) project file is not installed, a later one (if available) will now be referenced for analysis purposes instead.
  • Fixed a bug in the Eclipse and Visual Studio plug-ins which could cause code editor markers for issues without fully qualified pathnames to fail to appear.
  • Fixed a bug which caused legacy Eclipse/CDT project (.cdtproject/.cdtbuild) project files to be loaded in place of newer .cproject files.

Notwithstanding the long list of changes above, there are plenty of changes (e.g. updated report templates) that we unfortunately didn't get a chance to put into this build. We will be going back to those tasks over the next few months, and those for which it is practical to do so will of course be back-ported from our development branch to Visual Lint 4.0.

We welcome any feedback you can offer us on the new version.

Posted by Anna at 12:37 | Get Link


Visual Lint 4.0 is coming...
Wednesday, December 19, 2012

Fine tuning aside, development work on Visual Lint 4.0 is now effectively complete so a public build of the new version should be released early in the New Year.

Once released, Visual Lint 4.0 will supersede Visual Lint 3.5 as the latest public Visual Lint version. As a major update, existing per-user Visual Lint 3.x licences will need to be upgraded to work with this version (suitable upgrade licences will become available in our online store at the same time as the public version of the software, at the same cost as the existing v1.x/v2.x to v3.x upgrades). Floating and site licence customers (as well as priority support customers with qualifying active subscriptions) will receive new v4.x compatible licence keys around the same time.

However, the good news is that if you have purchased any full per-user Visual Lint licences since early October, these licences are already v4.x compatible so can start using the new version of the software as soon as it becomes available without any need to upgrade.

Full details of the changes in this version will be published soon, but for us the highlight is the arrival of VisualLintGui - a standalone interactive version of Visual Lint which makes possible the analysis of projects for development environments (e.g. CodeGear C++) for which a dedicated Visual Lint plug-in is not currently available:

We expect to add support for a number of embedded project types to VisualLintGui (and by inference VisualLintConsole/Visual Lint Build Server) within the coming months, so if there is a particular embedded environment whose projects you would like to be able to analyse in VisualLintGui and VisualLintConsole please let us know.

For new installations, Visual Lint 4.0 also includes a much improved Configuration Wizard which includes predefined PC-lint analysis configurations for most supported project types. Our Win32 suppression files (rb-win32-pclint8.lnt and rb-win32-pclint9.lnt) are also included in the installer.

Visual Lint 4.0 supports Visual Studio 2012 themes, so if you are using Visual Studio 2012 with the dark theme, Visual Lint 4.0 fits into the development environment far better than its predecessor. Similarly, if you are using an x64 version of Eclipse, Visual Lint 4.0 also includes an x64 version of the Visual Lint Eclipse plug-in.

We welcome any feedback you will be able to offer us on the new version once it has been released.

Posted by Anna at 16:18 | Get Link


PC-lint compiler options files for Visual Studio 2012
Wednesday, November 28, 2012

Since Visual Studio 2012 was released we have been using the compiler options files for Visual Studio 2010 (co-msc100.lnt and co-msc100.h) when analysing code for it as a set for VS2012 was not available.

For the most part that works fine, however it does mean that code which checks _MSC_VER etc. to invoke conditional behaviour may not analyse correctly in some cases.

We have now submitted dedicated PC-lint 9.0 compiler options files for Visual Studio 2012 (co-msc110.lnt and co-msc110.h) with the correct values for these symbols as given by the Visual Studio 2012 RTM. The co-msc110.lnt file also includes some suppression directives for Visual Studio 2012 unit tests.

In due course they will become available in new PC-lint 9.0 installations and via the PC-lint 9.0 patch page, however for the time being Gimpel have made them available from the PC-lint 9.0 beta page at

Incidentally the current PC-lint 9.0 beta version (9.00i2) looks like it contains some fairly significant changes to MISRA, PCH and function call side effect analysis - so that is a pretty good indication of what to expect in the next public version (PC-lint 9.00j).

Details of the changes in PC-lint 9.00i2 are available at

Posted by Anna at 09:39 | Get Link


Visual Studio 2012 theme support
Thursday, Aug 2, 2012

One of the unexpected (and I would suggest from the comments, unwelcome) changes sprung on developers in the Visual Studio 2012 Beta back in February was the Metroification of the development environment.

However, eye candy (and eyesores!) come and go, and within that change is a more fundamental one - direct support for themes within the Visual Studio IDE. The Visual Studio 2012 Beta and RC include two themes - light (i.e. grey) and dark. Whilst the latter has an obvious appeal within the developer community (we all know devs who prefer green text on a black background) the former hasn't exactly been welcomed, to say the least.

Personally, rather than develop custom theme support for each tool individually I wish they'd just add a "dark" theme to Windows instead and respect the theme settings of the operating system. Obviously my view just isn't "cool" enough for the Visual Studio UX team, but I digress...

Although a campaign to retain the existing Visual Studio 2010 theme has been running on the UserVoice site since the beta arrived (see Add some color to Visual Studio 11 and Leave VS 2010 theme (and the theme editor extension) as an option) Microsoft have not indicated what - if any - changes will be made to the Visual Studio 2012 themes at RTM.

Our working assumption therefore has to be that the themes in the RTM will be broadly comparable with those in the RC (i.e. light and dark). We will find out whether that assumption is correct later this month, of course.

With that in mind, we have been working on theme support in the development branch for Visual Lint for some time now, and things are now beginning to come together:

Visual Lint running with the Visual Studio 2012 RC dark theme

Visual Lint running with the Visual Studio 2012 RC light theme

As Visual Lint uses standard Win32 controls for most of the UI (which for the most part do not support custom text/background colours), to get this far we have had to write custom painted WTL checkbox, radio button, combobox and header controls in addition to the usual WM_CTLCOLORxxxx voodoo. Other UI elements such as menus, scrollbars, command buttons etc. yet haven't yet been looked at, but hopefully will be in due course (there seems to be some indication in the MSDN blogs that scollbars will be auto-themed by the RTM, but we'll see).

Within the displays themselves, the text and background colours of each item are checked for adequate contrast, and the text colour adjusted (by tweaking the luminance) automatically if need be.

Although the Visual Studio interfaces expose the colours used in the active theme (via IVsUIShell2::GetVSSysColorEx() ), they do not seem to provide any way of detecting if the theme has changed (or indeed, finding out which theme is actually running at the time). Our workaround for this is simply to reload the colour scheme whenever the "Tools|Options" command has been executed. We don't really care which theme is running after all - just what colour values it uses, and where.

Indeed, one of the first things we did while working on this was to dump all of the colour values used by the VS2012 RC light & dark themes, as well as the default VS2010 theme, into spreadsheets so we could use them for testing without firing up a host instance of the IDE (developing add-ins may be fun, but it is also much slower than working on your own executable).

Finally, it is a little known fact that the Visual Studio IDE has had colour scheme support internally for some time, so the scheme we have designed will also work with Visual Studio 2010 if you have the theme editor extension installed:

Visual Lint running with Visual Studio 2010 with a modified 'Expression' theme

Needless to say, all of this is proving to be a major task, and it has therefore diverted significant resources from other things we should really have been working on this summer. As a consolation, the theme code we're developing is generic (albeit only on Windows), so can also be used with Eclipse 4.0 (I note that themes are coming to that IDE as well) when the time comes.

Another obvious benefit is of course that there's potentially at least one new CodeProject article (want a themed XP button with a custom background colour? We know how to do it now) in all of this once the dust settles and the inevitable bugs have crawled away. It's about time I wrote a new one, anyway.

Once Visual Lint theme support is complete, we'll obviously also take a look at ResOrg. Beyond that, I think a new article is a foregone conclusion, once we've cleaned the code up a bit and built a good enough demo project...

Posted by Anna at 12:45 | Get Link


Visual Studio 2012 RTM release date announced

Well, it's official - Visual Studio 2012 has been released to manufacturing and the RTM build should become available to MSDN subscribers on 15th August:

...but: what's a virtual launch event, and (more importantly, for those who regularly attend such events) does it entail free stuff?

We've been working on support for the new IDE version in the Visual Lint development branch since February, and quite honestly with all of the IDE changes it's been like pulling teeth (a different sort of teeth from the bloated buggy ones we pulled while working with the VS2010 beta, but teeth regardless).

Although there's no word yet on whether the RTM is any less grey than the RC (though the smart money says they're not listening, thankfully it doesn't look like the Beta anymore) it's a done deal either way, and as such we're stuck with it until the next fad (Metro++ ? Metro# ?) comes along.

Regardless of how the RTM ends up looking, we will be releasing Visual Lint 3.5 and ResOrg 2.0 builds compatible with it as soon as we can confirm that the RTM does not require any code changes over the VS2012 release candidate (which we have already tested against, obviously).

Visual Lint running within Visual Studio 2012 RC

Note that this version will not (yet) include support for Visual Studio 2012 themes - dropping that particular bombshell on us at beta in February was just too short notice to develop and test the control and framework changes necessary to do this in time for the RTM.

However, theme support is being actively worked on in our development branch (see and will come later (more on that in the next blog post, with a possible CodeProject article as a nice spin off).

Posted by Anna at 11:08 | Get Link


Visual Studio 2012 RC
Monday, June 11, 2012

Well, the Visual Studio 11 saga (or would it be better described as a slow motion trainwreck?) rumbles ominously on. We had very high hopes for this release (mostly relating to C++ 11 support and far better performance than the abominably sluggish VS2010), but the way it is going is really putting us off - sufficiently so that we are now seriously considering a move to an alternative complier within the VS2008 IDE as an alternative to VS2012.

First it was the forced change in the Visual C++ runtime which rendered it incompatible with Windows XP hosts (XP being still far more common than you would expect with customers), then the UI styling changes in the Beta (see my earlier blog post UI changes in Visual Studio 11 - what do you think?) and most recently the hoo-hah over Visual Studio Express being kneecapped to no longer be capable of developing non-Metro projects (which could obviously have significant impacts on the open source ecosystem that many of us rely on).

Far, far less importantly, the expectation that Visual Studio 11 would be branded "Visual Studio 2012" has been confirmed - which means it will be out this year (my bet is on November).

Naming aside, the most recent developments are that MS have relented slightly on the "light" (i.e. waves of greyness) theme included in the Beta, conceded that runtime support for Windows XP SP3 is desirable but won't be available at RTM (but may be as an SP or patch), and have relented over the change to Visual Studio Express - promising something called "Visual Studio Express 2012 for Windows Desktop". The hated ALL CAPS toolwindow titles have been removed, only to reappear on the main menu (wtf?).

If you have time to burn you can follow the whole sorry saga through the following posts (and the associated comments, of which there are several thousand) on the Visual Studio team blog:

I despair sometimes, I really do. This whole saga seems to be a textbook example of how to take a promising product release, and then shoot yourself in the foot not once but as many times as you possibly can.

Against this unsettling background we of course have to decide how best to support VS2012 in both Visual Lint and ResOrg. Although the basics are already in place (as you can see in the screenshot below of Visual Lint running within the Visual Studio 2012 RC) there is obviously much still to do if our extensions are going to "fit in" within the new version of the IDE:

Visual Lint running within Visual Studio 2012 RC

However, given the changeable nature of the VS2012 RTM environment, we are holding off adding support for specific Visual Studio themes for now (though if Microsoft relent and include a VS2010 style theme, Visual Lint and ResOrg will obviously look right at home), so at present we can't say if or when the styling of our products will match that of the built in themes (icons, grey/black backgrounds and all).

Part of the problem is not just the likelyhood of the IDE styling changing again in the RTM in response to negative feedback, but also the very practical point that the Visual Studio EnvDTE interfaces we use in our products do not seem to offer any support for theme switching.

For example, once an add-in has installed its commands, there is no documented way to change the icons on them other than by destroying and recreating the commands - (which requires admin privileges and will muck up your toolbar layout). Nor is there a theme changed event (at least, not one I can find).

It's a mess, quite frankly. We are however keeping a close eye on developments (and in particular on Carlos Quintero's blog, as the techniques for handling theme switching will almost certainly be documented there first) so things may well change quite quickly between now and the RTM.

However, for the time being the screenshot above is representative of what you can expect from both ResOrg and Visual Lint within the Visual Studio 2012 environment.

So what do you think about Visual Studio 2012 so far? Feel free to tell us by email or via Twitter (@annajayne).

Posted by Anna at 11::22 | Get Link


Introducing VisualLintGui
Friday, April 20, 2012

If you have been following me (@annajayne) on Twitter, you may have noticed me talking about something called "VisualLintGui".

This is actually the second of two projects (the first being VisualLintConsole - the command line version of Visual Lint) we got underway after the release of Visual Lint 3.0.

Now that VisualLintConsole (the command line version of Visual Lint) is out in the wild, we have turned our attention to VisualLintGui. This is, as the name suggests, a standalone Visual Lint application with a graphical user interface - basically a text editor focused on code analysis:

Although it has been fully functional in terms of analysis functions for quite some time, until recently we were not able to devote a great deal of time to the details of its user interface. That has now changed, and since February VisualLintGui has gained many essential capabilities including a syntax colouring editor with analysis issue markers, MDI tabs, Find/Replace and Source/Header flip to name but a handful of the more obvious recent changes.

VisualLintGui is currently capable of analysing projects for Visual Studio, Visual C++, Eclipse, CodeGear C++ and AVR Studio 5.0, but it can obviously potentially analyse a far wider variety of codebases than that.

Indeed, one of the reasons we have been keen to develop it is to provide a way to support embedded IDEs for which developing a Visual Lint plug-in is not a viable proposition. As such we expect to add support for further project and workspace file formats as and when our customers need them.

VisualLintGui currently resides in our Visual Lint development branch, but given the recent pace of development on it we are likely to look at porting it back into Visual Lint 3.5 in the not too distant future.

In the meantime we will have a development build on our stand at the ACCU Conference next week, so if you are going please do come and take a look.

Posted by Anna at 15:23 | Get Link


UI changes in Visual Studio 11 - what do you think?
Friday, February 24, 2012

A very interesting MSDN blog post about the forthcoming Visual Studio 11 landed this morning titled Introducing the New Developer Experience.

The bottom line - it's grey...very grey - even the icons, which are monochrome glyphs:

As someone who finds vast expanses of grey hard on the eye my first instinctive reaction was "Yuck!". I personally find the Visual Studio 2008 visual style to be about right for me - Visual Studio 2010 feels a bit too glaring (as well as being dog slow to start, but that's another debate....), and I really don't think I could use an IDE as grey as this one all day without feeling quite low about the whole experience.

We all have to make up our own minds, of course - and this isn't necessarily representative of what we will have to use on a daily basis. I do have to wonder if MS are trying just a little too hard to "reinevent the world" again though - and as a plug-in developer I certainly don't relish having to have to maintain yet another set of icons (monochrome this time) just for Visual Studio 11!

If you use Visual Studio on a daily basis, it might be a good idea to make Microsoft aware of your thoughts on such a major change in the user interface before they become entrenched in the product.

Posted by Anna at 10:57 | Get Link


ResOrg 2.0 has been released
Sunday, January 22, 2012

Well, it's done. After a rather extended incubation period ResOrg (the first public ResOrg 2.0 build) was uploaded earlier this morning, and the ResOrg product pages updated to match.

If you have used ResOrg 1.x before, you will notice that the user interface of ResOrg 2.0 is subtly different from its predecessor - notably in the Visual Studio plug-in (which now of course supports Visual Studio 2008 and 2010...).

In particular, the old (and rather limited) "ResOrg.NET Explorer" toolwindow has been replaced by a much more useful "Symbol Files Display" which is also available in the standalone application.

If you are using Visual Studio 2010, it might interest you to know that ResOrg 2.0 can automatically update Ribbon Designer (.mfcribbon-ms) files when an ID referenced in a ribbon resource is renumbered.

I won't include any screenshots in this post as a couple of good ones were included in the previous post, however if you are reading this post in your RSS reader you can find them at

Posted by Anna at 11:24 | Get Link


Visual Lint and Atmel AVR Studio 5
Friday, September 16, 2011

From our perspective one of the more intriguing embedded environments to appear recently is Atmel's AVR Studio 5.

When I first saw a screenshot of this IDE (it was mentioned in a post in the CodeProject Lounge) it was immediately obvious that this was some sort of Visual Studio derivative.

In fact, although it uses GCC toolchains, the environment is based on the Visual Studio 2010 isolated shell (which incidentally is something we briefly considered using ourselves for a future standalone GUI version of Visual Lint, but decided against because of its complexity and the size of the download).

It obviously occured to us then that as a Visual Studio derivative, it shouldn't be too difficult to get Visual Lint running within it. The first step was obviously to install the IDE in a VM (XP SP3 - doesn't XP look a bit old these days...?) and experiment with some projects.

AVR Studio 5 codebases uses the Visual Studio 2010 solution file format (albeit rebadged as a .avrsln file) and a new MSBuild based project file format (.avrgccproj), so the first thing we obviously had to do was implement parsers for these files (something that will also benefit LintProject Pro, of course). Once that was done, we turned our attention to getting Visual Lint to load within the IDE itself.

This turned out to be fairly straightforward. Although AVR Studio 5 does not seem to support COM add-in registration in HKEY_LOCAL_MACHINE (which is how the Visual Lint add-in registers in Visual Studio), the corresponding registration in HKEY_CURRENT_USER\Software\Atmel\AVRStudio\5.0\AddIns does work. Although this is problematical from an installation point of view (see my previous post on the Visual Studio 11 Developer Preview) it is not a showstopper by any means.

With manual add-in registration in place, Visual Lint loaded within the IDE. Although a few minor tweaks were needed to work around issues such as AVR reporting itself as "Visual Studio Express Edition, version 1.0" (which caused the version detection code in Visual Lint to default to 16 colour command bitmaps!) those were easily addressed.

As a result, we now have AVR Studio 5 running with a development build of Visual Lint:

Visual Lint running within AVR Studio 5

Visual Lint running within AVR Studio 5

Although we still have quite a bit to do (not least the code editor markers and installer) before AVR Studio 5 can become a supported host environment for Visual Lint this is a very promising start. Needless to say, beta testers are welcome.

Posted by Anna at 16:17 | Get Link