Random Web Developer

NCacheD (Part 1)

2010-03-10T11:19:00.001-08:00

NCacheD (pronounced N-cache-D) is live on CodePlex at http://NCacheD.codeplex.com. The original intent of this project was to create a very simple, bare bones distributed cache system. It was meant to be an exploration into how such a system works and how it could be implemented in .NET. And to provide a skeleton for a more powerful cache system in the future.

As far as distributed cache systems go, Memcached and Velocity are the main options in .NET and NCacheD is intended to be another alternative. Memcached is known for it's raw speed and Velocity (or I think it's now called AppFabric caching) seems more intended for cloud computing (this might be inaccurate but at this time it's still only RC.)

Memcached gets it's speed from being small and being written in C. That has it's advantages for sure but for a .NET shop and .NET developers it can also be problematic. It can be hard for non-C developers to understand exactly what's going on with C code. And it can be even harder to modify and fit to your specific needs. If you want to run the code as-is, I think this is fine but if you want to integrate it into your system and especially into your code base, you want to use the same platform.

When I started thinking about how a distributed cache system must work I saw two important pieces or hurdles to overcome: the cache server must know the size of the objects it's holding so that the total size can be controlled to ensure as little paging as possible (we want to keep it all in RAM), and it must ensure that different clients will communicate with the same server for the same key value. If client 1 has an object with key "products2010" on server 1 and client two has the same object with key "products2010" then not only are we wasting space, but we run into serious problems when client 1 updates the cache and client 2 is unaware of any changes to "products2010".

Determining the size of an object in C# is not a trivial task. Because it is all managed code, there is no way of counting the bytes on the stack or heap. But I realized that determining the size of the objects in a distributed cache system would be pretty easy. In order to send the objects over the wire, they must first be serialized. And the length of the resultant byte array was in effect, the "size" of the object. I could also store the object as a byte array on the server since the serve would never care about the actual type of the object.

Ensuring that every cached item's key goes to the same server every time was also not too difficult. NCacheD uses a pretty simple method for doing this. It will check the total available size of each server (assuming all clients use all the same servers) and will "weigh" the servers by their sizes. It will then create a small lookup table of servers giving out slots based on weight. And when a request is made to determine the server by the key, the key is hashed, modulo, and used to determine the particular server.

With these two parts figured out, the next step was to create a simple cache class for the server (which turned out to be a wrapper around a ConcurrentDictionary<>), a client/server networking system for which I used WCF to keep it simple, and then the rest was plumbing which was greatly simplified by the TPL (Task Parallel Library.)

Next time I'll talk more about how the server is determined and the way the cache itself works.

Consolidation, the Lost Art

2010-02-18T11:49:00.001-08:00

While working with the Google AdWords API, I discovered a forgotten principle (or lost art) of software engineering. It is called “Consolidation”. This principle, I believe, must have somehow fallen through the cracks when people started talking about DRY, KISS, SRP, etc. But I believe it will revolutionize the way we write programs.

Up till now it was commonly thought that breaking logic apart into easily manageable pieces was a good way to build software. “Divide and conquer,” we said. We thought that having well-named, meaningful blocks of code was the best approach to take for creating flexible, maintainable applications. We always thought that two very simple lines of code would always be better than six that did the same thing.

We thought wrong.

The following description of “Consolidation” is taken from http://code.google.com/apis/adwords/articles/migrating.html#consolidation

Inspiration

2010-01-25T11:49:00.001-08:00

"the first chess program put into practice was designed by legendary British mathematician Alan Turing in 1952, and he didn't even have a computer! He processed the algorithm on pieces of paper and this "paper machine" played a competent game." - Garry Kasparov

Learning a New Language

2009-09-29T09:16:00.001-07:00

Since I got my Mac, I've been trying to learn Objective-C, Cocoa, Cocoa Touch, Xcode, and the rest of the iPhone development stack. As I spend more and more time on this, I've noticed some parallels between learning a new programming language and learning a new spoken language.

A few years back I moved to Central America and, among other things, learned Spanish. Learning Spanish was a long, slow, difficult process. At one point in the process (maybe a few months in) I realized that Spanish is not just a literal translation of English. That is, you can't just translate the words from English to Spanish. You also can't just translate the grammar from English to Spanish.

Aside from the basic spelling and grammar rules, languages are made up of many things such as styles, idioms, phrases, mannerisms, local accents, dialects, and more. Because of this, the trick to learning a new language (once you already have a basic understanding of the syntax and grammar) is to try and think in the new language. You want to try and make the dialects and colloquialisms your own. You don't want to just translate directly as your speaking as this usually leads to pidgin. You want to fluently express yourself in this new language and be understood as well as possible.

Translating this to learning a new programming language, you can see that just knowing the syntax and APIs of the new language is not enough. When writing code in a new language you want to own that new language. You want the code to look like it was written by someone fluent and familiar with the language. This will greatly improve the quality and maintainability of the code.

This means that when you learn a new programming language, you should learn the coding standards as well. So when you write code in C#, it should look like C# and should not use hungarian notation. And when you write code in Objective-C, it should use the Objective-C styles and it shouldn't look like .NET or anything else. It can be difficult to adjust to different code/language styles but you haven't really learned the new language until you've done so.

How much to you trust Microsoft?

2009-09-16T14:14:00.001-07:00

Being a .NET (Microsoft stack) developer requires a substantial amount of trust in Microsoft. I have to trust them to stay in business. I have to trust that having in-depth knowledge of there technologies is a good economic decision for my years ahead. I have to trust them to fix bugs in there software, trust the quality of their products like IIS, Windows server, Visual Studio, SQL Server, and others, and trust them to support the technologies I use for the foreseeable future. I have to trust that the web sites I develop will work properly when running on their platform.

This is a lot of trust. And Microsoft has been working hard for years to gain it. But now they are asking for an entirely new level of trust. With Microsoft's cloud computing services called Azure, Microsoft is asking us to not only trust their software but their hardware as well. They're now asking us to trust them to take care of all the infrastructure and to trust that everything will work just fine in their hands.

This is a big step. And so I wonder if Scott Guthrie's announcement yesterday about putting jQuery and Ajax.NET on their new Ajax CDN is not just an act of goodwill but is also intended to help build trust in Microsoft hosted web content. Maybe it's a bit of both.

Performance of an Asp.Net Page versus an Http Handler

2009-09-11T11:23:00.001-07:00

A coworker recently mentioned to me that he was thinking about using an http handler instead of a page for performance reasons. My first thought was of a quote I saw in a comment on StackOverflow "He who sacrifices correctness for performance deserves neither." I like the quote. But it doesn't really say much about the problem at hand.

My second thought about these options is that I have trouble imagining that the ASP.Net page life cycle's way of calling events and virtual functions would really add much overhead. Especially if these requests will have to communicate with the database. I would think that the cost of calling the database would far outweigh the cost of generating the page.

But talk is cheap. The code for my page is very simple:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="PerfTestPage.aspx.cs" Inherits="WebSandBox.PerfTestPage" %>Hello

The code-behind for the page is just an empty partial class declaration. "Hello" is on the same line as the page declaration so I don't end up with extra "\r\n" charecters in my response stream.

The code for the handler is equally simple:

public void ProcessRequest(HttpContext context)
{
  context.Response.Write("Hello");
}

After wiring up the page and the handler in IIS I created a seperate project to do the performance testing. The call to get the request does a simple GET request and ensures that the text "Hello" came back on the response.

public static void DoRequest(string url)
{
  WebRequest request = WebRequest.Create(url);
  request.Method = "GET";
  WebResponse response = request.GetResponse();
  string resp = (new StreamReader(response.GetResponseStream())).ReadToEnd();
  if (resp != "Hello")
      throw new Exception();
}

To ensure that the test is fair, I'm going to call each request a bunch of times before actually timing them. This will ensure that I'm not testing calls that are warming up IIS. In addition, this is all locally so network/wire time should not be a factor in this. Here is the test runner:

static void Main(string[] args)
{
  var page = "http://localhost/WebSandBox/PerfTestPage.aspx";
  InitializeTest(page);
  var pageTime = RunTest(page);

  var handler = "http://localhost/WebSandBox/PerfTestHandler.axd";
  InitializeTest(handler);
  var handlerTime = RunTest(handler);

  Console.WriteLine("page time: {0} ms", pageTime);
  Console.WriteLine("handler time time: {0} ms", handlerTime);

  Console.ReadKey();
}

static void InitializeTest(string url)
{
  for (int i = 0; i < 20; i++)
  {
      PerfTester.DoRequest(url);
    }
}

static long RunTest(string url)
{
  var sw = new Stopwatch();
  for (int i = 0; i < 1000; i++)
  {
      sw.Start();
      PerfTester.DoRequest(url);
      sw.Stop();
  }
  return sw.ElapsedMilliseconds;
}

For this test we're executing each request 1,000 times to make the time more significant. Here are the results:

	Page (ms per 1,000 requests)	Handler (ms per 1,000 requests)
	6186	6259
	6152	6216
	6145	6182
	6156	6208
	6133	6201
	6169	6190
	6536	6416
	6161	6190
	6162	6189
Average	6200	6228

I don't understand why or how the page is faster than the handler. Maybe IIS is doing some kind of caching. Or maybe there was additional traffic and CPU usage on my computer during these tests. But at around 6.2ms per request, I don't see much of a difference.

Also, this test is only for very simple text "Hello". There would of course be additional overhead when using Asp.Net controls on the page. But I would doubt that the overhead of these controls would far outweigh whatever method the handler would use to generate the same HTML. And that's another topic entirely.

The moral of today's story, "measure twice, cut once".

My new MacBook

2009-09-03T10:45:00.001-07:00

This Monday I received a MacBook so I could create an iPhone application.

This is the first time I'm using a Mac since my mom brought home something like this before I was in highschool. This is also the first time I'll be using a linux type of system since college. Needless to say I'm very excited.

I've started playing with it a little. I downloaded XCode and the iPhone SDK. You can see in the photo that I learned how to change the background color. I think this is probably one of the most common things people do right after turning on a new computer for the first time.

After using C# for the last bunch of years, Objective-C is like getting in a time machine and going back 10 years. So many practices that I've come to take for granted are gone. I'm doubt I'll ever come to grips with the "NS" prefix for everything.

At the same time, the MVC framework to Cocoa seems pretty cool. And the idea of message-passing for dynamic invocation of methods in a strongly typed system is very interesting.

In addition to my thoughts and feelings about the platform, framework, language, hardware, etc. it's also cool to be starting from scratch again. I barely know how to save a file on the Mac. I haven't explicitly used a pointer in almost 10 years. I'm excited to see what the learning curve is like and exactly what programming skills really do transfer between languages, frameworks, etc. I've been learning F#, haskell, python, and ruby out of personal curiosity but now I have to actually build something in Objective-C. Should be interesting.

Dynamic Stored Procedure Execution

2009-09-01T16:37:00.001-07:00

With the imminent arrival of the dynamic keyword to C# I think we will be seeing more prototypes of ways of putting dynamic objects to use within .NET. One interesting use is Phil Haack's method of HTML encoding properties that are predicated with an underscore. After reading about this I wanted to try creating my own dynamically driven class.

Disclaimer: I'm still on the fence over the use of dynamic in C#. I'm not advocating the use of this code. I just wanted to see if it was possible and what it would look like.

One problem with ORMs is mapping stored procedures. This is usually a manual process because stored procedures are inherently not typed. So I was envisioning something along the lines of:

IList<Person> people = DataContext.Sproc.ExecuteGetList<Person>.spGetPeopleByDOB(dob: myDate);

For the purpose of this prototype, I decided not to use any real data context. That could be added in easily enough. For now, I'll be rolling my own data layer.

Step 1 - Create a simple DataContext:

Step 2 - Create the Sproc class

This class will basically be a factory for different dynamic stored procedure executers. This way we can easily differentiate between ExecuteScalar, ExecuteNonQuery, getting an object, and getting a list of objects. For now, I'm going to implement ExecuteScalar<T>:

Step 3 - Create the DynamicExecuteScalar<T> class

The real magic here is the use of TryInvokeMember. This is the function that will be invoked at runtime whenever someone calls a method on your DynamicObject. So when I call myDynamicExecuteScalar.CallingSomeMethod() I'm actually calling TryInvokeMember.

Inside of TryInvokeMember we use binder.Name to get the name of the method called (eg. "CallingSomeMethod"). Then we use the binder.CallInfo.ArgumentNames and args[] to get a list of named parameters that we can turn into our sql parameters.

Once you have this code wired up, you can get a scalar for any stored procedure from your code simply by calling:

And using this as a starting point you can add ExecuteNonQuery, ExecuteGetList<T>, etc. You can also modify the data context to be more extensible and mockable.

Design vs. Structure

2009-08-25T15:08:00.001-07:00

In many conversations about development, words like design and structure are thrown around. It is important then when discussing software development to understand the differences between the two.

According to Merriam-Webster, design is

a particular purpose held in view by an individual or group... deliberate purposive planning

The definition of structure is

something arranged in a definite pattern of organization... manner of construction

The difference is that a design is about purpose while structure is about organization. Code that is structured but has no purpose for it's structure may as well not be structured at all. There is no cohesion, no single responsibilities, and no reason for a class to exist if it exists for structure alone. When we set out to structure our code, we should have a design purpose in mind.

Another way of saying this is "form follows function". Determine the function and the form will follow. Determine the design and the structure will follow.

Member Variables are not Global Variables

2009-08-24T13:08:00.001-07:00

It is widely accepted that global variables, in almost any context, are a bad practice. But there is a common practice that leads to code that is harder to maintain - the use of member variables for passing information between functions for a particular set of functionality. This is a subtle way of creating global variables in that they are "global" between functions.

As an example, let's look at the code below. For this example, we're going to assume that "memberVariable" is not used anywhere else but "DoA()" and "DoB()".

private bool memberVariable = false;

public void MainFunction()
{
   DoA();
   DoB();
}

private void DoA()
{
   // do some stuff

   if(something)
       memberVariable = true;
   else
       memberVariable = false;

   // maybe do something else
}

private void DoB()
{
   // do some stuff

   if(memberVariable)
       DoOneThing();
   else
       DoAnother();

   // do more stuff
}

Member variables are used for maintaining the state of the particular object. But as can be seen in this case, "memberVariable" does not contain state. It contains a flag that is particular to the logic of "MainFunction()". This is a bad practice because it is very hard to know what "DoB()" is going to do without also examining "DoA()". If this were expanded further and the class had many functions, it would be difficult to know who uses "memberVariable" how and why.

There are a number of ways to refactor this code to change the use of "memberVariable". DoB() could take memberVariable as a parameter or retrieve it's value by calling another function. Even though there are different ways to alleviate the problem, the idea is the same. Functions should be autonomous and not require other functions being executed in order to work properly. And even if a "global" variable is only global to two private functions, it's still global.

Don't Arbitrarily Reference the Base Class

2009-08-19T11:59:00.001-07:00

All too often I have seen developers referencing properties and methods of the base class directly. Instead of calling “this.SomePropertyOrMethod()” or just “SomePropertyOrMethod()” they call “base.SomePropertyOrMethod()”. This has a number of drawbacks.

1) It implies that a class knows something specific about the parent.

