free html hit counter
Posted on: Thursday, December 20, 2007 by Rajiv Popat

Broken Windows - If Broken They Are, Fix Them You Must.

Tess’s Blog Title provides profoundly important advice to every developer - “If broken it is, fix it you should” – Words of wisdom, which are much more important than they would sound the first time you hear them.

A young an enterprising engineer recently looked at one of our code base and asked me why we use interfaces and abstract classes so extensively when we could have coded using code-behinds in ASPX pages.

Another engineer I worked with in the past often wondered why I sent out long and loud emails to team members when I discovered they were using band-aids to mend their code and were moving on to new functionality without fixing small problems and issues resulting out of their using these band-aids.

Another young college graduate fresh out of college, who I worked with in the past also, believed that I often strive for – “perfection for the sake of perfection” – and questioned why I push developers to use Re-sharper, CodeRush or other similar tools.

The answer to all of these questions and why I strongly insist on every developer developing a certain sense of responsibility towards writing clean, small, cohesive and maintainable code can be summed up in two words – “Broken Windows”.



The Broken Windows theory has been rather old but I continue to be amazed at how much influence it has, on both – software development and our lives in general.

For the last couple of weeks, during my stay in a hotel suite in San Francisco, I was working working a client during the day time and a small but very smart team back at work during the late evenings. A lot of work was leaving me way too tired to cook and I had primarily moved to frozen food, vegan broccoli hot-pockets, chips and snacks – all of which came in plastic packets.

The first time I used the frozen food I left the empty plastic packet on the cooking shelf because I was way too tired to thrash it. The next day, I was tired again and history repeated itself. Soon packets started piling up on my kitchen shelf. The housekeeper stopped cleaning the kitchen and in a matter of less than a couple of weeks plastic packets started showing up in my entire suite making it look like a thrash-room. This in turn started making me feel very depressed every time I returned to the suite from work.

What I had experienced first-hand, in my very own life, was a classic example of the Broken Windows Theory in action.

As someone who has read about this theory many-a-times and has tried his best  to keep this theory from becoming a reality in his projects, I keep getting amazed at how the broken windows theory does in fact, starts affecting us, both in our projects and our lives, every time we leave just one little broken window unfixed.

Broken Windows can destroy lives and projects faster than most people think they can.

Andrew Hunt describes the Broken Windows Theory and why it is dangerous to live with Broken Windows in his book the pragmatic programmer and his online interview. He describes the basic theory much more articulately than the little hotel suite example from the recent past I described above. He explains:

Researchers studying urban decay wanted to find out why some neighborhoods escape the ravages of the inner city, and others right next door - with the same demographics and economic makeup - would become a hell hole where the cops were scared to go in. They wanted to figure out what made the difference.

The researchers did a test. They took a nice car, like a Jaguar, and parked it in the South Bronx in New York. They retreated back to a duck blind, and watched to see what would happen. They left the car parked there for something like four days, and nothing happened. It wasn't touched. So they went up and broke a little window on the side, and went back to the blind. In something like four hours, the car was turned upside down, torched, and stripped - the whole works.

Hunt in the same interview gives another example:

They did more studies and developed a "Broken Window Theory." A window gets broken at an apartment building, but no one fixes it. It's left broken. Then something else gets broken. Maybe it's an accident, maybe not, but it isn't fixed either. Graffiti starts to appear. More and more damage accumulates. Very quickly you get an exponential ramp. The whole building decays. Tenants move out. Crime moves in. And you've lost the game. It's all over.

Jeff Atwood in his post on this topic brings out a new perspective. He believes that it’s all about perception. He explains:

Programming is insanely detail oriented, and perhaps this is why: if you're not on top of the details, the perception is that things are out of control, and it's only a matter of time before your project spins out of control. Maybe we should be sweating the small stuff.

As developers we all make compromises for the sake of shipping. It's also a hard fact of life that after all, we all make shitty software with bugs.

But here is what differentiates the veterans who have seen the light or have mastered the art of shipping, from the programmers who can’t program.

  1. The Veterans know that they have written shitty software when they have and they are unashamed to admit it.
  2. The Veterans know when and how the shit usually gets out of control and are very careful about fixing the broken windows as soon as they are broken, before things start getting out of control. 

Ever been a part of a project that you wished you were never a part of? Ever been a part of a project where you felt glad that the project ended and felt happy that you could run far away from it?

Look back. Chances are that it all started with one or two broken windows which no one bothered to fix.

Do you have broken windows in your current project? Fix your broken windows, before you yourself and others in your team, start getting a perception that your project is a dumping ground for bad code and start vandalizing your own project, subconsciously, innocently and unknowingly.

