[Do you tweet? Follow me on Twitter @matthawley]

We deployed the latest version of the CodePlex software today.

WYSIWYG Wiki Editor

With this release, we have enabled the ability for project members to edit their wiki pages in either the Wiki Markup or with a WYSIWYG Html editor. When you create or edit a wiki page, you’ll have the ability to switch between Wiki Markup and Html Markup.

If you currently have existing Wiki Markup and click the Html Markup option, the Wiki Markup will be converted to HTML Markup for you. You can always switch back to using Wiki Markup, but the content will revert to the original Wiki Markup for the current version. That means

1. Switching to Html Markup, editing content in the WYSIWYG editor, and then switching to Wiki Markup will not retain your changes.
2. Once an Html Markup page is saved, switching to Wiki Markup will result in no Wiki Markup available.

Below you will see the converted Wiki Markup of the home page for WikiPlex.

Here are a few tips for working with the Html Markup:

1. You can always go back to a prior Wiki Markup version to either save it as the current version or copy the Wiki Markup to be used later.
2. When the Wiki Markup to Html Markup conversion executes – the RSS, Silverlight and Video macros will be rendered as friendly text with a link to the resource.
3. When attaching files or images within your wiki page, we now list each attachment as a link to the resource allowing you to right-click and copy the URL to be used in either the image or link editor.
4. You can have a mixture of Wiki Markup and Html Markup pages within your project. There is no reason to convert everything over if you don’t want to.

Mercurial Servers Upgraded to 1.6 We also upgraded our Mercurial servers to the latest version. By upgrading to this version, you have the ability to take advantage of the latest features of Mercurial, including pushing Bookmarks to the server. Click here for a complete list of new features or bug fixes in Mercurial 1.6.

[Do you tweet? Follow me on Twitter @matthawley]

We deployed the latest version of the CodePlex software today.

Support for ClickOnce Releases

With today’s release, we are happy to announce that our #1 most requested feature, hosting ClickOnce applications directly from the CodePlex website, is now available for all projects! For those that are not familiar with ClickOnce, it is a .NET deployment technology that enables a user to install and run a Windows application by simply clicking a link from a web page. ClickOnce applications are also inherently self-updating, as they check for newer versions as they become available. ClickOnce applications are also “low-impact”, in other words, they do not need administrative rights to install, only install for the current user, and are isolated from other ClickOnce applications.

Since there is no direct way of publishing your ClickOnce application to CodePlex from within Visual Studio, we have attempted to make the process as simple as possible. The next few sections will walk you through the preparation and publishing, and ultimately creating a ClickOnce release on CodePlex.

Publishing a ClickOnce Application

This first step assumes that you have an existing .NET Windows application (Console/Windows Forms/ WPF) that you wish to publish using ClickOnce. When you open the Publish dialog (Build -> Publish) from Visual Studio, the first step will ask for a location to place the published ClickOnce application files. Feel free to change this value to an easy-to-remember path on your computer.

The next step asks where users will be installing this application from. Select “From a Web Site” and type the following in the textbox, replacing “ProjectName” with your project name.

http://ProjectName.codeplex.com/releases/clickonce

This is a very important step, and the CodePlex software ensures that your ClickOnce application has a valid URL that matches your project.

At this point, you can either click “Next” to walk through a few other steps or you can click on “Finish” to complete the publish operation.

Preparing the ClickOnce Application for CodePlex

If you open up the location where your application is published, you’ll see a folder structure similar to the following:

As you can see, there isn’t just a single executable that can be uploaded. Each version of your ClickOnce application has a folder with the necessary files in it that is contained in the “Application Files” folder. To prepare the ClickOnce Application for CodePlex, zip the entire directory, making sure the *.application file is at the root of the zip file.

Note: This is a mandatory zip file structure that is required. Validation of your ClickOnce application will fail if this is not followed.

Creating a ClickOnce Release

When you create a new release for your project, you’ll notice a new checkbox underneath the release name. When that is checked, a file upload control is displayed. Select the zip file you created in the last step and fill out the rest of the create release form.

A few notes about ClickOnce releases

1. The ClickOnce application becomes your “default file”. There is no way of making another file for that release the default.
2. ClickOnce releases are always public. There is no way of “hiding” them.
3. You can only have 1 active ClickOnce release at a time. All older ClickOnce releases will be “archived”, which means they are still accessible you just cannot make them recommended releases, or update the release’s ClickOnce application.

When the ClickOnce release has been created, you’ll be redirected to view the release.

If you click on the “ClickOnce Installer” link, it will start the download and ClickOnce installer.

Note: The ClickOnce installer will launch only for Internet Explorer and FireFox (should you have the plugin installed). If you are prompted to download the application file, save this file locally and execute it to launch the ClickOnce installer.

Clicking on “Install” will install and launch the application.

Updating a ClickOnce Release

When you have a new version of your project to release, you should follow the same steps for publishing and preparing your ClickOnce application.

Note: Visual Studio should retain the URL that you previously specified during publishing.

When you are ready to upload the ClickOnce zip file, you have the choice of updating the current ClickOnce release or creating an entirely new ClickOnce release. The latter of the two will archive your current ClickOnce release automatically. Both choices will prompt your users to update the currently installed application on the next launch.

[Do you tweet? Follow me on Twitter @matthawley]

The information in this entry applies to project coordinators and developers that are using TFS with the Team Explorer client. If you are using Mercurial or a Subversion client, then nothing will change for you.

During the upcoming weeks we will be migrating all of the CodePlex TFS projects onto our new TFS 2010 servers. This upgrade will allow us to support new TFS features and provide increased server performance and reliability. The move will happen on a server by server basis, so expect each TFS server (TFS01 to TFS10) to be down for a few hours as data is migrated. Updates on when each server will be offline and an estimate on when they will be back online will be posted on our system outage page.

As part of this migration, the URL of your TFS server will change and this will require you to update your projects source control bindings. After your project has moved, instructions on how to connect with Team Explorer to the new TFS server can be found on the source control tab of your project under “Source Control Setup”. If you need help updating your source control bindings, you can view our detailed instructions online. Additionally, if you connect to your project using Visual Studio Team Explorer 2005, you will need to install the 2005 forward compatibility pack. If you connect using Team Explorer 2008, you will need to install the 2008 forward compatibility pack.

Finally, the TFS 2010 upgrade process checks two build templates files into your project under \BuildProcessTemplates. These templates can be removed safely as we currently do not support TF build.

I am pleased to announce the final release of PostSharp 2.0.