2) It is now difficult to override the method in this class or a class that inherits from the current class. The base version of the method will always be called even if the method is overridden.

3) This defeats the purpose of object oriented programming. Calling the base class directly is akin to calling the same method on a utility class. The only difference is that the base class might be looking at the current class’s state. It’s just messy.

4) This is a code smell that makes me think of the Base Bean anti-pattern. “A class should not inherit from another class simply because the parent class contains functionality needed in the subclass.”

Now there are definitely times when this is necessary and that is why the keyword exists in the first place. If I’m overriding Page.OnLoad, I should call base.OnLoad at some point. If I override List<>.Add, I better call base.Add() to add the item to the list.

But just because you can do something doesn’t mean that you should. And this keyword is no different. Most cases of base.SomePropertyOrMethod() should be replaced with this.SomePropertyOrMethod().

Maintenance Cost and C# Auto Properties

2009-08-11T21:59:00.001-07:00

Auto properties in C# provide a simple way to implement a property on a class without explicitly creating the field that the property accessors (get and set) will work on. There have been many discussions on whether or not auto properties are good, their advantages, and their disadvantages. Looked at from a code-maintenance perspective, an auto property is much better.

When maintaining code, one big problem is making sure that the code you’re maintaining isn’t doing anything tricky that will make it difficult to modify or fix. This is one of the reasons why SRP and DRY are so important. If there’s only one place that does something and that place is only responsible for the one thing that it does, a code maintainer’s life is very joyful. When this is not the case, a small change or fix may have detrimental repercussions.

