Hadi Hariri

Last Post

2012-04-10T18:03:00Z

I was invited to join Devlicious a few years ago by Jak and Brendan and very thankful for the opportunity. During this time, I have cross-posted some of my posts on both my personal site as well as here, and have found that as a result, conversations become segregated; somewhat expected.

As grateful as I am of the the privilege of being part of this great community, I value greatly conversations that arise from posts, and prefer to keep them in one place. It is easier for me, as well as you, dear reader. For this reason, I'll no longer be posting on here. If you'd like to continue the conversations, find me at my blog. I'd love for you to join the recent one about Dealing with Too many dependencies.

Once again, thank you to Jak, Brendan, and the entire Devlicious community, including my fellow bloggers. And most importantly, thank you.

Submit a patch

2012-02-06T16:56:08Z

We love to complain, and Twitter has just made is so much easier. By merely including a handle or keyword of some company or product, we can attract the attention of those we’re moaning about and have them run to try and solve our problem. The speed at which they run is proportionally direct to the number of followers we have or the ‘people we know’ (I have 10 followers but my best friend is a celebrity with 300K followers and RT’s anything I ask him to). Apparently it’s called Social Media Damage Control.

When it comes to software products, we’re quite good at it too. After all, that’s why we pay for software, to have someone to hear our roar on the other end of a phone, a forum or a twitter handle.

But that only applies to commercial software.

When it comes to OSS however, it seems different rules apply. Specially when it's free. Complaining about OSS is often viewed as ungrateful behavior. Numerous times I’ve seen reactions from OSS developers, contributors or merely a simple passer by, responding to a complaint with: submit a patch or well if you can do better, write your own framework. In other words, put up or shut up.

We’re not all Einstein's

It’s not always a patch they are after. At times, when you find a bug, an OSS team member can ask you for a failing unit test. Now granted that we all strive to unit test and promote unit testing, feeling that every developer should know, understand and practice unit testing, the reality of the matter is that it’s not all green pastures out there. For one reason or another, not everyone has that knowledge, the ability or the opportunity to. So often, sending a failing unit test can seem daunting.

Of course, coming back to patches, there’s the added issue of figuring out how to work with the given source control the project is using, get the right unit testing frameworks to run, creating new unit tests, making the necessary changes, submit them and wait for your pull request to be accepted. And that’s if the project is using a DVCS and you can figure out what Pull, Push, Clone, Fork and Checkout mean. All this doesn’t even take into account that you need to figure out how the actual code-base works. And we all know understanding other people’s code isn’t easy.

For someone that is merely using an OSS project, all this can be overwhelming, not to mention intimidating at times.

Lowering the barrier to adoption

The OSS community often complain how big “Enterprise” and “Microsoft” shops don’t buy into OSS. It seems they go for commercial software in order for their legal departments to have someone to sue in case things go wrong. A little far-fetched of course, but nonetheless something you hear often. These shops also go for commercial software because it provides them with someone to call, someone that won’t tell them to submit a patch or provide a unit test. Someone they can call when they need support and not be judged (or at least not humiliated publicly on a forum or mailing list). Of course, the somewhat sad irony of this is that often, the support provided on OSS projects outdoes commercial products by a long shot, and that’s not to mention OSS projects that offer the possibility of commercial support.

However, we need to look at ourselves and see how much of this low adoption of OSS that we’re so passionately fighting for is our fault. If we expect all the users of our projects to know how to work with our source control or compile the source and deal with dependencies, submit patches or work with our testing framework, all we’re doing is raising the entry barrier to OSS.

Before shouting that I’m stereotyping OSS projects, I’m not. I’m well aware that there are amazing projects out there with beautiful and thoughtful teams and communities around them that make many commercial support alternative envious. However, I’ve seen the submit a patch attitude often enough, over the many years I’ve been involved in OSS to warrant mentioning it.

What about me? What about my time?

Now there is the opposite side to all this. You. The Project Lead. The Core Contributor. The guy that has spent several years of his life giving to the community, contributing to OSS projects, helping others. Why should you, despite having given so much, take more of your time to help others. The minimum, that someone that is using your project (for free might you add), owes you, is a failing unit test. No? Not just some lousy steps to reproduce…

Here’s the thing. If you’re working on OSS, you’re doing it because you are benefiting from it. You benefit because you enjoy it. You benefit because you learn. You benefit because you potentially can rise to fame (albeit a micro-celebrity), and you benefit because it can ultimately provide you with potential consulting and training opportunities.

Nobody owes you anything for working on OSS!

Providing Intellisense, Navigation and more for Custom Helpers in ASP.NET MVC

2011-12-07T13:47:00Z

You probably are aware by now that as of ReSharper 5 we added first-class support for ASP.NET MVC. This included among many things, the ability to provide Intellisense, Create from usage and Navigation to built-in methods such as Controller.View or Html.ActionLink:

Navigation

Ctrl+Left Mouse Click or F12 will navigate to the corresponding View

or to the Action and/or Controller

Intellisense and Create From Usage

Ability to have Intellisense when providing Actions/Controllers

as well as the possibility of creating from usage

However, what happens when you want to use a custom function, for instance, a better ActionLink or your own View method? Did you know that you can still get all these goodies? All you need to do is use some Annotations.

Using JetBrains.Annotations

ReSharper uses annotations via the form of .NET attributes to figure out what an ASP.NET MVC View, Action or Controller is. As such, all we need to do for our custom method and extensions to leverage this, is tell ReSharper what parameter corresponds to what.

Referencing the annotations

To use ReSharper annotations, we have mainly two options (with a third one hopefully coming soon):

1. We can include the library JetBrains.Annotations.dll in our project and reference it.

2. We can copy the annotations and include it as source in our project

[3. We can use nuget install-package JetBrains.Annotations] Coming soon!

The first option is pretty simple. The DLL is located in the ReSharper installation bin folder. For the second option, we open up ReSharper | Options and select Code Annotations entry

select the Copy default implementation to clipboard button and paste into an empty file.

Annotating custom methods

Once we’ve completed this step, all we need to do is annotate our parameters with the correct attributes. We’re interested in 3 different attributes in particular:

AspMvcView which indicates the parameter is a View
AspMvcAction which indicates the parameter is an Action
AspMvcController which indicates the parameter is a Controller

Here is the header corresponding to a base controller with a custom method named ExtendedView

and here’s the header for a custom ActionLink

(the body of both methods are omitted and are not necessary to demonstrate the functionality)

As soon as we do this, ReSharper picks up these methods and offers us the same functionality that is provided for the methods that ship out of the box:

Notice how we still get Navigation (the underlining), Intellisense and Create from usage in our TheOnlyActionLink custom method. Its much the same for the ExtendedView method

That’s all there is to it.

Setting up TeamCity as a native NuGet Server

2011-12-01T16:27:00Z

TeamCity 7.0 EAP (Early Access Program) was recently opened and one of the new features is the built-in support for NuGet. I recently blogged about setting up TeamCity to pack and publish NuGet packages via a plug-in and this plug-in is now included by default in TeamCity 7. However, the real new interesting feature is that TeamCity is now a native NuGet repository too!

Native NuGet Server?

Many of those that have been using NuGet, have most likely been using it to consume packages from nuget.org where there are currently over 3800 unique packages, most of which are open source.

What happens however if for some reason or another you do not want to submit packages to nuget.org? For instance, think that you want to use NuGet to modularize and distribute code inside your own organization, or create libraries for private consumption. In this case, publishing to nuget.org does not make sense. This leaves you with basically two options:

Setup your own NuGet repository by downloading and installing the code that nuget.org for instance
Copy nuget packages to a local share and have everyone read off of that

Both of these options come with their own share of overhead. With the local share you now require sharing of folders and permissions. Setting up your own NuGet repository also requires managing permissions and whatnot separately. At the end of the day, its another service to manage.

Fortunately, you now have a third option: TeamCity. The same server that builds your projects, runs your tests, packs and publishes your packages can now also serve them. The best part of it is that it is so simple, that I had to take up the rest of this blog with the previous nonsense just to give it some meat.

Enabling TeamCity as a NuGet Server

I am not going to cover how to pack and publish packages in this post. All that is covered in detail in the previous post I wrote, so please read that first if you’re not familiar with the process. Enabling TeamCity as NuGet and making packages available consists of two steps:

1. Enable the server to be a NuGet server

Go to Administration | Server Configuration | NuGet tab

Click on the Enable button to enable it. The same screen with then display two different feeds: a public and a private one:

If by chance the Public Url is not available, you will probably see a message telling you that you need to enable the Guest account in TeamCity, which can be done from the General tab.

2. Make your packages be your Artifacts

Since TeamCity itself is going to be a NuGet server, the step to publish a package is no longer required. However, packing the package is. In this step (NuGet Pack Build Type), we can just configure the output for the package to point to some specific folder, for instance packages

We need instruct TeamCity to ouput the results of this folder as artifacts. This is done in the General Settings step of the Build Configuration

and with that, we’re done. Next up is to configure Visual Studio to consume from this feed.

Configuring Visual Studio

Although this step is optional, it is recommended to add your repositories to Visual Studio to avoid having to type long URL’s in each time you want to read from a specific package repository. To do this, click on Options | Library Package Manager | Package Manager Settings

We need to add a new NuGet Repository. I’ve called it Local TeamCity and the URL corresponds to the public URL provided to me by TeamCity in Step 1:

Notice that I have another entry which is Local TeamCity Auth which corresponds to the authenticated version.

Once we have this, we can now easily consume packages from our repository by merely specifying it in the Package Manager Console, either via the Combobox or explicitly in each call:

Summary

That’s all there is to it. By merely publishing our packages as artifacts, TeamCity now provides a full-fledged nuget server which opens up great possibilities when it comes to working and managing dependencies between projects. TeamCity is currently in EAP and much of what I’ve described here is in open to improvements. That is why your feedback is very important. Download 7 and start playing with it today. Let us know what you think.

Native NuGet Support in TeamCity

2011-08-24T20:01:00Z

A few months ago, Scott Hanselman gave a session at TechEd US were he showed some new features we were working on for TeamCity, in order to provide first class support for NuGet. He later blogged about it here.

Instead of delaying until the next release of TeamCity, this feature (like many), has been developed as a plug-in. Eugene, who has been working on it, announced the availability of a first build a few weeks ago. After some initial trials and changes, I decided to setup YouTrackSharp to automate the publishing of the NuGet package. It was surprisingly easy as you'll see.

1. Installing the Plug-in

If your project is running on TeamCity at Codebetter.com, you can skip to Step 3, since it's already installed and configured. If not, then grab the latest build from our public TeamCity server. Place the zip file into the plugins folder of your TeamCity installation and restart the server.

2. Configuring the NuGet version

Once the server is running, and agents updated (automated procedure), you then need to tell TeamCity what NuGet version you want to use. The plug-in knows about the nuget.org feed to it can grab the latest version of the command line tool directly. Click on Administration | Server Configuration. If the plug-in installed correctly, you should now have a new Tab called NuGet:

Click on the "Install additional versions of the NuGet.exe Command Line". TeamCity will read from the feed and display available versions to you in the dialog box. Select the version you want and click Install:

Pull, Pack, Publish

The plug-in offers three main operations:

Pulling NuGet packages required to build your project
Creating NuGet packages
Publishing Packages

In my case, I want to create the package and publish it. To give you a general idea of my build process, here's the outline of the build steps:

The NuGet related steps are 3 and 4. Step 1 simply builds the project by building the solution file. Step 2 runs the MSpec tests.

3. Building the package

This step is for building the actual package. We create a new Build Step in our project and select NuGet Packages Pack. This will give us the following configuration screen:

As you can see, the configuration is pretty straightforward. Notice that in the Specification file, we can also provide a csproj file as opposed to a NuGet spec file. The advantage to this is that we do not have to redefine information such as version number and copyright information in the spec file. If you're not familiar with this feature, check out David Ebbo's post.

I've also checked the option to Include Sources and Symbols. This is also explained in David Ebbo's post and it's for publishing the sources to Symbolsource. Additional command line parameters (if required) can be passed in the Additional Commandline arguments. If you want to make this a release build, you can also do this by defining Configuration=Release in the Properties field.