This release occurs almost one year after the initial prototype of PostSharp 2.0, and 9 months after the first public CTP. Since then, the number of monthly downloads of PostSharp 2.0 has largely exceeded the one of PostSharp 1.5. PostSharp 2.0 is already being used by dozens of commercial customers and all issues reported during the pre-release period have been addressed. Therefore, it’s with great confidence that I recommend everyone makes the upgrade from any previous version of PostSharp, including 1.5 and 1.0.

Why Upgrading from PostSharp 1.5?

PostSharp 1.0 and 1.5 made aspect-oriented programming (AOP) popular in the .NET community.

PostSharp 2.0 makes it mainstream by enhancing convenience (Visual Studio Extension), reliability (dependency enforcement), run-time performance (optimizer), and features (composite aspects, property- and event-level aspects).

New features of PostSharp 2.0 over 1.5 include:

• Visual Studio Extension – for easier code reading
• Composite Aspects (Advices and Pointcuts) – for more powerful aspects
• Adaptive Code Generation – for better runtime performance
• Aspect Dependencies – to prevent conflicts between aspects in large projects
• Interception Aspects for Fields, Properties, and Events
• Instance-Scoped Aspects
• Build-Time Performance Improvements

For a detailed list of these features, see What’s New in PostSharp 2.0.

How To Upgrade from 1.5?

PostSharp 2.0 contains a library called PostSharp.Laos.dll. This is an emulation layer, and is meant to be used during the migration of 1.5 to 2.0. When you’ll build your project, you’ll get a lot of obsolescence warnings. When all these warnings are gone, you can remove the PostSharp.Laos.dll reference from your project. It’s only after complete migration that you will see improvements in runtime performance.

What’s New Since RC2?

The following issues were fixed:

• Invalid code generation when two MethodInterceptionAspects are applied on a method containing an anonymous method.
• Invalid code generation for pointer types ('valuetype' or 'class' keyword missing)
• Invalid code generation when an interception aspect is applied to a method containing a '.constrained' prefix
• Invalid code generation when multiple MethodInterceptionAspects are applied to a generic method
• When a method-level aspect is applied to an interface, it is not multicast to interface methods
• ILASM failure with symbol sequence points with a document but without a column
• KeyNotFoundException from MulticastAttributeTask.ImportCustomAttribute

A small breaking change was introduced to solve some well-definedness issue with aspects applied on abstract methods: when applying an aspect to a type or member defined outside the current project, use:

• MulticastAttribute.AttributeTargetExternalTypeAttributes instead of MulticastAttribute.AttributeTargetTypeAttributes
• MulticastAttribute.AttributeTargetExternalMemberAttributes instead of MulticastAttribute.AttributeTargetMemberAttributes

Summary

I would like to express special thanks to all people who helped during the pre-release period and to all companies who acquired licenses before the product was labeled as stable. I highly appreciate your support, and have a great confidence in the future of PostSharp and SharpCrafters.

Where to go next from here is not yet decided, but we’ll be working quite soon on a minor release. Most importantly, we’ll start real marketing and we’ll scale the company by hiring the best developers we can find.

Happy PostSharping!

From today, it will be easier to use PostSharp 2.0 in open-source projects. Indeed, the revised license includes a limited, but quite universal, redistribution license: any user, even of the community license, has the right to redistribute PostSharp.

Redistribute means just that: copy, or upload on a public server. Of course, it does not mean that you can grant somebody else the right to use PostSharp – otherwise we could immediately file for bankruptcy. But it does mean that you can include PostSharp in your public source repository, so anyone can build your project without installing PostSharp separately.

Even better: Users of your OSS project will not need to acquire a license of PostSharp. They will just check out the source code and it will build.

How does it work?

If you own an OSS project and want to use PostSharp in it, contact me. Give a brief explanation of what your project does. Tell your root namespace and the strong name public key token.

If your project qualifies (it must not compete with PostSharp itself, obviously), I will answer with an assembly license key. This license key is is bound to your root namespace and your public key token.

Create a text file named PostSharp.license and paste the license key. Include this file as a managed resource in the project containing the aspects. From this moment, all aspects contained in your project (if the namespace and the public key match) will be authorized, irrespective of the license entered by the user.

That’s how things are solved from a technical point of view. For the details of the legal point of view, please read the revised license agreement.

Please comment here if you have any question regarding this license.

Happy PostSharping!

-gael

Good News First

I am happy to announce PostSharp 2.0 RC 2, available for download now. From this release, the low-level library PostSharp.Sdk.dll has now a class reference documentation and all APIes are frozen.

Apart from lack of SDK documentation, the feedback from RC 1 is excellent. The number of reported bugs was historically small.

And Now Bad News

I will probably annoy a lot of people with this release but I had to do it.  I originally wanted to document PostSharp.Sdk after the RTW of version 2.0. Documenting is typically the moment I discover inconsistencies and correct them, breaking backward-compatibility. So by postponing SDK documentation to the next release, I also would also have postponed the promise of forward possibility, and forced many users to stay with PostSharp 1.5. So I decided to do this API clean-up and class reference documentation now

When documenting, I figured out there was some mess in the namespace organization, since some low-level APIes shared the same namespace of high-level APIes. So I did some clean up there. This affects also PostSharp.dll.

Concretely, you’ll probably have to do a global find-and-replace of import statements. I believe it’s a matter of 10 minutes to do the changes. I apologize for inconvenience. I think it’s better for everyone to do this small change now than to drag a debt during several years.

Breaking Changes for Everybody

The namespace PostSharp.CodeModel and PostSharp.CodeModel.ReflectionWrapper has been merged into PostSharp.Reflection. This has pretty low impact; the following find-and-replace will do the trick:

Find what Replace with using PostSharp.CodeModel; using PostSharp.Reflection; Breaking Changes in the Low-Level API

Basically, all low-level namespaces have been moved under the namespace PostSharp.Sdk. For instance, instead of PostSharp.CodeModel you will have PostSharp.Sdk.CodeModel.The same for most namespaces contained in PostSharp.Sdk.dll (the exception is PostSharp.Hosting, which is not considered a part of the SDK).

Other changes

1. Added an aspect (ManagedResourceIntroductionAspect) that allows to introduce a managed resource
2. Solved a race in the pipe client.
3. Solved an issue where IAssemblyLevelAspect.CompileTimeInitialize is not invoked.
4. Solved issues with the “Update Avaibable” warning.

Happy PostSharping – and thank you for your understanding.

-gael

[Do you tweet? Follow me on Twitter @matthawley]

We deployed the latest version of the CodePlex software today.

Project Openings Enhancements

With today’s release, CodePlex users now have the ability to search for project openings across all projects. Prior to today’s release, a user looking to contribute to projects that were requesting help required knowing about those specific projects. This feature is not limited to just developers, but any resource a project could be looking for (ie, testers, designers, editors).

