I was recently talking to a company about their development team’s adoption of new technology, frameworks, and the overall sophistication of their projects. During the conversation, the IT manager made several comments about wanting to become a more “complete” development shop.
This made me start thinking, how do you measure and compare one development shop with another? What does it mean to become a “complete” development shop?
I hear a lot of attempts to characterize one company as being “behind”, “ahead of the curve”, or on the “bleeding edge” but often times each person’s assessment of each company is so subjective to their own experience and skill set. Furthermore, the types of technologies each company use and the business needs they serve often vary dramatically, therefore so do their goals. So its hard to truly know the real comparative value of one development team or company to another without segmenting them into categories and/or coming up with some standardized tools for measurement.
In the past I have passively explored the concepts around the Capability Maturity Model (CMM), which is a topic seems to really fit this discussion. CMM focuses upon the stages of growth every IT shop goes through during its evolution;
- Ad-hoc
- Repeatable
- Defined
- Managed
- Optimizing
I think this is a good start in assessing an organizations “completeness”, however, it primarily focuses upon the process of software development not the technology, team-effectiveness, or rate-of-completion. CMM is incredibly useful, yet the aforementioned IT manager was really referring to all areas of their development. Yes, there was discussion of using Agile/Scrum and having a well built development environment using Team Foundation Server, but he also mentioned a number of other things such as what version of .NET they were using, the types of patterns & frameworks they had adopted, their ability to turn-on-a dime, and the relative skill level of developers implementing their applications.
Many of the details we discussed assumed an adoption of Microsoft’s development technologies, approaches, and general paradigm. So, on the one hand, you could easily take this methodology/technology stack and create a specific set of measurements for how the stages of growth of each company and compare on this bases. This would be good if all development shops thought the Microsoft Solutions Framework (MSF) was the ultimate goal and end-point of an organization, but the reality is that many do not.
Every shop is different, and many value ALT.NET technologies such as Mono, MVC, NHibernate, NUnit, Rhino Mocks, Subversion, Cruise Control, and other non-Microsoft tools much higher than those within the Microsoft development paradigm. Of course, there are also many shades of grey out there in the industry between MSF and ALT.NET. So, this brings us back to attempting to group together companies based upon their chosen, or trying to compare apples and oranges based upon other more platform agnostic factors such as flexibility, velocity, and quality.
But, at some point, I have to stop and ask myself “is this effort even important?”.
I know that its a great source of pride for some companies to say they are the “best and brightest” or are the “movers and shakers” in the industry, and undoubtedly if wielded properly, it can help enhance their recruiting of the best and brightest in the industry.
However, are there other values to a company beyond recruiting?
I guess it depends upon the type of company. For example; if you are a consulting firm or a product development company its a huge asset to sales of your products and services to customers who might value such a comparison of technologies & proficiencies.
But, what about traditional enterprise business where their development effort is not to deliver a product or service directly via technology, but instead they sell some tangible widget and simply use technology to perform internal logistics, supply chain, or customer-service functions? What is the value within these companies to using the newest technologies? What is the true ROI of continuing to adopt the latest & greatest technologies in these companies as compared to some other company who decided long ago that COBOL or FoxPro were sufficient for their business?
I think there is plenty of anecdotal evidence and case studies of how certain new technology and processes have been effective at reducing time-to-market, or producing greater results. But where are the numbers to qualify those examples?
Rather than just assuming newer technology is automatically better, I would like to see a more quantitative set of tools to measure these results and share them with the world so those companies who truly shine and benefit from these processes & technologies and shine the way for others in an objective and meaningful way.
Thoughts? Opinions?
...since I was here last. I'm sure my subscriber count has dropped significantly since November due to my lack of new posts.
Some may wonder what has been going on lately. If not, then go back to Facebook and find someone more interesting or at least less verbose than me. :)
Okay, great, for those of you still here, this is my attempt at an explanation for my absence from this blog for these past few months and an update on where I stand today:
Around October, I got busy with my work at Telligent on the "#1 project in the company". As many of my friends know, I can be a bit obsessive towards my work, especially when I am properly motivated and this project was no exception. As with many previous projects, I spent a ton of time on and off the clock working on things relating to our implementation of these sites built on Community Server 2008 (2008 beta, 2008.5, and 2008.5 SP1). The project was great, because it involved multiple sites broken out by language/culture and had many extensive modifications to the default Community Server product.
This was a big project; it involved very high scalability, required custom modules, data-extensions, forum/blog data migrations, enterprise search integration, and other work that involved collaborating with our fluctuating team of 4-8 developers. Not to be outdone, our client's entire company of business people, IT personnel, designers, and project managers were engaged from top to bottom and everyone had a stake (and often a say) in the project. My hours were long, but the work was challenging, my coworkers were exceptional, my ability to impact the project and team was great, and I was continuing to grow my knowledge in many areas of technology including Community Server, ASP.NET, Sql Server, SSIS, performance/scaleability, Debugging, Lucene.NET, and many other topics in the process.
This project grew and evolved much from those early days until we released in November/December and began on the next iteration. Throughout the end of 2008, I spent my spare time at home creating 3 Graffiti sites for myself, for my wife, and for an unnamed side project I've been working on. Also, I got acquainted with JQuery a bit, built a few ASP.NET MVC sites, and watched about 80 hours of PDC 2008 videos. Subsequently, I did some playing around with Microsoft's Azure Services Framework and started to grok cloud computing and Microsoft version of this concept.
Somewhere in there, I found time to volunteer as a coach on my son's basketball team, even though my wife was constantly busy with work and going back to school for her Master's degree. This coaching gig was perhaps my most rewarding project yet.
In 2009, the new year started off with a lot of planning and cleanup at work, which led to an opportunity to revamp our development processes around Software Configuration Management, Release Management, and QA. I had used Subversion and other version control systems for years, and I understood the value of setting up Cruise Control for continuous integration. Creating branches & tagging releases were habits that I now performed without thinking - it was all just part of the tools used for development.
In the gap between iterations, we reassessed the project, and where we could improve. I realized that although we knew the mechanics, we hadn't truly understood the discipline and the philosophies required to use these tools effectively to ensure developer productivity, to ensure changes to sourcecode within a project remain isolated, and to ensure releases are purposeful, repeatable, and contain only the changes you want, not just everything that happens to be in Trunk. In short, I realized how many assumptions we made that needed to be reevaluated. Luckily, I was tapped to spend the time to research & improve these weaknesses and turn them into strengths.
The short time I spent educating myself on Software Configuration Management concepts and their application was invaluable and is something that will help me throughout my career. These skills and concepts empower us to delivery better quality software no matter if the team has 1 developer or 100. Sadly, over the 15 years in technology, I don't recall ever hearing developers talk about their Branching Strategy, Codline Policies, or have a project lead define basics such as who can perform trunk-merges, and when/how should branches be created, or what the naming conventions should be for those branches & tags. We just did our development and reacted when necessary. Isnt that the Agile way?
Alas, I digress.... Suffice it to say, I learned a ton, directly applied it to our team, who rejoiced, and we began collectively kicking butt on the next iteration of the project.
So, in the midst of all this personal growth, incredible work experience, and smattering of entrepreneurial activity, I became so focused upon the work, my toy projects, my family, and my plans for how to achieve global domination that I was completely blindsided when one morning Rob Howard came to my office in a crisp formal executive outfit with a member of our finance department and asked to have a closed-door meeting in my office.
First, you have to understand that at Telligent, it is our culture that we all wear shorts, jeans, flip flops, t-shirts or whatever makes us comfortable enough to crank out outstanding sites with incredible code in a timely fashion. Occasionally you would see people dressed up, but it was typically only for a meeting with a client, otherwise everyone just gave the Telligenti a hard time and joked that they must be going job hunting, or perhaps attending a funeral.
So, anyways, Rob shows up, very nervous and pale, launches into his brief story of economy woes and so forth, and how unfortunate it is that he must reduce the workforce, yada yada yada - all the while I'm sitting there thinking....didn't I just stay here until 8pm lastnight working on this project?!?! Didnt I put my heart, personal/family time, and my entire future into this job? Why didnt I see this coming?!?!?
The truth is that I didnt WANT to see this coming. I didnt WANT to see reality. I knew the stock market, I knew about Jive's 30% cutback in staff. The warning signs were everywhere. My mom even works at HUD and had repeatedly warned me about the foreclosures and challenges she was seeing firsthand across this country. I just kept my head in the Azure clouds and blissfully ignored my cynical heart thumping out distress calls in multi-threaded unmanaged code.
I drove home in my 2 month old 2009 Honda Civic Hybrid, in a daze not even paying attention to the 10am Dallas traffic as my box of belonging clanked & slid back and forth in the back seat. The conversation with a hastily called head-hunter still ringing in my ears and one question running through my head.... How will I tell my wife?
My wife was incredible. She took it in stride, said a few expletives about Telligent, and began to focus on the future and helped me clear the cobwebs. I spoke to some of the other ex-Telligenti, and participated in the subsequent explosion of interest on Twitter. The people in the Twitterverse as well as the local community response were great! Shortly I was sending my resume' to several developers & thought leaders within the Dallas/Fort Worth .NET community, and began working on my future.
At this point, it doesn't matter why Telligent had their Reduction in Force - I am out and I need to come to grips with that fact.
The upside is that it wasn't personal, wasn't because of me or my work, I was just a salary & an office to them which they needed to eliminate. In fact, later I discovered that I was neither the first, nor the last who received Rob's earnest & dour talk that day.
Its late now, early Monday morning and only 7 hours before my first interview. The anger & angst is gone and I'm giddy with excitement about the future. As much as I hated to leave Telligent, I love new opportunities, and look forward to meeting some great people this week as I begin to interview again. It feels a lot like when I started in software development; the possibilities are limitless and the opportunities are exciting, I just cant wait to get started with my job, company, and project so my obsession with technology and the comradery with a great dev team can begin again.
I stumbled upon this today and definitely want to play with this further when I have time....
SeaDragon Ajax
http://livelabs.com/seadragon/
"The aim of Seadragon is nothing less than to change the way we use screens, from wall-sized displays all the way down to cell phones,
so that graphics and photos are smoothly browsed, regardless of the amount of data or the bandwidth of the network."
Deep Zoom Composer
http://www.microsoft.com/downloads/details.aspx?familyid=457b17b7-52bf-4bda-87a3-fa8a4673f8bf&displaylang=en
"...a tool to allow the preparation of images for use with the Deep Zoom feature currently being previewed in Silverlight 2. The new Deep Zoom technology in Silverlight allows users to see images on the Web like they never have before. The smooth in-place zooming and panning that Deep Zoom allows is a true advancement and raises the bar on what image viewing should be. High resolution images need to be prepared for use with Deep Zoom and this tool allows the user to create Deep Zoom composition files that control the zooming experience and then export all the necessary files for deployment with Silverlight 2."
I'm currently on a project creating a proprietary data-migration tool using C# & Linq. I'm still new to Linq, but quickly discovered the challenges of doing mass-updates and deletes with Linq.
Specifically, by default Linq to Sql generates a sql statement for each row you are updating. There is no built-in way to do large batch-updates or deletes without dropping to custom SQL. After a quick search, I found this great article and sample code by Terry Aney on Batch Updates and Deletes with LINQ to SQL.
It offers solutions to many of the basic problems with some elegant extension methods so you can do things like:
1: be_Posts.UpdateBatch( first10, new { Author = "Chris Cavanagh" } );
2:
3: and
4:
5: var posts = from p in be_Posts select p;
6:
7: be_Posts.UpdateBatch( posts, p => new be_Posts { DateModified = p.DateCreated,
8: Author = "Chris Cavanagh" } );
Cool stuff!
When updating Sql columns that need a minimum or maximum date, consider using the defaults from the System.Data.SqlType namespace:
1: DateTime minDate = SqlDateTime.MinValue.Value
2:
3: // and
4:
5: DateTime maxDate = SqlDateTime.MaxValue.Value
This can be a lot safer than putting hard-coded "magic date" constants in your code.
I like this article by Nathan Henkel, its essentially about assessing risk and scope of projects and strikes me as a simple truth about the uncertainties you encounter in every project:
Information about any project can be divided into four categories:
1. Things we know (and know we know)
2. Things we know we don't know
3. Things we think we know, but don't (i.e. things we're wrong about)
4. Things we don't know we don't know
Obviously, if you were to try to actually figure out where everything falls, you would put everything into 1 or 2. Everything that should be in 3, you would put in 1 (you're not going to have known mistakes in your information), and everything that should be in 4 would simply be missing.
However, without dealing with specific items, I do think that it's possible to guess at how much "stuff" goes in each category. You can take into account your history ("I tend to often be mistaken about X"), or a general feeling of ignorance ("I've never used framework Y before") to guess how much goes in each category.
http://simplyagile.blogspot.com/2007/10/classifying-information-or-what-we-know.html
Sometimes, I think we get so wrapped up with what we “know” about a project that we fail to quantify what we don’t know, or the degree of certainty to which we actually know what we think we know. As with solving any problem, the first step is to find a way to quantify and measure uncertainty and risk in order to minimize it.
If you track this measurement over time, it should also help your estimation and planning on future projects.
Good stuff!
I got an email yesterday that a major update to the Argotic Syndication Framework was released. I have used the older versions of this framework several times for projects that need basic RSS & Atom parsing/generating so I'm looking forward to digging-in to the new release.
If you are not familiar with it, here is a quick blurb:
The Argotic Syndication Framework is a Microsoft .NET class library framework that enables developers to easily consume and/or generate syndicated content from within their own applications. The framework makes the reading and writing syndicated content in common formats such as RSS, Atom, OPML, APML, BlogML, and RSD very easy while still remaining extensible enough to support common/custom extensions to the syndication publishing formats. The framework includes out-of-the-box implementations of 19 of the most commonly used syndication extensions, network clients for sending and receiving peer-to-peer notification protocol messages; as well as HTTP handlers and controls that provide rich syndication functionality to ASP.NET developers.
To learn more about the capabilities of this powerful and extensible .NET web content syndication framework and download the latest release, visit the project web site at http://www.codeplex.com/argotic.
Also, here are some of the new features in this release:
a) Targeting of both the .NET 2.0 and .NET 3.5 platforms
b) Implementation of the APML 0.6 specification
c) Implementation of the BlogML 2.0 specification
d) Native support of the Microsoft FeedSync 1.0 syndication extension
e) Simplified programming API and better online/offline examples
Brian has done an amazing job on this project from the start. I had intended (and still hope) to jump in and contribute some of my own work, so its great to see how far it has evolved from its first releases.
If you work with RSS, ATOM, or any other syndication format/protocol, you should definitely take a look at this framework for your next project.
After several months of using the Free version of the ClearContext addon for Microsoft Outlook, I just cant imagine what I would do without it. It has reduced my email time, kept me more organized, and uncluttered my Inbox better & faster than any ad-hoc system I have devised in the past.
As a developer, I hate it when I have to "code in Outlook". If it were up to me, I would ban all email during a project and deal with all communication via instant messenging, Scrum meetings, and whiteboards, but the truth is that email is a neccessary evil especially as a Tech Lead who needs to interface with the Project Manager, Customer, and IT personnel.
Enter ClearContext Information Management System...
First, I set it up to flag emails from my bosses in Red, so I dont miss them. Plus, for good measure, I have an Outlook rule that sets a FollowUp flag to make sure I dont overlook them. Also, ClearContext automagically ranks emails based upon my prior history with this person, so I know what to do when I get some nice blue and green colored mail too.
If I receive an email relating to my current project, I simply hit ALT-P to popup the CC dialog and flag it with the topic "projects/MyProject" then either leave it in the inbox for further review, or hit ALT-M to file the message for future reference. Accordingly, if I receive some corporate or administrative relating email, then I assign it's topic appropriately and file the message to send it to its respective holding area.
The act of assigning a Topic (ALT-P), automatically creates subfolders within my Inbox (e.g. inbox/projects/MyProject) matching the topic name (Note the trick of adding a "/" to the topic name to create a nested subfolder at the same time). The act of filing a message (ALT-M), moves it to the subfolder identified by the topic name. This is great because the messages are nolonger visible in the Inbox listing, but are still within the Inbox via the subfolder.
At that point, my AutoArchive settings will take care of moving it off on a monthly basis in case I need it later.
At some point, I want to look at the full product, which has features for deferring emails, converting them to tasks & appointments, assigning them to other people, etc. See their Features Overview section for more on these areas.
If these features are nearly as useful as the ones I use now, then I could *gasp* become even more productive! woot!
Whenever I lead a project, I always try to plan in such a way that sets me and my team up for success. I do this in many ways, starting with a good methodology, doing thorough analysis, and providing a level of risk/certainty along with any estimates I provide.
Part of this strategy involves ensuring that client expectations match developer and project expectations. I tend to use the tried and true approach; "Plan for the worst, hope for the best".
Some people see me as a pessimist, but I beg to differ - I consider myself a cynical, yet optimistic, realist. By that, I mean that although I do plan everything based upon the worst case scenario, in my heart I truly believe we are going to achieve the best case scenario every time. It often surprises me when people take my approach to be negative while at the same time, I often see their approach naive & overly optimistic.
The truth is that there seems to be a gradient scale of attitudes and philosophies employed from project to project depending upon the people leading and participating in the project.
Over the years, I started a private game in my head of creating nicknames for the different patterns of behavior. Here are a few names of I have toyed with in the past:
"Expect the worst, then add 20%" - The Pessimist
"Expect the worst, hope for the best" - Reformed Pessimist
"Expect the best" - Mr. Optimist
"Expect the best, but prepare for the worst" - Fallen Optimist
"Plan for the worst, hope for the best, but expect something in between" - Uncle Realist
"Just do it!" - El Toro
"It is what it is." - Aunt Apathy
"I don't want to hear about risks, just tell me when it's done." - The Ostrich
"Oh, you arent done yet?" - Captain Oblivious
"How much longer?" - The Waiter
Which one are you? Is there one philosophy or attitude you believe works better than others?
I have been working on a project lately that was already using the Telerik ASP.NET Rad Controls suite. One of the new features was a fully editable web-grid, so I chose to use the existing ajax-enabled RadGrid control to speed my development. I chose to use a 3rd party control, mostly due to time constraints since the project required a grid with inline-editing, full CRUD operations, plus custom column templates, all with heavy Ajax support to avoid postbacks and excessive page size.
I soon discovered, the Telerik controls are nice tool for simple uses where you can use asp.net DataSource controls and automatic databinding, but not so much if you need to get "fancy" with your implementation. In my case I needed to do 2 things that cross over into the grey area where these controls excel.
First, I'm using an early 2.0 version of NetTiers for the DAL (with Service Layer implementation) with custom mods to the entities as the datasource, and second, I'm doing some aggregate custom ItemTemplates that require custom data-binding.
This lead to extreme complexity in the implementation because, A) this version of NetTiers' had problems with properly generating CRUD operations for its EntityDataSource controls (NetTiers entities mapped onto a custom ObjectDataSource style control) which prevented me from using the declarative model, and B) the RadGrid control simply sucks if you cannot use automatic databinding and if you require custom databinding logic.
It would be great if I could upgrade NetTiers and/or Teleriki RadControls to the latest versions, but it wasnt possible in this situation, nor is it likely that this would have solved my problems.
Anyhow, all this discussion is basically just to share you this one link to a user-contributed example I found incredibly useful after 3 days of searching their forums, demos, and 3rd party blogs. This example shows how to manually implement Insert/Update/Delete functionality within the RadGrid control by handling the events OnNeedDataSource, OnItemCommand, OnInsertCommand, OnUpdateCommand, and OnDeleteCommand:
http://www.telerik.com/community/code-library/subm...
The reason this link is important is because the Telerik website, with all of its dozens of examples, consistently shows very basic scenarios, even in samples labeled "advanced". Also, not all of the API features are fully or well documented to help you figure this out on your own.
Hopefully this simple link (which should be promoted to Telerik's demos/samples page) will help someone else as much as it did me.
More Posts
Next page »