Finally I've specified the Build number of the package using the TeamCity variable %build.number% which auto increments on each build, and is also used by another feature of TeamCity new in 6.5 which is called the AssemblyPatcher, which I'll show you as the last step.

4. Publishing the package

The next step is to publish the package. As before, we need to add a Build Step and select NuGet Packages Publish.

This step is even easier to configure. By convention it uses nuget.org as the destination to publish the package. If you have your own NuGet server then fill in the address in the Packages Sources field. If you're using nuget.org, leave it blank. You need to provide your API key which is stored in a password protected field and finally indicate which packages you want published. Here you can list each package individually or use wildcards. [Note: relative paths are allowed but at the time of writing this post, there was an issue and I was using the full path. This should be fixed soon].

If you want to publish to multiple sources, all you need to do is add another step. Note however that we did not have to specify an extra step to publish the sources to symbolsource.org. TeamCity will follow NuGet's convention and do this for you automatically.

5. AssemblyInfo Patcher

Although this step is optional I recommend you use it. The AssemblyInfo Patcher is a new Build Feature added to TeamCity which temporarily patches all your projects AssemblyInfo.cs files to update the version number, and then reverts it back after the build is complete. This allows your build number, artifacts, packages and assemblies to all have the same version number. Adding this option is as simple as selecting it from the main project configuration screen:

That's it. There's nothing more to it. With a few simple build steps we have now fully automated packaging and publishing NuGet packages. As I mentioned initially, if you've got your project on CodeBetter, you already have this feature enabled. If you're running your own server, just download the plugin and set it up. It's very simple.

Try it out and please give us your feedback!

YouTrackSharp and YouTrackForReSharper on JetBrains GitHub

2011-08-17T14:38:00Z

Just a quick note to say that I’ve transferred the YouTrackSharp project from my own account over to the JetBrains account on github. I’ve also pushed the initial spike of YouTrackForReSharper which is a plug-in for ReSharper to talk to YouTrack. We’re looking for contributors for this project, so if you’re up to it, fork away!

Machine.Specifications for ReSharper 6 now available

2011-07-20T14:16:00Z

Many, myself included, have been eagerly awaiting the release of the ReSharper Runner of Machine.Specification (MSpec) for ReSharper 6. I’m glad to announce that this is now available, which is the result of a team-effort between Victor Kropp, Chris Nicola, myself and of course Alexander Gross, long-time contributor and main maintainer of the MSpec project.

NuGet packages have already been updated to support ReSharper 6. The source code can also be obtained via SymbolSource.org if using NuGet or directly from Alexander’s GitHub account.

Installing the Runner in ReSharper 6

If you’re new to MSpec or have simply forgotten how to install the runner under ReSharper, here are some simple steps to use Mspec in your project and integrate it with ReSharper:

1. Run the command install-package Machine.Specifications (or Machine.Specifications-Signed if you want the signed version). If this is an existing project, issue the command update-package instead of install-package.

2. Inside the packages folder corresponding to Machine.Specifications, a tools folder is created with a series of assemblies and some batch files. There are a series of batch files named InstallResharperRunner.X.X. – VS20XX.bat where X’s correspond to the version of ReSharper and of Visual Studio. By executing the corresponding one, it will copy the assemblies to the ReSharper plug-in folder.

You can of course do the second step manually, by copying the Machine.Specifications.ReSharperRunner.X.Y files to the ReSharper Plugins folder, located either under the ReSharper bin folder in %Program Files%\JetBrains\ReSharperX\bin (for all users) or under %APPDATA%\JetBrains\ReSharperX\bin (user-specific settings).

With that you should be up and running.

Enjoy.

Google+: Third Strike…and it’s in!

2011-07-09T14:57:00Z

Google+ is what could possibly be considered Google’s third attempt at Social networks. With the failure of Wave and Buzz, is Google+ going to make it this time? My first knee-jerk reaction to it was that it’s a Facebook AND Twitter killer, and after the short amount of time I’ve used it, and not knowing any better than to write about something you’ve not used long enough, I’ll give my opinion. If I’m right and this thing takes off, I’ll be a Social Expert. If I’m wrong, I’m not a Social Expert. And?

Why do I need Twitter AND Facebook?

One of the main reasons I use Twitter (having passed the phase of “Wheels Down/Up in AGP”) is for “professional” reasons. And I put professional reasons in quotes, in the sense that I mostly use it to interact with people regarding software development which is my field, as well as things related to my job (JetBrains and our products). These include discussions on specific topics, providing help, the occasional opinion on technologies and once in a blue moon a political or religious statement. I interact with all sorts of people on Twitter, people I follow and those I don’t.

Why do I use Facebook? Primarily to interact with friends. I try and keep a low number of people on Facebook, mostly those people that I have at some point met personally. I also use Facebook when I want to say something a little longer than 140 characters, as well as topics that are not directly related to my field.

Hello Circles

With Google+ you have the concept of Circles. You place your family, friends, acquaintances and followers in different circles. When you send a status update, you can make it public, or send it to a specific group. When you post a picture or a video, you can target specific circles or people. You can create your own circles, even a list of blocked people. What this means for me is that G+ now allows me to interact with both groups: those I talk to on Twitter and those I communicate with on Facebook.

It also opens up other benefits as I’ll mention later on.

But…but Facebook has lists

Yes it does. Did you know about them? I didn’t. The problem with Facebook lists was that it wasn’t staring me in the face. Now some argue that the reason for this is that Facebook aims at making it extremely easy for people to use. I think that’s nonsense. There’s a difference between creating systems that are easy to use and treating users in a condescending way. The argument that my mother won’t understand Circles doesn’t hold. My mother is over 70 years old and she has a blog, uses Windows Live Writer and a whole bunch of other applications. If she knows how to paste an image with WLW and set tags, I’m sure she’ll understand what a Circle is.

The reason for lists not being in your face in Facebook is most likely because Facebook’s policy is for you to share as much as you can, publicly. If it’s about making a simple user interface, explain to me why they make it so extremely hard to change privacy settings? In our field, we have a saying “Security through Obscurity”. It’s not about making things simple.

