1. Logic for budget accuracy calculations (just a method right now, no actual implementation on the site yet)
2. CRUD for recurrences (and a slick interface to boot—I’m really enjoying working with these DevExpress controls)
3. Account balance projection chart

So, that leaves the following stragglers on my to-do list before the first release (likely to be labeled an alpha—not all features are there, not everything works):

• Actual implementation of the budget accuracy calculations (displayed as % error)
• Logic/implementation for budget adjustment suggestions
• CRUD for manual entry and adjustments
• GUI work
• Data export
• Wizardry for new users to introduce them to key elements of the app

I’m really excited about where things are going with this project, to the point that I don’t think the Windows version of this project is going to be able to keep up with all the great features. I’ll tune in again next Thursday at the latest for another update on this (probably sooner). I should have some real web hosting by then, so I’m pushing hard to get a release out in the next two weeks.

1. Worked out web and data hosting (thanks boss). GoDaddy just doesn’t give me enough control over things to go that route with any real web applications (although they’re great at hosting this blog!)
2. Decided on some controls I’m licensed for through work. They aren’t free, but if you want to debug through any source code I make available you can install a trial. I decided quality was more important than making the code super easy to share in this case.
3. CRUD finished for accounts.
4. Some back-end work done on recurrences/transactions.
5. Balance calculations are working.

Immediately next on my list are:

• Logic for budget accuracy calculations (this one’s a new idea)
• Logic for budget adjustment suggestions (based on the accuracy calculations, also a new idea)
• CRUD for recurrences/manual entry/adjustments.
• Account balance projection chart
• More time spent on GUI design
• Data export functionality
• Process to drive new users to the most useful functionality right away so they see the real benefits over time (following the visualize, control, predict pattern):
• Set up an account with recurrences to visualize the current state of the account
• Use transactional adjustments to correct the budget with actual figures
• Modify budget (recurrences) based on suggestions (control)
• Using an established budget and calculations based on the average error margin, allow the website to predict the most accurate balance curve possible over the next year

I’m happy with the progress I have made so far. I have a lot of the groundwork laid, but it will still be a few weeks before the initial version is ready to be published. Here’s the summary…

Finished Work

1. Domain purchased
2. Database Schema tentatively complete
3. Website project created
4. Simple Logo produced
5. Default / login screen working
6. Error handling in place, notifications of problems being routed correctly
7. Maintenance mode working
8. Dashboard “shell” built
9. Accounts summary pane on dashboard finished

Needed Before Release

1. A place to host the website and database (being worked out, should have this soon)
2. Make a decision on whether to use some third party controls and which ones
3. CRUD (Create, Read, Update, & Delete) for:
   • Accounts
   • Recurrences
   • Manual Entry
   • Recurrence adjustments
4. Balance calculations
5. Account projections
6. Graphical visuals
7. Data export

I already have the database all laid out on paper, and I will make database diagrams and code samples available as I finish them. At some point I may be forced to stop posting source code for the sake of security, but until I start collecting sensitive data (right now the data I track can’t be tied to anyone or any actual accounts), I will continue to post code here.

• Improved interface:
  • Allows you to select the recording area from a list of pre-defined options
  • Allows you to move the window around to “frame” your recording area
  • The window containing the recording area stays on top, so you always know what you’re recording
• AVI files are now compressed using the WM3 video codec, resulting in far smaller file size
• Frame rate is now throttled at 25 frames-per-second, resulting in somewhat-smaller file size
• Ability to overwrite files when saving.
• Progress bar shows save progress while exporting the AVI file.

If you already have Screen Tracker, you should get the update the next time you use it. If you don’t have it yet, just click the Screen Tracker link under “Downloads” or go to the Screen Tracker page to install the latest release.

1. Progress bar when saving the .avi file (a piece of cake, but time-consuming to implement)
2. Use a compressed format (the current file-sizes are enormous!)
3. A resizable “recording area” instead of the X, Y, Height, and Width boxes.
4. A “quality” radio button that increases performance at the expense of frame-rate (and maybe even the image quality)

