I don’t know why I had the idea, but recently I thought it would be nice to just jot down a list of all those little interesting life memories I have stored away.

Sort of like a really zoomed out diary of your life, it’s been quite fun to do. I don’t really have time to do it, so every now and then I’ll just write a few more things down (it is a task in my @Downtime list in my previous post). I haven’t put any particular structure around it and it doesn’t have sentences at all, just one word bullet points to remind me of some interesting thing that has happened that I remember fondly.

For example, maybe just the name of a school you went to – and that is enough to bring back all those memories about the place that you wouldn’t even normally think of, and possibly even forget one day I guess??

If there are further particular little interesting memories I want to include about something I might have a little sub-list of things under that. One word is normally enough to trigger everything else related to that funny/fun/interesting/nice memory.

I’ve been trying to remember past holidays I’ve been on, jobs I’ve had, fun memorable little trips around home I’ve been on, places I’ve been to with cool / fun people. Something I’ve achieved or a hobby I used to do.

Best thing is not to think it’s a big task, just have fun while you remember stuff.

If you decide to give it a go - enjoy :)

In a similar vein to my previous post Project Managers Bridge to Agility I have recently stumbled across another nice article – this one from Pete Deemer at www.scrumtraininginstitute.com.

These things always ring so true – yet in practice it’s so hard for a company to do let go and trust in their team’s ability, especially when under pressure.
You really need to have all players sold on the belief that agile development does work.

As Jeff Sutherland mentioned in a seminar of his I went to last night, these things are so simple, but not necessarily easy.

Excerpt from MANAGER 2.0: THE ROLE OF THE MANAGER IN SCRUM below:

The traditional role of the manager in the corporate world is based on a model known as “command and control”. Here, the job of the manager is to identify what needs to be done, to issue detailed instructions to the employee, and then to ensure the employee completes the work according to the instructions. The role of the employee in this model is simply to follow the directions as given, trusting the judgment and wisdom of the manager to ensure that the right work is being done in the right way.

In complex, dynamic environments such as software development, this approach tends to break down. First, it is difficult and time-­-consuming for a manager to understand every requirement in full detail and issue precise instructions to guide the work of every employee. Within a software development Team, the work is highly interconnected, with intricate dependencies, and frequent change and surprise. To expect a single manager to do all the basic thinking for his or her team is unrealistic, and it often constrains the team’s productivity to the manager’s ability to give instructions. In addition, this approach tends to be demoralizing for employees; their role is simply that of “order follower”, and they often feel little sense of ownership of their work. Accountability is limited to answering the simple question, “did I complete the orders I was given?” If the answer is “yes”, the job has been done – regardless of whether the right thing was built, built well, or built to satisfy the business goals of the customer.

Scrum is based on a different approach: The Self-­-Organizing Team.

The Galaxy Team had been doing Scrum for several months, and the Team was
well on its way to being truly self-organizing. Their motivation was high, they were
focused, and after a few Sprints of under-delivery, they were now showing a
pattern of making reasonable commitments and delivering them 100% each
Sprint. Morale was high, and there was a real sense of “flow” in the work they
were doing. The engineering manager Francis had come a long way – once a
habitual micromanager, he was now acting like much more of a mentor and coach
for the Team. Unfortunately, though, in the eighth Sprint, the Team encountered
some unexpected difficulties, and about halfway through the Sprint, they were
significantly behind in their progress. The VP of the group, Simon, had ventured
into the Team’s work area to see their Sprint Burndown Chart, and called Francis
to his office.

“Francis, it looks like this Sprint is a disaster. What’s going on?” he asked.
Francis responded, “Well, the Team hit some bumps along the way, and they’re
trying hard to get everything done that they committed to, but it’s a bit touch-andgo
right now.”

Simon grimaced.

“Francis, this project is critical, and we can’t let it fall behind. I’m counting on you
to make sure the Team finishes what they commit to, this Sprint and every Sprint.
As a manager, your job is to make sure the Team gets it done; if things are going
well, then you can back off a bit, but the minute the going gets tough, I want you in
there making sure that no time is being wasted, and everyone is doing exactly
what needs to be done.”

Francis was exasperated. Simon had been too busy to attend the in-house Scrum
trainings, but Francis had emailed him a Powerpoint presentation about selforganizing
Teams and the new role of the manager, and Simon hadn’t voiced any
disagreement. Francis spoke up:

“But what about the self-organizing Team, Simon? What about our shift away from
micromanagement?”