For today I tweak Tess’s blog title slightly and leave you dear reader, with a thought worth harping on, for your project and your life - “if broken your windows are, fix them you must”.

posted on Thursday, December 20, 2007 6:18:36 PM UTC by Rajiv Popat  #    Comments [0]
Posted on: Thursday, November 29, 2007 by Rajiv Popat

Is Your Client Your Ally?

One of my first projects as a young developer, who was taking his first steps into software development, was a RUP / CMM / Waterfall text-book example of how successful projects should be run using Big Design Up-front Methodologies. It completed on time, it was on budget and it was transitioned successfully.

We had every single scenario and flow of the system documented. Every single change that was not elaborated resulted in a change request for which the client either ended up paying us more money or giving up the idea of wanting the change.

If you were to consider it a war, we won.

This so-called-success was one the biggest failures in my life as a software developer. A failure that turned me into a Shameless Developer and taught me things I would never have learnt otherwise. Later on I was also called in to support the crap the entire team (me included) had written and the same project also ended up teaching me how to refactor code ruthlessly.

Folks who worked with me in the project wondered why I considered the project a pathetic failure when it was transitioned with a successful UAT and we had a grand lunch to celebrate the project success. Here’s why:

"They’re changing their Requirements!"

"It’s there in the Use-case! Why didn’t they read the use-cases during elaboration?"

"What do they mean it’s just a validation change? It requires quite a bit of code change. I think this is a Change Request!"

"What do they mean by it’s not Quality? All the test-cases have passed, haven’t they?"

"What do they mean it crashes sometimes? They're supposed to give us the detailed steps to reproduce a bug! If they can’t give us the steps to reproduce the bug, we should just go ahead and close it."

Any of these sound familiar?

During the time we worked on this project, dialogues like these were a part of our daily lives. I heard these from team members more than once every day. It was a war and we were in it to win it.

Occasionally we would also hear whispers from the client which went somewhat on the lines of – “Umm… I’m not sure if this feature adds a lot of value” or “I wonder if we can…” – but who cared? We were building as per the approved specification.

We had spent a few odd months writing use-cases, test-cases, module specifications, low level system specifications, system requirement document, functional specifications, technical specifications and tons of other documents a lethal combination of RUP and CMM would require you to write and now we were there to ensure that they either stick to those documents or pay the price if they bothered us with changes while we were busy developing.

We had been constantly firing “them” with pages and pages of these documents, constantly reminding them that we were very organized team of guys who worked according to a systematic process. Anyone watching us, would have guessed that we were building a plan for a bridge, a building or a rocket when all we were building was a shitty piece of software that would hardly ever get used by anyone.

After sleep-less nights, meetings and brute force programming using incompetent mediocre developers, we, the team, delivered the project. The delivery and the UAT was the final blow and we got it over with before the client could even realize what the hell happened.

Things like usability, user experience and the like were never documented. So when they would come up asking us to reduce the number of clicks, we showed them a functional specification document, told them it was a change request and asked for more money.

More often than not they chickened out, which was good because we could comfortably meet the time-line. If they paid more money and wanted the change-request done, we would ask for more time and that would still allow us to comfortably meet new dead-lines.

After a few months of rigorous fighting, the project was on time and successful.

The client was defeated.

And that, by the way, is precisely why I consider the project a pathetic failure.

When I completed that project, the feeling of being a part of a team that had failed at achieving their fundamental undocumented-goal of building a system which is usable, wasn't particularly amusing. The fact that no-one in the team had even realized how badly they had failed, made things even worse. I went ahead and made a commitment to myself that I was going to get better at building good software and providing true value to my clients project after project.

When I made the commitment to myself, I thought that this is the lesson every programmer out there, who has been in the business of building software for more than a few kilo-seconds, must have learnt this same lesson the hard way. After all they don’t seem to teach these things in programming schools.

Years later today, I've lost touch with everyone from that project team but even today, all over the world, I see countless developers with years of work experience behind them, fighting their wars against their clients and winning every single one of them, one after another. With one war over they move to another and then another. Defeating client after client, not caring or giving a dam about developing deeper roots or getting better at what they do or even attaining enough skills to be able to provide true value to their clients.

Take a trip some of the larger software consultancy body shops in India and look around. You’ll be able find complete battalions of guys who specialize in RUP / CMM / Waterfall documentation which can even confuse veteran developers leave aside unsuspecting clients.  Walk down the corridors of these shops and you'll see developers talking about - SRS, FTC, UTC, CRQ  and countless other abbreviated document names, but you'll hardly hear them having white board discussions on how the code or design can be improved.

