AspNetResources.com articles, news and updates

Eyes Bigger Than Stomachs

Sun, 04 Jan 2009 00:00:00 GMT

Money has a peculiar property: if you don’t want or know how to manage it, somebody else will happily to do it for you and play you for fool along the way. As if there was a shortage of Wall Street scandals last year, there’s always room for one more. I’m referring to the freshly baked ordeal with Bernard Madoff and his clever scheme of siphoning off billions of dollars.

In the earlier scandals and the subsequent socialist-style bailouts of financial institutions, stupidity, greed, arrogance, etc, were the token accusations. True, banks are not there for you, only for themselves. However, here’s something that caught my attention in a recent WaPo article, Madoff Case ’Failures’ Put SEC in Spotlight:

Madoff attracted investors by promising steady returns with almost no risk of losses. He quoted a long-term average return of 1 percent a month and 12 percent a year, according to materials distributed to his clients.

It was a spectacular and improbable track record. Measured by a Wall Street ratio that compares risk and reward to evaluate hedge funds, investing with Madoff was more than a sixfold improvement over simply investing in the broad-based Standard & Poor’s 500-stock index.

Michael S. Meade, chief executive of Lampost Financial Group, a brokerage and hedge-fund manager, said one client who had invested with Madoff asked him for an evaluation. He investigated, then cautioned the client, saying the results were implausible. The investor remained with Madoff.

Fantastic returns, promises of improbable returns, a warning of a hedge-fund manager—and yet people stayed. Eyes bigger than stomachs. Those who ignored big red flags deserve what came to them.

For hundreds of years, since the tulip mania and South Sea bubble, investors have been acting the exact same way. Yet they still fail to understand that nobody is able to predict the future, nobody has consistently produced such improbable returns over a long period of time (Peter Lynch quit too soon to tell), and that there is no such thing as low risk and high return.

Become an educated investor

Pardon my insistence, but I’d like to very strongly recommend a couple of outstanding personal finance books. They don’t contain mysteries of get-rich-quick investments (there aren’t any); they don’t list “10 easy steps” to comfortable wealth. What they teach you is how the system works and how it’s been playing you so far.

The Four Pillars of Investing by William Bernstein. Of all personal finance books, this one is my favorite. Easy to digest. Balanced on the history of investment mood swings throughout history, discussion of risk tolerance, and various financial “vehicles” at your disposal. A great place to start!
A Random Walk Down Wall Street by Burton Malkiel. Once you’re done with the Four Pillars, put Random Walk on your reading list. It’s a very thorough look at the financial industry, lots of studies of historic performances of various investing strategies, and a lengthier overview of securities you can invest in.
The Total Money Makeover by Dave Ramsey. I’ve listened to Dave Ramsey’s Financial Peace University live recordings and learned quite a bit. I do get annoyed with his motivational speaker style of presenting and constant references to The Bible, but I’m willing to cut him some slack: the guy genuinely tries to help.
Fooled by Randomness by Nassim Nicholas Taleb. You can find my review of this title here.

Be the master of your own money, or somebody else will.

Good luck!

Book Review: Gotcha Capitalism

Sun, 04 Jan 2009 00:00:00 GMT

Bob Sullivan’s Gotcha Capitalism begins with an entertaining story of being ripped off by a hot dog vendor in mid-town New York. Having been charged $3, he mentions he works right around the corner at which point the street vendor forks over the rest of the change and apologizes profusely for mistaking him for a tourist.

I work in NYC and can almost hear their conversation in my head. Next time I wear a Beirhoff Bros ski jacket, perhaps I need to actually count the change.

We’re all tourists

We’re all tourists, every single day. Instead of hot dog vendors, we get ripped off by car rental outlets, banks, insurance companies, airlines, grocery stores, gyms, cell phone and cable companies, etc. An unexpected charge here and there doesn’t seem like much, but they add up. Some charges, such as your first cell phone or cable bill, actually cause bottom-line shock. This is gotcha capitalism in action:

An unfair, lawless playing field that’s replaced American’s former economic system, the market economy. Hidden fees are its most recognizable characteristic. The system rewards the sneakiest companies, rather than the most efficient companies with the best products.

Airlines. Besides Jet Blue and Southwest, the Deltas of America neither innovate nor improve their horrible service and are hamstrung by antiquated union obligations. The only recourse they see is to levy charges on everything under the sun, all the while providing inferior service. The same goes for U.S. auto makers.

In the age of the Internet, just-in-time manufacturing, and globalization, companies find themselves fighting to keep prices low like never before. Their response, almost universally, has been to compensate by lying about the true price of things. They’ve systematically dismantled other important market pressures, too, by tricking consumers into long-term contracts that virtually end real competition. […] They’ve abandoned old-fashioned ideas about consumer loyalty and actually set out to drive away consumers their computers identify as less profitable. And they’ve created contracts with typography so small that they’ve had to make up a word—mouseprint—to describe it.

“Mouseprint” is where gotchas usually hide. Or the scam is hidden behind cryptic fees. For example, when you shop for mutual funds to invest with for retirement, pay attention to expense ratios. Even a single percentage point can make a huge difference! The higher the expense ratio, the more active the fund, the more you get ripped off. On these management fees alone Wall Street can pocket 80% of your money; you get only 20%. How’s that for a fair game?

Surrender of privacy

One insidious side-effect of various rip-off schemes is your surrender of privacy. While you’re salivating over a new gizmo, they stuffed the purchase agreement with goodies to rob you of legal options and serve you a rotten deal.

Bob cites grocery “loyalty cards” as one of the effective scams. To sign up for one, you fork over personal information in exchange for savings which don’t save you anything! As Bob brilliantly puts it, “No one can tell you what the future cost will be for the surrender of privacy today.”

The takeaway

The book covers a wide range of other ripoff avenues. Even though Bob Sullivan puts a host of disgusting schemes in the spotlight, more are invented every day. With this come a couple of valuable lessons:

Stay free agent! This is how I like to roll. I abhor debt and lock-ins. Per author’s advice, “avoid long-term contracts as much as possible. Always opt for the shortest contract [when purchasing goods and services]. Companies want to tie you up and then take advantage of you; don’t let them.”
Complain. The book has sample letters to companies, if you dispute issues directly with them, as well as federal agencies when nothing else works. You need to learn how to complain effectively and whether it makes sense to complain at all. In some cases, you bring doom upon yourself by being inattentive, so even your state Attorney General office won’t help you. Educate yourself how the system you’re up against works.

The cover of the book irks me a little. “Learn how to save $1,000!” can be easily construed as a false statement. You will save money by staying vigilant, but your mileage will vary.

Happy Holidays!

Thu, 25 Dec 2008 19:08:11 GMT

Whether you put Christ in Christmas or prefer to think of December 25 as the Roman festival of Sol Invictus, I’d like to wish you happy holidays and the best of luck in the year 2009!

I Swear I Didn't Know I Could Do This!

Sun, 07 Dec 2008 00:00:00 GMT

I’m a big fan of HttpModules and HttpHandlers. Hey, I even created a tool to code-gen those for you!

Here’s one gotcha with HttpModules: if you invoke code which relies on HttpContext.Current, it may be null, as in the case of kicking off a timer which lives on its own, separate thread.

I dug into HttpContext with Reflector and noticed that the HttpContext.Current property had a setter. Imagine my surprise when I did the following, and it worked!

private void ScheduleCallback (object state)
{
    // ...
    HttpContext.Current = state as HttpContext;
    // ...
}

I don’t know if I’m violating anything here, but it functions just fine. I’ll take that.

Btw, this post clarifies what that state is.

Another (New) Book Is Here!

Sun, 07 Dec 2008 00:00:00 GMT