There was a glimmer of recognition, as Simon recalled a Powerpoint he’d seen a
few months before.

“Yes, the Team is responsible, but when they start to fail, I hold you responsible.
We want maximum accountability, so I’m holding them accountable and I’m
holding you accountable. In our department, everyone is accountable! Now make
it happen.”

At that, Simon spun his chair around and started typing. Francis took the hint and
left the office.

The next day, Francis showed up at the Daily Scrum Meeting.

“Guys, we’re going to do a different format for the meeting today. Due to the
criticality of this project, Simon has instructed me to more actively… uhhh…
‘facilitate’ your self-organization during the Sprint. So what I’d like to do this
morning is get a status update on each of the features you’ve committed to –
whose done what so far, and what’s left to be done – and I’m going to be giving
some more detailed feedback so hopefully we can get everything 100% finished
by the end of next week.”

The Team looked at each other. Philip, the ScrumMaster of the Team, spoke up.

“Francis… uhhh… does this mean that the Team is no longer responsible for
managing itself?”

Several Team members nodded in agreement.

Francis replied, “Guys, we’re all responsible. You’re responsible for managing
yourselves, and I’m responsible for making sure you get everything done. We’re
all responsible together!” Francis didn’t see the eyeballs subtly roll.

As the Sprint proceeded, Francis was more and more involved. The Daily Scrum
became an update meeting for the Team to tell Francis what they’d been able to
complete, and for him to assign them the next day’s tasks. The mood of the Team
shifted; motivation seemed to go down, and Team members seemed to be
reverting to their previous role, what they used to sarcastically call “servants-of-
Francis-the-Great”. By the end of the Sprint, the Team was fully back into “orderfollowing”
mode, and Francis was directing their efforts task-by-task.

At the Sprint Review, the Team was surprised when Simon joined the meeting just
as it was starting.

“So…” Simon announced, “Did we get our commitment done?”

The Team looked at each other. Francis answered.

“Simon, unfortunately there are a couple backlog items that weren’t finished.”

There was a flash of anger in Simon’s eyes.

“How did this happen? Who is responsible for this?”

The Team was silent, but their heads all turned slowly to Francis.

Simon continued. “Francis, I told you to get it done. Next Sprint, I don’t want to
see this happen again. If it does, there will be hell to pay…”

Upon hearing this, everyone on the Team made a mental note to think very
carefully about just how much to commit to in the next Sprint. The last thing they
wanted was to get shouted at again two weeks from now.

As the Sprints passed, Francis became more and more involved in directing the
Team at every stage of their work. Gone was any semblance of self-organization,
and with it disappeared the improved motivation, drive, and focus that the Team
had started to display. Morale had plummeted, and so too had productivity. Lunch
breaks were getting longer, coffee-breaks more frequent, and Francis felt like he
was spending more and more of his time just making sure people were at their
desks working. Those amazing few Sprints, when the Team was truly selforganizing,
and performing at the level they were really capable of, were
becoming more and more of a distant memory. The return to micromanagement
was made all the worse because they’d had a taste of the self-organization “good
life”.

Information overload – something that is very real when you are in the tech industry. One way to manage this and solve this problem is to simply ignore it completely. For instance, don’t read RSS feeds, don’t have a twitter account, poke into your email inbox once in a while to see if anything new and interesting is in there and use your inbox as a way of reminding yourself of things that you have to do.

Maybe there isn’t anything wrong with this approach. These people tend to live outside of technology and run their lives from conversations and what they have on their mind that they believe is the right thing to do at any one time. You quite often wouldn’t hear back from them if you sent them a message – so you may need to rely on ringing them for a definite response, which can be frustrating. But as I said, maybe there isn’t anything wrong with it. People just operate differently – and that’s fine, we just have to acknowledge that people do things differently and we have to change our approach to fit with how others go about doing business depending on who we are dealing with. You can’t make the world conform to you, unfortunately. (For example, I wish more people used twitter which I think is a great tool. The uptake in Australia / New Zealand is poor even between tech people, but there is not much you can do except maybe wait :)

I’ve decided myself that I don’t want to simply block/ignore information as a way of surviving, but I also don’t want to be swamped by it, so over the years I’ve been trying to refine my daily workflow process in an attempt to manage “information flow” (a.k.a information overload) effectively and efficiently.  It’s based a lot of GTD (Getting Things Done) which I highly recommend anyone read – the book is obviously written in fairly general terms (so everyone can benefit) and it’s really left to everyone to find their own concrete “implementation” of it. The concepts you come to realise in the book really turn on a few light bulbs that help you go forward with for the rest of your life. David Allen has since written a sequel to this book, “Making It All Work” which is definitely on my to-read list.