The Roadmap
I believe I am the only person who uses Cash Tracker on a consistent basis, but I’ve found the application so useful that I’m going to plow ahead until I’m satisfied. So, for the Cash Tracker 1.0 release I plan to unveil some big new features. Plus, I’ve determined to create an online version of the tool. Here are the steps needed to proceed to that point:

1. Add most or all of the features on the upcoming features list
2. Acquire a catchy web domain name and SSL certificate
3. Possibly re-brand Cash Tracker under a different name for the web (i.e. whatever catchy domain name I find)
4. Port the Windows project to a data-driven website project using ASP.NET and SQL Server technologies

Contributions
If you’d like to contribute to the project, just drop me an email; I’ll be happy to set up a source control server. The project doesn’t really need funding beyond a web domain and SSL certificate purchase, but an extra pair of coding hands would definitely accelerate the release timeline.

So what goodies do you have for us?
The tool I will post (most likely tonight or tomorrow, under the name Screen Tracker) will do the following:

1. Record frames from the screen or a portion of the screen to a working directory.
2. Compile the frames into an AVI formatted video file.

And my upcoming feature wish-list:

1. Audio recording (either through the computer itself or via a microphone, maybe both)
2. The ability to add an .mp3 or .wav audio track

Audio/video is not a world I am well-versed in, so don’t hold your breath on the wish-list Just hope my great idea motivates me to make useful tools for you.

Cash Tracker going Beta
I’ve been using my latest version of Cash Tracker for a while, now, and it’s been working beautifully for me. I will probably post the most recent code and installer tonight or tomorrow as well. It’s ready for beta status, so I’ll update that designation as well (and maybe someone else will actually start using it!).

Timeout expired. The timeout period elapsed prior to obtaining a connection from the pool. This may have occurred because all pooled connections were in use and max pool size was reached.

My Research
On the website in question, I use LINQ-to-SQL heavily to perform data operations. Naturally, I suspected that I wasn’t disposing of my DataContext objects correctly, causing me to exceed the number of connections available in the pool. After doing a little research on the subject, I read in several articles (some by folks who are much more knowledgeable than myself) that I shouldn’t have to dispose of them. They all said the following code is just fine:

CORDataContext mcon = new CORDataContext();
COR_Employee emp = mcon.COR_Employees.FirstOrDefault();

In fact, I should be able to put that into an infinite loop and never get the exception I was encountering. According to the experts, LINQ is not only smart enough to automatically open and close the connection for me, but also smart enough to dispose of the object when I’m done. No need for a “using” around my code or even a Connection.Close().

An Exception to the Rule

I noticed, though, that my code was slightly different. In my specific setup, I have a central database and a LOT of other databases I might want to connect to. So, to take advantage of connection pooling more, I always connect to the central database first and change to whatever catalog I need to access. In doing so, it is necessary to manually open the connection, like the following:

CORDataContext mcon = new CORDataContext();mcon.Connection.Open(); mcon.Connection.ChangeDatabase("OtherDB");
COR_Employee emp = mcon.COR_Employees.FirstOrDefault();

My Testing

I began to theorize that manually opening the connection in this way keeps the connection alive after I’ve run my query. I confirmed the belief by trying to run the following code:

for (int i = 0; i < 1000; i++) {

    CORDataContext mcon = new CORDataContext();
    COR_Employee emp = mcon.COR_Employees.FirstOrDefault();
    mcon.Connection.Open();
    mcon.Connection.ChangeDatabase("OtherDB");

    Console.WriteLine("" + (i + 1) + " / 1000");
}

I got the exception after 230 or so connections. By default there are 100 connections available in the pool, but the garbage collector kicked in and helped give me a buffer before I ran out. So, from that I can conclude that manually opened DataContext connections will stay open until the connection is closed or the DataContext is disposed.

The Solution

Once I fully understood the problem, the fix was common sense:

for (int i = 0; i < 1000; i++) {

    using (CORDataContext mcon = new CORDataContext()) {
        COR_Employee emp = mcon.COR_Employees.FirstOrDefault();
        mcon.Connection.Open();
        mcon.Connection.ChangeDatabase("OtherDB");

        Console.WriteLine("" + (i + 1) + " / 1000");
    }
}

Adding a “using” to automatically dispose of my DataContext did the trick, and this loop now finishes in about 3 seconds (even with the overhead of writing to the console). I hope this helps someone else, because it’s been plaguing me for weeks!

