Visual Lint 2.0.7.113 has been released |
|
Monday, June 22, 2009
|
The following changes are included in this version:
- PC-lint analysis results generated without an environment file (i.e. no env-vc*.lnt file) can now be parsed correctly.
- Project indirect (.lnt) files generated by previous versions of Visual Lint will now be automatically re-generated.
- When a lint issue without an associated source line number is displayed in the Analysis Results Display, the line number is now shown as blank rather than 0.
- Added a "Copy | Issue Text Only" command to the Analysis Results Display context menu. This is identical to the existing "Copy" command (now renamed "Copy | Full (with Source File Info)" but omits the source file information.
- Local analysis tasks now only report progress when the scheduler is not busy performing other tasks. This should improve performance on n-core high performance systems with "noisy" codebases.
- Visual Studio automation model interface pointers are now cached in the context of the calling thread. This reduces the use of the Global Interface Table, and hence simplifies thread synchonisation.
- Corrected a bug which was affecting Intel C++ Compiler support in Visual Lint Enterprise Edition.
- Added support for Intel C++ Compiler 11.0 projects, which use a different project file format to previous versions.
- Added support for Intel C++ Compiler 11.0 projects, which use a different project file format to previous versions.
- Modified the IncrediBuild version checking code for compatibility with IncrediBuild 3.4.
- Visual C++ 2008 project (.vcproj) files created using the "Create Project from Existing Code" wizard are now parsed correctly. Such project files are created with UTF-8 encoding instead of the usual Windows-1252, and it seems that MSXML does not correctly support loading an XML stream with a UTF-8 byte-order mark from a Unicode string.
- Fixed a bug in the "Delete Analysis Results" menu command in the Solution Explorer.
- If hosted under VS2008 and running on XP, new installations no longer create a linked window frame to contain the Analysis Status, Results and Message Lookup Displays. This avoids a recently identified shutdown crash which appears to be specific to this combination of operating system and development environment.
|
Posted by Anna at 10:53 | Get Link |
LintProject Professional 2.0.3.11 has been released |
|
Wednesday, June 17, 2009
|
When I recently blogged about support for non-Microsoft project file formats, I mentioned that we were in the process of adding support for Texas Instruments Code Composer 3.x (.pjt) projects.
I am pleased to announce that this functionality is now available as part of LintProject Pro 2.0.3.11. Other non-MS project file formats (notably Eclipse/CDT and the various CodeGear C++ Builder formats) are now also being looked at, so watch this space. 
The full set of changes in this build include:
- Added support for Texas Instruments Code Composer Studio 3.x (.pjt) projects.
- Added skeleton support for Visual Studio 2010 (.vcxproj) projects.
- Added support for Intel C++ Compiler 11.0 projects, which use a different project file format to previous versions [from Visual Lint 2.0.7.113].
- The help screen ('/?' switch) now shows which solution/workspace and project file types are supported.
- Project configuration specified on the command line are now case-independent.
- For loop compliance settings are now read from project files and written to the corresponding project indirect files directly.
- Corrected a bug in the parsing of the /param switch introduced in LintProject Pro 2.0.2.9.
- Improved command line validation and error reporting.
- Added logging of command lines and console output (to CSIDL_COMMON_APPDATA\Riverblade\LintProject Professional).
- Updated the readme file to include newly supported development environments and corrected a typographical error in the licence file.
|
Posted by Anna at 12:49 | Get Link |
Visual Studio 2010 Support for Visual Lint and LintProject Professional |
|
Tuesday, June 09, 2009
|
If you follow technical blogs you can't help but have noticed that Visual Studio 2010 has now entered beta. The new IDE is on course for release towards the end of this year (my bet is on November as that's when both Visual Studio 2005 and Visual Studio 2008 shipped).
Community Technical Previews (CTPs) of the new IDE have actually been available for the new IDE for over a year now, so it should come as no surprise that we have actually had limited VS2010 support in the Visual Lint development codebase for quite some time now. As a result, for us the recent release of Visual Studio 2010 Beta 1 has been an opportunity to see what has changed since last time. Beta 1 is actually quite a major change from the last CTP, including (for example) a new MSBuild style Visual C++ project file format (.vcxproj), a WPF (Windows Presentation Foundation) based editor and multi-monitor support.
The IDE now looks noticeably different to VS2005 and VS2008, and I have to say that my initial impression was not entirely positive (although Beth rather likes it). Whether that impression will last once I've had a chance to use it a bit more, we'll see.
Of more direct concern to us than the UI styling is of course the new project file format and whether the Visual Studio automation interfaces (which we use to interface Visual Lint to the development environment) are working correctly.
Being an MSBuild script, the new .vcxproj project file format is far more complex than the previous .vcproj format. Although that is something of a headache for us (Visual C++ project files can be rather intricate, so a new format always results in significant development and testing), it is probably not an issue for most developers. if however, you have a codebase where you have to maintain project files for multiple versions of Visual Studio and/or make a habit of hand editing project files (as I do sometimes) you may be in for a bit of a shock, however.
We actually wrote a basic parser for .vcxproj files some time ago (fortunately the format does not appear to have changed hugely since then) so over the next few months we will be gradually enhancing it to support the full range of Visual C++ project file capabilities already present in our existing .vcproj and .icproj (Intel C++ Compiler project) file parsers. In the meantime, the new parser will become available in LintProject Professional shortly - so LintProject Professional will actually gain full support for Visual Studio 2010 projects before Visual Lint itself.
What does concern us however is that Beta 1 appears to have significant regressions in the Visual Studio automation interfaces - even simple operations such as adding a pane to the Output Window, creating a Toolwindow or retrieving the handle of the top level window seem to be broken. These are quite fundamental operations which third party add-in products such as Visual Lint rely upon to function correctly, so it is rather worrying that we are seeing such regressions. As these interfaces seemed to be working just fine in the last CTP I think I can say with some confidence that the integration of the new WPF based editor is implicated in the regression.
We can only wait to see if Beta 2 will address these issues so that we can carry on integration testing. In the meantime, we are starting to post bugs on Microsoft Connect and waiting for feedback from Microsoft.
|
Posted by Anna at 11:17 | Get Link |
Non-Microsoft Platforms, Visual Lint and LintProject Professional |
|
Monday, June 08, 2009
|
Integrating a plug-in product such as Visual Lint into a new development environment is a rather time consuming and difficult operation - even (unfortunately) when the new IDE is just a new version of one we already support (I'm looking at you, Visual Studio 2010!). Even worse, although the big players (notably Visual Studio and Eclipse) have quite comprehensive plug-in models many do not - which effectively makes it impractical for third party vendors to port their tools to those environments.
As a result we have been forced to conclude that in most cases it is not practical for us to develop a Visual Lint plug-in for such development environments. Fortunately, the converse is now (following some recent changes to the way it handles project files) true for LintProject Professional.
Please note that the remainder of this blog post describes functionality introduced in LintProject Professional 2.0.3.11; it is not present in earlier versions.
In fact, adding a new project file format to LintProject Professional is rather easy - in most cases, as we need to do is add a new project file reader implementation and enable it in the build configuration.
As a test, we have just done exactly that for project files for one of the development environments recently requested - namely Texas Instruments Code Composer Studio 3.x. For clarity, I'll refer to this IDE as CC3 for now.
CC3 project (.pjt) files are actually very simple, so this was an ideal test case:
; Code Composer Project File, Version 2.0 (do not modify or remove this line)
[Project Settings]
ProjectDir="c:\CCStudio_v3.3\myprojects\CC3Test\"
ProjectType=Executable
CPUFamily=TMS470R2X
Tool="Compiler"
Tool="CustomBuilder"
Tool="Linker"
Config="Debug"
Config="Debug2"
Config="Release"
[Source Files]
Source="Untitled2.c"
["Compiler" Settings: "Debug"]
Options=-g -@"options.txt" -fr"$(Proj_dir)\Debug" -i"projectincsearch" -d"_DEBUG" -d"_HELLO" -u"_UNDEFTHIS" -mv5e --abi=ti_arm9_abi
["Compiler" Settings: "Debug2"]
Options=-g -fr"$(Proj_dir)\Debug2" -d"_DEBUG" -mv5e --abi=ti_arm9_abi
["Compiler" Settings: "Release"]
Options=-o3 -fr"$(Proj_dir)\Release" -mv5e --abi=ti_arm9_abi
["Linker" Settings: "Debug"]
Options=-c -m".\Debug\CC3Test.map" -o".\Debug\CC3Test.out" -w -x
["Linker" Settings: "Debug2"]
Options=-c -m".\Debug2\CC3Test.map" -o".\Debug2\CC3Test.out" -w -x
["Linker" Settings: "Release"]
Options=-c -m".\Release\CC3Test.map" -o".\Release\CC3Test.out" -w -x
["Untitled2.c" Settings: "Debug"]
Options="Compiler" +{-i"cppCC3Testincsearch"}
Once we had written a suitable project file reader implementation, LintProject professional was able to generate the following project indirect file, which it then used to analyse the sample project:
// Generated by LintProject Professional 2.0.2.10a from file: C:\Data\Projects\Applications\LintProjectPro\Test Solutions\CCStudio\CC3Test\CC3Test.pjt
// -dConfiguration=TMS470R2X|Debug
//
-D_DEBUG;_HELLO; // PreprocessorDefinitions = "_DEBUG;_HELLO;"
// AdditionalIncludeDirectories = ""optionsfolder";"projectincsearch" ;"
-ioptionsfolder //
-iprojectincsearch //
Untitled2.c // RelativePath = "Untitled2.c"
Although I have no doubt that we will have to "tweak" the contents of the project.lnt file output as a result of user feedback, this is a pretty good starting point from what I can see.
Ironically, CC3 workspace (.wks) files are binary (they actually look like serialised MFC CArchive files) so they are far as tricky to parse as the project files are easy. hence, for the time being we are only adding support for CC3 project files, and not the workspace files themselves.
While we are in the LintProject Professional code we have also made a minor change to the help screen, which now lists the solution/workspace and project file types supported:
Incidentally, I should clarify that we are certainly not ruling out a Visual Lint plug-in for Eclipse (or any other mainstream IDE with a comprehensive plug-in model for that matter) - it is simply that the steps needed to get support into LintProject Professional are a necessary precursor for a full integration anyway, and this way we also can deliver something useful up front.
|
Posted by Anna at 15:49 | Get Link |
Visual Lint for Windows 7 |
|
Tuesday, May 19, 2009
|
Hi there, my name is Beth Mackenzie. I've been rather overdue in introducing myself to you, but I hope to rectify that now. Among other things, I'm responsible for much of our testing as well as research into possible support for new IDEs (I've recently been working with Visual Studio 2010, CodeGear 2009 and Embedded IDE's such as Code Composer Studio 3.x/4 to name but a few) and Operating Systems. It's the latter I wish to talk about today - and Windows 7 in particular.
We have actually been testing with Windows 7 for several months, and in fact the grid computing demonstrator we recently showed at the ACCU Conference used a pair of Q9550 quad core machines running the Windows 7 Beta.
When a new operating system becomes available to developers, we usually run our normal tests to catch any breaking changes. In this case, the test's aim was to make sure Visual Lint will run with Visual Studio 2008 on Windows 7, i.e. to ensure that the application installs and executes as it should.
If you haven't seen it, Windows 7 displays its pulsating logo which appears in the center of the screen, it's an atomic aesthic just right for the Hadron collider age that we all live in:
Windows 7 has a nice smooth user interface layer, less clutter, an uncluttered install sequence like Windows 2008 Server. Here is my screen shot installing the development build of Visual Lint:
So far so good. 
And here is my screen shot of Windows 7 using Visual Studio 2008 running the development build of Visual Lint:
I think it's worth the mention that we used installed Windows 7 on both Quad-core test machines for the ACCU Conference 2009 that we recently attended in Oxford. Anna has been blogging enthusiastically about our time at the conference.
I plan to upload a running movie of Visual Lint in Windows 7, but i'd better continuing testing the latest build!
We tested with the Windows 7 Beta here, and of course will we shortly be retesting with recently release.
You can find me writing regular product updates through Twitter
~Beth Mackenzie
|
Posted by Beth at 09:19 | Get Link |
LintProject Professional 2.0.2.10 has been released |
|
Monday, May 18, 2009
|
The changes in this build include:
- PC-lint raw analysis results generated without an env-vc*.lnt environment file can now be parsed correctly. Also improved the handling of messages in the module wrap-up [from Visual Lint 2.0.6.111a].
- Wildcards can now be used to exclude both files and projects from analysis.
- Corrected an issue with relative paths in the handling of the PC-lint std.lnt indirect file.
- Empty projects are now no longer shown with "Pending" status in the solution report.
- Removed the "Uninstall..." shortcut from the Start Menu (as per current guidelines the Control Panel "Add/Remove Programs" applet should be used instead).
- Revised the way command line swiches are parsed. As a result, a delimiter ('=' or ':') should now be used with switches (e.g. /configfile) which have following parameters.
- When a Visual C++ project file containing comma delimited preprocessor definitions (the IDE uses semicolons) is read, the corresponding definitions in generated project.lnt file will now be correctly semicolon delimited (this fixes an analysis error when definitions of the form SYMNAME=, are encountered in the project.lnt file) [from Visual Lint 2.0.4.107].
- Corrected the category totals and sort order in the "Issue Count by Project" section of the HTML solution report template [from Visual Lint 2.0.4.107].
- If exception handling (/GX) is enabled in a Visual C++ project, _CPPUNWIND will now automatically be defined in generated project.lnt files [from Visual Lint 2.0.5.109].
- Charts generated as part of HTML reports are now saved as .bmp and then converted to .png using GDIplus, as the lpng.dll used by TeeChart8.ocx to perform this function natively seems to have issues with DEP on Windows Server 2008 and Windows Vista [from Visual Lint 2.0.5.109].
- Fixed a bug in the project indirect file writer which could cause paths such as "..\..\Folder" to be incorrectly resolved [from Visual Lint 2.0.6.111].
- Fixed a bug which would cause a crash if a project file containing files of the form "\\filename.ext" was encountered [from Visual Lint 2.0.6.111].
- Fixed a bug in the project indirect file writer which could cause paths such as "Folder1\Folder2\..\Folder3" to be incorrectly resolved [from Visual Lint 2.0.6.111].
- Added support for Visual Studio variable $(WebDeployPath) in .vcproj files [from Visual Lint 2.0.6.111].
- Corrected a bug in the Analysis Results parser which could cause a reference line in a specific walk to be parsed as a lint message - leading to an erroneous fatal error [from Visual Lint 2.0.6.111].
- Added support for "AdditionalOptions" within inherited property sheet (.vsprops) files [VS2002 onwards] [from Visual Lint 2.0.6.111].
- Guarded against malformed -i directives (e.g. /I"Path) in Visual C++ response files [from Visual Lint 2.0.6.111].
- Corrected the handling of .vsprops files whose location is defined via configuration specific Visual Studio environment files (e.g. "$(SolutionDir) Common_Sources\Win\CompileOptions\$(ConfigurationName)Plugin.vsprops") [from Visual Lint 2.0.6.111].
- Project configurations which inherit Intermediate and Output Directory values within .vsprops files are noware now correctly handled [VS2002 onwards] [from Visual Lint 2.0.6.111].
- Improved error handling when an unsupported solution, workspace or project file type is specified.
|
Posted by Anna at 09:45 | Get Link |
Visual Lint 2.0.6.111 has been released |
|
Tuesday, May 12, 2009
|
The following changes are included in this version:
- Fixed a bug in the project indirect file writer which could cause paths such as "..\..\Folder" to be incorrectly resolved.
- Fixed a bug in the project indirect file writer which could cause paths such as "Folder1\Folder2\..\Folder3" to be incorrectly resolved.
- Fixed a bug which would cause a crash if a project file containing files of the form "\\filename.ext" was encountered.
- Added support for the Visual Studio variable $(WebDeployPath) in .vcproj files.
- Corrected a bug in the Analysis Results parser which could cause a reference line in a specific walk to be parsed as a lint message - leading to an erroneous fatal error in the analysis results.
- Added support for "AdditionalOptions" within inherited property sheet (.vsprops) files [VS2002 onwards].
- Fixed a bug in the parsing of analysis results returned by IncrediBuild [Visual Lint Enterprise Edition].
- Corrected a bug in the Analysis Results Display which caused the "Categories" control to be configured incorrectly on start-up [Visual Lint Standard and Professional Editions].
- The "Auto-select project" option in the Analysis Status Display is now persistent. In addition, if this option is active when a solution is loaded the display will now automatically reflect the contents of the active window.
- The "View" control in the Analysis Results Display is now persistent.
- Version information for IncrediBuild is now only shown in the "Visual Lint Status" pane in the Output Window if the active product edition is Visual Lint Enterprise Edition.
- The default subject text in email enquires from the About Box now includes details of the active product edition.
- Added support for additional command line options of the form -I "folder path" within Visual C++ project files.
- Guarded where possible against malformed -i directives (e.g. /I"Path) in Visual C++ response files.
- Corrected the handling of .vsprops files whose location is defined via configuration specific Visual Studio environment files (e.g. "$(SolutionDir)Common_Sources\Win\CompileOptions\$(ConfigurationName)Plugin.vsprops").
- Project configurations which inherit Intermediate and Output Directory values within .vsprops files are now correctly handled [VS2002 onwards].
- Corrected a potential deadlock in the interactions between the "Delete Analysis Results" command and the IncrediBuild task scheduler [Visual Lint Enterprise Edition].
- Re-themed the installer and Configuration Wizard.
|
Posted by Anna at 10:48 | Get Link |
ACCU 2009: So many sessions, so little time... |
|
Monday, April 27, 2009
|
Preamble [21st April 2009]
Well, we're here at the Barcelo Oxford Hotel again, and for us ACCU 2009 starts tomorrow (though the pre-conference workshops happen on the Tuesday, we haven't booked onto one this year).
We are a little more prepared this year than last - for example we now have a 6 foot roll-up banner, better printed materials and a pair of Q9550 quad core machines configured as a networked code analysis demonstrator. All of that adds up to quite a load to move (and we obviously do not want to leave equipment unattended during the night), so we are expecting to have a bit of a rush around to get everything set up and ready after breakfast each morning!
(in case you are wondering, the two quad core boxes are under the table and controlled from the keyboard on the left).
Day 1: Wednesday
After breakfast this morning we headed to the sponsors hall to set everything up. As we had a rather more elaborate stand this year it took us something like 45 minutes to get everything ready.
That done we had a little time to cool down a little, mingle and generally catch up with those we know from previous years.
Keynote: "The Birth of Craftsmanship" (Robert C. Martin) [Slides]
This morning's keynote was "The Birth of Craftsmanship" with Robert Martin (aka "Uncle Bob"). Robert is the author of Agile Software Development, Principles, Patterns, and Practice, a book which I can wholeheartedly recommend to anyone wanting to learn about modern software development practices.
The theme of this keynote was the changing perceptions of the nature of software development over the past 40 years, and where our perception of what we do might be heading.
He opened with a rather memorable quote: "In the beginning, the expectation was that you could throw specifications into a room, then throw in meat (i.e. programmers!) and code would come out". This of course evolved into the belief in "Big Plans" or "Big Up Front Design" prevalent from the 1970s to the 1990s (and of course that didn't work either...).
Things have changed a lot since then - and today we have accepted ways of developing software which work very well in practice (when companies deign to use them correctly - far too many still don't, unfortunately).
Robert's assertion is that we should now accept that software development is not (as has so often been supposed) science or engineering - but instead a craft. As such, very different rules apply - rules to which we as a profession have not yet adapted to.
Following an interesting diversion into Wave-Particle Duality and the Uncertainty Principle, he then gave a fascinating history of the evolution of software development practices from 1992 (Jack Reeves assertion that "Architectural blueprints are analoguous to source code, not the Big Plan") through the arrival of the patterns movement in 1995 and the Agile Manifesto in 2001.
As a late arrival to the party, I found the history fascinating.
Robert suggests that "Agile is the gateway to craftmanship and to a profession" and predicts that the next big thing will be the realisation that the only way to go fast is to go well, and do it right in the first place! i.e. for developerss to have a Profession and therefore Ethics ("no, I will not write bad code"). Although laudable, that's a lofty ambition - particularly when you consider the mass of undertrained developers out there and the tension between increasing skills (which implies higher rates of renumeration) and commoditisation of software development skills.
One of his more controversial (or is it...?) assertions was that the rapid adoption of Scrum among development teams is not likely to significantly improve the success of software projects generally unless Scrum itself evolves to include the technical practices of agile software development (notably TDD, measurement of team velocity and potentially pair programming) it omitted from XP. Time will tell, I suspect!
Agile Makes Progress Transparent - but who wants to be confronted with reality? (Jutta Eckstein)
Jutta's session was an informal discussion of human factors in software development, and some of the tensions which can arise if an organisation or team is unwilling to commit to learning (it doesn't have to be formal training, of course), trust (a lack of which often results in excessive formality) and quality.
Change (in particular in software architecture) is a fact for developers, but businesses are often afraid of it. Hence, communications with stakeholders should avoid inappropriate detail and use appropriate terminology for the listener. Conversely, organisations often fail to accept what they are advised is really possible, despite being told. There is a tension between innovation in business and what we as developers believe is realistic.
I'm not going to even attempt to detail all of the topics discussed, but they included issues such as the optimum size of a development team (5-7 people), ways to rescue a failing team (in general adding more developers will make things worse rather than better - Brookes Law) and how Stable architecture is a bad idea (the design must be able to evolve with the requirements).
To me, the closing statement really said summed up the number one issue those advocating software quality face:
"Agile is very often a trouble detector, and although it only exposes issues which exist anyway, this is often not welcome, and as a result the process gets blamed. One way to expose this is to perform a retrospective on the project - showing the true picture.
"Ultimately, key people need to give a damn. If that is not the case, no amount of process will help."
Introducing Parallel Pixie Dust: A Novel C++ Threading Library (Jason McGuiness ) [Slides]
Jason is well known in ACCU for his expertise in parallelisation, so this session (in which he presented a library which can be used to parallelise operations on data in standard STL containers in a lock free manner without risk of deadlocks or race conditions) promised to be a fascinating discussion on the subject (and one which built nicely upon the discussion on the subject we'd had in the pub the previous evening...).
He didn't disappoint, and if you are at all interested in the subject I really suggest you take a look at the slides.
Panel: Programming in a Multilingual World (Kevlin Henney, Steve Love, Russell Winder and Ric Parkin)
This session discussed issues relating to multi-programming language development, including which languages each of the panel suggested a new developer should try to learn (always an interesting debate!), and what drives the adoption of new languages in organisations.
At this point I should own up to the fact that as I'd been rushing around trying to get everything ready for our stand I'd not had a chance to read the session programme to learn what each session was about. Consequently, I'd assumed that it was about internationalisation.... 
Welcome Crappy Code - The Death of Code Quality (Nicolai Josuttus) [Slides]
Nicolai is the author of The C++ Standard Library, and in this session he made the deliberately controversial assertion that inevitably globalisation and increasiing commercial pressures will lead to even crappier code and buggier systems. In effect, this is the strawman to Robert Martin's "Software Craftsmanship" session.
The strawman is a simple one:
- Code quality is not possible
- Accept that it happens, and react accordingly
Whilst I accept the second premise (I'm a pragmatist after all!) the first is one that's easily disproved simply by studying teams who do it right in the first place.... 
Day 2: Thursday
Keynote: "The Benefits of Abstraction in Patterns" (Linda Rising)
This morning's keynote focused on Linda's personal experiences with patterns, and is loosely based on a paper she wrote for IEEE Software. She described what she does now as "I think about how people think, and how they solve problems".
Her session described her journey from developing specific technical patterns through corporate behavioural patterns to abstract patterns for improving (for example) peoples lives in third world countries. The latter teaches us an important lesson - when introducing change you must take local conditions into account if you want the change to succeed.
The session began with a history of the pattern movement, beginning with the publication of the "Gang of Four" book at the OOPSLA conference in 1994 where it was met with absolutely huge demand. Quote obviously, it touched on a rea pain point for many developers present. A particular strength of the GOF book is of course that the concepts presented are both language and platform independent - they are about re-using ideas rather than any specific implementation. In her own words: "ideas captured in patterns are timeless".
She then moved on to describe the process of submitting a patterns paper to a PLOP conference, and how the experience (which is based on writers workshops) differs from that used in most conferences, before describing how she has gradually became aware that patterns could be applied to the process of introducing change to organisations. In fact, her book Fearless Change originally started in 1996 as "Patterns for introducing patterns into organisations" (metapatterns?). Since then it has evolved into patterns for introducing any type of change - it does not have to be a technological change.
Linda also described what she saw as "the abstraction dilemma" - do we have lots of detailed patterns for each domain, or far fewer more abstracted patterns, and illustrated this by the response of the Ada community to the GOF book: basically "nothing here applies to us" for the trivial reason that the examples were not written in Ada...
Controlling Project Risk by Design (Niels Malotaux) [Session Materials]
I actually ended up in this session by accident (I couldn't get into Kevlin's session at the same time) but I'm so glad I did. Niels' presentation was humourous, useful and interesting (exactly the same reason I try to hear Kevlin speak, in fact!).
The session focused on defining and controlling risk during the design process, using an iterative self-leaning approach known as the PDCA or Deming cycle.
Key points included:
- Most real risks are in the product, not the implementation. Hence,if you can control the risks in the project you will have more free resources to cope with product risks (which are often much less predictable).
- If a defect is a problem experience by avstakeholder, then it follows that:
- Not satisfying the project goal is a defect
- Being late is a defect
- Being over-budget is a defect
I have to say that I particulary like his approach to defects...
Code Analysis Tool Parallelisation and Grid Computing (Anna-Jayne Metcalfe) [Slides]
This was an informal ("BOF") session I'd put together just before the conference as a direct result of conducting benchmarks on the parallelisation (both local and network grid) of PC-lint analysis tasks, and the issues this raises in task scheduling - particularly if PC-lint 9.0 precompiled header support is also used.
The benchmarks are those we described in the blog post Visual Lint/IncrediBuild case study and benchmarks, and were performed while writing the Accelerating PC-Lint C++ Code Analysis case study for Xoreax earlier this year.
The most interesting part of this subject for me is the promise that PC-lint precompiled headers hold for reducing analysis time (always an issue with large codebases) and the corresponding implications for the scheduling of analysis tasks. In particular, running a PCH enabled PC-lint analysis "on the grid" requires very careful scheduling if it is to be faster than the non-PCH equivalent. Notably however, the scheduling requirements for PCH are far simpler for local analysis, and our benchmarks certainly reflected this.
A fascinating subject, I hope you will agree.
Multithreading in C++ 0x (Anthony Williams) [Slides]
Dealing as it does with one of the most compelling areas in the forthcoming C++ standard, this was (not surprisingly!) a very popular session. In it, Anthony gave a rather comprehensive (or at least it seemed so to me) introduction to the new threading capability introduced in the new standard.
The C++ 0x threading toolkit is based on boost::thread, and deliberately basic. In essence, it comprises:
- Thread launching
- Mutexes
- Condition variables for blocking waits
- A clearly defined memory model - allowing safe use of atomic variables without thread locks
- Futures for high level concurrency design
std::lock() - which allows multiple mutexes to be locked simultaneously with a guarantee to not cause a deadlock.
Futures are very interesting, and to my mind are the single most compelling feature of the new standard threading support. A future is a "token" for a value which will be available later - allowing the developer to focus on communications rather than locking access to a shared variable which will contain the result.
Anthony gave an overview of the various new standard types, including std::unique_future, std::shared_future, std::packaged_task (whose value is the result of a function call), std::promise (where a value set explicitly) and std::async (a possible contender for the standard, in which a library manages a thread for the function call) and gave examples of each.
Overall, the session illustrated well the fact that multithreading is hard - but it isn't the threading itself, it is the communication between threads and the unpredictable effect locking can have on performance. C++ 0x threading promises to make that just a little easier, and I for one am looking forward to being able to use it in anger.
Day 3: Friday
Keynote: Geeks, Nerds & Other Prejudices (Susan Greenfield)
Susan Greenfield - or Baroness Greenfield if you prefer formality - is one of Britain's leading female scientists, and to be frank it felt like a bit of a coup for ACCU that she was able to speak for us at the Conference.
The subject of her very entertaining keynote was the experiences and perceptions of women in technology - with all of the stereotypes, misconceptions and so on that subject raises.
Susan started by debunking common myths such as "It's all genetic", "Girls don't like science and technology", "Girls are bad at science and technology" and "Female scientists/technologists are 'not normal' by using a high level (but extremely interesting) description of the structure and operation of the brain to illustrate how such simplistic and naive such misconceptions really are. To quote: "In such a complex system it is simplistic to assume that genes constrain behaviour".
She then descibed commonplace traps which can lead women to underachieve, such as confidence (women are less confident and less likely to emphasise their strengths than men), conflation of personal with professional (women and men use language differently, and women take conflict more personally), not finding the right mentors (they don't have to be female, of course), social factors such as lack of availability of childcare etc.
I found this to be a very entertaining and enlightening session, and judging from the reactions of the rest of the audience I was far from alone!
Panel: Women in Technology (Astrid Byro, Anna-Jayne Metcalfe, Sue Black, Frances Buontempo)
I was honoured to be asked to participate in this panel. Susan Greenfield was also meant to be on this panel, but unfortunately she had to rush off for another engagement at the last minute. Regardless, she set quite a stage for us, and the discussion was extremely wide ranging, covering topics as diverse as the effect of corporate culture on the advancement of women within an organisation to social conditioning and family expectations. We could quite easily have carried on the discussion for hours - 45 minutes really wasn't enough to do the subject justice.
The fact that I felt safe enough in that environment to talk about my experiences of socialisation and gender within the trans community was testament (in that community, female technologists outnumber the male ones) to how safe and diverse an environment ACCU represents for female technologists. As a transwoman myself, this is not a subject I discuss lightly, believe me!
After the panel I had quite a few people come up to me to thank me for participating in it, so I'm glad I took part, despite my nerves beforehand.
Bletchley Park Presentation and Appeal
During the lunch break (did I mention ACCU lunches last 1 1/2 hours...?) there was a presentation on the history and possible future of Bletchley Park (the site of a groundbreaking codebreaking effort during the Second World War, and the location where computing as we know it began).
By this stage I was starting to flag so I didn't take any notes, so I hope Allan Kelly will forgive me for reproducing what he quite eloquantly said on the subject in his blog:
Several activities this year were designed to support Bletchley Park]. A donation scheme, a raffle, challenge puzzle and a sponsored bike ride (thereby hangs a long story.) In keeping with this theme Simon Greenish from the Bletchley Park Trust and Dr Sue Black from Westminster University gave a talk at lunch time.
The history of Bletchley Park is increasingly well known. Simon and Sue focused on the future, how they trust wanted to improve the park and the difficulties that stood in the way. The key point was that the trust is now in a race against time, the buildings are decaying and need repair if they are to be preserved at all. There are still enough Blethchley Park war veterans alive to make historical projects based on the park worthwhile. Before long much of our history will be lost if we do not act now.
Certainly it was enough to persuade me to make a donation to the Park, and hopefully I?ll go and see it this summer. And....
IF YOU ARE READING THIS BLOG PLEASE SIGN THE PETITION TO SAVE BLETCHLEY PARK NOW http://petitions.number10.gov.uk/BletchleyPark/.
Designing 'Good' Components, Interfaces and Contracts (John Lakos)
John Lakos is the author of Large Scale C++ Software Design, and the originator of the well established ACCU tradition of "being Lakosed". If you work with large C++ systems, you really should have a copy of this book on your bookshelf.
His presentations are always interesting and thought provoking, and this was no exception. This session covered four particular areas, each in significant detail:
- Physical design (files, libs etc)
- Interfaces and contracts
- Good contracts
- Proper use of inheritance
Unfortunately there was far too much material to take detailed notes on, so if I find a link to his slides I suggest you read them carefully. Much of what John said I agreed with, but not all, of course!
Day 4: Saturday
Keynote: Principles for Successful Software Management (Allan Kelly)
Allan is an ACCU regular, and well known as a speaker who eloquently puts "the case for effective management" to balance the more commonplace technical perspectives within ACCU.
In this keynote Allan sets out key considerations for better management of software development.
Developers often see the management of software development as a dark art. While the tools and technology constantly race ahead, software management is all too often stuck in the 1950s.
Alan observed that the continuous minor course corrections we all make in the course of our work are more important than "the big stuff" which organisations typically may most attention to. Furthermore, the quality of the people involved is key - as Fred Brooks famously commented in The Mythical Man-Month":
"the quality of the people on a project, and their organization and management, are much more important factors in the success than are the tools they use or the technical approaches they take." One critical - but all too often overlooked - point is that someone has to give a damn (and it must be someone who actually understands development...). Companies appoint managers to be that person, with widely varying degrees of success. Unfortunately bad management can all too easily destroy a projec - and in fact bad managenent is actually worse than nothing...
So, Alan proposes that we need a management philosophy, and some principles to follow:
- Know your customer, what their problems are and what they need and want
- Features, Resources and Time are relatively fixed, but scope can be controlled
- Quality is free
- Management by Routine (not exception)
- Stay Connected
- Risk Management by doing
- Continuous Improvement
- Trust & Honesty
- Its the people, stupid!
Legacy Code - Learning to live with it (Pete Goodliffe) [Slides]
This session was on the Saturday afternoon, and by now everybody was flagging. Although Pete's presentation was every bit as entertaining as ever, I was struggling to keep my eyes open. It was still worth it, as the photo below shows rather well(apologies for the poor contrast, it was the best I could manage at the time):
Need I say more, other than to ask:
Is your code pants?
So that's it for another year. We've had a great time, caught up with old friends and even learnt a littlelot.
If you didn't go this year, I hope you'll take the time to attend the conference next year and learn something new. Believe me, your code will thank you if you do.
Photos from this year's conference.
|
Posted by Anna at 18:20 | Get Link |
The ACCU Conference is next week...and we're totally linted! |
|
Thursday, April 16, 2009
|
It's hard to believe that the ACCU Conference is here again - in fact it is taking place next week at the Oxford Barcello Hotel.
As ever, we'll be there (for the third year in a row, now!). This year we have a new pull up banner for a stand (with the catchphrase "Promoting Quality in Software Engineering") and (of course!) a new tee-shirt design:
As well as looking after our stand (from where we'll be showing our new grid based code analysis demonstrator - a pair of Q9550 quad core boxes configured to form a small but effective IncrediBuild grid) we'll be participating in the sessions, which are as varied as ever.
From a title perspective, the best one just has to be:
"Reverse Engineering Patterns. I wouldn't start from here if I were you". 
If I can get a BOF slot (basically ad-hoc mini-sessions) I have a mini-session prepared titled "Code Analysis Tool Parallelisation and Grid Computing" which describes some of the issues we've encountered in adapting code analysis tools for a parallelised environment, and the considerations you need to make in order to do it work well.
If you're going to the Conference, please drop by our stand and say hi. If you happen to have a USB key with you we have some files (presentations, articles, sample config files etc.) we can give you, too. Just ask!
Postscript: If you want to get a flavour of the ACCU Conference, my blog entries from last year should give you a bit of an idea.
|
Posted by Anna at 17:03 | Get Link |
Visual Lint/IncrediBuild case study and benchmarks |
|
Monday, April 06, 2009
|
We've just had a case study published on the Xoreax website about the integration of Visual Lint and IncrediBuild:
As part of the study, we conducted a number of benchmark tests to quantify just how much of an improvement using IncrediBuild can make to the PC-lint analysis of a representative codebase (in our case a specific version of Visual Lint we've been using for benchmarking).
The results of the tests performed using this combination are (to say the least) striking. Using just six agents (four dual and two quad core desktop systems) we were able to complete a complete analysis of the Visual Lint codebase in just over 15 minutes - a seventeen-fold improvement on the single threaded equivalent.
When we added additional agents, we were able to improve on this further, bringing the analysis time down to just 12 minutes:| Description | Analysis time (178 kLOC codebase) | Speed relative to single threaded analysis |
|---|
| 1 Core (2.2 GHz). Single threaded conventional PC-lint analysis | 4 hours 25 minutes | x1 | | 2 Cores (aggregate speed 4.4 GHz). Native Visual Lint analysis using 3 parallel analysis threads | 2 hours 22 minutes | x1.8 | | 16 Cores (aggregate speed 40 GHz) using XGE | 15 minutes 10 seconds | x17.5 | | 23 Cores (aggregate speed 54.7 GHz) using XGE | 12 minutes 20 seconds | x21.5 |
Needless to say, this is a rather significant improvement over local analysis (and one which definitely justifies the "potential factor of 20" speed improvement which Xoreax claim for IncrediBuild).
|
Posted by Anna at 09:54 | Get Link |
Visual Lint 2.0.5.109 has been released |
|
Thursday, March 26, 2009
|
The following changes are included in this version:
- If exception handling (/GX) is enabled in a Visual C++ project, _CPPUNWIND will now automatically be defined in generated project.lnt files.
- System folders such as "$Recycle.Bin" are no longer searched for the PC-lint executable during installation or from the Configuration Wizard.
- Fixed a bug which was preventing yellow warning bars from appearing in the IncrediBuild Build Monitor [Visual Lint Enterprise Edition].
- Solution and project analysis configuration (.vloptions) files generated by Visual Lint are now formatted in a human readable form.
- Backward relative (i.e. beginning with "..\") paths are now supported in .vloptions (Visual Lint analysis options) files [Visual Lint Professional and Enterprise Editions].
- The lib-ole.lnt indirect file is no longer shown on the "Configure std.lnt" page of the Configuration Wizard as it is automatically included by co-msc*.lnt.
- If the std.lnt file is not located in the PC-lint installation folder, -i directive for the folder in question is now automatically added to the command line (before that for the installation folder) so that references to local indirect files are resolved correctly.
- Charts generated as part of HTML reports are now saved as .bmp and then converted to .png using GDIplus, as the lpng.dll used by TeeChart8.ocx to perform this function natively seems to have issues with DEP on Windows Server 2008 and Windows Vista. As a result, gdiplus.dll is now packaged within the installer to allow Window 2000 support to continue (hence the increase in installer size).
- Minor changes to the way IncrediBuild analysis tasks are queued [Visual Lint Enterprise Edition].
- File reports are no longer autogenerated as each analysis task completes.
|
Posted by Anna at 10:43 | Get Link |
Visual Lint 2.0.4.107 has been released |
|
Thursday, March 05, 2009
|
The following changes are included in this version:
- Updated Platforms.xml with new platform names for Smartphone and Pocket PC SDK.
- When an include folder mismatch in the global std.lnt configuration file is detected, Visual Lint can now prompt, automatically update the include folder directives in the file or ignore the discrepency.
- Added the "mark of the web" to HTML reports to avoid the "active content" warning from the browser when a Visual Lint generated report is opened on the local filesystem.
- Corrected a bug in the "View Analysis Results" command in the Analysis Status Display introduced as a result of threading modifications in 2.0.3.105.
- Fixed a bug in the generation of project.lnt files using PC-lint under Visual C++ 6 and eMbedded Visual C++ 4.0 (other IDEs and direct generation of these files by Visual Lint are unaffected).
- Corrected a bug in the detection of the Visual Assist X "VA View" under Visual C++ 6.0 and eMbedded Visual C++ 4.0.
- When a Visual C++ project file containing comma delimited preprocessor definitions (the IDE uses semicolons) is read, the corresponding definitions in generated project.lnt file will now be correctly semicolon delimited (this fixes an analysis error when definitions of the form SYMNAME=, are encountered in the project.lnt file).
- Added a missing WM_DESTROY handler to the chart control used in the Analysis Results Display. Likewise, TeeChart interface helper objects are no longer held open throughout the lifetime of a reporter object (these are potential fixes for an intermittent crash in TeeChart8.ocx seen on shutdown of Visual Studio 2008).
- Corrected the category totals and sort order in the "Issue Count by Project" section of the HTML solution report template.
- Fixed a potential crash in the Analysis Status Display.
- If the "Delete Analysis Results" command fails, a warning will now be displayed and written to the "Visual Lint Status" pane in the Output Window. Similarly, if the task dialog informing the user that Visual Lint has not yet been configured fails (this has been seen intermittently on one of our test systems), the Configuration Wizard will now be displayed automatically.
- The Visual Lint installer and Configuration Wizard now direct users without a PC-Lint installation to the online store rather than the Gimpel website.
- Updated the Visual Studio 2008 runtime libraries packaged within the installer to VS2008 SP1.
Of particular note in this build is the change to support project files containing comma delimited preprocessor symbols - such project files are typically generated by Qt.
|
Posted by Anna at 11:18 | Get Link |
|
Wednesday, March 04, 2009
|
I'm really not sure what to make of Twitter; I know it's supposed to be a good idea, but at heart I think I'm far more of a blogger than a twitterer.
Nevertheless, I'm giving it a go anyway! Please feel free to let me know what you think.
http://twitter.com/annajayne
|
Posted by Anna at 19:54 | Get Link |
LintProject Professional 2.0.1.8 has been released |
|
Friday, February 13, 2009
|
The changes in this version include:
- Corrected the installer properties text.
- Corrected the product name displayed in the ReadMe and Licence files.
- Added the "mark of the web" to HTML reports to avoid the "active content warning from the browser when a Visual Lint generated report is opened on the local filesystem.
- Updated the Platforms.xml file (which is used to support per platform environment variables) with new platform names for Visual Studio 2005 Smartphone and Pocket PC SDKs.
- Corrected a bug which was preventing reports from being correctly generated if a standalone project was analysed.
- Minor revisions to HTML report stylesheets.
- Display "Saved configuration" when /save is supplied on the command line.
|
Posted by Anna at 16:23 | Get Link |
PC-lint 101: What does "previously used .lnt file" mean? |
|
Thursday, February 12, 2009
|
A .lnt file is an "indirect file", which is simply a collection of PC-lint directives. Indirect files can be nested, and are expanded in the order they are encountered by PC-lint.
However, if PC-lint encounters the same .lnt file twice in the same context during execution, it will abort with Fatal Error 314 ("Previously used .lnt file"). Hence, if you are seeing this message your analysis has failed due to an error in your PC-lint configuration, or a clash between it and the command line used.
To fix this, simply determine which .lnt file is being duplicated and remove one of the occurances. The former can be done quite simply by running PC-lint with the -vi option, which lists the .lnt files encountered, and where they were found:
If there is a duplicated indirect file in the configuration/command line, you will receive an error 314 when the second instance is encountered:
Although this particular example is quite trivial, it illustrates on of the most common causes of fatal error 314 - specifying an indirect file on the command line when it is already in your PC-lint configuration.
In our experience the most common offenders in this are the warning policy file options.lnt and the IDE environment options files env-vc*.lnt - both of which are often specified both on the command line and within std.lnt.
To fix the error, all you need to do is remove the duplicate references to the indrect file in question - either from within your analysis configuration or (if applicable) the command line used to invoke lint-nt.
|
Posted by Anna at 16:26 | Get Link |
|
|
|