No, I still refuse to undertake writing a book—takes too long, becomes obsolete too fast, no money in it, etc, etc. But! If you follow this blog on a regular basis, you know what a voracious reader I am.

A few months ago I received an email from Dan Larson (aka “Father of VI”) who was writing a book with Microsoft Press. He got excited about the MS AJAX templates I wrote for CodeSmith back in November of 2007 (there’s even a fancy video) and fired off an introduction.

Sometime last week I received a printed copy of Daniel’s book, Developing Service-Oriented AJAX Applications on the Microsoft® Platform. I’m psyched even though I neither wrote it nor even tech-reviewed it. Just good to know I had some sort of a positive influence.

And so reading commenseth…

A Friendly Reminder to Quit Using Method Parameters As Local Variables

Fri, 28 Nov 2008 00:00:00 GMT

I see this aberration quote often when I refactor code. I noticed Steve McConnell has it down as a rule in Code Complete:

It's dangerous to use parameters passed to a routine as working variables. Use local variables instead.

Take a look at the following contrived example:

public int Sample (int inputVal)
{
  inputVal = inputVal + GetCurrentMultiplier (inputVal);
  // ...
  return inputVal;
}

The inputVal parameter loses its meaning and purpose as soon as it's used (and abused) as a local variable. Refactoring code this like can quickly become a nightmare. A more politically correct way is to actually use a local variable:

public int Sample (int inputVal)
{
  int workingVal = inputVal;
  workingVal = workingVal + GetCurrentMultiplier (workingVal);
  // ...
  return workingVal;
}

Assigning the input value to a working variable emphasizes where the value comes from. It eliminates the possibility that a variable from the parameter list will be modified accidentally.

I'll use McConnell's own excuse here that inputVal and workingVal are actually terrible names. This is only a drill.

This Must Be the Worst Scrum Book

Fri, 28 Nov 2008 00:00:00 GMT

Being a very curious person, and to keep up with jargon explosion, I came across The Enterprise and Scrum by Microsoft Press. Picking up bits and pieces on Scrum over the past year, I took this book for a definitive authority on Scrum education, especially so because it was written by a recognized Scrum expert.

The sad story about The Enterprise and Scrum is that the author knows the subject well, but can't get it across in an intelligible way. This happens often with geek titles.

The book is more of an endless gallery of success stories of how great Scrum is (and it may as well be). The author jumps right to slinging jargon, drawing tables, presenting diagrams which leaves me merely scratching my head and mumbling in bewilderment, "So what is Scrum and how can I have one of 'em kool success stories with it?" Then more success stories with a happy ending, more tables and diagrams…

And thus the quest for Scrum enlightenment continues. Can anyone suggest a good, down-to-earth Scrum book?

The American Flag As Seen By People with Color Blindness

Fri, 28 Nov 2008 00:00:00 GMT

I am a sucker for clever, visual ways of presenting information. Take a look at this combined simulation of color blindness applied to the American flag:

This poster dates back to 1895!

Color Blindness Simulator Revamped

Fri, 28 Nov 2008 00:00:00 GMT

It’s been a while since I touched my online color blindness simulator (read this post from 2005 for an overview of types of color blindness my tool supports and the algorithms behind it). Unfortunately, an elusive bug lurked in the calculations: once in a blue moon the tool would throw an exception on an integer overflow. I could never reproduce it or find the flaw in calculations.

Two readers of my blog asked to share the simulator as a stand-alone component. This prompted me to hunt down a more correct algorithm which is actually used in GIMP.

As an added benefit, the color blindness module I ported from GIMP also handles tritanopia (inability to discern blue and yellow). While at it, I heavily refactored my old, procedural code and extracted the simulator into a component of it own, as my readers requested. Feel free to grab the source code here.

Take a look at the output of two sample simulations of Toyota Matrix and Denver Airport produced by the new tool:

Looking forward to your feedback!

A Tale of Two Page Hits

Thu, 20 Nov 2008 00:00:00 GMT

I keep falling into this trap. If you see the phenomenon of a page being hit twice on a single request, read the following:

In the same vein: Session_Start or Session_OnStart?.

More On Singletons, Locking, and Thread Safety

Wed, 19 Nov 2008 00:00:00 GMT

Old P&P documentation on singletons used to have an example along these lines:

public sealed class Singleton
{
    private static Singleton instance;

    private Singleton () { }

    public static Singleton GetInstance ()
    {
        lock (typeof (Singleton))
        {
            if (instance == null)
                instance = new Singleton ();
        }
        return instance;
    }
}

Bill Wagner, in his excellent book More Effective C#, has a code snip which exhibits a similar issue:

public class LockingExample
{
    public void MyMethod()
    {
        lock (this)
        {
            // ... do work ...
        }
    }
}

The trouble here comes from locking on this or typeof (Singleton). Eons ago, Jeffrey Richter (whom I admire greatly) wrote an epic article on safe thread synchronization which describes in great detail what exactly the trouble is and how to circumvent it. Pay close attention to sections Synchronizing Static Members the Microsoft Way and Why the Great Idea isn’t So Great.

Something very wicked happens when you lock on a value type (bool, int, etc): it gets boxed! This leads to all kinds of trouble dissected in section Unboxed Instances of Value Types.

A Funny Exchange

Wed, 19 Nov 2008 00:00:00 GMT

Many places around New York City require you to sign in and present a photo ID to walk past the front desk. Here’s a conversation I witnessed recently.

Delivery guy: Cookie?

Security guy: Huh?

Delivery guy: Cookie?

Security guy: Whaaat?

Delivery guy: Is your name Cookie?

Security guy: No! My name is Kofi.

Picture the delivery guy’s face. I could barely hold my laughter.

jQuery(Sulky)

Wed, 19 Nov 2008 00:00:00 GMT

You know how you find a nice, secluded, family beach/park/etc…

And then a local reporter stumbles upon and writes an article about it…

And then the beach/park gets crowded and littered and loses its nice, secluded feel?

This is how I feel about jQuery right now. *sigh*

Microsoft PAG Still Doesn't Understand Singleton

Tue, 18 Nov 2008 00:00:00 GMT

When I was starting out in .NET a while ago, I used to read architectural “guidance” put out by Microsoft’s very own Patterns & Practices group. Back then, the guidance was sound enough because we were all in the same boat. However, as years went by, the proverbial “community” took the lead on architectural innovation, and P&P has been playing lame catch ever since.

Here’s one thing I clearly remember from old P&P documentation: they never understood the Singleton pattern. Really, there’s nothing extremely complicated about Singleton, but the big gotcha is thread safety!

Via the mighty ScottGu cometh think link: ASP.NET Patterns Developers Should Know by Alex Homer from the Patterns and Practices (PAG) team at Microsoft. Take a look at the implementation of the Singleton pattern. As my good friend Don the ~~Plumber~~ XML points out, IT’S NOT THREAD SAFE.

Amazing that PAG still doesn’t get it. Wait, no, they kind of do if you look at this code on the PAG site. Or at least they get double-locking, but don’t list two other important implementations. Can you, guys, talk to each other before you write something as embarrassing?

Normally, I would quietly refactor into a proper singleton and put a comment upon check-in, but when this snake oil is presented for sound guidance I have issues with that.

Managed Extensions Framework (MEF) Looks Interesting

Mon, 17 Nov 2008 00:00:00 GMT

When Brad Abrams posted a Simple Introduction to Extensible Applications with the Managed Extensions Framework, I read it and thought, “What a monstrosity.”

Then I read it again, and it made more sense.

Then I watched a recording of Glenn Block’s MEF talk at PDC 2008, and it made even more sense.