Through trial and error I’ve tried a few different things but am starting to get to the point now where I am pretty happy with the whole process – although I think it will always be a continually evolving thing, especially as your life changes. I have mentioned the tools that I am using to implement the process also, but tools always change too – even more so than the process. I realise that there are many other valid tool alternatives out there and new ones are always cropping up – this is just to document what I’m using right now.

My Daily Workflow       

Diagram Explanation

“Stuff” is everything that bombards you from day to day.

• Email – I tend to just process these throughout the day. For people who feel a sense of email overwhelm though, some suggest disabling automatic send/receive and processing these at certain times of the day (to avoid distractions). I believe in “inbox zero” philosophy – where read emails do not sit in your inbox. Once read, a decision is made whether it is deleted, it requires an action that is done right there (i.e a reply < 2 mins), converted to an action (or put in a @ToReply folder), delegated, filed, or deleted. The key concept is that e-mail is simply a mode of transport, nothing more and that the inbox isn’t for storage. I also make use of the MS Outlook follow up function for sent emails where you want a reminder where it is important that you receive a reply.
• RSS Feeds – These are a great way of keeping up with what’s happening out there in the world around you, especially with technology. There is a problem with them though – they are overwhelming, especially as your number of subscriptions go up (I’m at 233 subscriptions right now which I actually quite easily keep on top of). If you don’t read them for a week – you are more and more disinclined to want to even look at them because of the share number of updates. I use Google Reader which I have in “list” mode – this is where you only see the titles of each post. I also have each feed in an appropriate category. What I do now is literally spent 5-10 minutes of the day in the mornings (sometimes less) going through each category and scanning the titles. If one interests me, I may expand it and have a quick read – if it’s something that will take a bit more involvement to read (and I still want to read it) I will add it to ReadItLater with its Google Reader plug in. Aside from that, I will simply hit the “Mark all as read” button. That way if there is something really good, or something new going on – you will see it, but you aren’t going to spend your life reading RSS feeds. Important difference! I’ve recently added the free MobileRSS application to my iPod Touch that syncs with Google Reader and allows you to read offline, as well as add items directly to ReadItLater.
• Facebook / Twitter – I manage both these through TweetDeck, but especially for twitter. At the moment I still tend to prefer the facebook webpage interface in conjunction with www.fbpurity.com in order to hide all those farmville and fortune cookie requests etc. Nevertheless it’s still handy to be able to see updates from TweetDeck if you wish. You can manage the level of notifications you want TweetDeck to give you – depending on what sort of distractibility level you want. You can filter a twitter “column” for example for your close friends that will display a full popup notification, and have the rest display a smaller notification or none at all. Things like that. I also use Echofon on the iPod touch for twitter processing.
• Life – Life of course has many other inputs, phone calls, random thoughts, talking with people etc. The main notion with GTD is to keep things out of your head and stored in one location – where you can review everything in context with everything else. If you try to keep everything in your head you will feel stressed, constantly be thinking about things in order to “remember” them, and become less effective.

The key point to the process is - every input requires a decision to be made, right there and then.

Is it somewhere I need to be?
Then the calendar is where it goes and then the item deleted. A lot of events are organised through facebook these days so I make use of the “Export” functionality on the facebook event page that takes it straight through and into Outlook as an appointment.

Is it something that I need to do something with – i.e an Action?
If not, I decide whether I want to trash it, or store it somewhere for future reference. Where I store this depends on what it is. If it’s a bit of paper it will go in my filing cabinet, an electronic file on my file system (backed up with DropBox if it’s non-media), stored as a reference item in MyLifeOrganized (which I will talk more about soon), in an email subdirectory if it’s an email, or if it’s a link I will use Delicious to store it, which will then sync back to a few pages on this site. If it’s a web article that I want to read (which may or may not result in a further action) but don’t have the time right now, I add it to ReadItLater. Once upon a time I let this grow to over 100 items. This is bad. Very bad. Like the RSS feeds that you leave to fester, you will never want to look at this list if it is this big. I keep these processed and back down to 0 weekly the best I can.