When visiting the CodePlex site, clicking on the Project Openings link will direct you to a listing of projects with openings sorted with the most recent openings first. What you’ll notice, is the layout is similar to the Project Directory, except that opening descriptions are displayed in green text above the project description.

Clicking on the “Join this Project” link will direct you to the homepage of the project with the request dialog open and ready for your submission.

Another difference you’ll notice is how tagging is handled with project openings. As a project coordinator, you can tag your project opening with specific keywords. When CodePlex users visit the project openings page, they can utilize the tags specified to refine the results.

Ad Format Change

For projects that have The Lounge ads enabled, you will notice that larger 300 x 250 pixel ads are being displayed on the project’s pages. Just as adding the larger ads to a downloads page, increasing the ad size across the project will dramatically increase the ad revenue for project owners to better support their project (or charity contributions to Habitat for Humanity Int’l).

Fork Actions on Changeset Listing Page

After the recent release of the ability to view a fork’s changeset listing directly within CodePlex, we wanted to make managing forks as easy as possible. With today’s release, all fork actions are now available directly on the changeset listing page. No longer will you need to jump back to the listing of forks to send a pull request, apply/decline a pull request, or even delete a fork.

Silverlight 4 Support

The CodePlex wiki has been upgraded to support Silverlight 4 by default. Existing Silverlight applications hosted on CodePlex should continue to work due to built-in backwards compatibility. Should you need to explicitly specify the version for your Silverlight application, add the “version=3” parameter to your macro (you can also specify “version=2”).

Today we are releasing MonoDevelop 2.4, which includes plenty of new features and improvements.

The release highlights are:

• Workbench usability improvements, which include a new Navigate to Symbol dialog, Solution and Class pad zooming, better pad layout, and many other look & feel improvements.
• Improvements in project management, with support for standalone assembly projects, and external console support for Windows and Mac.
• Extensive text editor improvements, including in-line search, better code completion with new completion modes, editing support in block selection mode, and new refactoring operations.
• In the debugger, support for pinned quick watches, debug value visualizers, improved expression evaluation and a new exceptions dialog.
• Better support tools, such as a new Hex Editor, integrated T4 Templating and more Code Metrics.
• For web developers: code completion for C# regions in ASP.NET pages, and support for WCF web references.
• Improvements in many other add-ins: NUnit, MonoTouch, Vala and Mac OSX support.

You will find a more detailed description of what's new in the What's new in MonoDevelop 2.4 page.

Binaries and source are available from the MonoDevelop Download page.

The team is on #mono, #monodev and #monodevelop on irc.gnome.org fielding any questions you might have.

Today happens to be my birthday. Since it has invariably happened every year for the last 32 years, this is no significant day. Expect that, 20 years ago, I was my 12th anniversary.

I became a teen and a geek at the same time.

I believe that every geek has a story to tell. A story about a passion. Here’s mine.

My First Computer Was a UNIX Server

My family was living in Kinshasa, Zaire at that time (1990).  School finished at noon, so we kids had plenty of time in the afternoon to enjoy an expat’s life. My father was IT director in the brewery Unibra. In Spring 1990, he ordered a department server for the operations of the company. The machine was supposed to serve many VT100 terminals.

When the package arrived, it turned out that it did not work. The computer itself was perfect, but the COM multiplexer did not work. Therefore, it was only possible to connect two terminals (one on each COM port) instead of a dozen. The computer was deemed useless and was to be returned to NCR for repair and diagnostic. I don’t remember if the computer came by boat or by air, but you can imagine that shipping a 30-kg high-tech box from US to Kinshasa and back is not cheap. So instead of having the machine sent back, NCR offered a good discount and my father could buy it for personal use.

This department server became my first computer. It had a 25 MHz 80386 CPU, 4 MB of RAM and 100 GB of SCSI disk. At that time, 8 MHz / 640 KB / 20 MB was still the norm on the consumer market, so I became the principal user of a very high-tech toy. Yet, the most amazing piece was not its hardware but its software: NCR Unix. A real 32-bit operating system (the first 32-bit OS of Microsoft, Windows NT, was first released three years later). A real multi-user and multitask system! The most amazing of all components was VP/IX, an MS-DOS emulation package for UNIX, which could execute multiple instances of MS-DOS inside “virtual machines” running in virtual 8086 mode. The UNIX file system was accessible through MS-DOS virtual network drives.

The BASIC Years (12-13)

I started my first programs almost immediately. Weeks before receiving the computer (even before I knew we would get one), I started writing my first program on paper. I think my teacher at school was happy about that: I was so busy programming during class hours that I had no time to disturb my classmates any more. The program was a memory card game written in GW-BASIC (the well of Microsoft’s fortune), adapted from a listing I found in the fascinating techie magazine Science & Life Junior. Since MS-DOS had no decent editor, I typed it in VI. Most surprisingly, it worked. Oh, maybe not the first day, but probably the first week.

I spent most of the afternoons of my 13th year programming, to great despair of my parents hoping some healthier activities.

I soon received the book “The PC Bible – System Programming” (probably a suggestion of my uncle and geek Francois Carlier), covering hardware, DOS and BIOS programming. I read it during a couple of hours every day in near-dark when my parents thought I was in bed (for my defense, I was in bed). At the age of 13, I probably had a complete understanding of PC system programming (it was, arguably, still an achievable task in system as small as MS-DOS 3). Tim Paterson became my hero, while other kids were playing football and discussing about pop stars I’ve never heard of. Bill Gates? Probably a businessman, not a hero of any kind. That’s what I still thought 2 years ago.

"With all the code being written out there, who gets the credit? People like Bill Gates get it all and he hasn't written anything in years!" – Tim Paterson, 1983

This big book was in French. But the UNIX documentation was not, of course. It’s something US geeks may easily overlook but… we other geeks had to learn computing from books written in a language we did not speak a word of! I eventually had my first English lesson at the age of 13.

I figured out that virtual 8086 mode is not cool enough, created a DOS boot floppy, a DOS partition, and let UNIX aside. In the process, I erased the partition table a couple of times. I wonder if my father was really angry, but when it happened for the third time, I was so afraid that I installed UNIX from floppy disks. At the age of 13, without knowing English. I could probably congratulate UNIX engineers.

My mother and kids were repatriated by the Belgian and French paratroopers during the so-called “October 1991 events”. We could take with us anything we could bear. Since the computer and the monitor were probably heavier than me, they staid. It eventually came back to Belgium by boat six months later.