With G+, circles are there from day one, in your face. G+ is giving you the option to choose. It also prompts you to who you want to post a status update, including defaulting to last used:

Finally, people have circles of friends, not lists of friend. Psychologically, the term circle resonates.

It’s missing the Charm of Twitter

Why is Twitter successful? Well if we define successful as a business generating profit, then Twitter really isn’t successful. If we talk about success in that millions of users are using it, then yes, it is. One of the the prime thing that pushes Twitter to success however is the concept of followers. We are all humans and we have egos and we like to be noticed. The concept of having thousands of followers seems to attract many. That is an advantage Twitter has over Facebook. With Facebook, if you want to be loved, you either set up a Fan Page (which very rarely people do), or accept everyone has a friend, which becomes a bit too busy.

G+ however allows you to have the best of both worlds. When someone adds you to their circle, you don’t need to add them back, thus allowing you to drive up your ego, while keeping the noise to a minimum. You can also follow people without being acquainted to them, by placing them in the Follower circle.

But I like 140 Characters

Please, have we stooped so low as a society that we need to express ourselves with 140 characters? Worse yet, have we become so completely and utterly mindless that we actually need that enforced by a software system. If you don’t want to type more than 140 characters, don’t! If you don’t want to read more than a 140 characters don’t. Personally however, I’m getting tired of “Sorry 140 chars is really hard to express myself”. It’s become the perfect excuse to run from a debate.

There is no Tweetdeck

If you’re using Tweetdeck exclusively to post to Facebook and Twitter, why are you posting to both? Won’t G+ solve that problem with Circle? If you’re using Tweetdeck like I do for instance to handle multiple accounts, yes then there’s a problem.

However, G+ has no concept of Company account or Fan page as of yet, so we can cross that bridge when we get to it.

Google+ is filled with nerds only, not my friends

The argument that G+ will not be successful because it is limited to invites and nerds is quite ludicrous, yet seems to be repeated time and time again. Whatever the reason that G+ is closed currently to those with an invite (which recently also includes those with a Gmail account), is temporary.

In fact, it actually even works to Google’s favor, just like it has with many other services. Everyone wants to be part of an “exclusive” club. Gmail itself for quite sometime was a closed group. As G+ grows, it will open up.

Regarding the nerds, let’s not forget that many of the current social networks were initially limited to nerds and geeks.

The limited group is temporary, and as more people join, it will just become bigger. Will it reach the (what 700 Million now?) users Facebook has in a year? Probably not. But I think it will grow faster than many expect it to.

G+ has no Developer Story

Another criticism I’ve read about G+ is that there’s no API. Facebook is a platform for building applications on. Twitter is also a platform for…..getting screwed. Yes, this is true, G+ does not have an API story but it’s still early days. I’m sure it will come.

Some more of G+ Benefits

Conversations

Personally I’m tired of not being able to follow a conversation on Twitter. With G+, much like Facebook, I can now do that. I can read an entire thread. I can participate. Some have mentioned that this also allows others to participate in a conversation and that it’s not really “social”, that somehow Google doesn’t get it. Let’s not forget that Twitter initially allowed you to view all conversations, not only when you were following all people involved in the conversation (as it is now). When Twitter made this change, the Internet was in uproar. People threatened to leave Twitter. They said Twitter had lost all the social aspect and that you couldn’t now discover new followers or be discovered. Yet now they defend it?

Instant Notifications

Apart from G+ benefit of combining Twitter and Facebook, it also has some other ones. It’s integrated with other Google services. If you use Gmail or Google as a search engine, you instantly get a notification icon in the top bar indicating status updates.

This allows you to turn off notifications via email. It also allows you to not be sent an email on EVERY single post someone else makes to a post or comment you’ve made, which can be quite annoying. The number of times I’ve not made a comment on a post so as to not be bombarded with notifications. G+ lets you fine-tune all that:

Security

This is again inline with circles. How many times have we heard on the news how people have posted about going on Holiday’s or going out for the night, only to come home to find their house being burgled. If you have the desire to let your friends know when you’re leaving and coming back, you can do so by limiting it to those that you really trust by using the correct circle.

Hangouts

G+ has the concept of Hangout area, where it uses a webcam (which pretty much everyone has these days) and your microphone to allow you to speak to other people in the hangout area (think of it as a room). You can start a hangout area or join an existing one. Forgetting the social aspect of this, multi-cast video conferencing for meetings is a big win in and of itself.

It’s Google

Recently Google’s agreement with Twitter to offer real-time content in searches expired. Was this due to G+ or not, no one will know. With G+, Google doesn’t have that problem. It’s Google. It controls the searches. It will be able to provide real-time info if the case arises. In addition it can also provide other G+ features:

not to mention “sponsored” ads.

Summary

As I mentioned previously, many of the posts reviewing G+ recently are judging it based on the fact that it’s closed, beta and also it’s too complicated for the average user. G+ is as complicated as one wants to make it, which is sometimes influenced by conflicting interests.

The only potentially “complicated” or “nerdy” thing about G+ right now is Circles. In fact, I’d go as far as saying that when it comes to settings, both concerning privacy as well as general ones, G+ is far simpler and less obscure than Facebook.

If our mothers and fathers learnt how to use Gmail, Twitter or even their phones, they’ll “get” G+. Let’s not be too condescending. Users are not stupid.

[Update]: I updated the post in regard to the ownership of content. Apparently G+ screws up here too. The Legal Notices of Picassa (which it uses for photo sharing) said that you owned all rights to content. However, as someone pointed out, the TOS says pretty much the same as Facebook, which in my book is a big negative to G+.

* Much of the comments I’ve made in this post in reference to reviews of G+ are posts I’ve seen over the past couple of weeks. As and when I find them, I’ll add references to them. Unfortunately I didn’t keep the links, but it’s all there…just Google it!

YouTrackSharp: A .NET Client for YouTrack

2011-06-26T10:25:00Z

On and off I’ve been working on a .NET library that is a wrapper around YouTrack ReST API’s. If you’re not familiar with YouTrack, it’s our Web-Based Issue Management system, which is currently at version 3 and recently we announced the availability of a free version. If you like keyboard-centric tools (like for instance ReSharper), you’ll love YouTrack.