Me: “How does the car go?”

Mom: “I press the gas pedal and it goes.”

Me: “What does the gas pedal do that makes the car go?”

Mom: “I don’t know, ask your father.”

I probably had 5-10 conversations like that per day from the age of 3 until the age of 12. I was (and always have been) thinking about the details.

I define seeing the details as being able to look at something and dissect it into its smallest parts. This is a valuable skill for any programmer, and, I believe is what separates people who should learn to code from those who might be better off avoiding it. I had far too many classmates who were in it for the money, but had no passion or thirst for understanding. That drive is a key determining factor about someone’s future in software development. Seeing the details in my job means being able to mentally translate an assignment into code, including all the edge-conditions, so I can accurately estimate how long a project will need for completion. Seeing the details means being able to predict potential problems in January while the team is planning instead of getting caught off guard in June while we’re coding. It even means not writing the bugs other developers might. Yes, seeing the details is a valuable skill in software development, and I don’t see that changing anytime soon.

I never was a big picture kind of person growing up. I made passable grades on my papers in school because I could make really wonderful points, but I had trouble making everything from the first sentence to the last cohesive. Instead, my papers ended up often containing a few somewhat related ideas with an underwhelming effort to tie them together. As it turns out, while seeing the details is an important skill in software development, the converse is equally true; being able to let go of fine details and see the big picture is necessary for anyone who is more than just a code-monkey.

I define seeing the big picture as being able to look at something and understand not just how it can or does work, but how it could and should work. Seeing the big picture also means being able to look at something and understand how it should coexist and cooperate with other things. This is a valuable skill for anyone who wants to be more than a programmer. It separates people who should get a coding job and just take their annual pay increase from those who should attempt to scale the ladder.

I really believe that to be a truly successful leader in software development both of these skills are a must. One or the other just won’t do. Those who can only see the big picture can be great managers of small or open-ended projects, but without being able to see the details a project manager must rely on his developers to understand what a project will cost. Alternatively, those who can’t see past the details are wonderful programmers, but without seeing the big picture a developer must rely on his manager for direction. In my opinion, someone who has both skills can be a great leader and an invaluable asset, adding efficiency to an entire department.

With .Net 3.5, Microsoft released the DataContractSerializer. It has a variety of uses, but at the very least it’s an improvement over the XmlSerializer. In Cash Tracker we started out by using the XmlSerializer to save files, but quickly found it inadequate, the reason being XmlSerializer does not play well with mixed access properties.

For an example, let’s look again at our Person class:

public class Person {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Initials { get; private set; }

    private Person() {
    }
    public Person(string first, string last) {
        this.FirstName = first;
        this.LastName = last;

        this.Initials = String.Format("{0}.{1}.", FirstName[0], LastName[0]);
    }
}

Notice I’ve added a new property with a private mutator. Also, I added a constructor to take advantage of the new property and made my default constructor private. Now when we try to serialize using the XmlSerializer we get an error:

Unable to generate a temporary class (result=1).

error CS0200: Property or indexer ‘Person.Initials’ cannot be assigned to — it is read only

What to do?

In .Net 3.5, to get around this problem, Microsoft suggests using the DataContractSerializer, so we will investigate switching to the new technology here. First, we need a reference to System.Runtime.Serialization:

Once that’s done it’s actually pretty simply converting our old code. The new code looks like this:

static void XmlSerializePerson(Person myPerson, string fileName) {
    DataContractSerializer xs = new DataContractSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
        xs.WriteObject(fs, myPerson);
    }
}

static Person XmlDeserializePerson(string fileName) {
    DataContractSerializer xs = new DataContractSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
        return (Person)xs.ReadObject(fs);
    }
}

Notice we simply re-used the old methods, changing the object and methods used to serialize our Person. Our code will now execute as expected:

Download the Solution

You can download a zip file of the solution by clicking the link below.

DataContractSerializerDemo.zip

Class: Person

Below is a simple class Person. My person has a name and an age:

public class Person {
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Person() {
    }
}

The XmlSerializer requires that I leave an empty constructor in my class. I can make the constructor private if I don’t want it used for other things. Now, let’s create an instance of a Person.