Fortunately, I received some older “laptop” with two 3.5” disk drives and MS-DOS 5.0. I wrote my first commercial software there, a management tool for a school library (where I “invented” the bubble sort), sold 10$ to my uncle who was school director. This piece of software, written in 1992 by a 12-years-old kid, was still reported being used in production in 2003.

The C Years (14-16)

Very soon, I wanted to evolve from BASIC. So, Pascal or C? Pascal was for students, I thought, and C for professionals. So I learned C. Kids’ vanity is amazing – but armless, and driving. I got a copy of Borland Turbo C 2 from my uncle (I have to apologize today: all these copies were illegal!). I bought, this time, a copy of “Undocumented DOS” (Addison-Wesley, 1993), wrote the infrastructure for Terminate-and-Stay-Resident (TSR) program that was more stable than SideKick itself, then dropped the project because the funny part was done.

I played with Borland Turbo C++ 3 too, did some Windows programming, but never became an ace in OWL neither in Windows. Even today, my knowledge of MFC and ATL is very superficial.

The PowerBuilder Years (16-17)

My father maybe figured out that I should start doing something useful, and bought me a copy of PowerBuilder 4. I have still an enormous admiration for this piece of software and its companion, the amazing Watcom SQL. Productivity was really impressive compared to C++, and possibilities huge compared to Paradox (we had the Quattro Pro / Paradox package too).

Indeed, I started doing something useful. This is, again, a story of vanity.

My English teacher whispered me after some class: “Gael, would your skills be sufficient to develop a note-managing software?”. The question was so elegantly formulated that I could only jump into development. I did some analysis, I read Codd's rules of database design at this time. It took me the summer to deliver the first version. (Again - coding ten hours a day when folks were flirting or pursuing other activities typical to their age.)

This first was a catastrophe and a revelation. This is where I learned what a user is. I learned what a user interface is. I learned that users don’t care about what’s inside the box, they don’t even care about features, they want a tool that help them getting their job done. It took me another year to have it right. The software was used by a dozen of teachers during five years. It was a classic client-server application typical of the late 90’s, with a central Watcom/Sybase database. Teachers could work at home with a subset of data and integrate their changes to the central database by replaying the transaction log. I think there were reasons to be proud about this application: it was addressing a concrete problem in an efficient and reliable way. Teachers Jean-Luc Goffeau and Benoit Cordy, as well as the retired engineer Francis Lagas (I’m not sure I can still spell all names correctly), offered me a lot of help and support in this effort.

We did try, with Benoit and Francis, to sell our solution. We managed to have some interviews and demos with government officers and industrials. I was present in a contest for young programmers in Poitiers (as you can imagine, with such a boring application, I won strictly nothing). We did not sell anything. Even then, the reason was pretty clear: the system was too difficult and expensive to operate, requiring an SQL server in every school. It was before “Software as a Service”, and, as it happened, many internet-based solutions appeared in the 2000s.

The University Years (18-22)

University marks the end of the first act in my passion.

I was quite lucid I would make a career in computers whatever I study, so I chose to take a break. I studied engineering (“polytechnique”) at the University of Louvain, but I did a major in mathematical engineering instead of computer science.

Having spent most of my previous 6 years with computers, I do not regret this choice. I studied two minors in philosophy, took as much as non-engineering classes I could. Attended lectures the less I could. Drank lots of beers during my first 3 years and spending my last 2 years representing the interests of beer-drinkers to the university vice-rector Gabriel Ringlet, became one of the forest student negotiators, with a couple of achievements I never forget to narrate every time I meet a fellow student.

Yet, I hardly found time for programming. The only exception was the last year, where I wrote a hot strip mill simulator in Matlab (actually, Octave) with some parts in C. I learned Linux/Debian at that time, but never really felt in love for it.

The Dark Years (23-28)

I have always feared to get bored. For me, pursuing an an engineer’s career had no appeal, probably because there’s too much determinism there. So when I met my wife, it was not a difficult decision to move to Czech Republic. It was now or never – it’s too hard to cut lifestyle when you’re used to one, so it’s better to start with a low one just after study. So we did.

I was not disappointed by the difficulty of the situation I put myself into. I did not know Czech well at that time, and they seemed to ignore that I had the best technical diploma available (as we were repeated at faculty). I did not have any social network.

I was lucky enough to find a job in Newlink, a small Flemish web shop based in Prague. I soon figured out that the shop was too small and left after 18 months. In the meantime, I pushed ASP.NET 1.0 in the company.

After a couple of small iterations, my fate got into the hands of Adastra, a consulting company – I now call that a body shop. They sold me to Oskar, a mobile telecom operator, where I was asked to code business processes in PL/SQL. I became fairly good in programming large Oracle databases, and discovered that just the scale makes an apparently trivial problem much more difficult – and interesting – than expected. Then I became a TIBCO programmer, which gave me a good insight on distributed architecture.

I learned important things in Oskar. I learned professionalism. It’s shocking to program a telecom offer, know it’s being released during the night, then the next morning see the billboards in the street. No right to error. No right to delay.

I lived the metamorphosis of a startup (Oskar) into a corporate (acquisition by Vodafone). It was stunning to see how the cost structure was steadily increasing, the efficiency of the IT department constantly decreasing.

I have enormous respect for the tools developed by my predecessors and superiors Filip Kubec, Jakub Adamczyk and Karel Kalivoda during the early days. They were of an elegant simplicity and solved the problem they addressed. I have much less admiration for the culture of bureaucracy, sycophancy and machismo that progressively replaced the “agile” culture of the first days.

These 3 years spent in Oskar then Vodafone were synonyms of frustration. My political failure was almost complete. I could not accept this culture where everybody had to lie (by filling in false information in timesheets) to protect the career of our directors and VPs. I have never been able to work with yes-men, neither to shut up when witnessing technical aberrations. Yet, with some years back, I think we managed to achieve some good work given the rotten environment we had to work in.

It was the time I started to write PostSharp in my spare time.

I have already written about the history of PostSharp itself and the objectives I had when starting the project.  One of these reasons is that I got the impression – right or wrong – that I stuck again with career determinism. Having understood how “consulting” works, I saw no bright perspective for a Belgian programmer in Czech Republic. All desirable career paths – as I perceived them at that time – were blocked due to my still-non-perfect Czech and, probably more than I admit, my lack of sense for political compromise. PostSharp was due to raise my international visibility and get me out of the rabbit hole I got into.

I eventually left Vodafone in Spring 2007 with an indemnity which allowed me to start as a freelancer.

The Freelance Years (29-30)

My objective during this period was to consult 60% of time to have 40% of time available for PostSharp. It supposed I could invoice 165% of the usual consulting rate in Czech Republic, which I have been able to achieve most of the time.

