The Delphi Brand Confusion

Previously Delphi was pretty much the equivalent of VB brand-wise. It was the IDE and the language (although Object Pascal is strictly speaking the actual language, but decades of referring to it as Delphi has cast it in stone). But now confusion abounds in the CodeGear camp. Delphi is the language and the IDE. And there is Delphi for AS400. So far so good. But now there is Delphi for PHP. So Delphi is perhaps the IDE only. But to add even more confusion there is no Delphi for Ruby. It is called 3rdRail.

Blackfish

CodeGear have produced what seems like a pretty solid embeddable database engine, Blackfish. Besides being SQL standards compliant it allows you to write procedures and triggers in Java and .NET, a far cry from SQL Compact Edition. Now, perhaps its just me but I can’t seem to find out if you can get it without having to buy Delphi or any other CodeGear product. Say it ain’t so!

Musical Chairs

The uncertainty about the company never seems to go away. After the name changes Borland-Inprise-Borland-CodeGear, the almost sale, then the spin off and now the acquisition, one wonders what lies next. This uncertainty is not doing anything for a dwindling market share and brand value

I’ve gotten a lot of encouraging feedback about the feed reader. Contrary to popular belief, work has not stopped. In fact I will have a feature complete version within a fortnight or so. I’ve been very tied up in an number of things, chief of which is a very turbulent political situation in my country Kenya that understandably had distracted me and then some. For details see my other blog.

Here’s to an excellent 2008!

They’ve got guts, I’ll give them that ….

Progress As Of Today

If I do say so myself, I have been VERY BUSY working on this. It is beginning to take shape and then some.

New Icons

Preliminary UI For blogs & smart feeds

Smart feeds will be searches or watches for particular key words in all subscribed feeds

Marking items as read and unread

Less Laziness

Don’t you hate it when you see the following: 1 Message(s) unread? That’s laziness right there. LAZINESS!

Tags

You can create your own tags and then apply them to articles. Since there can be dozens of tags, a way to force you to organize yourself is to use what I’ll call quick tags. What are quick tags? Simply tags that you decide you will use more often then most. They will appear in the main UI as follows:

Search

The search on the main UI is now functional

Hitting enter pops up this screen

As you can see, the article text, title, categories, authors and tags are used in the search

Click Through Searches

A particularly handy feature is the ability to click on an article’s categories and tags and immediately get a list of other articles with the same category or tag

Clicking on a category link will popup the link below

Clicking  a tag link will popup the link below

Task Area Menu

I’ve added support to display the reader only in the task area (configurable from the settings). See the last issue for details

Lesson For Today: Connectivity

The very first problem is getting the raw XML feeds, identifying them and then as appropriate interpreting them for storage and display.

Identifying & Downloading Feeds

Identifying the feed type (ATOM, RSS, RSD, etc) Ideally should be something that you do once. So I identify the feed type when you subscribe for the first time. How?

As it so happens the Argotic Framework has a SyndicationDiscovery class that, surprise surprise, discovers a whole lot of information from a feed. It is especially functional because it has LocateEndpoints method that given a URL it will determine all the RSS feeds that can be subscribed to on that particular URL.