With this in mind, there is a maintenance cost to not using auto properties. If there’s a field hidden under your property, as a maintainer of your code, I now have to check all uses of the field as well as all uses of the property. With an auto property, the property is the only thing that needs to be investigated.

When explicitly creating a field for a property it is important to consider the costs of doing so. In addition, it’s important to ask if this field is really necessary. Can all your methods access the property instead? If so, why even have this extra level of misdirection. Chances are YAGNI plays a big part here.

DeflateStream versus GZipStream

2009-03-18T09:17:00.001-07:00

DeflateStream and GZipStream are the two compression classes that come standard in the System.IO.Compression namespace. If you're looking for all out performance, DeflateStream is the answer. According to msdn,

The GZipStream class uses the gzip data format, which includes a cyclic redundancy check value for detecting data corruption. The gzip data format uses the same compression algorithm as the DeflateStream class.

GZipStream is basically DeflateStream with some additional functionality and integrity checking. So if you only care about speed, DeflateStream will be faster.

How I Didn't Get in Trouble

2009-01-02T13:59:00.001-08:00

A few months ago I noticed a significant performance problem during the application startup of the really big, web system I work on. It was literally taking up to a minute and a half for IIS to load up the application.

After some digging I found out that the application was loading about a million records or so from the database into the application's cache. Regardless of the decision to implement this, I did not want this happening locally. I couldn't test any of my work. I couldn't develop.