I first contracted for Good Data in their very early days during 3 months. My only objective was to work with the serial entrepreneur Roman Stanek to see and understand how a start-up work. Without knowing why yet, I though this guy was good to know – indeed, he became an investor in SharpCrafters 2 years after. I was ready to everything just to learn out something about the business of software.

Yet, the rate did not allow me to reach my 60-40 objective, so I started working on a regular basis for Starcounter.

I spoke at several conference and user groups in Europe during this time. PostSharp made huge progress. I could stabilize and release PostSharp 1.5. Yet, I found out that 40% of paid time was not enough to maintain and develop the software. After an unsuccessful attempt to sell support on PostSharp (still released as OSS), I came to the conclusion that I needed to make it a fully commercial product.

SharpCrafters (31-?)

The development of PostSharp 2.0 started in March 2009. It took more than one year to build the product and the company behind it.

Spring and summer 2009, when I designed and prototyped the aspect framework of PostSharp 2.0,  was a period of extraordinary creativity. The abstractions behind what you can see in PostSharp.dll are brilliant; the idea to use graph theory to address aspect composition was innovative. There’s probably no achievement I am more proud of than this aspect framework, written in 3 months (then tested in 6 weeks and stabilized in 6 months…).

Today, PostSharp 2.0 is technically completed. Customers started to buy it. Cash flow is positive. Now I have to build a team that will further maintain and develop PostSharp, and create other products. A fully different story.

Taking Great Hackers Out Of Corporates

Why productivity sucked so much in Vodafone remained an enigma for me till very recently. Why was I so bad there and so great here? During a couple of years, my explanation was bad management. There was a bunch of talented people there, but they are strangled by bad management, stressful environment, and rotten culture. Lately, I have been proved wrong and naive. Management may explain a difference of productivity of 30%, not of 500%.

I now believe I severely underestimated my own talent. It’s not that people in corporate are bad; they were actually pretty good in Vodafone. There may actually even be gems in corporate, as I and probably other were. The problem is that corporate environment gums differences in technical talent so that nobody can make the difference between a good programmer and what Paul Graham has called a Great Hacker. Since great hackers don’t stand out (or even underperform, as I did), “just” good programmers look comparatively better than they actually are. So you won’t make a great start-up team out of programmers who were “just” good in corporate environment. Only great hackers, those who underperform in corporates, may multiply their productivity in a different environment.

It’s only lately, by reading books on the software of business by Spolsky and Wink, that I realized I was a great hacker and could be proud of it. Before that, I only thought I got some abnormal teen age and I never mentioned that I wrote my first program at the age of 12. Yet, now, it’s the first question I would ask to any candidate.

Between Talent and Pathology

I once attended a conference about psychoanalysis at university, and the lecturer told something I will always remember: psychopathologies are common in normal life; most of the time, psychopathologies positively translates into a choice of profession. Sadist can be great doctors. Melancholic can be great musicians. Only exceptionally does a pathology translates into a criminal or suicidal behavior.

Are great hackers psychopaths? I think so. Any talented artist, crafter, scientist, doctor, teacher, anyone who devotes himself to his profession obsessively enough to become great, must have some psychopathology.

A psychopathology is something you’re born with, or you are taught by your parents when kid. In one way or another, you inherit the pathology. You can’t choose. The only thing you can choose is how you will use that pathology: will you strangle it and become average and frustrated, or will you unleash it and become talented?

Looking to my near family, I can clearly see points converging to me. From the 4 boys of my father’s family, two excel in obsessive activities (one is champion of Scrabble and the second builds family trees going back to centuries), and three are entrepreneurs or freelancers. From the 3 girls of my mother’s family, 2 have contemplative activities, their father is a PhD and his brother was the rector of a business university. You have all the ingredients converging to PostSharp: a 5-year obsessive, highly intellectual and entrepreneurial effort.

Fortuity? I don’t believe so. Pathology turns into talent just as caterpillars metamorphose into butterflies.

Summary

This post was exceptionally long; I probably violated all rules about blogging, starting from: not talk about yourself. I hope I have been able to communicate reflections that are not specific to myself and, hopefully, will resonate with what you’re living every day. Next time in 20 years. Please apologize me this one.

I am pleased to announce PostSharp 2.0 RC 1, available for download today. This is a real release candidate: it could be promoted to RTW if community’s feedback is good. The last CTP proved very stable (only a couple of major bugs have been reported), so I am very confident with this RC.

People, now it’s seriously time to migrate from PostSharp 1.5 to 2.0. I’ll blog about it next week so you won’t have any excuse!

What’s New in this RC?

• Documentation!
• Fixed support for Code Analysis (FxCop)
• Easier configuration using files PostSharp.Custom.targets.
• Streamlined license configuration and checking.
• Happy Monday. Users of the community edition will figure out next Monday.
• Add methods GetValue/SetValue to class LocationInfo
• SDK: support for moving declarations from one parent to another

Bug Fixes

This release fixes the following issues:

• MethodInterceptionAspect: local variables not visible in the debugger    
• Native host: access to AssemblyReferenceList cache should be synchronized    
• Support for assembly key revocation    
• The MSBuild task should clean the license key before adding it to the command line    
• ImportMemberAdvice may import the wrong implementation if Order=AfterIntroductions   
• EventInterceptionAspect does not work for delegates returning a value   
• Possibility to move a declaration from one parent collection to another    
• AssertionFailedException in InstructionBlockBuilder    
• GUI feature allowing to disable the evaluation period expiration message    
• OnMethodBoundaryAspect throws InvalidOperationException    
• PathTooLongException thrown during license checking    
• Reference assemblies passed through file name (not directory) are not found   
• MethodExecutionArgs.Method is set to the generic method definition instead of the generic method instance   
• Optimization of OnMethodBoundaryAspect may cause unwanted sharing of MethodExecutionTag    

What’s Next?

I consider my job is done with PostSharp 2.0. I’m confident I’ll publish the RTW in early July. I should be able to provide hot fixes very quickly (even next business day) during the next 30 days.

Now that the product is finished, it’ll be time to temporarily remove my programmer’s hat and focus on two essential activities: marketing and hiring. If you know a sharp crafter, I want to hear from him :).

Happy PostSharping!

-gael

There are tasks you never know when you are done with. Documenting a complex API is one of those. I spent the last 6 weeks working on PostSharp 2.0 documentation, and it seems like I could spend another month on it. Yet, I think the result is already better than good enough – it’s actually pretty good. It’s available online here:

http://doc.sharpcrafters.com/

Note that the documentation refers to the last hot fix (1266+). Some features or APIs may not be available in the last CTP.

Inside the Book

The documentation is structured in two principal parts: deploying PostSharp, and developing with aspects.