class Program {
    static void Main(string[] args) {
        Person myPerson = new Person();
        myPerson.FirstName = "John";
        myPerson.LastName = "Smith";
    }
}

How to serialize our class

I will add a couple methods now to handle serializating and deserializing myPerson.

static void XmlSerializePerson(Person myPerson, string fileName) {
    XmlSerializer xs = new XmlSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
        xs.Serialize(fs, myPerson);
    }
}

static Person XmlDeserializePerson(string fileName) {
    XmlSerializer xs = new XmlSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
        return (Person)xs.Deserialize(fs);
    }
}

Code in action

Now, saving myPerson is simple:

static void Main(string[] args) {
    Person myPerson = new Person();
    myPerson.FirstName = "John";
    myPerson.LastName = "Smith";

    XmlSerializePerson(myPerson, @"C:\MyPerson.xml");
}

Let’s take a look at the resulting XML:

<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <FirstName>John</FirstName>
  <LastName>Smith</LastName>
</Person>

Now, let’s deserialize our person and display its data:

static void Main(string[] args) {
    Person myPerson = XmlDeserializePerson(@"C:\MyPerson.xml");

    Console.WriteLine("Name: " + myPerson.LastName + ", " + myPerson.FirstName);
    Console.ReadLine();
}

The result:

As you can see, the XmlSerializer did its job.

Download the Solution

You can download a zip file of the solution by clicking the link below.

XmlSerializerDemo.zip

It’s really rough; I’m giving it a version of 0.7. I don’t have any error handling in place, so if you put the wrong values into the tracker it will probably scream at you and then die. If you’re not a geek you probably want to wait at least until version 0.9 gets released. Until then, I’m probably not going to settle on a reliable file type, so .tfx files saved before 0.9 probably won’t be compatible with later versions.

For a current list of features, check the Cash Tracker’s main page.

The idea for Cash Tracker came to me when I was trying to find an easy way track my own finances. I wanted something I could put my income and bills into and get a simple projection of my account balance throughout the year. Then, if I didn’t mind making adjustments later to reconcile (thus improving the projections as time goes by), I wanted to be able to enter a manual transaction here and there, too. But my main focus was keeping it simple. So, I wrote a very simple program that reads in a set of recurrences (bills, income) and transactions (non-recurring expenses or adjustments to bills/income). Then, it displays a set of numbers that are designed to help give me peace of mind about the future, like my project low and high balances for the year. To help me reconcile with my balance at the bank as the year goes on, I had the program output a running total I could open in Excel and compare with the bank.

Right now, that’s pretty much all the Cash Tracker does. It’s ugly, but it works as well as I need it to and keeps me from worrying about my finances. The project I’m undertaking is to bring Cash Tracker from “personal helper” to “helper to a lot of people” by making it easier for people to use who can’t write code or format a flat file correctly; people who don’t know what a CSV file is or what XML looks like. And, of course, I want to bring the Cash Tracker to other people like me who just don’t want to waste time on a “big” personal finance application, but still want to feel secure financially and have some numbers to support themselves with. I’m doing this solely because my Cash Tracker has helped me organize my own finances so much over the past 3 months.

I think Cash Tracker will appeal to many people because it makes maintaining finances so painless. Now that I have all my income and expenses into the program, it takes me just a few minutes every week or two to make the current projected balance line up with my actual balance. That includes the time I spend editing ugly, tab-delimited files. I am sure I can speed up the process even more.

So, the goal right now is to get the Cash Tracker into a form that other people can actually use. Eventually, I’d like to get it to “auto-magical” status, which would look something like this:

1. Select your financial institution
2. Enter your login credentials
3. Hit “Track It!”
4. <magic>
5. View a list of your regular expenses and income, your projected high and low balances this year, your projected balance for any date in the future, etc.

We’re talking zero maintenance. I believe we can get there, but we’re going to take baby steps.

In your class definition you need to implement the interface System.Web.SessionState.IRequiresSessionState. Once you’ve done that you’ll find yourself magically able to use session once more.

using System;