Where I work, even though we all have a local development environment, we all share the same development database server. And these million or so records were being loaded by a stored procedure aptly named spGetAll[Things].

I notified my boss and the developer responsible for creating this stored procedure about my problem and told them that I was practically unable to work and that we had to change this behavior in our development environment. They said that it would be done... And I waited... and waited...

And after a day and a half, I modified the stored procedure to return only the top 20 rows - problem solved! But I knew that this could cause problems for someone else who might be debugging a problem related to this data and find that the data was missing.

So I waited, expecting someone to yell about the missing data and then at me. But I could work again. Other's could work again. Adding "Top 20" to a stored procedure on a development database saved countless minutes and probably a lot of money for the company.

Finally the email arrived. "There is a problem with the data in such and such table and we're going to overwrite it with what's on production. Is this OK?" So I humbly sent out an email saying that I modified the spGetAll[Things] and that maybe this is the problem.

Here I am, thinking that I'm going to get in trouble, that some poor developer spent hours or even days trying to track down a problem that I intentionally created. And what happens? They apologize to ME. OMG. They said that they were sorry but they'd have to fix the stored procedure.

"Ok" by me. They fixed the stored procedure. And I quickly add a configuration variable to use a new stored procedure spGetAll[Things]Truncated. I probably should have done this in the first place but adding "Top 20" is just so much simpler. Especially when it's done under the radar.