Brad also points to ScottGu’s MEF keynote from PDC, which I haven’t seen yet, but all this whets my appetite in a big way. I don’t think we’re going to see a mega-battle of IoC (Inversion of Control) containers, though, because MEF is a different beast.

The Very Handy "Using" Statement

Mon, 17 Nov 2008 00:00:00 GMT

I’ve lost count how many times I had to refactor code that looks like this:

SqlConnection conn = new SqlConnection (...);
SqlCommand cmd = new SqlCommand (...);
// ... 
conn.Open();
cmd.ExecuteNonQuery ();
// ...

I rejoice if such code has conn.Close() at the end. What happens if an exception is thrown in ExecuteNonQuery(), for example? Your database connection stays open for a while because, well, nothing closed it. Keep doing this, and you exhaust SQL Server’s connection pool. Besides leaking resources, your application becomes unresponsive.

There’s an easy way out: the using statement (MSDN):

using (SqlConnection conn = new SqlConnection (...))
using (SqlCommand cmd = new SqlCommand (...))
{
    // ... 
    conn.Open();
    cmd.ExecuteNonQuery ();
    // ... 
}

The code above expands into something like this (“note the extra curly braces to create the limited scope for the object”):

{
    SqlConnection conn = new SqlConnection (...);
    try 
    {
        SqlCommand cmd = new SqlCommand (...);
        try 
        {
            conn.Open();
            cmd.ExecuteNonQuery();
        }
        finally 
        {
          if (cmd != null)
              cmd.Dispose ();
        }
    }
    finally 
    {
      if (conn != null)
          conn.Dispose ();
    }
}

In other words, you get a try-finally block for free. You still end up with an exception (notice the lack of catch there?), but the finally clause is guaranteed to dispose of expensive resources properly.

Naturally, this trick works only with classes which implement IDisposable. However, IDisposable comes with a lot of baggage, so don’t rush to implement it all over the place.

As a side benefit, calling Dispose() on SqlConnection also closes it.

To me, this is unwelcome coupling because it exposes me to the inner workings of the SqlConnection class—something I shouldn’t worry about. If I call a method, thinking, “Oh, and it also calls Xxxxx() inside”, I see it as bad API design.

A neat trick

Here’s a neat trick I picked up from Bill Wagner’s More Effective C#. Look at this code:

public void GetThingsDone ()
{
  T driver = new T();
  using (driver as IDisposable)
  {
     driver.DoWork();
  }
}

In Bill’s words:

The compiler creates a hidden local variable that stores a reference to the driver cast as an IDisposable. If T does not implement IDisposable, then the value of the local variable is null. In those cases, the compiler does not call Dispose(), because it checks against null before doing extra work. However, in all cases where T implements IDisposable, the compiler generates a call to the Dispose() method upon exiting the using block.

We saw the null check in finally above, but the interesting point here is that if a soft cast of IDisposable produces a null, the compiler just bails. Pretty cool!

Book Review: Clean Code

Sun, 12 Oct 2008 00:00:00 GMT

The latest book by Bob Martin, Clean Code, is a cross between Steve McConnell’s Code Complete, Martin Fowler’s Refactoring, Joshua Kerievsky’s Refactoring to Patterns, with some tidbits of Kent Beck’s Implementation Patterns. About a year ago I reviewed another book my Bob Martin, Agile Software Development, Principles, Patterns, and Practices which goes over such important concepts as SRP, OCP, the Liskov Substitution Principle, IoC. You meet these usual suspects again in Clean Code, so it really helps to know them. You can read up on them here (PDF).

The good stuff

The book starts off with a philosophical discourse about what clean code is, the benefits of maintaining such code, its power to communicate, etc. The book tries to answer such tough perennial questions as, How do you name a method, class, variable, etc? I don’t know anyone who doesn’t struggle with this. The guidance is presented forcefully, with no excuses—take it or leave it, and feel free to disagree (I did, at times).