Everything, ranging from the abbreviated document names, long winded processes, bulky documentation which has no respect for DRY, code and design done with contempt for KISS and Orthogonality, is focused towards one goal – defeating the client in a war.

A huge number of these guys have been trained into believing that Big Design Up-Front is the only way to build software and that if a company isn’t doing RUP or CMM, it probably doesn’t know how to build software and if a team does not cross the size of twenty people they are not really building a good software. Every once in a while I will interact with folks from these body-shops - folks with a mind-set who believe that If a guy talks about backlogs, daily scrums and weekly iterations through sprints and particularly getting the client involved in active feedback, he probably is an alien who is contaminated with the Agile virus.

No wonder more than seventy percent of the software that is built, fails. No wonder software professionals are the most hated group of professionals in the world after lawyers. :)

Almost instantly after my first so-called successful project, I turned into a thick-skinned developer who fails early and fails often and started working for organizations / clients / managers who, till date, thankfully, have allowed me to fail early. Failing early in projects all these years has allowed me to be a part of projects which both the client and I can consider – successful.

Every single project that I’ve worked on since then, has been a war against time, a war against badly written code, a war against huge complexities and a war against so many other things, but thankfully, not a war against the client. I sure do hope things continue that way for me, project after project.

This is not about how you build software or your development process. After all, we all build shitty software. This is about "working with your clients" and providing them value for money. If you want to come remotely close to winning the battle of building decently acceptable software, you may want to start by having the client on your side.

The next time you write a thirty page functional specification for the login screen, followed by a twenty page login test case and send it to the client asking them to review it in a couple of day, ask yourself if you’re really helping them. Would they rather by happy seeing wire-frames followed by a quick five minute recorded screen capture video where you run them through mockups and re-iterated their requirements? Can you spice up your functional specifications and tempt your clients into reading them? Maybe they appreciate slightly  better ways of capturing functional specifications - How about trying to convert you functional specifications to a wiki?  

The next time the client tells you they can’t send you the steps to reproduce that bug, maybe you might want to do a code review on that module and check out if there’s an erratic bug hiding somewhere.

The next time all your test-case documents come back executed successfully from the Quality Assurance but the client is still not happy, maybe you might want to increase the code coverage your QA teams are testing. You may even want to consider writing a few Unit Tests to test your code and growing the number of tests over time to increase coverage.

The next time the client asks for a tiny business logic change and you find yourself complaining that they should have said that before - maybe you could have done a better job at making it configurable rather than leaving it hard coded in there. Maybe you never cared about Orthogonality.

Ask yourself - Are you sending out builds frequently? Can your client run your builds? Are you seeking constant feedback? Are you iterating fast enough?  

Rather than spending hours in building support for law-suite in our processes and documentation we as developers would be much more loved and respected by our clients if we spent this same time building good software and making life simpler and better for them. Confusing the client with documents is easy. Simplifying their life and building software that adds genuine value is hard.  

In the war of building good software, you have enough to fight against. Don’t rage a war against your clients. Make them your allies.

posted on Thursday, November 29, 2007 7:57:37 PM UTC by Rajiv Popat  #    Comments [0]
Posted on: Sunday, November 25, 2007 by Rajiv Popat

TacticSheet New Features - Announcement 3

For those of you who still don’t know what TacticSheet is – TacticSheet is a Free and Open Source Timesheet and Expense Tracking system. If you want more information about TacticSheet you can click here.

I've been busy at work for the last couple of weeks. I've also been traveling for a couple of days last week primarily for work but none the less, we’ve been putting in quite a bit of time every weekend on TacticSheet. I'm happy to say that TacticSheet is slowly and steadily starting to shape up decently well.  For the last two weeks we were a little slow at adding new features but we've been taking one step at a time and making sure we don't burn out in the long marathon ahead.

Here are some new features that have been rolled out based on the work we did last weekend and this weekend:

Introduction of 'Clients'

TacticSheet now allows you to add your clients to the system. Once you’ve done this, while adding a project TacticSheet will let you group and create project under a given client. In the long run this is supposed to allow us to answer multiple questions. For Example:

  1. How many clients does my organization have?
  2. How many projects are under each client?
  3. How many employees are dedicatedly working for a client?
  4. How many man-hours has the organization put in behind one client and their multiple projects?

Adding the concept of allowing you to add clients in the system and then group projects under each client opens up a host of possibilities for TacticSheet in the future. We're also hoping that it would help integrate with accounting and billing systems in the long run.

Introduction of 'Tasks'

For a day job, to earn my daily bread and butter, I work at an awesome software shop. We estimate each task for a project that we work on. Then we let folks take ownership of the task and work on the task. Once the tasks complete we go ahead and compare the estimated time with the Actual Time taken and this comparison allows us to get better at our future estimations.