The moral: if I didn't fess-up to what I'd done I could have gotten in real trouble... and maybe even fired. Don't be ashamed of your work. Even when it's bad. There is no way to work in a team if you hide what you've done. And you'll see that people are very forgiving when you admit to making a mistake.

The IE6 AntiPattern

2008-12-22T13:11:00.000-08:00

This might be a little behind the times but it’s still not uncommon for me to spend half a day or more just trying to fix CSS for IE6. I was reminded of this while reading Joel Spolsky’s blog recently where he said

"I’ve been debugging the new site. The first problem: hopelessly messed up rendering on IE6. The best way to fix CSS problems with IE6 is to generate random mutations on the style sheet until it looks fixed. That’s really the only way to approach these kinds of things; CSS is nondeterministic, and many better minds than mine have gone completely stark raving mad trying to understand the rhyme and reason of IE6 rendering bugs." - Joel Spolsky

My method is not too different from that of Joel’s. I know the hacks of putting a “#” before the class name or wrapping the entire CSS in “”. But these are ridiculous work-arounds… and the amount of time wasted… I wonder if the additional costs of maintaining MSN, Live, MSDN, Microsoft.com, etc. for IE6 outweigh the expense of…

Allow me to digress. Just the other day my uncle mentioned that he wanted to upgrade his version of Windows XP from the Home Edition to Professional The reason is that Microsoft was going to stop supporting the Home version soon. My uncle is the type of person that I would consider an average user. He uses his computer for managing his photos, email, and the like – nothing fancy. Because of people like my uncle, I’m pretty sure that IE6 isn’t going away any time soon. And with IE 6 still at 20% of the market share, it’s a browser that we all have to support.