YouTrack offers quite a lot of possibilities when it comes to interacting with it. I’ve previously blogged about how we can easily create some HTML 5 graphs using nothing but the ReST API and some jQuery. Of course, we could also take advantage of this API from .NET using merely an HTTP client.

YouTrackSharp

What YouTrackSharp brings to the table is a compact interface to work with YouTrack without worrying about things like cookies, URL’s and other HTTP concerns. It abstracts all that away to provide a simple series of classes to work with YouTrack.

Here’s a sample of a command line app I just wrote to make feature logging easier for ReSharper:

var connection = new Connection("youtrack.jetbrains.net");
 
 connection.Authenticate("username", "password");
 
 var issueManagement = new IssueManagement(connection);
 
 var issue = new Issue
             {
                 Assignee = "ReSharperProjectManager",
                 Summary = summary,
                 Description = description,
                 ProjectShortName = "RSRP",
                 Type = "Feature"
             };
 
 
 issueManagement.CreateIssue(issue);
 
 Console.WriteLine("Feature request logged");

Currently it allows you to Create Issues, Upload Attachments, Get Issues, Apply Commands to issues as well as a bunch of tasks on Projects. I’m adding features as and when I can, so if there’s something you’d like, log it here.

How to use it

YouTrackSharp is available as a NuGet package and source code is available on GitHub. To use it, just do:

install-package YouTrackSharp

You first need to create a Connection object (providing host) and then either a IssueManagement or ProjectManagement based on what you need to do. The classes are simple and the methods should be self explanatory. The project also comes with tests using MSpec which describe many scenarios. If you have any questions, shout!

Ruby

If you are a Ruby developer, know that Anna Zhdan, a colleague at JetBrains, has also started working on a Ruby library for YouTrack, which is available on GitHub

Did you just take a dump on standard versioning practices?

2011-05-18T11:37:00Z

Original source: http://blogs.msdn.com/b/endpoint/archive/2011/04/18/microsoft-net-framework-4-platform-update-1.aspx

Who was the genius that thought calling a 4.x update a “Platform Update 1” and referencing the knowledgebase would ever be a good idea? Does that person actually understand what he/she is doing?

WTF happened to calling things by Major/Minor version? As if the Client Profile wasn’t already a really stupid idea, now you come out with this crap.

Why are you messing people around like this? You realize some of us actually write software and deal with deployments?

Getting things done daily

2011-05-04T09:15:00Z

For over a decade now, except for one year, I’ve been working from home. Home is kind of metaphorical considering the amount of travelling I do. However, to all effects, it means working alone, physically isolated and with no real 9-5 schedule.

Personally, I love it. I find it much more productive than working in an office, since I rarely am able to concentrate when surrounded by other people or noise. Sure, it’s probably out of habit. I know when I first started, I missed the office buzz, so it’s all just a matter of getting used to things. But having worked in both an office and at home, I’d stick to what I have now.

One of the greatest struggles of working from home, is adhering to a schedule. You need to have discipline in order to be productive. It’s far too tempting to get out of bed a bit late, watch a bit too much TV while making a coffee, or chat on the phone a bit too long. Today of course, we don’t need any of that, as Twitter and Facebook are here for our procrastination pleasures.

On top of sticking to a schedule, if you’re somewhat responsible for defining your own, the feeling can be overwhelming. Often you feel lost. You feel you’ve got way too many things going on and certain days can end up resembling the most unproductive days of your life. It happens. Even if you run a tight shift. Sometimes there are just those days. The best thing to do is just get over and, well, call it a day.

Organizing your daily tasks

What I have found fundamental is organizing a list of tasks you need to do on a daily basis. Now over the years, I have tried everything. I’ve gone through all the ToDo list applications that were available on downloads.com. I’ve tried different flavors of Outlook, The Bat! (great mail client, really bad PIM), to the more recent Remember the Milk and a bunch of other apps. And of course, none of them worked just right. And being a developer, what did I do? Write my own, which of course also failed miserably.

The problems I encountered with them all were always similar, but you know what? I could never pinpoint it. Some where to simple, others too complex, ultimately having me spending more time on managing the tasks than getting them done. My last resort was just an empty text file with a list of tasks. That didn’t work either. So what did work?

This:

Yep. A piece of paper and a pencil (or pen as Dino rightly mentioned). It seems silly doesn’t it? Having all this technology at the tip of our hands and yet the best thing I’ve found that allows me to concentrate on getting the job done and knowing what I have to do each day would be a piece of paper and a pencil.

Some of the reasons for this I think can be attributed to:

It can’t go wrong (well it can but you have an eraser).
It’s simple. It won’t distract you in trying to re-organize or finding a better way to handle the tool.
It allows you to focus. It removes the overwhelming lists of tasks you have pending.
It's staring you in the face.
You know exactly what you need to get done. It’s the list.
As you cross things off of the list, you see that you’re getting things done. It somehow entices you to even be more productive. It gives you a good feeling.

Now I’m not an expert in human psychology but I do believe that many of the previous points are actually psychological effects at play.

This is a daily Workflow

This works well on a daily basis. I still manage tasks using software. I use YouTrack for certain things, Thunderbird /Google Calendar for appointments and Checkvist for managing list that I collaborate on with others. However, when it comes down to what I need to do on a daily basis, I select items from all these sources and write them out on the sheet of paper, and I try and adhere to what’s on the paper, not deviating. So it’s important to realize that this is something I do on a daily basis. It doesn’t scale well for multiple days, weeks, months or even across teams. It’s a personal tracker for my daily routine.

It all boils down to one thing…a goal

There have been many techniques, tips and tricks that try and allow people to concentrate on a task. There’s even been certification programs for some, which I’ll refrain from making any comments on. Some tips which I’m sure you’re well aware of are things like closing down Email, Twitter, Facebook and other tools that decrease potential productivity (unless of course you’re a “Social Media Expert”). On the whole however, I think the main root of the problem here is not having a clear objective, not having a goal to reach. If we have that, you won’t procrastinate. This technique, I find, helps focus and reach that goal, daily.

