Its odd to me to be back here again typing away, putting effort into this long dormant repository of random thoughts. I guess that I became disillusioned with blogging somewhere along the way.
In the beginning, I loved finally having a place to exchange ideas with other developers, stake my claim to a piece of virtual real-estate and proclaim my ‘genius insights’ into development techniques & technologies. I thoroughly enjoyed the early days being part of a small group of founding members of this blog dating back to the .Text days, its evolution into Community Server and dotnetweblogs.com, and its eventual Microsoftization when Telligent sold-out Scott’s baby to Microsoft who hosted & rebranded it as weblogs.asp.net. I even liked social media enough to join Telligent for a few years and contributed a bit to their rise. However, at some point blogging got too big, too competitive, and too commercialized. Then it became ‘Social Media’ and tens of thousands of consultants came out of the woodworks to proclaim themselves “Social Media Strategists”.
Frankly it got a bit weird, lost its way, and stopped being fun!
I remember the day when Community Server got so expensive to upgrade that the early adopter users, community-creators, and contributing-developers couldn’t afford it anymore – and then the licensing somehow got muddled such that the former open-sourced product wasn’t so open anymore. I witnessed blogger, livejournal, wordpress, and the likes be bought-up, commercialized, homogenized and/or commoditized for the masses. For a while, it was nice to see the over-priced commercial social media products get competition from their Free counterparts, but then the advertisements crept in, ‘journalists’ became bloggers and it all felt like watching network-TV without a DVR to skip the commercials.
Hey, I don’t begrudge anyone making a buck where they can, but it exploded in such a ridiculous way that it quickly lost its innocence & joy.
It wasn’t just the commercialization that stole my blogging thunder, it was also the people who were blogging. A few early tech-bloggers soon found web-fame and often improved employment due to their writing, so they doubled-down and baked up a career just from their blog posts. This quickly spread like wildfire and advertisers, software companies, and book publishers starting paying bloggers, building exclusive networks, and generally sucking the life out of the once innovative, creative, and unique collections of bloggers.
If popular bloggers would write a review about their products, they would be compensated. Surprise! Rarely did those reviews turn out negative. Even as poor of a writer I am, I was even approached a few times, and in cases where the product or book was a dog I felt embarrassed to blog my true thoughts, so instead I was morally compelled to return the “Free” product to its owner with a note explaining that they would not like what I wrote.
As my mother always said “If you cant say anything nice…”.
Today, it seems like the number of ads (mine included) dominate the number of unique thoughts shared in blogs. The TMZ-crowd and the infomercial snake-oil peddlers own massive SEO farm sites that gum-up and obstruct any attempt at providing useful or witty information. Sure there are still blogs & bloggers of value out there, but its hard to see the forest for the trees, separate the wheat from the chaff, or {insert your own equivalent inane saying here}
Bloggers that I used to follow have mostly moved to Twitter, Google+, and the like and may only keep a blog for stuff that’s just too big for those venues. Sure, there are other reasons such as to promote themselves or books they write, or help get consulting gigs.
A lot of dev-bloggers just choose to quit blogging and prefer to speak through their code on github. Perhaps that’s the way it should be…
I still think there was something lost when blogging jumped the shark, and today there remains an opportunity if someone can offer an innovative new way for developers to share their thoughts in more than 140-characters and without building circles, friends lists, profiles, professional networks, or indulging other inane distractions that detract from their wonderfully self-absorbed musings.
For those bloggers still at it, for the pure art and ego-stroking love of sharing technology with likeminded nerds, I salute you. For the rest of you, peddle your commercialized nonsense elsewhere.
Anyhow, this post is a bit of an apology to both of the readers who may still follow me. Sorry for going away for so long, but at the same time this is less of a return to blogging than an explanation of why I’m still not back….
Disclaimer: the thoughts, opinions, and history discussed in this blog post are my own, no others. Factual discrepancies, may be present, but I lived it, and this is my blog, so I get to tell it the way I remember it. If you disagree, go write your own blog post. 
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!”
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 »