If this item is something that I need to do something with, GTD philosophy is to do it right then if I can do it in less than 2 minutes. Otherwise, it is going in my “to-do” list and prioritised alongside everything else. For this I have been using MyLifeOrganized. This tool is very flexible and there are many ways in which you can use it. I have taken to using a combination of Weekly/Monthly/Yearly goals as well as Contexts (another GTD term).

My first decision is what goal I should assign to the item:

• Week – Items assigned a weekly goal are essentially the ones that I have in view each day. This isn’t a hard goal where I punish myself if don’t have them all done by the end of the week, but allow them to roll over. It’s more of a focus thing than anything else. For agile methodologists, I guess this is more like the Kanban/Lean way of doing things with flow rather than Scrum’s fixed iterations. For work projects though I think fixed iterations are still good.
• Month – Items which will most likely become weekly goals within a month (or two). There is still a sense of time importance with these.
• Year – Items that I really don’t need to think about for quite a while, still want to do at some point but definitely have on the back burner right now.
• Downtime – For items that I don’t assign a Week/Month/Year goal, I have set these up to be visible in a view I call Downtime. These are typically tasks that are non-important and non-urgent – but still things that you would probably do before Year goals. Could be things that you can do while watching TV and may tend to be more @Fun – it does not matter if these are not done in any particular time frame.

Doing this is a way of prioritising what you think is important for you to be looking at and what should be shielded from your thoughts for now.

The next step is to set a context on the item. These are very personalised in my opinion. Everyone is going to have these looking different. The GTD book suggests these are things like @Phone, @Car, @Shops, @Home, @Work…. You get the picture. The idea being you filter the list based on the context you are in at the time. At this stage in my life I didn’t find much benefit from this so my contexts at the moment are more to do with the area of my life they belong in (which still helps me choose items off the list when they are grouped this way). It’s all very flexible, these vary a lot depending on your lifestyle.

MyLifeOrganized operates by allowing you to define different “views” on your master all encompassing task list. I have created a week view that displays anything that has a weekly goal assigned to it, or any item that is now “due” with the due date property (the items are also grouped by the context I assigned to them). The monthly view shows all monthly goal items and the yearly view in this case I have grouped by project, another GTD/MyLifeOrganized concept (projects are made up of tasks). 

I essentially only ever have the weekly view open at any one time (or maybe the Downtime list depending on the time of day / energy levels), unless I’m doing a “weekly review” which is an important GTD task conducted weekly where you look over all of your items. This is where I shuffle weekly / monthly / yearly goals to make sure my weekly list is current. It is important to empty anything that you have on your mind into the system at this point so it is all there in front of you to view and prioritise alongside everything else.

It sounds complicated but I’m feeling quite effective now. I would be delighted to hear how other people go about dealing with “stuff” in case there is something I can borrow and use myself :) We are all in this fight against this world that’s heading for information overload meltdown together :) I believe, with the right simple process that you eventually internalise and don’t need to think about, it becomes quite easy to manage information without having to block it out entirely.

Note that I’m not necessarily saying that you should use or invest in any of the tools that I have mentioned in this article. I just wanted to share what I’m currently doing with the idea that it might give you (the reader) some ideas about how you could tweak your own setup. Everyone’s circumstances / lives are different and everyone is going to want to do things slightly differently. This article just gives you my version :)

  A lot of the systems that I have worked on have involved more than one component. For example, instead of just an ASP.NET website, there would also be some sort of windows service, maybe a windows forms component, or independent modules and libraries working within those components – all working together to form a final solution.

This tends to create a bit of a versioning and deployment nightmare and you need to have a good solid strategy around it before launching into things. I have tried a couple of approaches.

For one project, I had an automated build script that would go through and modify the version number of all the assemblies, build all the components and label the version from the root in source control. All components would then be redeployed for every release, regardless of whether they have changed or not. This removed human error in deployments as everything was automated, and the deployment steps were always exactly the same for each release so even those could be automated.

This worked pretty well for this project, because there were so many developers that it would have been too time consuming to do a full version to version diff to figure out which components have changed for each release and to deploy only those. Yes there would be release notes on what has changed for each of the components as written by project management or the developer, but that would be reliant on how dutiful Mr developer happened to be at the time, and it’s possible little “tidy” ups were done, or refactorings in components that do not end up appearing on release notes. So one answer is just to test and redeploy everything (this is where automated testing can be very useful also to test for regressions across the system). The only problem with it is you potentially end up deploying a lot of unchanged stuff – albeit just with updated version numbers, all for potentially one small change in one of the components.

For another project – there were far fewer developers, and it was quite easy to just know what components were being changed for each release – so it was possible to just deploy those that were being updated. I came up with the concept of a system version.