If you’re having issues with getting things done, I recommend you try this simple approach, which is by far my invention and I’m sure many already use.

EasyHttp

2011-01-16T17:03:00Z

As of late, much of the code I write, somehow or other has to communicate with an HTTP server. Be it a “ReSTful” service or a “Wanna-be-ReSTful” service, I’ve had the need to make GET, POST, PUT et al operations and work with JSON.

After writing smaller wrappers around WebRequest on a few occasions, I decided it’s time to formalize the wrapper. This has given way to EasyHttp. It’s been sitting on GitHub for quite some time and both myself and others have been using it for several projects, so I think it’s reached a point where more people can try it out if they wish.

Best way to describe the features of EasyHttp is with some code

var http = new HttpClient
           {
               Request = {Accept = HttpContentTypes.ApplicationJson}
           };

var response = http.Get("http://domain.com/customer/25");

var customer = response.StaticBody<Customer>();

The code is self-describing: we create an instance of HttpClient and indicate that we accept content-type application/json (since in this case the server sends us json). By specifying this Accept header, EasyHttp knows how to decode the request.

How do we obtain the response? In the code above we are using the StaticBody method which gives us back a strongly-typed Customer. But we have other options:

var http = new HttpClient
           {
               Request = {Accept = HttpContentTypes.ApplicationJson}
           };

var response = http.Get("http://domain.com/customer/25");

dynamic customer = response.DynamicBody();

Console.WriteLine(customer.Name);
Console.WriteLine(customer.Email);

In this case we want to return a dynamic type so we call the DynamicBody method. EasyHttp will automatically deserialize the response to a dynamic object. This allows us to access properties without having to declare types ahead of time (quite useful when working with JSON). Finally we can also get access to the raw response via the RawText property.

If we want to stream to a file, we simply do:

var http = new HttpClient();

http.GetAsFile("http://hadihariri.com/header.png", @"C:\Temp\header.png");

Working with other verbs is pretty much the same process. Let’s say we want to create a customer calling a service:

var http = new HttpClient();

var customer = new Customer()
                    {
                        Name = "Joe Smith",
                        Email = "Joe@Gmail.com"
                    };

http.Post("http://domain.com/customer", customer, HttpContentTypes.ApplicationJson);

In this case we are posting a Customer object and asking EasyHttp to encode it using application/json. Similar to when receiving a response, when making a request that requires a body, we can also use dynamic objects. As such, this would also work:

   var http = new HttpClient();

   dynamic customer = new ExpandoObject();

   customer.Name = "Joe Smith";
   customer.Email = "Joe@Gmail.com";

   http.Post("http://domain.com/customer", customer, HttpContentTypes.ApplicationJson);

Internally, EasyHttp is using the excellent JsonFX which currently provides support for JSON and XML encoding/decoding. EasyHttp extends this by adding encoding support for www-form-urlencoded. Extending it with other format should be pretty easy.

As well as GET and POST, EasyHttp also provides support for PUT, DELETE and HEAD. Request and Response headers are surfaced as properties, so instead of having to add headers manually, we can just assign them individually (some of these are surfaced from the existing WebRequest).

Summary

That’s pretty much all there is to it. As I mentioned, I’ve been using it myself to talk to CouchDB, as part of YouTrackSharp and a few other projects. It’s far from feature complete, but I’m adding things as I or the few that are using it request them.

Feel free to download it and play with it. The source code is on GitHub and Issue Tracker is on CodeBetter. If you are interested in running the tests, you will need CouchDB. I originally wrote this because I needed to do some things for CouchDB and it served as a good platform for testing different Http Verbs (yes, they are integrations tests and not unit tests).

That dreaded M in ASP.NET MVC

2011-01-02T16:50:00Z

When it comes to working with Models in MVC, I’ve tried many approaches, some good, others not so much. I’ve ended up settling on ViewModels, whereby the Model I submit is dictated by the View I’m working with. This allows me the flexibility of displaying or gathering only the information I need. It also allows me to provide additional information on the view that isn’t necessarily required by my domain.

It works, but it also adds a lot of friction. Be it mapping, be it validation, it’s continuously repeating same processes over and over again. Even automating some of this still requires constant set up. Every time I work with ASP.NET MVC, I dread having to deal with all this. Way too much friction.

I’ve often wondered whether I’m overly complicating myself by trying to add so much flexibility. I mean if the Rails guys can work with ActiveRecord, why can’t I? Granted that maybe much of the drawbacks of ActiveRecord can be remedied in some way in Rails because of Ruby being a dynamic language and allowing for things such as Mixins, but still, what about the other stuff? The mapping to an actual domain model. What happens when they need a list of countries? What happens when they have to update only 2 out of 7 fields of their domain model?

I decided to ask Shay how he works. As a guy who works with both ASP.NET MVC and Rails, and has written a book on IronRuby, I thought he’d be a good candidate. Plus, he’s a nice guy.

I have to say I wasn’t really surprised by his answer. He binds directly to his Domain Model in ASP.NET MVC. I asked how he dealt with additional info: Html Helpers. I asked how he solved partial updates: In the controller. Although, not surprising, it was interesting. As a guy that’s worked heavily in Rails, he seems to cope fine with this approach in C#.

So again I wonder, am I focusing on too much flexibility? I decided to ask others by running a quick survey on Twitter asking how people worked with M in MVC.

1. First the disqualifying question. Are you using Strongly-Typed views?

98% voted they are. I’m guessing more than 2 people were not, but since the Survey was focused on strongly-typed views, they probably didn’t take part.

2. Now the question to see if I am the odd one out using ViewModels

Apparently not. 78% of people use ViewModels.

3. The next question was how one deals with only partially updating some fields of a Domain Model if binding directly to them.

4. What about that damn list of countries?

(I’ve actually found another way to solve this problem, partially based on conventions, and we might even build it in to AutoReST. But that’s for another post).

5. Key question the following. Mappings (read friction). If you use ViewModels, do you manually map information or use something like AutoMapper?

Surprised by the number of people doing manual mapping. You would think that if AutoMapper’s only responsibility is to do mapping for you, why not use it? Could it be again the same issue? Too much friction to setup? NuGet to the rescue? Too much ceremony?