Here are some key points that resonated with me the most:

Command query separation (Chapter 3)

This rule states that “every method should either be a command that performs an action, or a query that returns data to the caller, but not both.” Or, as the author puts it,

“Functions should either do something or answer something, but not both. Either your function should change the state of an object, or it should return some information about that object. Doing both often leads to confusion.”

For example, if a SetXxxx method on a class returns something, what is that return value? Can you easily tell? And why is there a return value at all? Is the method performing one too many actions? I’ve seen too many APIs which I had to look up in the docs because the signature was both a command and a query.

Have no side effects (Chapter 3)

Bob Martin puts it very succinctly: “Side effects are lies.” Indeed, side effects are insidious. “Uncle Bob” cites an example of a checkPassword method which is supposed to validate user credentials. Upon successful validation, though, the method also initializes a user session! Now, two problems: 1) the method is unfocused, and 2) the signature does not advertise the side effect (it other words, it’s lying).

Prefer exceptions to returning error codes (Chapters 3 and 7)

Here’s an interesting angle I’ve never thought of before:

“Returning error codes from command functions is a subtle violation of command query separation. It promotes commands being used as expressions in the predicates of if statements:

if (deletePage (page) == E_OK)

This does not suffer from verb/adjective confusion but does lead to deeply nested structures. When you return an error code, you create the problem that the caller must deal with the error immediately.”

I agree. Try/catch blocks can get ugly and clutter code, as “Uncle Bob” rightfully points out. Therefore it makes sense to extract code inside try/catch blocks into methods of their own.

As a bonus, Michael Feathers delivers an authoritative opinion against checked exceptions in Java.

Comments do not make up for bad code (Chapter 4)

Generally, your code should explain itself. The majority of comments are poisonous refuse and clutter. The discussion in this chapter goes above and beyond this soundbite.

The fluff

Bob Martin doesn’t seem to know when to stop. Clean Code has too much dead weight for my taste. His other book I mentioned was like that, too. The sample code is all Java. There is a chapter on JUnit internals, which I found boring to tears.

Then, there’s a chapter on step-by-step refactoring of a SerialDate class. The entire listing is printed in the back of the book, in small font, with tests and everything. Now, come on! Have trouble sleeping? Here, read the listing.

Finally, there’s a chapter and an appendix on concurrency. These two have nothing to do with the scope of the book itself. It beats me why they have been included. Wait… Say what? The publisher wanted padding? That explains it.

Conclusion

Overall, this is a good book. Poor typography, awful drawings, and typos aside, I’ve found some good ideas in there. The book is unfocused, though, so your mileage may vary.

In Love With Complexity

Sun, 05 Oct 2008 00:00:00 GMT

I have just finished reading Simplexity by Jeffrey Kluger, a senior editor and writer for Time magazine. The full title of the book is Simplexity: Why Simple Things Become Complex (and How Complex Things Can Be Made Simple). This is precisely the kind of question that’s been on my mind for a long time.

One of the arguments I’ve heard against offering simple solutions is that simple is not “professional.” The UI has to look sophisticated, rugged. With lots of buttons to click. The customer wants it, the claim goes.

Really? I have yet to bump into someone who’d say, “Thank you so much for making my life and job more complicated. I really enjoy feeling overwhelmed. Your product gives me all the worry I’ve hoped for.”

“Of course, it’s not just in the service of customers who ask for features that companies keep things complex. It’s in the service of the balance sheet too.”

This is what I see happen in the Microsoft world. I tend to agree with people who call Microsoft “complexity merchants.” Where simple solutions would’ve worked, Microsoft produced unwieldy monstrosities that require armies of people to maintain.

Same story with books. Publishers prefer (or some used to, for sure) bigger, thicker books because they seem to convey more value. Never mind it’s futile to cover every nook and cranny of ASP.NET. Even in 2,000 pages you’re still only scratching the surface. That’s not the story a publisher would tell you because it’s not in the interest of their anonymous, faceless “shareholders.”