Say if you have the following structure in your source control repository for your software solution:

• MySolution
  • ASP.NET Website
  • Windows Forms Application
  • Windows Service
  • Reporting Services Reports
  • Database Scripts

When you deployed the first version to production, imagine everything was versioned at 1.0.0. All assemblies / exe’s would have been deployed as version 1.0.0 (or using other techniques for database scripts like updating the database version row to this), and the label Version_1_0_0 (or similar) then applied to the MySolution root in source control.

This is in contrast to labelling each subcomponent separately in source control and keeping a configuration management register updated with what versions are deployed where and what versions are all working and tested with what other component versions – uggh.

Now – say that a bug in the windows forms application is reported – it makes sense to just send out a new version of just that, not everything. You make the change, and update the windows forms application’s version to 1.0.1. Now, the solution is is labelled with Version_1_0_1 from the root – where 1.0.1 is effectively the new system version. Note however that the rest of the sub-components are still set at version 1.0.0 (literally within the AssemblyInfo.cs classes) – but the 1.0.1 label spans across them, effectively grouping the various current sub-component versions under the 1.0.1 system version umbrella.

Now – lets say a whole lot of work is done across all the different components to create a new feature asked for that will become version 1.1.0. During this time, another small issue is found in production – this time in the windows service. Since we are in the middle of development of version 1.1.0, which is subsequently unstable – we must branch the solution from version 1.0.1 (using the source control branching functionality). Here we make our change to the windows service, update it’s assembly version to 1.0.2 and then label the root of the branch as system version 1.0.2. We then deploy just the windows service to the client.

If we were deploying this solution to multiple clients, who for some reason were running on different versions, you can easily recreate in the development environment the version that they have running in their environment as long as you know their system version. Note that this must be recorded somewhere – but in this case it’s just one number per system deployment, as opposed to a complex set of versions of all the components installed. Pulling that label out of source control will retrieve all the subcomponents in their correct version as deployed for that system version, and consequently retrieve exactly what is running in production for each component.

The only danger with this technique is the possibility of a component being changed (maybe a developer deciding to re-factor some previous work), and not having this component deployed along with the next system version. This would effectively create a mismatch between what is deployed and running on the client’s system and the code associated with that system version in source control. This creates unreproducible bugs and other issues. To solve this, a quick and easy technique should be devised to query source control to see what components have been “touched” since the last release.

I would be interested to hear how others go about versioning in these sorts of situations. I may make a follow up post at some point about database versioning, and UAT deployment techniques.

In August last year – almost at the beginning of this blog I made a post about creating a “Cool Tools” page that will house links to all my favourite tools that I come across and use.

The original blog post suggested that I would be using a Wiki to manage the set of links. Even though I did develop that component in the end (which I may still find use for), my gut feeling said there was something smelly with managing these links in a wiki since I also use Delicious to store links conveniently with the Firefox Delicious Bookmarks extension – and having to then copy items across into a wiki seemed like too much of a pain and a bit of a double up (I’ve learnt that if something isn’t seamlessly easy, human nature is to put it off so much that you end up not doing it at all). 

However, at the same time I wanted to display the list of tools I bookmark in delicious on my website in a nice categorised, hierarchical view… so I got my thinking cap on of how I could have the best of both worlds. After googling around I found that there wasn’t much code out there that converts a set of delicious links with tags into a categorised hierarchy view of them all – so after some sketching I came up with a way to do it (i.e and algorithm to convert tags » hierarchy).

Long story short, my list of tools is finally up and fairly stable (I haven’t been adding huge amounts to the list for the past little while).

You can find it at:

• http://www.hamishgraham.net/page/My-Favourite-Tools.aspx

I am also using the same tool (by filtering on a different set of delicious tags) to provide a list of my Favourite Blogs and Favourite Articles.

Each set has their own feed that you can subscribe to if you are interested, or they have a “View by Date Added” button you can use to see what was added since your last visit.

All in all, doing this is part of my “manage information overload” flow (without just shutting it off completely) that I have been trying to fine tune over the last little while which I may blog about at some point – as well as a way to share with the world things I find that I think are good enough to share! 

Lately I have come up with a phrase that I have been experimenting with that I believe is really quite useful to frequently ask yourself.
It is:
“What am I doing, why am I doing it, the way I'm doing it and how could it be done better?”