Now TacticSheet allows you to store tasks under each project and allows employees to file their time against a task instead of a project.

This is supposed to open up new dimensions for TacticSheet once we move into reporting. Having this data in place will allow TacticSheet to answer questions like:

  1. How many employees worked on a given task?
  2. How many man-hours of work went into a given task?
  3. Which task in the project took the maximum amount of effort to complete?

Percentage Allocation and Percentage Criticality Captured During Allocation

In the last check-in we added the ability for enhanced employee allocation to projects into TacticSheet. In this check-in we also allow you to capture additional facts about the allocation:

  1. Percentage Allocation of the Employee – In a lot of organizations I’ve seen employees being allocated to more than one project at a given time. Now in TacticSheet, while allocating an employee to a project you can not only choose the time-line for which he will be allocated to the project but you will also be allowed to pick the percentage of his time you typically want him to give against the project.
  2. Percentage Criticality of the Employee – In a lot of organizations I’ve seen employees being assigned to a project to complete ad-hoc tasks. At times I’ve also seen employees being assigned to a project because they’re on the bench and having nothing else to do :) – Now in TacticSheet, while assigning an employee to the project for a given duration you can also choose the criticality of the employee to the project. A high criticality indicates that moving the employee out of the project might considerably impact the project and a low criticality indicates that the person can be moved to another project if he is really needed in a different project. In other words, a low criticality indicates that the employee is not critical in the project and moving him from the current project will have no or very little impact on the current project.

Minor Bug Fixes

An issue with TacticSheet with multiple connection strings being used by TacticSheet was reported in this thread of our mailing technology mailing list. We’ve gone ahead and fixed it.

What’s next?

More Features - good software is never complete and we’ve hardly started yet. More features, posts and goodness coming up! Stay tuned!

posted on Sunday, November 25, 2007 5:15:40 PM UTC by Rajiv Popat  #    Comments [0]
Posted on: Monday, November 5, 2007 by Rajiv Popat

TacticSheet New Features - Announcement 2

If you are interested in a free open source Timesheet and Expense-sheet tracking system built on C# 3.0, .NET 3.5, LINQ and Orcas Beta 2, you should checkout TacticSheet. A couple of weeks we announced a development version of TacticSheet live. You can read that announcement and learn more about TacticSheet here. We also published our First New Features Announcement Last Week and announced a couple of new features which are expected to add a lot of power to TacticSheet when we move to our first release.

If you're a .NET developer you could go grab a copy of the latest TacticSheet code from TacticSheet Source Forge SVN and start playing around with it. You can also go ahead and join our General Mailing List or the TacticSheet Technology Mailing List.

A lot of new ideas have started coming. I’m bubbling with ideas myself and new ideas are also being thrown at me by folks who are interested in using TacticSheet when it reaches a release ready stage. We’re taking one step at a time and adding a few new features every weekend. Here’s what we’ve added to TacticSheet this weekend:

Enhanced Resource Allocation while Creating Projects

While allocating employees to Project it was natural for me to provide a Move-List in the Edit Project / Project Creation screen so that you would be able to allocate employees to project:

At the first glance the idea seemed good enough for the basic project allocation requirement that we had and made a lot of sense. You could allocate employees to a project and they would work on the project till the project ended. If you wanted to stop employees from filing Timesheets pertaining to that project you could remove them from the project team.

Apparently, it looks like people who have been using commercial timesheets for a long time feel that this is the biggest pain-point of some of the commercial timesheet entry systems.

A commercial timesheet entry system I looked at while playing around with the idea of writing TacticSheet seem to be doing exactly the same thing I did initially with TacticSheet, which is to allow you to either assign employee(s) to a project or unassigned employee(s) from a project.

Last week someone who saw TacticSheet and had used a couple of other timesheet entry was very helpful in giving feedback. He brought it to our notice that In reality, organizations tend to be much more dynamic. Here are some scenarios where the basic assumption that if employees are assigned to a project, they will work on the project during the entire span of that project, creates a nightmare for the administrators:

  1. An Employee will need to work on the project just for the first three months of the project.
  2. An Employee will need to join the project three months after the project started and will work only for two more months after which he will need to be moved from that project into another project.
  3. An employee will be allocated to a project and will work for two weeks in that project. Then he will be moved out of the project and will be needed again for two weeks, three months later.

A couple of commercial Timesheet entry systems I saw while playing around with the idea of building TacticSheet just allow you to either add employee(s) to a project or remove employee(s) from a project when they are no longer needed. Which means in case of the above scenarios administrators would find themselves manually remembering (or relying on emails sent by Project Managers) to add and remove resources from a given project.