6. Here’s another one. Validation.

So pretty much everyone (79%), some way or other has to deal with decorating their models with attributes.

7. Finally, I was curious how people felt in general with the development process. Did they also encounter friction?

Not surprisingly, 70% find some level of friction in doing web development.

Conclusions

First off, this is not a stab at ASP.NET MVC. If you take it like that, you’re barking up the wrong tree. I’m sure in one way or another, any platform or language has a certain level of friction when it comes to developing applications. No, this is more of a self-stabbing.

I also agree that on the whole, there’s too much friction. However, I’m not sure how much of that friction is caused by the platform vs the mentality of us developers to think big and try to build in so much unneeded flexibility. Are we really applying YAGNI? Are we really applying KISS? Maybe adding so much flexibility in terms of ViewModels because, and I quote, “when dealing with complex scenarios, simple approaches fall apart” only actually solve a 5% edge case that could be remedied in a different way.

Maybe we should stop being afraid of trying to be too strict and not flexible enough. Maybe we should take the concept of conventions more seriously than just what folders our Views, Controllers and Models reside in. Maybe we should push conventions to the limit and see if we actually reduce this friction.

And that’s the next journey I’m going to embark on. It might be time to drop the ViewModel, it might not be. What I do know is that writing good software shouldn’t be so complex.

SRP, as easy as 123…

2010-12-18T15:55:00Z

…of course, you’d need to have the song ABC from the Jackson Five in your head for that title to be remotely amusing.

Single Responsibility Principle is such a simple principle. It states that a class should only have one responsibility. One responsibility. Not two, not three, one. Such a concise and simple definition is hard to get wrong, right? Right? RIGHT??? Hmm…

A conversation between two friends

I’m looking at this Customer class, it does a bit too much no?

Huh? What do you mean? It’s a Customer Class. It deals with Customers. That’s all it does. Not Employees. Customers. I can fetch a customer. I can fetch a lot of customers. I can store a customer. I can calculate their age. I can check if they are VIP customers. Everything there is to do with customers. That’s all it does. Isn’t that what this Single Responsibility Principle states? To only have one responsibility?

Well, yes, but I think you’ve kind of missed the point on what this whole responsibility thing is .

How so? It just deals with Customers right? In fact, isn’t what I’ve just described pretty much the ActiveRecord Pattern?

Indeed it is.

So then WTF is the problem? I don’t get it.

Digging deeper…

Hmm, let’s look at this class. It reads/writes a customer(s) from/to the database. Therefore it has some code that has to do with reading from a database. It calculates age and verifies if a customer is a VIP. So it must have some business logic code in there.

What happens when you need to change the persistence logic?

Well I’ll change the code.

Which code?

The Customer class of course.

Right. What happens when you need to change the business logic of how a customer is considered a VIP?

I’ll change it again…..Sorry. What’s your point?

So again, you’ll touch that class. What happens when Customers need some validation? You’ll again have to touch the same class.

And?

What happens when you touch code? You usually end up breaking things. And it’s not necessarily that particular thing you touch. You break other things that at that point you had no clue were somehow related. The more complicated the code, the more chances you have of breaking something. Of course, if on top of everything, you don’t even have regression tests…well I’m sure you’ve suffered the consequences.

I kind of think of myself a competent developer. I’m sure I can work with enough care to not break things.

Right…. Now while you go and convince yourself of that, let me explain another problem. You see, writing code is easy. Understanding it is hard. The more code in a class, the harder it will be to decipher. The less code, the easier it will be to comprehend. If a class does many things, it will most likely have what? More code. The less it does, you got it! Less code. Forget logic for a moment. It even has psychological impacts. Open a large class and a small one. Which one will depress you more?

I have no problem understanding my own code.

Sure. You’re very smart and you’ve worked on this code base and you know it well. What about other team members? Hell. Forget others. Why don’t you look at code you wrote yourself eight months ago. Do you know what it does?

Well mostly yes. But I guess that’s kind of why comments are useful

Why do you need comments if your code is clear enough to understand? And you know why your code is hard to understand? Because you’re trying to solve too many problems at the same time. Think about it. You’re doing Customer listings, storing, reading and some business logic. It might be the case that for this particular example it’s not too hard to understand, but that’s because both of us have beaten Customer management to death (along with Authentication) so we’re experts in it. But imagine being thrown into some code that you have little knowledge of the domain. Is it easier to understand a class if it does one thing or five?

So what are you proposing?

It’s actually very simple. Divide and Conquer. Remember that? Back from our College days? Divide up a problem into smaller problems and solve the smaller issues. Dealing with mini-problems is easier than dealing with mega ones.

When we take a class and divide it up into smaller classes, it will be easier to deal with it. And dealing can mean both understanding it and modifying it. But if your customer class is doing all that, it’s bound to be harder to understand and maintain. That’s why it’s important to get these responsibilities right.

I see. But where have I gone wrong then? I kind of thought I understood the Single Responsibility Principle. Going back to my Customer class, how do I define what the responsibility is if it’s not “dealing with customers”?

Getting a grip on responsibilities

The main problem in complying with SRP is defining the responsibilities. Where do we draw the line? A few things that have helped me along the way have been…

Change

Have you ever heard people say:

“A class should only have one reason to change”

when talking about Single Responsibility?

Yes, actually I have.

Well think about it. If a class changes for more than one reason, it must be because it’s doing more than one thing. Going back to your customer class, think how many reasons there is for it to change. If we have to touch the same class for changing different things, the risk of breaking something is higher, which leads to higher costs in maintainability.

One way therefore of trying to figure out the responsibilities of a class is by asking the question of how many reasons are there for it to change.

Naming

Naming is a good way to discover the responsibilities of a class. What does your class do? Give it a name describing what it does. Does it use And or Or? Is it hard to explain what it does? Do you need to use suffixes like Manager, Processor or Admin because you can’t pinpoint the exact word describing what it does? Maybe it’s because it does two things that one word can’t describe. These are all clues that your class is doing more than one thing.

Cohesion

