Over the years, I have sampled approaches to software development ranging from RAD, XP, Waterfall, Agile, Scrum, SOA, TDD, and have recently started looking more seriously at the BDD/DDD(D) camps. However, throughout my forays into this potpourri of acronyms and metaphors for programming, I continue to find myself falling back on the crutch of GDD – the least Agile and productive approach of all.
Yes, I’m referring to none other than the ubiquitous Google-Driven Development (GDD).
Its like when I first realized how dependent upon Intellisense I had become, except now I find that GDD is far worse since it is simultaneously more subtle, insidious, and disruptive. At least Intellisense tries (yet arguably fails) to help you get things done faster, but GDD despite its popularity and benign appearance is truly the greatest time-sucking vortex in the universe.
GDD dulls the developer’s mind, lulls us into a complacency about trying to solve problems ourselves – since by simply Googling, you can let others provide an answer for you. GDD is like dark-matter obscuring developers from grokking quality software engineering. It is the elusive Higgs-Boson particle of development that is driving us toward anti-productivity and mediocrity. It is the reason why aspiring developers’ growth often stalls mid-career, becomes stunted and eventually causes them to revert to (MS-style) demoware quality development rather than maturing into true software engineers, craftsmen, and thought-leaders of the industry. GDD is more subtle than the common-cold and a greater pandemic than H1N1, and it must be eradicated. [1]
Inevitably if we continue to abuse GDD, we may one day be faced with a future similar to that depicted in the fictional (yet highly plausible) movie Idiocracy where our development communities are filled with below-average developers and hacks who are ruled by a few barely-average people and their well SEO implemented code repositories.
Diagnosis
I implore you to perform this self-diagnostic test today to see if you too have acquired the GDD addiction:
Ban yourself from Google (and/or Bing) for 1 day…If you find that you struggle to produce code without searching for 3rd party libraries & open-source, notice a sense anxiety at being unable to find blog code samples, feel concerned that you cannot validate your ideas against posts in forums and sample apps, or cannot make coding progress without seeking out online API’s and reference sheets, then you too may suffer from Google Driven Development. [2]
Remedy
GDD is difficult to completely eradicate from our lives, however here is a proven 7-step approach that helps to reduce its harmful affects;
- Blank Browser - Change your browser start-page to about:blank (or equivalent) rather than a search page.
- Cleansing Period - Perform a 1 week cleansing period of total search abstinence.
- Moderation - Afterward, slowly reintroduce Google and other search tools with extreme moderation.
- Reward Abstinence - Reward yourself each time you successfully complete a task without search that normally you would have. (note: don't use GDD as a reward for GDD abstinence)
- Cheat Hour - Schedule one timed GDD Cheat Hour each week where you allow yourself to indulge in unadulterated hard-core GDD. (Note: make sure the 1 hour isn't exceeded)
- GDD Diary - Keep a log of how much time you use search tools for development. (Tools like RescueTime.com may help)
- GDD Monitoring - After 21 days of intense anti-GDD focus & moderation, open up your calendar and schedule 1-2 days of GDD abstinence each month to measure your progress. If abstinence of GDD still causes excessive anxiety, repeat these 7-steps.
Note: beware that its common to see GDD sufferers seek-out alternatives, or shift habits towards Twitter, StackOverflow, and other social networking sites. These are just variants on GDD, each with its own set of problems, thus should be avoided. [3]
Good luck!
[1] Okay, I’m not really saying never reuse code, but hey, try writing some stuff yourself first and at least you will better understand the problem rather than taking other developers’ word on how to solve it.
[2] There is obviously some truth in this post, but I really hope you don’t think that I’m totally serious and off my rocker with all this stuff. Its just a fun way of pointing out something we all know already, which is that we tend to go down rabbit-holes when we google anything, and waste more time googling and digging than it might have taken to write it ourselves in the first place.
[3] This is also a belated partial-rebuttal of Phil Haack’s 2007 post “Increase Productivity With Search Driven Development” in which he argues the value of Search for code/solution discovery. I don't even mention the risks to Intellectual Property and job security if you are a commercial product developer…
I’ve watched and read most of the flame wars about WebMatrix and Microsoft.Data with equal parts bemusement and alarm. I wont rehash everything, since Evan has already neatly done so in his blog post yesterday, but I will offer this thought…
Eventhough we are rightfully concerned about the direction Microsoft is going, and where its spending its time on developing the Microsoft .NET Development Platform, over the past few years, it seems that the public .NET Community has become more and more elitist and biased towards “purity” in programming to the extent that anything less than perfectly crafted code is failure.
We increasingly look around at other platforms and see the green grass growing and envy Java’s patterns-driven community, PHP’s low cost hosting and startup-success, and Ruby’s simplicity and elegance and wonder why Microsoft thinks so differently than the others.
In the case of WebMatrix, the truth is Microsoft is changing their approach, and its not all bad if you put it in the right context as David Heinemeier Hansson (creator of Ruby On Rails) does for ruby on rails in his video “There’s No Such Thing as a “Pure” Programmer”. Please watch the video below and imagine substituting “WebMatrix” for Ruby on Rails.
Now, I’m not saying that WebMatrix is going to achieve the greatness and success that RoR has, in fact I think its a fairly naive attempt at best so far. However, I think Microsoft’s goals are very much in line with those that led to the creation of Ruby on Rails.
In the end, you can fault Microsoft’s implementation, but their goals are definitely valid and well proven with BASIC, PHP, Visual Basic, and even Excel macros and many other technologies that began their lives and succeeded BECAUSE of their focus on simplicity and enabling non-technical people to attack & solve complex challenges.
As David says, we NEED new developers and new ideas, and that means we need to lower the bar to do so. Now the debate should be HOW to do that, and that's where I think we, the community can help by putting together our own WebMatrix and helper frameworks that perhaps demonstrate use of good patterns under the hood, but make things as simple as Rails does for creating apps.
So, the question really isnt whether WebMatrix is good or evil, or the pill is blue or red. Its a question of does the .NET framework, ASP.NET, and its development community evolve to become more and more complex and advanced and eventually make it impossible for anyone but PhD’s and those of us who grew up with the platform to write code or do we begin to look at the entire development ecosystem and try to bridge that gap.
I ran into the following error recently in Visual Studio 2010 while trying to port Phil Haack’s excellent T4CSS template which was originally built for Visual Studio 2008.
The Problem
Error Compiling transformation: Metadata file 'dotless.Core' could not be found
In “T4 speak”, this simply means that you have an Assembly directive in your T4 template but the T4 engine was not able to locate or load the referenced assembly.
In the case of the T4CSS Template, this was a showstopper for making it work in Visual Studio 2010.
On a side note:
The T4CSS template is a sweet little wrapper to allow you to use DotLessCss to generate static .css files from .less files rather than using their default HttpHandler or command-line tool. If you haven't tried DotLessCSS yet, go check it out now!
In short, it is a tool that allows you to templatize and program your CSS files so that you can use variables, expressions, and mixins within your CSS which enables rapid changes and a lot of developer-flexibility as you evolve your CSS and UI.
Back to our regularly scheduled program…
Anyhow, this post isn't about DotLessCss, its about the T4 Templates and the errors I ran into when converting them from Visual Studio 2008 to Visual Studio 2010.
In VS2010, there were quite a few changes to the T4 Template Engine; most were excellent changes, but this one bit me with T4CSS:
“Project assemblies are no longer used to resolve template assembly directives.”
In VS2008, if you wanted to reference a custom assembly in your T4 Template (.tt file) you would simply right click on your project, choose Add Reference and select that assembly. Afterwards you were allowed to use the following syntax in your T4 template to tell it to look at the local references:
<#@ assembly name="dotless.Core.dll" #>
This told the engine to look in the “usual place” for the assembly, which is your project references.
However, this is exactly what they changed in VS2010. They now basically sandbox the T4 Engine to keep your T4 assemblies separate from your project assemblies. This can come in handy if you want to support different versions of an assembly referenced both by your T4 templates and your project.
Who broke the build? Oh, Microsoft Did!
In our case, this change causes a problem since the templates are no longer compatible when upgrading to VS 2010 – thus its a breaking change. So, how do we make this work in VS 2010?
Luckily, Microsoft now offers several options for referencing assemblies from T4 Templates:
- GAC your assemblies and use Namespace Reference or Fully Qualified Type Name
- Use a hard-coded Fully Qualified UNC path
- Copy assembly to Visual Studio "Public Assemblies Folder" and use Namespace Reference or Fully Qualified Type Name.
- Use or Define a Windows Environment Variable to build a Fully Qualified UNC path.
- Use a Visual Studio Macro to build a Fully Qualified UNC path.
Option #1 & 2 were already supported in Visual Studio 2008, so if you want to keep your templates compatible with both Visual Studio versions, then you would have to adopt one of these approaches.
Yakkety Yak, use the GAC!
Option #1 requires an additional pre-build step to GAC the referenced assembly, which could be a pain. But, if you go that route, then after you GAC, all you need is a simple type name or namespace reference such as:
<#@ assembly name="dotless.Core" #>
Hard Coding aint that hard!
The other option of using hard-coded paths in Option #2 is pretty impractical in most situations since each developer would have to use the same local project folder paths, or modify this setting each time for their local machines as well as for production deployment. However, if you want to go that route, simply use the following assembly directive style:
<#@ assembly name="C:\Code\Lib\dotless.Core.dll" #>
Lets go Public!
Option #3, the Visual Studio Public Assemblies Folder, is the recommended place to put commonly used tools and libraries that are only needed for Visual Studio. Think of it like a VS-only GAC. This is likely the best place for something like dotLessCSS and is my preferred solution. However, you will need to either use an installer or a pre-build action to copy the assembly to the right folder location. Normally this is located at:
C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PublicAssemblies
Once you have copied your assembly there, you use the type name or namespace syntax again:
<#@ assembly name="dotless.Core" #>
Save the Environment!
Option #4, using a Windows Environment Variable, is interesting for enterprise use where you may have standard locations for files, but less useful for demo-code, frameworks, and products where you don't have control over the local system. The syntax for including a environment variable in your assembly directive looks like the following, just as you would expect:
<#@ assembly name="%mypath%\dotless.Core.dll" #>
“mypath” is a Windows environment variable you setup that points to some fully qualified UNC path on your system. In the right situation this can be a great solution such as one where you use a msi installer for deployment, or where you have a pre-existing environment variable you can re-use.
OMG Macros!
Finally, Option #5 is a very nice option if you want to keep your T4 template’s assembly reference local and relative to the project or solution without muddying-up your dev environment or GAC with extra deployments. An example looks like this:
<#@ assembly name="$(SolutionDir)lib\dotless.Core.dll" #>
In this example, I’m using the “SolutionDir” VS macro so I can reference an assembly in a “/lib” folder at the root of the solution. This is just one of the many macros you can use. If you are familiar with creating Pre/Post-build Event scripts, you can use its dialog to look at all of the different VS macros available.
This option gives the best solution for local assemblies without the hassle of extra installers or other setup before the build. However, its still not compatible with Visual Studio 2008, so if you have a T4 Template you want to use with both, then you may have to create multiple .tt files, one for each IDE version, or require the developer to set a value in the .tt file manually.
I’m not sure if T4 Templates support any form of compiler switches like “#if (VS2010)” statements, but it would definitely be nice in this case to switch between this option and one of the ones more compatible with VS 2008.
Conclusion
As you can see, we went from 3 options with Visual Studio 2008, to 5 options (plus one problem) with Visual Studio 2010. As a whole, I think the changes are great, but the short-term growing pains during the migration may be annoying until we get used to our new found power.
Hopefully this all made sense and was helpful to you. If nothing else, I’ll just use it as a reference the next time I need to port a T4 template to Visual Studio 2010.
Happy T4 templating, and “May the fourth be with you!”
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.
More Posts
Next page »