Try it -- It's amazing how just asking yourself this at times when you least expect asking it will make a difference, makes a difference... you then think of ingenious new ways of doing something that you have been doing for a long time (in a poor way)... or alternatively decide that what you are doing really isn't that important after asking they why part and should possibly just be stopped.

It even stretches to fit with mundane things, you could ask yourself it as you are walking up the stairs and decide running up 3 at a time from now on would be better (or if it's really important to you maybe you might invest in an escalator). Or as you are making your cereal for breakfast you might have a think about it after asking the question and decide from now on that bananas on top from now on would be good for you and probably taste good too.

Stopping yourself as you are dredging through your inbox trying to sort it out... step back, ask how could it be done better, you remember that you can sort by subject or from address..sweet.

Ask yourself when someone's noisy twitter feed keeps popping up and distracting you... why? Well I still want to follow them.... but decide it would be better to download a twitter client that allows you to add that person to a special group that does not show you a popup notification (like TweekDeck).

Or you get annoyed at how you never seem to be able to reach the phone before the answer machine kicks in, actually take the 5 minutes out to find the setting to increase the number of rings instead of just not being bothered to.
 
Maybe you can never find your car keys, you could consider buying a key rack and have it installed by your front door for you to get into the habit of putting them on when you come in. 

Basically a process of continual minor improvements (the Japanese know it as “Kaizen”) - until eventually (over years) you are a sleeked well oiled productivity machine.
The process never stops - but you are reaping the benefits of all the other improvements in the mean time (which are now on autopilot).

This obviously also suits work life at an even more meta scale - applying it to a business process, for example, and of course right down to that portion of code that you are writing (being careful not to get stuck in a continual loop of perfectionism however) - just little chunks, when you can manage it.

A previous Brazillian colleague of mine, Edge, descibes another important thing to do at the end of every day, where you ask yourself:
"What have I done today that I could have done better?".
 
Edge suggests actually writing the answer to this question down which is a good idea as there may be more than one, and items that may need to be fed back into your task list. 

If you asked yourself the first question as often as you could remember (eventually though it just becomes a feeling) and the second question every day, then just imagine the improvements that you will see over time.

Unfortunately BlogEngine.NET is currently stuck back on .NET 2.0 due to a few lingering web hosts still not supporting .NET 3.5 yet.
Here is a comment made from Ben Amada, a BlogEngine.NET developer:

I agree, we can gain from using the new features in .NET 3.5.  You may or may not be aware that the BE core project has already been upgraded to .NET 3.5.  Some of the new .NET 3.5 compiler level features are being used -- but new namespaces such as Linq (and probably the Syndication namespace too) are not yet being used.  The website project is still on .NET 2.0.  Probably sooner than later, the website project too will be upgraded to .NET 3.5.

I think the main reason it hasn't yet been upgraded is because there are some BE users hosting their sites at webhosts that don't yet offer .NET 3.5.  The core project is at .NET 3.5, but because none of the new 3.5 namespaces are being used, the compiled core DLL can still be used in a .NET 2.0 environment.  At this point, I think just automatic properties and lambdas are being used in the core project (compiler level features).

Hopefully as the number of webhosts not offering 3.5 gets fewer and fewer, the website project too can be upgraded to .NET 3.5.

If you want to write a user control or widget however in .NET 3.5 now for your BlogEngine.NET site (which I have needed to do) – it is relatively simple to do. All you need to do is modify the web project’s web.config slightly, you can see the changes that you need to make here:

• Changes to web.config for running on .NET3.5 

The above diff was created using the report export functionality of WinMerge. p.s I wouldn’t normally recommend posting your web.config files to the web but in this case there are no “secrets” there.

General Tip:
In terms of making substantial modifications to your BlogEngine.NET instance (if you are in the habit of doing this, not necessarily just for this web.config change) – I recommend being connected to the BlogEngine.NET subversion repository (https://blogengine.svn.codeplex.com/svn) using TortoiseSVN. Now you can track any modifications that you make as Tortoise will flag the file as modified. Subversion will also attempt to automatically merge any further changes to the file that come from the BlogEngine.NET developers when you do an update, you of course won’t be able to submit your changes back unless you are part of their team. After doing the SVN update you can also monitor the changed files that come across and subsequently upload them to your web instance. Depending on if you are a risk taker or not, you may only want to do this when they mark a particular revision for a stable build.

Recently, I have switched across to using Disqus as the comments system on my blog instead of the inbuilt BlogEngine.NET comments.

Immediate benefits are:

1. Threaded conversation (i.e you can reply to someone’s comment directly).
2. Identify yourself with your Facebook or Twitter account (by logging in safely directly to the Facebook and Twitter sites respectively).
3. If you subscribe to the comments conversation by email – you can use email to leave replies to comments on the website.
4. Lets you keep track of comments you make across the blogosphere on all sites that use Disqus.
5. As the owner of the site you can moderate directly from email notifications (i.e by replying with “Delete”). This makes moderation easy when out on the road.
6. Generally looks sleek + many other reasons for using it (link#1, link#2, link#3).

I love comments so feel free to leave any and try the new system out!

Now, for the benefit of anyone using BlogEngine.NET who wishes to do this also, continue reading and I’ll outline the steps I took to do it:

1. Create an account at http://disqus.com
2. For Facebook integration, get your Facebook connect API key from http://developers.facebook.com/setup.php (you will also be asked to upload a xd_receiver.htm file to the root of your website).
3. If you wish to use Akismet spam protection, use your Wordpress account API key located here http://dashboard.wordpress.com/wp-admin/profile.php (in small text at the top of the page)
4. Within Disqus, under Settings –> General –> “Cross-domain Receiver URL” it describes an advantage to upload a blank.htm file to the root of your website and pointing to it.
5. Under Settings –> Customize, change from the new Narcissus theme to either of the Classic ones. I found that the new Narcissus theme’s Reply and Edit buttons on a comment did not work for me as they initiate a post back and the AJAX action is lost. After some FireBug debugging I found that this simply because the buttons do not contain a “return false;” on their onclick events (works fine when I manually add this in using FireBug). I have sent an email to Disqus about this but as of yet have received no reply. [Update: It seems the Narcissus theme has been updated and it works fine now, and looks sleek – I would recommend this one now].

I made the following alterations to various files in my BlogEngine instance (note that some alterations are made to core BE.NET files themselves which is going to make upgrading BE.NET more of a pain but I believed it would be easy enough to integrate again if it was documented well enough, i.e here):

1. Retrieve the second code snippet from http://disqus.com/comments/universal and add it to the “Tracking script” section of the BE.NET settings tab.
2. Modify /theme/MyTheme/PostView.ascx, removing any html referencing the BE.NET comment system and replacing it with:

   <a rel="nofollow" href="<%=Post.PermaLink %>#disqus_thread">Comments</a>

3. In the main /post.aspx change the visible property of the CommentView control to false:

   <uc:CommentView ID="CommentView1" runat="server" visible="false"/>

   And add the following: Yours will vary slightly, your version can be retrieved from the first snippet at http://disqus.com/comments/universal. Note the commented out disqus_developer variable, this can be uncommented to test the system on your local machine before deploying.
4. Find the comments variable in /widgets/RecentPosts/widget.ascx.cs and replace the line with: While I was there, I also added a "Read more..." link that links to the archives page (which I think should be there): I do not use the RecentComments widget hence did not have to modify this - it would need to be however if it was used.
5. Inside /archive.aspx.cs locate the comments.InnerHtml variable of the CreateTableRow method and replace it with: Note even though you can change what Disqus replaces the text with here by going to the Settings->Customize->Appearance Tab on your Disqus account, this is a global action across your site. Normally the archive page just has a number for the comments, not the "Comments" text itself so I had to modify my theme’s css a bit to accommodate the extra width required in this column.

That’s it :) Looks more daunting in hindsight actually. It would be much nicer if BE.NET had Disqus integrated into the standard build as an option.

Oh, and one more thing, something I have always wanted, comments on BE.NET pages. With the default BE.NET commenting system this is not possible, but with similar Disqus modifications, it is possible to have Disqus comments on your BE.NET pages also :)

Here are the steps I took to enable this:

1. Add the following lines under the AdminLinks section of \page.aspx: Once again, yours will vary slightly and can be retrieved from the first snippet at http://disqus.com/comments/universal. There is a little bit of extra code here to make the comments appear only after the link is clicked (for tidyness sake). This is not necessary though.
2. Add the following property to \page.aspx.cs:

And enjoy :)
Hamish