Retailers are this way, too.

“Many electronics retailers have an understandable interest in telling you, ’The world is too complicated. We’ll manage all of this for you. […] If a line of products came out that didn’t require professional assistance, you wouldn’t have to go to the store that said it had the best.

[…] There’s this whole business built around complexity. It’s like selling something dangerous and then selling the service that makes it less dangerous.”

How simple is simple enough, then?

“The design irony, of course, is that if any products ought to confer status, it’s often not the most complex-looking ones, but the simplest-looking ones—those with their features artfully integrated into the whole rather than stamped and studded all over the outside.”

iPod is cited as an example of such a device. Simple does not mean primittive. I’m sure iPod is far from primitive on the inside, but it does a good job of hiding complexity from spilling outside.

This, to me, is pretty close to the Holy Grail of interface design.

Sweet Denial on Wall Street

Mon, 22 Sep 2008 00:00:00 GMT

Living in close proximity to New York City, you get to see, hear and feel the aftershock of the recent collapse of several financial giants. And while talking heads on financial news networks rant against greed, lack of foresight, deception (look who’s talking!), I keep thinking of this excerpt from Shōgun:

“How baffling it was that even the most cunning and clever people would frequently see only what they wanted to see, and would rarely look beyond the thinnest of facades. Or they would ignore reality, dismissing it as the facade. And then, when their whole world fell to pieces and they were on their knees slitting their bellies or cutting their throats, or cast out into the freezing world, they would tear their topknots or rend their clothes and bewail their karma, blaming gods or kami or luck or their lords or husbands or vassals—anything or anyone—but never themselves.”

Are you building something awesome and hiring?

Wed, 03 Sep 2008 00:00:00 GMT

You are building something awesome. You take pride in your product or service. You hire only the best people you can find. The thought of nine-to-five cubicle life gives you cold sweat. Writing software is a lifestyle but you do have a life outside of office.

If this is you and you are hiring, I’d love to hear from you: milan@aspnetresources.com

Keeping Pulse on Your Site With ASP.NET 2.0 Health Monitoring

Fri, 23 Mar 2007 00:00:00 GMT

One of the best, yet often overlooked, features of ASP.NET 2.0 is health monitoring. I believe it is absolutely essential to be notified of any problems with your web application, and this is where health monitoring comes in handy. A few years ago I wrote an article about custom error pages and demonstrated various ways to tap into error details. Health Monitoring is a natural progression of that approach.

The Dark Side of File Uploads

Thu, 12 Jan 2006 00:00:00 GMT

I saw a December MSDN article, entitled Uploading Files in ASP.NET 2.0, and wanted to offer my comments on some gotchas with uploading files. I’ve spent countless hours and tried numerous hacks to tame file uploading and have enough bruses from hitting my head against the wall (figuratively speaking).

Session_Start or Session_OnStart?

Sun, 18 Dec 2005 00:00:00 GMT

Ever since I started to develop with ASP.NET, I’ve been wondering why global.asa from the ASP days quietly moved over to ASP.NET as global.asax. When you look at it, it just feels so outdated, so VBScript-ish, so loosely–typed. And what is the right way to name event handlers?

Crafting Lightweight Page Templates with CSS

Sun, 19 Sep 2004 00:00:00 GMT

Giving your web application a consistent look and feel is a task of paramount importance. Yet, templating in ASP.NET has been complicated, to say the least. Learn how you can craft lightweight, efficient page templates with CSS.

Weather Custom Server Control

Sat, 11 Sep 2004 00:00:00 GMT

Need a quick and easy way to display weather on your site? Templated custom server controls to the rescue!

Adding Variables To Style Sheets

Thu, 08 Jul 2004 00:00:00 GMT