One of our goals while creating TacticSheet was also to provide a Timesheet System with the Infrastructure that will allow folks integrate TacticSheet with external systems and consume the Timesheet data from multiple other systems.

When I think of a full blown Resource Management System talking to TacticSheet, the whole idea of adding resources to a project for the entire course of the project and not letting the administrator choose for how long an employee would work on a project, sounds fundamentally wrong.

This weekend we ended up addressing this issue and we seem to have solved it rather elegantly.

TacticSheet now offers a separate Project Allocation screen. This screen allows you to add an employee to a project which is what most commercial timesheet entry systems also allow you to do.

The same screen also offers an advanced allocation option - which allows you to pick the exact dates or range of dates for which the employee will be involved with the project. You can add the sample employee to the project multiple times by choosing different start dates and end dates as long as these start dates and end dates don’t overlap for the same employee.

The screen allows you to address all three scenarios I described above using TacticSheet.

The same feature is also going to allow us to give you a lot of other additional kick-ass features in the future. For example, storing this data will allow TacticSheet to look into the future and see how many guys are really busy and for what time durations. Having this data there opens up a new dimension of reporting for us and will let us do some awesome reports primarily on the Resource allocation side in the future.

More features, goodness and posts coming up in the future. We have barely started, and are far from done. Stay tuned for more!

posted on Monday, November 5, 2007 5:39:48 PM UTC by Rajiv Popat  #    Comments [0]
Posted on: Wednesday, October 31, 2007 by Rajiv Popat

TacticSheet New Features - Announcement 1

A few days ago we completed building the basic framework of TacticSheet, uploaded a development sprint of TacticSheet and announced it live. TacticSheet is an Open Source Timesheet and ExpenseSheet System built on .NET 3.5, C# 3.0, LINQ and Oracas Beta 2. If you haven’t heard of TacticSheet or want to learn more about it, click here.

This weekend I worked on a couple of other enhancements to make this product much more usable in the long run. Some of the features completed this weekend include:


Support for Timesheet Audit Trails

Respecting the iron triangle plays a vital role in any software project. But when you are only giving time to a project only during free time, weekends and holidays this prioritizing becomes vital. Audit trails for timesheets was on my mind when I played around with the basic idea of building TacticSheet. Dropping it out of the first sprint I uploaded on source-forge, was purely a matter of respecting the iron triangle and realizing that I lacked time.

I found some time this weekend and this was one of the important features that I really wanted TacticSheet to have - So obviously it made it into TacticSheet. Today, you can see audit trails at timesheet level right on the same screen where you are filing your time using TacticSheet. We decided to draw inspiration from most commercial time-sheet entry systems out there and call our timesheet based audit trails "Timesheet History".

For audit-trail purposes we also go ahead and catch data at each timesheet line item level, but these audit trails are not shown anywhere on the TacticSheet screens because we don’t see these adding a lot of value for most organizations. Given the stage where TacticSheet stands today, we need to focus on other important features before we get carried away with making audit trails better.

We still store the trails on a line item level and keep them there because we want TacticSheet to adhere to general auditing principal - delete nothing. In future, as the application grows, this is expected to allow us to provide screens which will provide detailed audit trails and deeper insight into what happens inside each timesheet every time it changes state.

Our Database is Now Scripted and under SVN

We’ve gone ahead and brought out database under SVN by scripting it out to a proper database project. Now you can have the database created by running a command file located under the database project which is included in the code base.

Running this single command file will have TacticSheet create the database schema and all sample data needed to get the application up and running. Once the file runs successfully, change your web.config connection-string to the right database. Once done, you can launch TacticSheet and login using default credentials (username: admin password: admin).

Setting up the development environment of TacticSheet is now stupid simple! So there’s no reason why you shouldn’t try it out. Go ahead, grab the latest copy of the code from our SVN and give it a dry run. Drop me an email and let me know what you think.

Employees should not be able to Un-submit Approved Timesheets

After I announced TacticSheet live I received a few emails from folks encouraging me, congratulating me and wishing me good luck. I also got a couple of feedbacks from guys who are not into .NET, but work with a lot with timesheets. Some of these feedbacks were fairly valuable. For example, one of the observation that was made was:

“Employees should not be allowed to un-submit timesheets which have already been approved”