The first part starts where the setup program stops: development environment may be very complex; deploying development tools to a large team may be very challenging. This chapter is based on my experience of supporting customers during last months. Special thanks go to Roy Osherove of TypeMock, who patiently went through all imaginable problems. His feedback prompted me to make deployment easier and to seriously document it. Thanks to all folks who reported issues or simply questions on the forum.

The second part is about aspect-oriented development itself. If you thought you knew everything about PostSharp, read this chapter. This is where you can contemplate the robustness and consistency of PostSharp 2.0 design. It’s elegant. Intelligent. Well-crafted. I’m proud of it.

Credits

Apart from Roy mentioned above, I would like to express my gratitude to two projects and the guys behind:

• Eric Woodruff’s Sandcastle Help File Builder (SHFB) is wonderful. I deleted my 4-years old Sandcastle custom build scripts and switched to SHFB in a couple of hours. Writing content in MAML rocks. Thank you Eric for this excellent work!
• Help Server of X-tensive.com is a superb product. You can judge by yourself on http://doc.sharpcrafters.com/. It’s a commercial product, but it’s definitively worth the money. Thank you Alex and team!

What’s next?

The documentation was the last big task to complete before the release. The rate of bug reports has dramatically decreased since the last CTP. So you can expect the RC very soon, hopefully next week.

Note: If you are still using PostSharp 1.5 and are not registered yet on our web site, do it now. Once PostSharp 2.0 will be RTWed, PostSharp 1.5 won’t be available any more for new users.

Happy PostSharping!

-gael

I’m pleased to announce that TestDriven.Net 3.0 is now available. Finally! I know many of you will already be using the Beta and RC versions, but if you look at the release notes you’ll see there’s been many refinements since then, so I highly recommend you install the RTM version. Here is a quick summary of a few new features:

Visual Studio 2010 supports targeting multiple versions of the .NET framework (multi-targeting). This means you can easily upgrade your Visual Studio 2005/2008 solutions without necessarily converting them to use .NET 4.0. TestDriven.Net will execute your tests using the .NET version your test project is targeting (see ‘Properties > Application > Target framework’).

There is now first class support for MSTest when using Visual Studio 2008 & 2010. Previous versions of TestDriven.Net had support for a limited number of MSTest attributes. This version supports virtually all MSTest unit testing related attributes, including support for deployment item and data driven test attributes. You should also find this test runner is quick. ;)

There is a new ‘Go To Test/Code’ command on the code context menu. You can think of this as Ctrl-Tab for test driven developers; it will quickly flip back and forth between your tests and code under test. I recommend assigning a keyboard shortcut to the ‘TestDriven.NET.GoToTestOrCode’ command.

NCover can now be used for code coverage on .NET 4.0. This is only officially supported since NCover 3.2 (your mileage may vary if you’re using the 1.5.8 version).

Rather than clutter the ‘Output’ window, ignored or skipped tests will be placed on the ‘Task List’. You can double-click on these items to navigate to the offending test (or assign a keyboard shortcut to ‘View.NextTask’).

If you’re using a Team, Premium or Ultimate edition of Visual Studio 2005-2010, a new ‘Test With > Performance’ command will be available. This command will perform instrumented performance profiling on your target code.

A particular focus of this version has been to make it more keyboard friendly. Here’s a list of commands you will probably want to assign keyboard shortcuts to:

Name Default What I use TestDriven.NET.RunTests Run tests in context   Alt + T TestDriven.NET.RerunTests Repeat test run   Alt + R TestDriven.NET.GoToTestOrCode Flip between tests and code   Alt + G TestDriven.NET.Debugger Run tests with debugger   Alt + D View.Output Show the ‘Output’ window Ctrl+ Alt + O   Edit.BreakLine Edit code in stack trace Enter   View.NextError Jump to next failed test Ctrl + Shift + F12   View.NextTask Jump to next skipped test   Alt + S

 

By default the ‘Output’ window will automatically activate when there is test output or a failed test (this is an option). The cursor will be positioned on the stack trace of the last failed test, ready for you to hit ‘Enter’ to jump to the fail point or ‘Esc’ to return to your source (assuming your ‘Output’ window is set to auto-hide).  If your ‘Output’ window isn’t set to auto-hide, you’ll need to hit ‘Ctrl + Alt + O’ then ‘Enter’. Alternatively you can use ‘Ctrl + Shift + F12’ (View.NextError) to navigate between all failed tests.

 

For more frequent updates or to give feedback, you can find me on twitter here.

I hope you enjoy this version. Let me know how you get on. :)

Do you know how PostSharp is popular in your region? I just put online a map showing the number of PostSharp users per square inch in the world.

 http://maps-sharpcrafters-com.s3.amazonaws.com/users-2010-04/googlemaps.html

(I don’t give you absolute number of the color scale – I don’t know it myself -- so you can think the number-of-users-per-square-inch is a relevant unit.)

How I built this map

The map is constructed from web server logs, but I find it much more useful than anything I could see before. Google Analytics construct map overlays by drawing circles of different radius; since these circles largely overlap, it’s very difficult to get an idea of the real distribution of users.

This map has a strong mathematical foundation: it shows the Gaussian distribution of users in the world.

I used the following steps:

1. Start with IP of users, visitors, …
2. Map the IP to a geo location using GeoIP Free.
3. Associate each IP with a Gaussian distribution. Choose a small radius for precision, larger to see trends (here it’s pretty large). Note that computing the distance of a point from another, given their longitude and latitude, is not trivial.
4. For each point on the map, sum all distributions, then normalize.
   This results in a function [-180,180]x[-90x90] –> [0, 1].
5. Map the value to a color/opacity space, store it as PNG.
6. Use MapTiler to generate an overlay for Google Maps.
7. Upload it. I’m done.

Interesting findings

The proportion of PostSharp users is of course highly correlated to the demographics and the economics of the area itself. So the density of users in Europe is higher than in the USA, but there’re still more users in the USA than in Europe.

The map shows peeks in London and Taipei; Netherlands have a lot of PostSharp fans too. Germany has large areas of average densities, which suggests that German software development is less concentrated in cities than in other countries. A good thing. New-York is the home of may PostSharpers too. I would have loved to see a peek in Seatle, but…

Two deceptions: France and Japan.

And one good surprise: Bermuda.

Folks in Bermuda, I am offering you 1 week of free consulting – just pay T+E :).

Enough. I still have to finish the doc and finish 2.0.

Happy PostSharping!

-gael

[Do you tweet? Follow me on Twitter @matthawley]

We deployed the latest version of the CodePlex software today.

Multiple Project Downloads