namespace VersionChecker {
    class Program {
        static void Main(string[] args) {
            Version v1 = new Version("1.0.0.0");
            Version v2 = new Version("1.0.0.1");

            if (v1 > v2) {
                Console.WriteLine("v1 is higher");
            } else {
                Console.WriteLine("v2 is higher");
            }

            Console.ReadLine();
        }
    }
}

Here’s the result:

Here’s the method:

public static byte[] AppendImageToPdf(byte[] pdf, byte[] img, Point position, double scale)
{
    using (System.IO.MemoryStream msPdf = new System.IO.MemoryStream(pdf))
    {
        using (System.IO.MemoryStream msImg = new System.IO.MemoryStream(img))
        {
            System.Drawing.Image image = System.Drawing.Image.FromStream(msImg);
            PdfSharp.Pdf.PdfDocument document = PdfSharp.Pdf.IO.PdfReader.Open(msPdf);
            PdfSharp.Pdf.PdfPage page = document.Pages[0];
            PdfSharp.Drawing.XGraphics gfx = PdfSharp.Drawing.XGraphics.FromPdfPage(page);
            PdfSharp.Drawing.XImage ximg = PdfSharp.Drawing.XImage.FromGdiPlusImage(image);

            gfx.DrawImage(
                ximg,
                position.X,
                position.Y,
                ximg.Width * scale,
                ximg.Height * scale
            );

            using (System.IO.MemoryStream msFinal = new System.IO.MemoryStream())
            {
                document.Save(msFinal);
                return msFinal.ToArray();
            }

        }
    }
}

Deriving from System.Web.UI.Page 
A quick and dirty way to get a maintenance window up for your site is to write a base page (derived from System.Web.UI.Page) that all of your pages derive from. That way you can specify things to happen on multiple pages from one central location. So let’s say I have BasePage.cs in my App_Code folder. I can override the OnPreInit() method to check to see whether I’m supposed to be in maintenance mode or not. If the site is supposed to be “down” I will redirect the user to a page that will say the site is down for maintenance. For now I will just be checking a flag I’ve set in app settings.

protected override void OnPreInit(EventArgs e) {
    base.OnPreInit(e);
    if (ConfigurationManager.AppSettings["MaintenanceMode"].ToUpper() == "TRUE") {
        if (Request.Url.AbsolutePath.ToLower() != "/maintenance.aspx") {
            Response.Redirect("Maintenance.aspx");
        }
    }
}

Using an HttpModule

An alternate way to add code that checks for maintenance (and is less work if you have medium-to-large sized site OR multiple sites that need to use the same maintenance code) is to place it in an HttpModule and add the module to web.config. I personally think the HttpModule is perfectly suited to solving this problem. Checking for maintenance is typically something that is separate from most other things, so it makes sense to modularize it as much as possible. It’s just good form! Here’s my module code:

public class MaintenanceModule : IHttpModule
{
    #region IHttpModule Members

    public void Dispose() {

    }

    public void Init(HttpApplication context) {
        context.BeginRequest +=new EventHandler(context_BeginRequest);
    }

    public void context_BeginRequest(object sender, EventArgs e) {        if (ConfigurationManager.AppSettings["MaintenanceMode"] == "TRUE") {             if (Request.Url.AbsolutePath.ToLower() != "/maintenance.aspx") {                 Response.Redirect("Maintenance.aspx");             }         }
    }
    #endregion
}

And here is my web.config entry (added to the httpModules section in system.web for local use; put it in the modules section of system.webserver for IIS to pick it up):

<add name="MaintenanceModule" type="MaintenanceModule" />

Scheduling Maintenance Ahead of Time

I like to give my users several days’ notice before I bring a site down for maintenance, so I do two things to accomplish that. First, I keep a table called MaintenanceSchedule that I can put a start time, end time, public message, and private message into. Then, on pages where I want to notify users of the upcoming maintenance, I check the table for maintenance periods that haven’t yet begun.

string connectionString =
    ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;