I looked at this one with a little bit of skepticism. So if an employee makes a mistake, how does he fix it? After a little bit of communication back and forth the person who had requested the feature explained:

  1. A normal user is allowed to un-submit timesheets which have been submitted by him till they are approved.
  2. Once approved, the user should not be allowed to un-submit the approved timesheets.
  3. The administrators however, can un-submit even approved timesheets on behalf of the user so that the user can go ahead and fix his mistakes.
  4. Once un-submitted by an administrator, the user will need to re-file that timesheet and the timesheet will have to go through approval process all over again.
  5. No approved timesheets can be deleted. Not even by the administrator. Administrators can un-submit the timesheet which have been approved.
  6. Once un-submitted the timesheet can then be deleted by the employee himself.
  7. All of this is audit trailed so there is no confusion.

In general the above rules made a lot of sense and are now a part of TacticSheet.

We have more features, goodness and posts coming up! Stay Tuned!

To stay informed about TacticSheet new features you can sign-up to the TacticSheet Mailing List. If you are an enthusiastic .NET developer and want to stay informed about the technical changes we’re making to TacticSheet signup for the Developer Mailing List. We have barely started, and are far from done. Stay tuned for more!

posted on Wednesday, October 31, 2007 10:36:17 AM UTC by Rajiv Popat  #    Comments [0]
Posted on: Thursday, October 25, 2007 by Rajiv Popat

TacticSheet - Open Source TimeSheet and ExpenseSheet System Built On .NET 3.5

Last couple of weekends, I started work on an Open Source Timesheet Entry System using .NET 3.5, C# 3.0 and ASP.NET, which, for no particular reason, was named TacticSheet.

In the coming months (depending on the number of free weekends I get :)) TacticSheet will have its own domain domain name, a full blown website and a steady open source life cycle but for now that I seemed to have reached a logical point where I can at-least see the basic functionality of the application taking shape. I could hardly resist the temptation of sharing TacticSheet with fellow developers and my blog readers.

If you care, here’s a quick FAQ of TacticSheet (or a list of few questions that might be going through your head right now as you read this :)):

What is TacticSheet?

It’s a Free and Open Source Timesheet Entry System which in the long run is supposed to provide the the ability to do Timesheets and Expense-sheets within an enterprise.

Can I Use TacticSheet in My Organization Today?

No. It’s far from being production ready yet. It has the basic framework which will allow people to file timesheets and project managers and line managers to approve or reject timesheets. As of Today TacticSheet is not fully stable, not fully tested and may have a lot of breaking changes in the next months as it moves towards a Release 1. Some of the very important features that most organizations would need e.g. Audit trails, email notifications etc. are currently missing. To make things worse, even our database isn’t scripted yet. :)

In the coming couple of months we’ll be working to get these issues ironed out so that you can start using TacticSheet in your organization and upgrade safely to a new version every time a new version comes out. Till then, feel free to play around with TacticSheet Development builds, but please don’t deploy them to production environments.

If it’s not fully ready why are you announcing it live?

Because good software is never complete. :) On a serious note, I’m interested in getting some feedback and contributions from the community, fellow developers and above all - you dear reader! Go to our Source-Forge Home Page, grab the source code from our SVN (or Browse our online SVN), try it out, drop a comment or email and let me know what you think about the application!

We don’t have a lot of documentation on setting up the development environment but we're hoping most folks will find it very straight forward. If you want help setting it up, please drop question(s) in the Product Forum and we’ll be happy to answer them.

If you think you’ve found a bug, please file it here.

Feel like contributing? Read on!

How Can I Contribute?

We’re looking for a few one-man-armies who are thick skinned developers and people who are into shipping good software (not just writing documents and following crazy process!). We really think the world could use one more Timesheet entry system built on .NET, especially if it’s free and open source! Do you?

Besides kick ass developers, we are also looking for UI folks and people who can test the application inside out! Interested?

If you fall in any of the above categories, are fortunate enough to find some free time during weekends and crazy enough to write code during that free time, Email me using the “mail” icon on the left panel of this page and we can discuss how you can contribute.

You can also contribute by Submitting SVN Patches, filing bugs or just participating in the forums.

What’s the Technology Stack?

We’re starting out with .NET 3.5 and Beta 2 Release of Orcas. Of course whenever Orcas RTMs, (end of this year / next year), we will be working to ensure that TacticSheet migrates over to and works with the RTM version. For the enthusiastic and passionate .NET developers here’s the technology stack TacticSheet uses:

  1. Orcas Beta 2.
  2. .NET 3.5.
  3. C# 3.0.
  4. LINQ to SQL.
  5. XLINQ.
  6. ASP.NET Ajax and ASP.NET Ajax Toolkit.
  7. SQL Server 2005. (But there’s no Reason why you couldn’t make TacticSheet work in SQL Express!)

How Can I Stay Informed about the Project?