Take your class. Look at your methods. Do they have parameters or are they using instance fields? If they are using parameters, remove them. Make them instance fields. Do you end up with methods that only use one of the five instances? That most likely is a warning of the low cohesion that exists between that method and your class. Cohesion is a indication of how well related lines of code are, how well related methods are to a class.

And you use ReSharper right. Next time ReSharper prompts you if you want to make a method static, it’s telling you it does not use instance fields. That’s where you need to decide if that method actually belongs in that class. Sometimes it might, many times it might not.

OK, that’s kind of making sense.

Wait though. Many look at Single Responsibility Principle as something that applies only to classes. Wrong. It applies to methods too. The more things your method does, the more lines of code. The more lines of code. The harder to understand. The harder to debug.

Use the same process to identify responsibilities in methods. How many reasons do I have to change the method? What do I name it? If I can’t name it on a single line, bad! If I can’t name it without using And/Or , bad!

Refactor your methods to smaller ones. Give each smaller method a good name. Make it descriptive. Don’t waste time trying to comment your methods and the 20 parameters it takes. If it’s well named and has one or two parameters at most, it should be self-describing. Remember, parameters are used to operate on values, not decide what path to take in the method. For that, you create two methods.

(Beer enters the scene…)

Hahahhaha…

What?

I remember back when I first started using non-locking source control, I was concerned about running into conflicts when merging. I was right. I did run into issues. I bitched at the SCM. But now that I think of it, the problem wasn’t the SCM. It was the way I was working. It was having too much code in the same class.

Yep, and that would lead to contention since many people would need to touch the same code.

Yep. I was fighting the wrong problem. Damn, it seems such a simple principle, but hard to get right then….

Yes. It’s about asking the right questions. Single Responsibility Principle is about making code maintainable and understandable. That’s all there is to it really.

Right. Well dude, I guess it’s time for me to Refactor out that Class.

Yep. Oh and do yourself a favor. If you’ve not read the book Clean Code by Robert C. Martin (@unclebobmartin), get it. It teaches you much of what we’ve been talking about.

Cool!

Coverage with TeamCity and dotCover with MSTest, NUnit or MSpec

2010-12-10T11:26:00Z

As some of you know, we recently shipped TeamCity 6 which includes, out of the box, a bundled version of dotCover. What this means is that you can now get coverage reports for your code easily, and of course, for free if you’re using the Professional version of TeamCity. The setup is quite easy if you are using MSTest and NUnit. For MSpec, you need to take a few additional steps.

Using MSTest / NUnit Runners

Normally build files consist of a series of tasks that involve compilation and running of tests. With TeamCity, you can separate some of these steps out into individual TeamCity Build steps, which is what we will be doing in this case (everything that we see here applies to both MSTest and NUnit).

Here is our build.xml (MSBuild) file:

As we can see, other than compiling a solution, which in this case consists of the actual application and the test assemblies, not much else going on.

[Note: this could have been done using the SLN as the Runner Type under TeamCity since this example build script does not do much else. In real scenarios however, build scripts do more than just call a solution (in fact normally you’d call projects not solutions)].

In TeamCity, we create a new build project and setup the VCS root. We then add a new Build Step which calls this MSBuild file:

Notice that all we are doing here is calling our MSBuild script. No coverage settings yet.

Next thing is to add an additional build step in TeamCity. This time, we are going to call MSTest as opposed to MSBuild:

(the sections cut out are blank).

In the .NET Coverage tool section we select JetBrains dotCover and then add the assemblies we want coverage for (just the name of the assembly) prefixing them with +: and filtering out those we do not want coverage for with –:.

That’s all there is to it. Once we run the Build, we should now see a new tab with Coverage Reports as well as a new Artifact which contains the Coverage files zipped up.

The Code Coverage tab goes into more detail:

We can even drill down into individual classes and examine the code coverage:

If we are using NUnit instead of MSTest, the only difference is there test runner we select when adding a new Build Step in TeamCity. Instead of MSTest we choose NUnit along with the version:

What about MSpec or my Specific Test Runner?

If we are using MSpec or a different test runner that is not supported directly by TeamCity, we can still get coverage reports; we just need to do a little bit of additional configuration. TeamCity has an API which allows us to send it messages when we want to interact with it (this is actually quite a powerful feature but out of scope for this post so please leave a comment if you’d like me to cover it in more detail). We can leverage this API to tell it when to start coverage and where to get the results from.

Here is the build script for MSpec:

We have created two targets. The second one (TeamCity) is the one we are interested in. This does a couple of things:

1. The first <Exec> runs all MSpec tests so that we can see the test results inside TeamCity. This is not strictly necessary for Code Coverage but usually build processes do display these results. The --teamcity option we are passing in to MSpec is for it to generate the system messages that are then fed to TeamCity (see point 3)

2. The second <Exec> is the one that runs dotCover. This uses a configuration file called dotCover.xml which we will examine further down. We pass in the c (or coverage) option when calling dotCover.

3. This is a message we send to TeamCity to tell it that we have run coverage. We indicate the tool we are using (dotcover in this case) and where the results are located. TeamCity uses this information to then display the results in the UI. This is one of the API messages mentioned earlier.

Finally we need to define the dotcover.xml file with out configuration for running dotCover (for detailed information on creating dotCover configuration files, see here and here):

In terms of TeamCity, we then just define our build step that calls out to the build script:

Notice how we do not specify .NET Coverage options explicitly. And if all goes well, we can see the coverage output just as before:

Summary

We can see that running code coverage is now pretty straightforward when using MSTest, NUnit or even a custom test runner. Most of what we have covered for MSpec will work with pretty much any test runner in terms of coverage (feel free to vote here for MSpec support).

With any build process, there are numerous ways of doing the same thing. I’m going to show you one of them. Based on your setup and needs you might want to do things differently. Fortunately TeamCity is flexible enough to allow for many scenarios.

One thing to be aware of is that dotCover creates some temporary files for the XmlSerailizer in the Temp profile folder. This normally is not a problem unless the folder does not exist. If you are running TeamCity under the SYSTEM account, make sure that the folder C:\Windows\system32\config\systemprofile\AppData\Local\Temp exists. This will probably change in future versions so to avoid any possible issues.

Enjoy!