As far as I know, there isn’t much we can do about the situation except wait it out. Hopefully with IE 8, Windows 7, and limited support for Windows XP the usage of IE will eventually end.

And since we’re all complicit, we should also be thinking about how we got here (like the frog in the pot) and how we can make sure that this does not happen again. I know the story conventional story line that IE 6 was “The Browser” at the time and so whatever worked on IE was correct. Then came Firefox and it was back to trying to support two different browsers. Then came IE 7 which was “broken” because it was “fixed”. And now with the plethora of options (Safari, Opera, Chrome, etc.) we have our work cut out for us.

Isolating 3rd Party JavaScript

2008-12-19T14:50:00.001-08:00

I'm looking for a way of protecting our web pages from 3rd party javascript files that might timeout or throw errors. These files are usually for ads where we just include a script reference.

What makes it worse is that these files contain code that does a document.write(). Because of this, moving the reference or trying to load the file asynchronously will cause the ads to be rendered on a different part of the page. Because of the use of document.write(), the only way to load the files without affecting the page's load time is to load them from within an iframe.

In addition, we can override on the onerror event for the page in the iframe.

This method scares me since I really can't imagine what would happen if other developers start putting this little snippet of script into all their pages. In addition this sounds like a whole lot of extra work just because some other companies product is problematic. Stop using their product is what I think.

Deep Zoom Composer

2008-11-04T13:15:00.000-08:00

Wow! DeepZoom composer with PhotoZoom is awesome. Here's my first ~~photo album~~. All the pictures are from my iPhone so the quality isn't great. But it was so easy to make.

However, one thing is missing. I'd like to be able to click on a photo and view the original in case I want to print it or send it. Maybe I'll see if I can add this to the opensource proj. We'll see if there's time for that.