We have 2 different mailing lists – depending on the kind of involvement you want to have to the kind of information you want to stay updated with feel free to join any one of our mailing lists.

  1. The General TacticSheet Mailing group – Users who are interested in staying informed about the new features of TacticSheet can sign up for this mailing group.
  2. The TacticSheet Technology Mailing Group – We will be discussing most new technologies we use in TacticSheet here whenever we decide to use a new technology. We will also be discussing the design and technical changes that TacticSheet undergoes in the future in this mailing group.

When will TacticSheet Development Complete?

As of now, I don’t think I’ll ever be ‘done’ with this project, which is the whole point! I’m a firm believer of supporting everything I write. I intend on extending and supporting TacticSheet for years to come. Watch out for a lot of new features and version, year after year!

Why are we writing TacticSheet?

This calls for a long post, but for now let’s just say - Because, we can. (You can expect another detailed post on this topic in the near future :))

What’s the TacticSheet License?

The product is currently under GPL. Also, we do not allow or encourage forks of TacticSheet for the time being. I personally feel that the product is too premature for now and forking will add to confusion. As the product grows we plan on moving to a much more liberal license like FreeBSD.

Even though the license is strictly GPL we are fairly liberal towards the use of TacticSheet – it’s primarily written for a hobby and not with an intent of making money – so if you want to do something crazy with the code-base please email me and we’ll see to it that you can do whatever you are trying to do without being charged or sued :).

So, now that TacticSheet has finally been born, wish us luck and growth! Stay tuned for more posts, features and goodness.

posted on Thursday, October 25, 2007 6:30:46 PM UTC by Rajiv Popat  #    Comments [4]
Posted on: Tuesday, September 18, 2007 by Rajiv Popat

Did You Loose Your Visual Studio Intellisense?

In one of my older posts I announced out loud and shamelessly that I find it really difficult to code without intellisense. Besides Intellisense, I’ve always been for tools which increase developer productivity. A couple of months ago I played around with a Resharper 3.0 Trial to see what the interesting new features were. I have all good things to say about Resharper 3.0 but this post is not about any of those good things. It’s about one tiny little complaint I have towards Resharper Trial.

It killed my Visual Studio Intellisense.

After I had installed it and played around with it for around a week I lost intellisense from my Visual Studio – suddenly and completely. I could use the Intellisense Resharper offered me but Visual Studio Intellisense wouldn’t work while the trial was working. Soon the Resharper trial was over and the Resharper Intellisense died as well. Another colleague had a similar problem. She had tried out Resharper, and had lost her intellisense as well. Google and you'll see a few others running into similar problems.

As soon as I lost intellisense, I hit Resharper Options and told it not to use Resharper Intellisense and to use Visual Studio Intellisense instead – restarted my Visual Studio - didn’t help.

Turns out, whatever Resharper had done to turn Visual Studio Intellisense off is very easy to undo. Turning intellisense on or off in Visual Studio is a simple option I didn’t know about. In-fact, it is a part of those thousands of IDE options that a lot of us don’t even know exist.

If your Visual Studio Intellisense does not work, because you installed resharper and it killed your Visual Studio intellisense (or if your Intellisense doesn’t work for any other reasons) here’s a process to get back your Intellisense:

The picture pretty much sums up all you need to do to get your intellisense back in Visual Studio but if you’re a “Follow-the-instructions” kind of guy here are the instructions:

  1. Hit Tools / Options in your Visual Studio.
  2. On The Left Tree click Text Editor / All Languages.
  3. Under Statement completion ensure that “Auto list members” is checked with a tick mark. (Make sure that this option is fully selected and not partly selected)
  4. Under Statement completion ensure that “Parameter information” is also checked with a tick mark. (Make sure that this option is fully selected and not partly selected)

If you’ve downloaded Visual Studio 2008 / Orcas Beta Releases and have observed that you do not get intellisense (for whatever mysterious reasons) the above procedure works with Oracas too and will help you get your intellisense back. And if you're like me, hopefully with your intellisense back, the world will seem like a slightly better place to live in. :)

posted on Tuesday, September 18, 2007 8:28:13 AM UTC by Rajiv Popat  #    Comments [11]
Posted on: Monday, September 10, 2007 by Rajiv Popat

Setting Up Intellisense With Ruby on Rails.

I’ve always been a Microsoft Developer. Besides the productivity that Microsoft Tools offer me, here’s a little dark secret on why I’ve always been a Microsoft developer:


Yes, it’s the single feature that got me away from C, C++ and GW-Basic and made me take a jump towards Visual Basic years ago.

Intellisense might be the single best gimmick that Microsoft pulled in the history of computers but it sure did wonders - for thousands of developers around the world. It helped thousands of folks move to Microsoft Development Environments.