With today’s release, CodePlex users now have the ability to set multiple default releases for their project. The primary usage for this feature is for projects that are jointly developing and distributing pre-stable versions while still maintaining a current stable release. When creating or editing a release, you are allowed to set that release as a recommended release. If you currently have a recommended release, you’ll be prompted to either add to or replace the recommended releases.

When multiple default releases are active, and a user visits the Downloads page, they are shown a listing of the recommended releases. This view will allow them to see high-level information regarding each release and quickly download file’s associated with a particular release. The most recently created project will show first.

Another feature that was added, was the ability to not have any recommended files for a release. This is very helpful for applications that distribute multiple downloads, all of which have no more importance over the other. A primary use for this, is if a project distributes both an x86 and x64 version of their application – neither of which should be the recommended release as it requires a decision by the downloader.

Wiki Enhancements

A long requested feature (currently #3 most requested), deleting wiki pages has been added! We have also simplified creating new wiki pages. When viewing a wiki page, you’ll now see two new sub-menu links.

Clicking on “Create New Page” will take you to a page allowing you to supply a title and wiki markup. After saving, you can link to this page from any other page by using the inter-wiki link syntax [Page Title].

Clicking on “Delete”, will do just that. Any wiki page children of the page you’re deleting will be moved to the deleting page’s parent. All history, comments, and attachments will be permanently destroyed.

Forks on User Profile

Lastly, a new feature that was added is the ability to view a CodePlex user’s forks across all projects easily. When you visit a user profile page, the listing of forks is displayed on the right hand side. Clicking on the fork’s name will bring you to view all of the forks change sets. 

We are extremely happy to announce Mono Tools for Visual Studio 2.0 Beta 1! (MonoTools)

Mono Tools for Visual Studio is a commercial add-in for Microsoft Visual Studio 2008 and Microsoft Visual Studio 2010 that enables developers to build, debug, and deploy .NET applications targeting Mono without leaving Visual Studio.

MonoTools 2.0 is a major upgrade from MonoTools 1.1, bringing many new features:

• The Mono soft debugger, for more reliable debugging
• Server profiles, for easier deployment options
• Compressed deployment for faster copying to server
• Full Run/Debug support for Linux, Mac, and Windows

Full details of these features can be found in the Mono Tools for Visual Studio 2.0 Release Notes.

You can Download the 2.0 Beta of Mono Tools for Visual Studio, as well as fully preconfigured Linux VMware or Virtual PC images, from the Mono Tools for Visual Studio download page.

To purchase Mono Tools for Visual Studio, visit our store

I am pleased to announce the release of PostSharp 2.0 CTP 5 (build 1199). This is the final CTP, and could have been a release candidate if the documentation were finished. This release is feature-complete and has reached a good level of reliability.

This CTP was silently released last week and updated since two major bugs were quickly discovered. Those who already downloaded a previous revision of this CTP should upgrade now.

What’s New in this CTP?

Support for .NET 4.0 and Visual Studio 2010 RTM

PostSharp 2.0 now supports the final version of .NET 4.0 and Visual Studio 2010.

Support for Windows Phone 7, Silverlight, and Compact Framework

PostSharp 2.0 now supports the following platforms:

• Microsoft .NET Framework 2.0, 3.0, 3.5, 4.0
• Microsoft .NET Compact Framework 2.0, 3.5
• Microsoft Silverlight 3.0, 4.0
• Microsoft Windows Phone 7 (both Silverlight and XNA),
• Novell Mono 2.6.

Well read: PostSharp now supports Windows Phone 7!

Support for serialization

Aspects are now correctly initialized when an object is deserialized by the old good BinaryFormatter or by WCF formatters.

Access from user code to binding classes

This release has a somewhat cleaner code generation, and aspects now have direct access to binding classes created by PostSharp. Binding classes allow you to invoke the next node in the chain of invocation even outside the lifetime of an advice. (This is quite hard core; I’ll document it later.)

Merge from PostSharp 1.5 SP1

This CTP contains all the bug fixes (including regression tests) from PostSharp 1.5 SP1.

46 bug fixes

• COMException from EnvDTE.Project.get_ConfigurationManager()
• ArgumentException when getting EnvDTE.ActiveConfiguration from ProjectWatcher.UpdateSymbolPath
• NullReferenceException in QuickInfoTracker.OnMouseMove
• InvalidCastException in CSharpLanguageAdapter.VisitPropertyAccessor
• Disable logging in release build.
• Should raise a warning when an aspects has a serialized field of type FieldInfo
• When an OnMethodInvocation aspect is applied on a non-const method of a struct, modifications are lost
• Make it possible to add aspects to unmanaged (native) methods
• Exception: The located assembly's manifest definition does not match the assembly reference
• Tracing of DotNet20Platform.GetSymbolReader must be improved
• Issues when assemblies to be processed are located in the GAC
• "An item with the same key has already been added" thrown from ModuleDeclaration.WriteILDefinition
• Support for ASP.NET is broken
• Build processed stopped in unattented sessions because of the tray icon
• Licensing component throws System.ArgumentException
• TypeLevelAspect.RuntimeInitialize is not invoked
• Bug in the example NotifyPropertyChanged
• Clueless error when trying to apply an interception aspect to an abstract method
• MulticastAttributeTask ignores attributes of properties
• Advice Analyzer throws a NullReferenceException when the method to be analyzed is abstract
• ArgumentOutOfRangeException in LayerRanker.GetRank
• NullReferenceException in PostSharp.VisualStudio.VsPackage.BeginInvoke
• InvalidOperationException in CodeElementVisitor.GetEnhancedCodeElement
• Integration problem with Resharper: Resharper removes PostSharp QuickInfo content
• Static constructor of the MSBuild task may crash when hosted in Visual Studio
• It should be forbidden to add instance-scoped aspects on a value type
• MethodPointcutEngine throws "ArgumentException: You have required a generic definition, but you have passed a generic instance."
• Add property LocationInterceptionArgs.LocationName
• Refactor HandlerProviderTransformation and other mechanisms behind advices/pointcuts.
• The CLR host should not automatically consider an assembly as CLR-loaded if it's in GAC
• Win32Exception in PostSharp.VisualStudio.HWndDispatcher.BeginInvoke
• DocumentInfo.GetDocumentInfo should return null when the document is not C#
• COMException thrown by EnvDTE.CodeElements.GetEnumerator
• Emit a performance warning when PostSharp is executed on an assembly without aspects
• Conflict when the same user opens a privileged and non-privileged pipe server
• Invalid serialization of type values into custom attributes member: assembly name missing
• Multicast inheritance does not work when a type inherits a generic interface defined in a different assembly
• Adornment layer not displayed in Visual Studio 2010 RTM
• Native host: aspects can't call Assembly.Load with a partial name
• Install the license key directly in registry
• PostSharp removed from Custom.After.Microsoft.Common.targets during upgrades
• VsPackage.GetServiceFromBackgroundThread throws InvalidCastException
• Attempt to use two adornment layers when symbol file is updated
• Licensing UI should close pipe servers automatically
  License or exception dialog box may cause MSBuild to hung
• Methods GetUniqueName may cause infinite loop

Roadmap

As I said, this is the last CTP. I am quite confident in the quality of this release, but it still needs to be tested by the community. The reason is that I can’t think about all the possible situations and combinations (I can only test what I expect). I am generally able to fix a bug within 1-2 days if I can reproduce it, so you don’t have to be afraid.

I’ll now spend most of my time in writing the conceptual documentation. I’ll upload frequent updates on http://doc.sharpcrafters.com/postsharp/2.0. The offline documentation is currently unavailable while work is in progress.

If everything goes right (as I expect), the first release candidate will available early June and the RTW may be released late June, depending on the feedback of the RC.

Happy PostSharping!

-gael

[Do you tweet? Follow me on Twitter @matthawley]

We deployed the latest version of the CodePlex software today.

Application Analytics

With today’s release, CodePlex users now have the ability to instrument their applications to get analytics on their runtime usage. CodePlex has long offered reports on what user activity occurs on the project website, but what happened after the user downloaded the software was unknown. Now, using this new application analytics capability, CodePlex users can see information such as how many people are using the application.

This capability is provided by the new Runtime Intelligence Service from PreEmptive Solutions. The Runtime Intelligence Service allows for developers to inject usage instrumentation directly into application binaries. When the application is run by an end user, the instrumentation will collect analytics data from the application. No personally identifiable information is ever collected and applications can include opt-out dialogues.

CodePlex users instrument their .NET applications via the latest release of Dotfuscator Software Services Community Edition included in Visual Studio 2010. Application analytic reports will then be available on CodePlex from the project statistics page with the ability to view more advanced statistics through a portal hosted by PreEmptive Solutions.

Getting started with instrumenting your application is easy. PreEmptive Solutions has created a sample application and a very thorough walkthrough that demonstrates this process. Once you have instrumented your application, you will need to link your CodePlex project to your Runtime Intelligence Service Application ID (which was created in the first step in the walkthrough). As a project coordinator, edit the project details and enter the value as shown below.

Should your startup / shutdown instrumentation mean something different, you can change the display name, which will be used instead of “Application Runs” when viewing the statistics in CodePlex. After you save these settings, CodePlex will begin importing the application runtime usage on a daily basis.

Browsing Forks

Also with today’s release, you now have the ability to browse a fork’s source code similarly to browsing a project’s source code. When you view the listing of forks, each fork name is now clickable.

Upon clicking the fork name, you’ll be taken to a familiar change set listing page. From there, you can view change set details, browse the fork’s source code, and download the individual change sets just as you would for a project.

There are two ways you can develop ASP.NET projects with Visual Studio: ASP.NET Web Applications and ASP.NET Web Sites. The difference between these two variants of ASP.NET projects lays in the way the way the “code behind” is built:

1. In ASP.NET Web Applications, the code behind is built by Visual Studio using MSBuild.
2. In ASP.NET Web Sites, the code behind is built by ASP.NET itself, or precompiled by the ASP.NET precompiler aspnet_compiler.exe.

Historically, it has always been possible to use PostSharp with ASP.NET Web Applications since PostSharp naturally integrates with any MSBuild project.

Things have been more complex with ASP.NET Web Sites. I developed an assembly post-processor that hooks into the ASP.NET build process and calls the PostSharp command-line utility just after the C# compiler. It worked – as a hack may work: sometimes, in best cases.

But there are good reasons not to use PostSharp with ASP.NET Web Sites:

• Performance issues: You probably don't want to load the CPU of your build server by an extra build step. Remember that PostSharp is about 10x slower than the C# compiler itself. If you want your web sites to start in reasonable time on web servers (where CPU is usually scarce), refrain for using PostSharp this way. Workaround: use precompiled web sites.
• Licensing issues: PostSharp is licensed for uses by developers. PostSharp does not offer a single license for use on web servers. If you're using PostSharp on a web server, you're probably breaking the license agreement. Workaround: use precompiled web sites.
• Functionality issues: Unlike ASP.NET Web Applications, which are built into a single assembly, the ASP.NET Web Sites build pipeline breaks a single web site into multiple small assemblies. This may break some PostSharp functionalities.

So I had to take a decision with this, here it is:

The use of PostSharp 2.0 with ASP.NET Web Sites is officially unsupported by SharpCrafters. Unofficially, we released the assembly post-processor on CodePlex as PostSharp4AspNet under the permissive Ms-PL license, so you can still use it at your own risks. But you have been warned.

Happy PostSharping!

-gael

[Do you tweet? Follow me on Twitter @matthawley]

We deployed the latest version of the CodePlex software today.

Upgraded to .NET 4

While normally we wouldn’t mention an infrastructure upgrade, we decided that with the recent launch of .NET 4, our more technical audience wouldn’t mind knowing that we are constantly evolving. In fact, we have been running prior beta, escrow and release candidate builds of .NET 4 for several months now. Along with this, we have also upgraded to ASP.NET MVC 2.

Change Set Listing

Another requested feature from our users has been to view the listing of files that have been added, modified, or deleted in a particular change set.

With this page, we are finally highlighting an existing (but rarely known) feature, viewing a diff of the file. The “view diff” link will be present for edited files, and will open a new window with the difference view. To see this in action, view a change set for WikiPlex.

The difference engine (DiffPlex) was built-in house by Matt Manela and is available as an open source project on CodePlex.

Mono Tools for Visual Studio 1.1 has officially been released, containing several of the most requested features, as well as many bugfixes.

Mono Tools for Visual Studio is a commercial add-in for Microsoft™ Visual Studio™ that enables developers to build, debug, and deploy .NET applications targeting Mono from within their preferred IDE.

Along with many bugfixes and small enhancements, the Mono Tools 1.1 update features the following improvements:

• Smarter Remote File Copying
• Automatically Detect Future Updates
• Preview of Visual Studio 2010 Support
• Easier Packaging of Precompiled Web Applications

More details regarding this release can be found in the Mono Tools for Visual Studio 1.1 Release Notes.

You can Download a free, fully-functional 30-day trial of Mono Tools for Visual Studio, as well as fully preconfigured VMware or Virtual PC images, from the Mono Tools for Visual Studio download page.

To purchase Mono Tools for Visual Studio, visit our store