using (SqlConnection con = new SqlConnection(connectionString)) {
    con.Open();
    using (SqlCommand com = con.CreateCommand()) {
        com.CommandText = "GetNextMaintenancePeriod";
        com.CommandType = CommandType.StoredProcedure;

        using (SqlDataReader sdr = com.ExecuteReader()) {
            if (sdr.Read()) {
                DateTime start = sdr.GetDateTime(1);
                DateTime end = sdr.GetDateTime(2);

                litUpcomingMaintenance.Text =
                    "<strong>Alert!</strong> "
                    + "This site will be going down for maintenance from "
                    + start.ToString() + " until " + end.ToString() + ".";
            }
            else {
                // throw an exception to show the default message.
                throw new Exception("No maintenance period found...");
            }
        }
    }
}

This method also allows me to put a more specific message out when the site is actually being worked on as well as a way to keep a record of when past maintenance periods occurred.

string connectionString =
    ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;

try {
    using (SqlConnection con = new SqlConnection(connectionString)) {
        con.Open();
        using (SqlCommand com = con.CreateCommand()) {
            com.CommandText = "GetCurrentMaintenancePeriod";
            com.CommandType = CommandType.StoredProcedure;

            using (SqlDataReader sdr = com.ExecuteReader()) {
                if (sdr.Read()) {
                    DateTime start = sdr.GetDateTime(1);
                    DateTime end = sdr.GetDateTime(2);
                    string message = sdr.GetString(3);

                    litMaintenance.Text =
                        "This site is currently undergoing maintenance. "
                        + "Maintenance is expected to start at "
                        + start.ToString() + " and end at " + end.ToString()
                        + ".<br/><br/>" + message;
                }
                else {
                    // throw an exception to show the default message.
                    throw new Exception("No maintenance period found...");
                }
            }
        }
    }
}
catch (Exception ex) {
    // This is in case my database goes down during the maintenance period.
    litMaintenance.Text = "This site is currently undergoing maintenance."
        + " Please try again later.";
}

I’ll also alter my base page to automatically take the site down when maintenance is scheduled to begin.

string connectionString =
    ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;

if (Request.Url.AbsolutePath.ToLower() != "/maintenance.aspx") {
    using (SqlConnection con = new SqlConnection(connectionString)) {
        con.Open();
        using (SqlCommand com = con.CreateCommand()) {
            com.CommandText = "GetCurrentMaintenancePeriod";
            com.CommandType = CommandType.StoredProcedure;

            using (SqlDataReader sdr = com.ExecuteReader()) {
                if (sdr.Read()) {
                    Response.Redirect("Maintenance.aspx");
                }
            }
        }
    }
}

Code Sample

I’ve included a sample website with a SQL script to show how all the pieces fit together. Just download the files, run the SQL against your database, open the website (I used Microsoft Visual Web Developer 2008 Express Edition), and put your connection string into the web.config. Then, add some rows into the MaintenanceSchedule table and run the site to see how it all works.

Download Sample Code (.zip)

Categories
CategoryID
Name

Products
ProductID
CategoryID
Name
Price

Suppose I want to collapse the categories named Televisions and Ipods into a the Electronics category, knowing only the category names. There are two obvious ways to pull off the update statement: using a sub-query OR an UPDATE FROM.

Using a sub-query

DECLARE @NewCategoryID int
SELECT @NewCategoryID = CategoryID FROM Categories WHERE Name='Electronics'

UPDATE Products SET CategoryID = @NewCategoryID WHERE CategoryID in (
    SELECT CategoryID FROM Categories WHERE Name IN ('Televisions', 'Ipods')
)

Here we simply ensure that our category is in a list. It’s important to remember that the list here gets queried fresh for each row. For a small table or a simple, well indexed, table this isn’t a real problem. Now, imagine there are millions of categories in our table. We’ve dramatically increased the processing time by adding a sub-query.

Using an UPDATE FROM

DECLARE @NewCategoryID int
SELECT @NewCategoryID = CategoryID FROM Categories WHERE Name='Electronics'

UPDATE Products SET CategoryID = @NewCategoryID
FROM Products p INNER JOIN Categories c ON p.CategoryID = c.CategoryID
WHERE c.Name IN ('Televisions', 'Electronics')

The UPDATE FROM statement has an advantage over the sub-query because it performs the query with the join only once. The WHERE still has to be evaluated on each row, but if you look at our last example the WHERE was being evaluated for every row in the categories table for every row in the products table, or, the product of the count of rows in each table. So we’ve saved time by not running an extra query for each row and by cutting down the number of expression evaluations to perform.