It’s obvious that today no one does Intellisense like Microsoft does. With Visual Studio 2008 – they’re getting even better. In fact Microsoft does it so well, that even Wikipedia acknowledges it:

IntelliSense is a form of automated auto-completion popularized by the Microsoft Visual Studio Integrated Development Environment. It also serves as documentation and disambiguation for variable names, functions and methods using metadata reflection.

Ok, so where does Ruby on Rails come in all this discussion about Intellisense and Microsoft?

As Billy Hollis describes in his rather funny video on code addiction, our goal as software developers is not to write code. Our goal as developers is to provide the maximum value to the client and users for lesser pain, lesser risk and lesser cost. One of my mentors at work is often heard saying – “We need to build systems that are - Cheaper, Better, Faster”.

With the amount of buzz that has been going on the Ruby on Rails Side and how it can bump up Developer Productivity, I couldn’t help but investigate. Last weekend, I wandered a little distance away from .NET and took a casual stroll into the uncharted territory of Ruby on Rails.

<Aside> Before you drop an email, message or ask, No I’m not leaving Microsoft Development – it’ll continue to be my bread, butter, hobby and passion going ahead :) – but I like knowing what the other smart folks around the world are up to and I must admit, that the Rails community is definitely up to something!</Aside>

I even borrowed a copy of Agile Web Development with Rails and browsed through parts of it. I would highly recommend this to anyone who’s interested in doing some serious work with Ruby on Rails.

One of my primary concerns as I worked on downloading and installing Ruby on Rails was getting intellisense to work with Ruby on Rails. I’ve been spoilt my Microsoft. Now I demand intellisense in every single IDE that I am expected to double click and open; leave aside programming in it.

Move away from Microsoft and Visual Studio.NET and you are bound to be faced with choices about which IDE you’ll use. With Ruby on Rails I was faced with a few choices:

  1. Sapphire Steel – If you're a Microsoft Developer, this thing let’s you code with Ruby on Rails from within the homely environment of Visual Studio.NET. But shelling out money? Naah! It's a little bit too much to ask from me :) Not for a casual hobby! Not until I have other options.  
  2. Text-Mate on Mac – even though my machine looks like a Mac it’s hardly a Mac, so this option was pretty much ruled out. 
  3. Aptana RadRails on Windows / Windows Vista – Free and open source (Yeah! Now we’re talking!)

Of course, I settled for Aptana RadRails. Needless to say, I downloaded it using the big fat “Download Aptana RadRails (Win)” button on the website.

After I had it installed, I “railed” (created) my first few “Hello World” Ruby on Rails projects using the command prompt and started running them on WebRick (for those who have never tried out Ruby on Rails, which I assume will be around 99%+ of the people reading this line of this post :), WebRick, is supposed to be much like the Cassini in the .NET World).

So, by now I was generating my controllers and scaffolding my screens and code. Basically I was loving it, but I wasn’t getting Intellisense and that was making me feel a little - frustrated.

Turns out that Intellisense support is pretty much present in Aptana. However, it’s not very easy to find.

Now this could be either be because of usability issues on the website, given the fact that this instruction button is hidden here (link updated as of 03/14/08) or because I was a little asleep (I was trying this out at 2:00 in the morning) but I couldn’t figure out how to get intellisense on Ruby installed for a couple of hours.

Anyway, the instructions for getting Ruby on Rails intellisense with Aptana are available here and once you click that link – the instructions have been listed under – Aptana M8a/Eclipse 3.2/Rails plug-in Instructions. The instructions of-course, are a little deceptive – they state: To add Rails Support to Eclipse 3.2 and then the section provides detailed instructions on setting up intellisense with Ruby on Rails.

Now, there'll be folks like me who don’t know much about Eclipse and who will say – “Eclipse!? What Eclipse? I just downloaded Aptana. How do I get Ruby on Rails Intellisense with Aptana?” - If you’re like me and don't like reading the manual or in general, don’t know much about Eclipse (because you come from a Microsoft world or for any other reason) don’t worry – these are the same instructions you want to follow for Aptana and you’ll have intellisense working for Ruby on Rails.

Once you’ve followed the instructions you can even go – File / New / Project and pick “Rails Project” instead of “Railing” your projects through the command prompt!

That’s it for the day dear reader. You have a link to the book, you have a Free Ruby on Rails IDE for you Windows box and you have Intellisense with Ruby on Rails. What else do you want? Free Ruby Lessons!? :)

Seriously! Go play around with Ruby on Rails.

posted on Monday, September 10, 2007 2:58:40 PM UTC by Rajiv Popat  #    Comments [2]