Even though the spec defines CSS as a style sheet language, this language is missing one of the essential features: variables. Every time I've seen people in newsgroups ask how to implement variables in CSS a typical advice was to build the style sheet on the server. Luckily, it is easy to do in ASP.NET with the help of HTTP Handlers.

Building Dazzling Charts With Office Web Components

Tue, 08 Jun 2004 00:00:00 GMT

Need to create eye-popping charts in real time and do it at no cost at all? Give Microsoft Office Web Components a try.

Make Every Web Page Printer-Friendly

Wed, 02 Jun 2004 00:00:00 GMT

You found an article online and want to print it to nicely punch thee holes on the side and store it with other useful stuff. Almost every site nowadays provides a printer-friendly page of this and that, but some sites don't and you're still stuck with staring at their printed navigation bar, footer, ads, etc, for ever and ever. All this online decor means nothing on paper. How do you strip page parts that are irrelevant for print?

Beware Of Deploying Debug Code In Production

Wed, 05 May 2004 00:00:00 GMT

You have spent several months developing a killer web application (a web site, perhaps) and the long anticipated release day has come. You deploy the application and take it for a test drive. As you navigate from page to page you notice that each page “thinks” before rendering. What’s going on? Didn’t Microsoft folks promise code compilation and ultra fast execution? Isn’t it why we beat ASP, Java and PHP by such a wide margin?

Bringing CSS2 to Visual Studio.NET

Tue, 27 Apr 2004 00:00:00 GMT

Even though the CSS2 Specification has been around since 1998 its support in the Visual Studio line of products has been rather weak. In this article you’ll learn how to enhance IntelliSense in Visual Studio.NET to display CSS2 properties.

Remastering Web Form Templates

Sun, 18 Apr 2004 00:00:00 GMT

Visual Studio.NET comes with a number of templates for all kinds of coding occasions. The one I'm going to talk about in this article is the one you probably use most often (provided you are an ASP.NET developer): the Web Form template. Default templates suffer from being stuffed with needless markup. In this article we'll analyze what is supposed to be there and learn how to clean them up.

What's In Your DOCTYPE?

Tue, 13 Apr 2004 00:00:00 GMT

When you create a web form in Visual Studio.NET using the canned "Web Form" template you might ask yourself, "What is this DOCTYPE declaration about?"

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >

What is this strange-looking beast?

ASP.NET State Management: View State

Sun, 14 Mar 2004 00:00:00 GMT

ASP.NET view state is a great feature and an essential tool for web development of today. It maintains the state of a page as it travels back and forth. There is no more need to worry about restoring values of page controls between postbacks. In this article you will get an in-depth perspective on view state. We will talk about ways of reducing unnecessary payload and protecting view state from prying eyes.

Skinning Web Applications with CSS

Sun, 22 Feb 2004 00:00:00 GMT

The common approach to skinning web applications lies in reshuffling controls on a page. Traditionally developers define templates with different color schemes and/or control positioning, tables and inline font tags. While this used to be a perfectly viable solution the overhead of run-time application of these skins is staggering. A much better way is to separate skin structure from presentation and let CSS take care of the layout and typography.

Producing XHTML-Compliant Pages With Response Filters

Fri, 13 Feb 2004 00:00:00 GMT

Programming with web standards in mind, although vastly ignored, is becoming more and more important. It almost seems it took too long to promote ASP.NET. Now that we're over the hill and "this stuff works" it is about time to start paying attention to web standards. In this article you will learn how to implement a response filter and plug it into the ASP.NET pipeline. The filter will transform outgoing HTML into XHTML 1.0-compliant markup.

ASP.NET Custom Error Pages

Sun, 01 Feb 2004 00:00:00 GMT

ASP.NET provides a simple yet powerful way to deal with errors that occur in your web applications. We will look at several ways to trap errors and display friendly meaningful messages to users. We will then take the discussion a step further and learn how to be instantly notified about problems so you can cope with them right away. As a geek touch we will also track the path 404's travel.