At home we have previously had issues with our ADSL dropping out intermittently and have had the ISP send technicians around to fiddle test and rewire etc. This seemed to make a difference for a good while, but as of the last two days we are back to square one with frequent and annoying ADSL disconnections (no changes to anything in the house).

What I’m afraid of doing now is ringing the ISP again and being told the standard “restart the router”, “pull all the phones out of the wall”, “turn the oven off”/”Pray to the Gods” etc etc, all of which I know most likely has nothing to do with it (tried it all before).

I decided to do my own internet research for reasons why ADSL might drop out. I learnt all sorts of interesting things about noise margin’s, line attenuation, data sync rates etc that all have an impact on how stable the line is.

Checking my Belkin router’s status page, I note that it actually gives me this information - cool:

Of course, I start rapidly refreshing the page to see how the numbers are changing as the ADSL internet connection drops in and out. The Data rate is different on each reconnect, and the noise margin is fluctuating all over the place.

Refreshing is no good, tonight I decided that this goodness needed to be graphed!

Window’s inbuilt performance counters are ideal for this sort of thing. We just need a custom performance counter for the ADSL connection data, poll the router’s status page and feed the new performance counter with data.

I fired up Visual Studio and started plugging away at a windows app that will do this for me – easy to do – behold the ADSL Monitor:

The following code creates the new ADSL performance object, with the four counters I’m interested in (noise margin up/down and data rate up/down):

CounterCreationDataCollection counters = new CounterCreationDataCollection();

counters.Add(new CounterCreationData("Noise Margin Down", "Noise Margin Down", PerformanceCounterType.NumberOfItems64));
counters.Add(new CounterCreationData("Noise Margin Up", "Noise Margin Up", PerformanceCounterType.NumberOfItems64));
counters.Add(new CounterCreationData("Data Rate Down", "Data Rate Down", PerformanceCounterType.NumberOfItems64));
counters.Add(new CounterCreationData("Data Rate Up", "Data Rate Up", PerformanceCounterType.NumberOfItems64));

string _performanceCategory = "ADSL"; 

if (PerformanceCounterCategory.Exists(_performanceCategory))
{
PerformanceCounterCategory.Delete(_performanceCategory); 
}

PerformanceCounterCategory.Create(_performanceCategory, "ADSL Diagnostics", PerformanceCounterCategoryType.SingleInstance, counters);

I then fire off a thread and have it looping over the following every second:

	           
	while (running)
	{
		WebRequest request = WebRequest.Create("http://192.168.2.1/status.stm");
		WebResponse webResponse = request.GetResponse();
		StreamReader stream = new StreamReader(webResponse.GetResponseStream());
		string statusPage = stream.ReadToEnd();
		stream.Close();
		webResponse.Close();

		//Providing data to the performance counter 
		PerformanceCounter pc = new PerformanceCounter(_performanceCategory, "Noise Margin Down", false);
		pc.RawValue = Convert.ToInt32(GetDataResult(DataMatch.adsl_noise_margin_ds, statusPage));
		...

		Thread.Sleep(1000); 
	}

A simple Regex is used in GetDataResult to pull the appropriate data off the router’s status page.

Now, browsing to the inbuilt windows Performance Monitor, we can add our newly created ADSL performance object and graph what is really going on. For me, it was looking like this:

What the ! !  It seems more than half the time I’m without internet. The most important lines I believe are the blue and red. The blue shows the synced data downstream rate (higher the better), and the red shows the downstream noise margin (once again, higher the better – apparently anything below 6 is quite unstable).

Where the blue line is at rock bottom is where I don’t have any internet at all. What a pain – as you can see towards the end it started to stabilise with quite a high noise margin, albeit a low data rate :(
This will hopefully give me more information to provide the ISP however when I finally do ring as well as letting me monitor the situation and not even bother surfing the internet while it is ridiculously unstable.  

Sigh.

For a while now I’ve been getting frustrated with hardly ever being able to safely remove my external USB HDD, as it was always “in use” even after closing as many applications as I could think of. However, using LockHunter (great tool) reveals the following information:

Trying to safely remove the device at this point of course gives the following message:

The first two items are windows handles that do not interfer with the safe removal process – the second two however do.

I have enjoying my use of xplorer² (lite) as a windows explorer replacement that makes life a lot easier when doing a lot of file system maintenance. However, if the last folder you have open with it was on the USB drive, then the process stays alive even after “closing” the xplorer² window (probably for faster reloading?), keeping a hold of the drive in the process. I have found that the following option however fixes this issue (if you don’t tend to use the DOS functionality):

 As for ObjectDock as far as I can see the only solution to this is not to have the Recycle Bin docklet on the dock – I guess I will just have to live with it being on the desktop for now.

Sometimes it pays to just take a bit of time out to sort out the things that can frustrate you daily and you will be much better off :)