The relevant code is as follows:

   1: //————————————————————

   2: //    Determine the feed format from a given URL

   3: //————————————————————

   4: Uri uri                     = new Uri(“http://thinkersroom.com/bytes/”);

   5: SyndicationFormat format    = SyndicationDiscovery.DetermineSyndicationFormat(uri);

The first time I ran this code it failed spectacularly. Why? Because the Argotic Framework assumes a direct connection to the Internet! Now that right there is a problem for those of us that are behind proxy servers!

Digging around the source led to the discovery that it is peppered with code like this:

   1: //————————————————————

   2: //    Create web client to download feed data

   3: //————————————————————

   4: using(WebClient webClient = new WebClient())

   5: {

   6:    //————————————————————

   7:    //    Apply security credentials if available

   8:    //————————————————————

   9:    if(this.Settings != null && this.Settings.Credentials != null)

  10:    {

  11:        webClient.Credentials   = this.Settings.Credentials;

  12:    }

  13:  

  14:    //————————————————————

  15:    //    Download feed data

  16:    //————————————————————

  17:    byte[] data = webClient.DownloadData(sourceAsUri);

  18:  

  19:    //————————————————————

  20:    //    Load syndication feed using created stream

  21:    //————————————————————

  22:    this.Load(new MemoryStream(data));

  23: }

This will fail every time if you are behind a proxy server. Fixing it is trivial enough. Since the Argotic code is peppered with such code, a utility function to correctly build a WebCllient is needed

   1: public static WebClient GetClient(WebProxy proxy)

   2: {

   3:     //

   4:     // Create the web client

   5:     //

   6:     WebClient webClient = new WebClient();

   7:     //

   8:     //Add a header to identify ourselves

   9:     //

  10:     webClient.Headers.Add(“user-agent”, “FeedCruncher”);

  11:     //

  12:     //Assing the proxy where applicable

  13:     //

  14:     if (proxy != null)

  15:         webClient.Proxy = proxy;

  16:     return webClient;

  17: }

How about the proxy that’s being passed then?

This one is constructed by the client based on the configured user settings. Here is the code (I’m writing the UI itself in VB.NET, and the logic in C#. Why? Because I wondered if I could!

   1: If My.Settings.UseProxy Then

   2:     ‘

   3:     ‘ Create a web proxy

   4:     ‘

   5:     Dim proxy As WebProxy = Nothing

   6:     If My.Settings.ProxyAuthentication Then

   7:         ‘

   8:         ‘ Create network credential for authentication

   9:         ‘

  10:         Dim nc As New NetworkCredential(My.Settings.Username, My.Settings.Password, My.Settings.Domain)

  11:         ‘

  12:         ‘ Create web proxy with overload for network credentials

  13:         ‘

  14:         proxy = New WebProxy(String.Format(“{0}:{1}”, My.Settings.Host, My.Settings.Port), True, _

  15:         Regex.Split(My.Settings.ByPassAddresses, “;|,”), nc)

  16:     Else

  17:         ‘

  18:         ‘ Create web proxy without overload for network credentials

  19:         ‘

  20:         proxy = New WebProxy(String.Format(“{0}:{1}”, My.Settings.Host, My.Settings.Port), True, _

  21:         Regex.Split(My.Settings.ByPassAddresses, “;|,”))

  22:     End If

  23:     ‘

  24:     ‘ Return our proxy

  25:     ‘

  26:     Return proxy

  27: Else

  28:     ‘

  29:     ‘ We don’t need a proxy. Return nothing

  30:     ‘

  31:     Return Nothing

  32: End If

And so, our connectivity issue is sorted.

The DetermineSyndicationFormat returns an enumeration. Once you know this you can correctly download the appropriate feed type using code like this:

   1: SyndicationFormat sf = SyndicationDiscovery.DetermineSyndicationFormat(new Uri(URL), proxy);

   2: switch (sf)

   3: {

   4:     case SyndicationFormat.Rss:

   5:         RssFeed rfeed = RssFeed.Create(new Uri(URL), proxy);

   6:         myFeed.Type = FeedType.RSS;

   7:         myFeed.SiteURL = rfeed.Channel.Link.OriginalString;

   8:         myFeed.FeedURL = URL;

   9:         myFeed.Name = rfeed.Channel.Title;

  10:         myFeed.Header = rfeed.Header;

  11:         myFeed.Description = rfeed.Channel.Description;

  12:         myFeed.LastUpdated = rfeed.Channel.LastBuildDate;

  13:         myFeed.Generator = rfeed.Channel.Generator;

  14:         foreach (RssItem item in rfeed.Channel.Items)

  15:         {

  16:             FeedItem myFeedItem = new FeedItem(item.Link.OriginalString, item.Title, item.Description, item.PublicationDate, item.Guid.Value, false);

  17:             myFeedItem.FeedID = myFeed.FeedID;

  18:             foreach(RssCategory cat in item.Categories)

  19:                 myFeedItem.Categories.Add(new Category(cat.Value));

  20:             myFeed.Items.Add(myFeedItem);

  21:             myFeed.Guids.Add(item.Guid.Value);

  22:         }

  23:         break;

  24:     case SyndicationFormat.Atom:

  25:         //

  26:         // Same logic but for the ATOM format

  27:         //

  28: }

  29: return myFeed;

To store the results, I use plain old C# objects to mirror a blog (Feed) and its items (FeedItems)

So, as you can see the bulk of the work is done by the Argotic Framework.

Conditional Get

When it comes to feed readers, an essential consideration is saving bandwidth. The most common way is to only fetch a feed if it has been updated since the last check. This is implemented on the http conditional-get method, and in this manner we can save quite a bit of bandwidth.

However the build that I believe to be the latest, 2.0, always returns true for the HasChanges property. I’ve been looking for the code for a while but it’s not clear to me how the headers are set in the conditional get request. Hmm.

Now what do we do once we have this data in our custom objects? Why save it of course.

Stay tuned for Episode 4: Persisting to Database

To keep you interested, and prove that I’m not just talking, what I’ll be doing is showing you where I’ve reached so far and then go on to the meat and potatoes

Progress As Of Today

Grouping

Feed Cruncher can now group articles by Date and By Month, which you toggle with buttons on the menu bar

Grouping By Day

This groups all items by day, so you can see at a glance all articles from a particular day. This is good for blogs that have lots of daily posts. And believe me there are many!

Grouping By Month

This group all items by month, so you can see at a glance all articles for a particular month. This is good for blogs that post less frequently

Settings

The application can now persist settings

Lesson For Today: Understanding The Problem

So, as I mentioned yesterday, I found myself bemoaning the inability to find a good reader. So I decided to write my own.

Deciding to write your own does not necessarily mean starting from scratch with File -> New Project. There must be some readers with source available. As it turns out there are two that I know of: RSS Bandit and RSSOwl.

RSSOwl I dismissed as a non starter because it is written in Java. My last brush with Java was many years ago and describing myself as rusty would be flattering myself.

Which leaves RSS Bandit. I used to use it a while back until the horrifying feature creep that Jeff Atwood speaks so eloquently about began to creep in. Newsgator? NNTP? It also uses Infragistics for UI, which is yet another huge library. A bit much if all you need is a listview and a treeview. And every time I used it it would seem to fool itself into thinking it was SQL Server 2008 and begin taking all the memory it could get its hands on!

Ok, ok, those are lame excuses. RSS Bandit is excellent software but it does not do some of the things that I consider crucial. I also don’t agree entirely with some of the design decisions that were taken. Eventually I decided to start off with a clean slate, make all the choices and design decisions myself and build the freed reader!

So, that is the problem.

Build A Feed Reader

From experience and education, and lots of reading, I have come round to the school of thought that all big problems (including Wars In Iraq, Inflation, Reality TV, etc) are actually composed of many smaller problems.

Solve these small problems and the big ones automatically get solved.

So what are the small problems in building a Feed Reader

Problem Definition

1. Knowing where feeds can be found, or discovering new feeds to subscribe
2. Storing these subscriptions, and allowing user to manage them
3. Connecting to remote websites with subscribed RSS feeds
4. Downloading RSS feeds from the Internet
5. Interpreting these feeds
6. Storing these feeds
7. Displaying these feeds to the user
8. Allowing user to mark as read, tag and otherwise manipulate these items
9. Storing these changes
10. Updating feeds
11. Allowing user to search all these
12. Other features e.g. search, export, etc

Looking closely at the problem definition, we can tentatively abstract the following as the core functionality

1. Download Feeds (Connectivity & Interpretation)
2. Store them (Storage)
3. Display to the user (Interface)

Download Feeds (Connectivity & Interpretation)

Here we will need to connect to a website, download its RSS feed and then interpret it. Why interpret? Because there are several formats:

• Atom
• RSS
• OpenSearch
• RSD

At first I was considering doing this using a WebClient to download the data and a lot of XML and Regular Expressions to identify and parse the feeds until I stumbled upon the Argotic Syndication Framework. Brilliant does not begin to describe it. It does exactly what I wanted and then some.

In the course of using it I have found some quirks and some bugs but the guys get 11 points out of 10 for the excellent job. A third of my battle is won!

Store Them (Storage)

The next problem was storage. Basically there are three options:

1. Store the actual XML on disk
2. Store the actual XML in a database
3. Interpret the feed and split it into its constituent parts and store those in the database

Storage on disk is the least attractive option for a couple of reasons

1. There will eventually be a performance hit after getting a lot of files on disk to process one after another
2. Search will be very difficult, if not impossible
3. It is bound to be a wasteful strategy because if an entry is added you download the old entries all over again
4. Some other reason I can’t remember at this point

Which leaves storage in a database. Which opens another can of worms … which database to use?

To be lightweight clearly we need something … well, light. Which knocks out of the running things like SQL Server Express. What is lighter than that? Microsoft Jet. Which leaves me very uncomfortable. I’ve never fully trusted jet after getting my fingers burnt several times. Is there something even lighter that can run in process?

Turns out there are several. SQL Server Compact Edition, VistaDB, CodeGear Blackfish. Since I am fiscally constrained, VistaDB and Blackfish need not apply. So SQL Server Compact Edition it is. Although I would have preferred to use either of the latter because they support a greater SQL dialect, triggers, stored procedures and views. There’s also SQL Lite, but this is a good an exercise as any to try out SQL CE before I deploy it for some real projects that are coming up.

Reading some of the white papers about SQL Compact Edition fills me with admiration. Some people in Microsoft are truly masters of spin. It is only a brave man who will attempt to explain how lack of triggers, views and procedures is a good thing! Maybe its just me but I don’t find the arguments as to lack of these things convincing in the least.

But I digress. Once settling on that and doing some research, it seemed that it addition to what’s missing, it actually stores XML as NText, which knocks out option 2.

Which means I must interpret the RSS feeds, extract the content and then store it, which on reflection sounds like a pretty solid solution. Why? I can search quickly using normal database expressions. I can do things like sort on various fields — date created, author, etc. And it won’t be too hard to generate XML should I need to

Display To The User (Interface)

This is the final part … displaying to the user.

Since I want the application to be desktop based, Windows Forms is the obvious choice. I could do WPF but I’m pressed for time and WPF might be an overkill for this. Displaying the feeds out to be simple enough. All we need is to load the feeds from the database at startup and populate the tree view on the left. Then when you click on a feed populate the listview on the right. Then when you click on an item, display its content in the WebBrowser pane below.

Here is a mockup

This, as it turns out, despite sounding simple, is a bit more complicated that I thought

Stay tuned for Episode 3: Downloading Feeds

For a very long time I have been looking for a good RSS Feed reader. What do I mean by a good RSS Feed Reader?

• Desktop application. Google Reader / Bloglines / NewsGator need not apply!
• Stable. ‘Nuff said.
• Fast. ‘Nuff said.
• Portable. Can carry around on my flash disk. And no, synchronization with NewsGator/Bloglines will not do
• Lightweight.
• Newspaper View AND Item View
• Offline Reading.
• Quick Search, integrated right into the main UI.
• Smart/Search Folders.
• Support for downloading enclosures.
• Filters to allow view of Read/Unread/All messages
• Groups items by custom groups — Day, Month, Category, etc
• Allows me to flag articles to return to later
• Allows me to tag articles with my own tags.
• Can easily customize display with styles and themes.
• Exports content to PDF.
• Works quietly in the background and notifies me via desktop alerts.
• Can discover feeds on web pages.
• Keeps track of update frequency, allowing me to purge feeds that are rarely updated.
• Allows me to have custom folders to store feeds.
• Allows me to nest the custom folders.
• Displays links to comments (where available)
• Differentiates read from unread items
• Offers various reports and charts.
  • Feeds per folder
  • Subscribed Feeds
  • Most recently  updated feeds
  • Most popular generator software (blogger / wordpress / movable type / feed burner / etc.)
  • Tags per feed
  • Tags for all feeds
• Saves bandwidth by making use of conditional get.
• Imports and exports to OPML

Believe you me I have looked high and looked low. I have tried them all out. FeedDemon, FeedReader, Snarfware, RSSOwl, GreatNews, SharpReader, RSSBandit, RSS Reader, BottomFeeder,  Outlook, Omea, Internet Explorer, Firefox, Thunderbird, Opera and countless others I forget right now.

They all have something or the other missing from the list, and every time I button down and pick one, after a while I come to resent what it is that I have sacrificed.

And so I did the only logical thing.

I started writing my own.

It has been much easier than I thought, to tell the truth. The .NET Framework is very powerful and Visual Studio 2005 is an excellent tool for development and debugging. In a couple of days I’ve been able to put together the skeleton of the application. Here are some screen shots of what is currently working so far

Main Screen

Subscribing To A Feed

Discovering Feeds

Folder Management

Feed Properties

Not too bad for a couple of day’s work. Hopefully with some free time I can put in all the features I want in a fortnight or so and eventually share it for like minded individuals to find the bugs.

Note that I’ve not paid too much attention to the look and feel. That, naturally will be a distant last.

In the process of writing this application I have had to consult MSDN and Google heavily to overcome some of the problems that i have run into. I have also learnt quite a bit, which is the purpose of this series.

I hope to share with you, dear reader, some of the challenges I have run into and how I have solved them. A great man said we see far because we stand on the shoulders of great men. Hopefully after I have shared some of my problems and thoughts, we will all be the wiser for it.

I hope to also capture my logic in moving from an idea to a design to a working application. Ideas, as ever, are most welcome.

Stay tuned for Episode Two: Understanding The Problem(s)

NB: Those about to start being outraged at my re-inventing the wheel, hold your horses until we get to Episode Two!

1. How fast it (the program) executes
2. How fast each method executes
3. Bottlenecks within the code
4. Number of times loops execute
5. Memory usage
6. Number of objects created

These are pretty useful metrics that can help you identify notoriously difficult to identify bugs, such as memory leaks. They also show you where you can concentrate on optimizing your code.

For this example I will use a very trivial console application that does nothing more than concatenate a large number of strings. This is in a static function imaginatively called ConcatenateWithPlus()

   1: class Program

   2:     {

   3:         static void Main(string[] args)

   4:         {

   5:             ConcatWithPlus();         

   6:         }

   7:         static void ConcatWithPlus()

   8:         {

   9:             Random r = new Random(0);

  10:             string s = “”;

  11:             for(int i =0;i <5000;i++)

  12:             {

  13:                 s += r.NextDouble().ToString();

  14:             }

  15:         }        

  16:     }

A couple of interesting things to note:

1. It is entirely possible that if we used the same string repeatedly to concatenate, the compiler or the runtime might make some optimizations to improve the performance. To avoid this I use the random class to generate 5000 (pseudo) random strings
2. Yes yes, pseudo random. This is because I want to generate the exact same sequence of strings. You’ll see why shortly

So, the next thing to do is run the application through a profiler. The better known ones are Red Gate Software’s ANTS Profiler and JetBrains’ dotTrace. Today I will use ANTS. (Both have evaluation versions you can download to check out)

First, open ANTS

This is the screen you should get

We want the detailed mode. Click next

As you can see, quite a number of applications can be profiled. A console application is a .NET desktop application so we select that an move on to the next screen.

Here select the executable that you want to run. In our case, the console app.

The final screen gives you control over what to profile. We can if we want also profile the .NET classes, or choose exactly what we want to profile. For simplicity, let’s take the first choice. Then click Finish and we’re off.

Yes I do!

You should get something like you see above

The points of interest are the following:

1. The summary pane gives you an overview of the profile that has just been run and two reports:
• Slowest Lines Of Code
• Slowest Methods
2. The all methods pane gives you a grid with all the profiled methods and some metrics, such as time (for the method itself) and time with children (for the method and any other methods it calls)
3. The source code pane gives you the actual source code and time taken for each line of code. This is very valuable information because you can identify any slow algorithms and method calls.

The all methods pane tell us that the ConcatWithPlus() call is the slowest, at 0.482 seconds. Can we improve this? Methinks so.

String concatenation is a very slow process. Due to the fact that they are immutable (cannot be changed once created), any method that purports to manipulate a string actucally creates a new string with the manipulations. So stuff like ToUpper(), ToLower(), etc actually creates a new string and returns the new instance.

Naturally, concatenation also has the same side effect. So in effect our code creates 5,000 string objects.

Hmm.

Can we avoid 5,000 string objects being created? Turns out that we can.

Enter the StringBuilder.

This is an object designed for precisely this sort of thing. So let’s create a second method that uses a StringBuilder.

Modify your code as follows:

   1: class Program

   2:     {

   3:         static void Main(string[] args)

   4:         {

   5:             ConcatWithPlus();

   6:             ConcatWithStringBuilder();

   7:         }

   8:         static void ConcatWithPlus()

   9:         {

  10:             Random r = new Random(0);

  11:             string s = “”;

  12:             for (int i = 0; i < 5000; i++)

  13:             {

  14:                 s += r.NextDouble().ToString();

  15:             }

  16:         }

  17:         static void ConcatWithStringBuilder()

  18:         {

  19:             Random r = new Random(0);

  20:             System.Text.StringBuilder sb = new System.Text.StringBuilder();

  21:             for (int i = 0; i < 5000; i++)

  22:             {

  23:                 sb.Append(r.NextDouble().ToString());

  24:             }

  25:         }

  26:     }

Now, we run the profiler again, by clicking the green Go button or Control + G

Then click the All Methods pane. The results should be interesting

The method with the StringBuilder is several orders of magnitude faster than the concatenation!

The source code view reveals the same information slightly differently

You can see the line with

   1: s += r.NextDouble();

Has a little red bar after the time (0.427). This is a contribution of that line of code to the total time taken. Notice the corresponding line for the StringBuilder

   1: sb.Append(r.NextDouble().ToString());

Does not have the bar. This is because graphing 0.0099 next to 0.430 is a bit of a stretch.

Thus we see the profiler has helped us identify a bottleneck and we have investigated how to correct it. Version 2 of our do nothing application will be MUCH faster.

AOB

Now, back to that Random business.

The System.Random class does not actually generate truly random numbers. In fact it is fairly predictable because given the same seed it generates the same sequence of numbers. I used this to generate a large set of randomish yet predictable strings for the test.

Type the following into a shiny new spreadsheet

Press Enter and you should see the following

Then, type the following

You’d think you’d get the same result. This is where you would be wrong

Let’s try with other factors

The result?

Ok, maybe there’s something special about 77.1, 850 and multiplication.

From what I remember from school, A * B = A / (1/B). Let’s see if Excel 2007 agrees

Type the following

Then type the following formula and fill down

What do you reckon the results will be? Without further ado:

The point of this post is not to gleefully point out the bug. I have my fair share of the same! And so do you! It is to merely speculate

1. What conditions in the algorithm the Excel guys used could lead to such a situation? Does it have anything to do with the number 65535, that just happens to be 2^16?
2. Since the bug manifests itself in the division, it conjures up some food for thought. In the division algorithm does it actually divide or does it reduce the expression directly to multiplication?
3. Where else will this beast rear its head? For instance, some formulas make use of multiplication
4. Are there any other magic numbers that cause this behaviour?
5. How do you test for this, short of writing tests for all permutations of numbers being added/divided/multiplied/subtracted?

But I digress.

Point is, as I typed away at my SQL Server 2005 Management studio and flipped between a random PDF that said that it was impossible to roll back truncates, I Wondered …

And if at first you don’t succeed, try try it yourself.

First, a dummy database to hold all our experiments

   1: create database Springfield

Next create a table to store the test data

   1: create table Residents(

   2:     ID int identity,

   3:     FirstName varchar(50),

   4:     Age int

   5: )

Next create some sample data. For the slower ones among us I’m sure a pattern is emerging!

   1: insert into Residents(FirstName,Age) values (‘Homer’, 40)

   2: insert into Residents(FirstName,Age) values (‘Marge’, 35)

   3: insert into Residents(FirstName,Age) values (‘Bart’, 11)

   4: insert into Residents(FirstName,Age) values (‘Lisa’,  

   5: insert into Residents(FirstName,Age) values (‘Maggie’, 3)

Now select and see our nice clean data

Awesome.

Now from past experience, truncate and delete affect identity columns differently. To make our experiment a bit less misleading, what we’ll do is to find a way to make the IDs NOT begin from 1. A simple delete will suffice, then we recreate our residents again

   1: delete from Residents

   2: go

   3: insert into Residents(FirstName,Age) values (‘Homer’, 40)

   4: insert into Residents(FirstName,Age) values (‘Marge’, 35)

   5: insert into Residents(FirstName,Age) values (‘Bart’, 11)

   6: insert into Residents(FirstName,Age) values (‘Lisa’, 8 )

   7: insert into Residents(FirstName,Age) values (‘Maggie’, 3)

Our data now looks like this

Right. Now let’s get cracking.

Even the most shiny faced new programmer is aware of the mysterious thing called the transaction that allows you to recover data from the live table you delete my mistake preserve atomicity of transactions. So what we’ll do is create  a transaction and within it delete all the data and roll it back

   1: begin tran

   2: delete from Residents;

   3: select * from Residents;

   4: rollback;

   5: select * from Residents;

Our data will now look like this. Which should be the same as above

Right. Now let’s try the same query with truncate instead of delete

   1: begin tran

   2: truncate table Residents;

   3: select * from Residents;

   4: rollback;

   5: select * from Residents;

The results pane should be as follows:

Observations

My dear Watson, I do believe the following

1. The truncate has been rolled back, just like the delete
2. The truncate appears to have preserved the identity values, and not started again from 1 (I’d be amazed if it did otherwise, this being a rollback and all, but one should not assume!).

Moral

Truncates can be rolled back, at least for SQL 2005. I’ll try and find a SQL 2000 box somewhere and see if it also holds true there.

Caveat

This is not always true. Truncates fail spectacularly if the table being truncated, hereby called the truncatee, is participating in a foreign key relationship. To be exact, if is being referenced.

As a happy iPod classic owner (I’m tempted by the iPod touch but 16 GB of storage does not cut it for me), getting stuff, especially DVDs onto the iPod is a problem and then some. I’ve spent months looking for the best rippers, and have tried  out over 15. Yes. 15. Finally yesterday I chanced on GOLD. Ladies and gentlemen if you want to get DVDs onto iPods, or indeed any other device, look no further than SlySoft Clone DVD Mobile. Awesome does not begin to describe it!

The first step is selecting the device you want the video to go to

Next browse to the Video_TS Folder and watch your videos loaded

You can even preview the video if so inclined. Finally you get a chance to tweak various aspects of the video — resolution, file size, number of passes, and so on, one of the most powerful features. Not many rippers offer this.

Finally you hit go and away you go! And there is where more features becomes apparent. It can correct those annoying DVDs that have the audio out of sync with the video. Also, I had a DVD that was partially scratched near the end of the movie. Unlike most rippers that threw up their hands and gave me a 600MB useless file, Clone DVD Mobile rendered the file until the point of damage, so I can, if I chose to, watch the first 130 minutes of Coach Carter.

Brilliant.

And no, I have no affiliation with SlySoft. I just love their product. You can get a 21 day demo that FULLY WORKS. None of that 10 minute limit nonsense.

Seriously, buy it if you can.