Sharing User Controls between Web Projects

2008-10-31T09:54:00.000-07:00

How many times have you had rearrange your solution or copy code around in order to share user controls between projects? This is one place where Asp.Net is seriously lacking. A user control is supposed to be a piece of functional content that is broken into a separate control for maintainability and code reuse. Why then can I only reuse them within one project?

Well I guess there is one method for doing this by using virtual directories in IIS. So the better question would be why I cannot reuse them easily across multiple projects.

There are some additional steps to make it much easier to actually use these controls as well as access there public properties and methods. Here is the whole process:

1) Create a new web project for your user controls.

2) Create a folder in this project where you will put these controls. (This is not necessary since you can reference the folder of the project but I think that having the user controls folder named the same across projects can make things a little clearer.

3) In a separate web project from where you want to use your shared user controls, create a directory with the same name as the directory from the previous step. (In my example I call this “UserControls”.

4) In the Solution Explorer, right click on this directory and select Add->Existing Item…

5) Browse to the folder in your shared user controls project. Select all the controls along with their code-behind files. But instead of clicking the add button, click the down arrow on the right side of the button. Then select Add As Link.

6) You can now repeat this for any other web projects in your solution. When you’re finished, your solution will look something like this.

7) You can now repeat this for any other web projects in your solution. When you’re finished, your solution will look something like this.

8) Remember to make sure that IIS is aware of your “UserControls” directories as virtual directories so that the asp.net worker process compiles your pages properly.

Enjoy!

Ctrl+F is changing the way we read

2008-10-09T12:09:00.001-07:00

I don’t know about you but I love [ctrl+f] a.k.a the Find command. Just as copy/paste changed the way that we write and edit text, [ctrl+f] is changing the way that we read.

When I’m browsing a web site in search of some data, I find [ctrl+f] to be the easiest way of scanning the page to see if it might contain the nugget of knowledge I’m looking for. Especially today when most pages are full of images, ads, and other noise, [ctrl+k] will take you right to the text your looking for. And you instantly know, regardless of what the Google search brought up, if the page actually contains what you’re looking for.

Visual Studio also has [ctrl+shift+k] which is the short-cut for “Find in Files”. This allows me to search the entire codebase for any string (or regex) that I’m looking for. This is great when I need to maintain (read fix a bug) in a part of a system that I’m unfamiliar with.

For example, let’s say that some value isn’t displaying properly on a web page. Using Firebug I can usually find the control’s ClientID. This value usually contains part of the control’s ID. [Ctrl+shift+k] and I can find all the files (pages and user controls) that use this ID. Then you can find the type, class declaration… and finally fix the bug.

Imagine having this kind tool when reading a reference book. Sure the table of contents and index are useful. But just think of how quickly you could find information if you could quickly search the whole book for a word like ListView.

As more and more text based content is available online and we do more and more of our reading online, it will become imperative for any good UI to allow for instant text searching. That this isn’t already a standard feature in Windows causes a lot of grief. Just as all text boxes allow cut/copy/paste, they should also allow “find”.

SEO friendly forms in ASP.NET

2008-10-07T14:20:00.000-07:00

If you ever need to create a page in ASP.NET that uses some kind of Url mapper, you may run into some problems with posting back. If you look closer, you’ll find that the Url of the request is no longer the SEO friendly one but the actual one (possibly including some querystring parameters if they’re part of the mapping.) And .NET does not make it easy to override the address in the “action” attribute of your form.

The best way I’ve found to fix this problem is to create a Server control that inherits from the standard HtmlForm and overrides the RenderBeginTag() method.

You can now register and plug this new form into any page. You can then set the attribute AllowPostBack to false if there are no postbacks on your page. Or you can override PostBackUrl to set the “action” attribute on the form.

My first blog

2008-06-15T20:14:00.000-07:00

This is my first blog...