Home Antivirus Comparison

June 30, 2010 Leave a comment

Up until recently, I used to run several servers at home to support my personal consulting business. I had a Windows domain controller, an Exchange 2007 server, SQL Server, plus a few Linux CentOS systems that hosted virtual machines under the Xen hypervisor. Recently I had a couple of hardware failures that made me re-evaluate the wisdom of maintaining these servers myself. It just takes too much of my time, so I started looking for other alternatives. The first to go was the Exchange server, which was replaced by Google Apps. In short, it is simply awesome. Next to go was my antivirus setup, which is the point of this post.

Previously, I had been using Symantec Endpoint 11. Now I hate Symantec and Norton antivirus products as much as anyone else, but the main reason I was using it was because it worked on Windows server operating systems (I had both 2003 and 2008 servers running). Many of the more popular (and frankly, better) systems wouldn’t run on server OS’s. But now that I’m getting rid of my servers, it’s time to look for something better.

There are dozens upon dozens of antivirus products and I’m not going to do a comparison of all of them. Just the top 3 or 4 that meet my needs. My criteria for these are:

  • Must have a proven track record
  • Easy to use, stable system
  • Free or relatively inexpensive
  • Needs to run on Vista and Windows 7 (64-bit for both)
  • Not interested in peripheral features, like firewalls, because I already have other solutions in place for those needs
  • I need at least 3 licenses to cover my laptops and workstation
    In order to determine what the top 3-4 are, I looked at two main websites that rate antivirus products: AV Comparatives and Virus Bulletin. Both of these websites are well-respected in the antivirus community and they both use different methods and criteria to rate products. It is also worth noting that the rankings change quite often so I wasn’t too worried about which one was #1 at any given moment. But my choices are based on the rankings as of June 2010.

AV Comparatives gave the highest ratings to TrustPort, G DATA, Kaspersky, Microsoft, AntiVir (Avira), NOD32, F-Secure, BitDefender, and eScan. According to Virus Bulletin, the top-rated products were by AntiVir (Avira), avast!, and AVG. I picked 3-4 that were pretty high on both lists and were popular with most users. My picks were:

Keep in mind, I wasn’t out to evaluate the actual effectiveness of these products, because I trust AV Comparatives and Virus Bulletin to do that for me. All I needed was to compare the feature sets and prices.

Avira

Avira has three products targeted at the home market: Avira AntiVir Personal, Avira AntiVir Premium and Avira Premium Security Suite. These break down as follows:

  • Personal – basic antivirus, spyware, and rootkit protection. Cost: FREE
  • Premium – adds protection against phishing and protection for web browsing and emails. Cost: $26.95 for one license, $67.95 for three licenses.
  • Security Suite – adds backups, network bot protection, spam filter, firewall, and parental controls Cost: $53.95 for one license, $79.95 for three licenses

avast!

avast! comes in three versions as well:

  • Free – basic antivirus and spyware protection. Cost: FREE
  • Pro – adds the Sandbox, which uses Process Virtualization to run a web browser or other app in a safe, isolated environment. Also adds protection against scripts and “suspicious websites”, as opposed to the free version which only provides protection against “common websites”. This version also allows scheduling of scans, whereas the free version only supports manual scans. Cost: $39.95 for one license, $54.95 for three licenses
  • Internet Security – adds firewall and spam filters. Cost: $44.95 for one license, $59.95 for three licenses.
    AVG

Much like the previous two products, AVG also comes in three different versions:

  • AVG Anti-virus Free – basic antivirus, spyware, and web page protection. COST: FREE
  • AVG Anti-virus 9.0 – adds rootkit and phishing protections. COST: $27.99 for one license, $83.97 for three licenses
  • AVG Internet Security 9.0 – adds identity protection, firewall, and spam filter. COST: $43.99 for one license, $131.97 for three licenses.

Kaspersky

Kaspersky breaks the mold by offering only two versions of their product instead of three. Most notably, there is no free version. While they do offer a free trial of their two products, it’s only good for 30 days so there is no long-term free solution if you go with Kaspersky. Their two products are:

  • Anti-virus 2010 – basic antivirus, spyware, email and website protection. Also includes a virtual keyboard for entering sensitive data, privacy tools to clean up browsing history, and parental controls. COST: $49.95 for 3 licenses. They don’t have a way to buy just a single license.
  • Internet Security 2010 – adds protection against hacker attacks, phishing, and identity theft. Also includes a spam filter and a firewall. COST: $59.95 for 3 licenses. Again, there is no way to purchase just a single license.

For me personally, I chose to go with the Pro version of avast!, because it rated high on both surveys and had the lowest price. I couldn’t go for the free version because their free license only covers non-commercial use and my computers are used for business. Plus I like some of the extra features, like scheduling and protection against scripts.

But at the end of the day, I think any of these products would work well. They are all highly regarded. Even many other products not on this list are quite good, and even ones that aren’t would still be vastly superior to not having any antivirus protection at all.

Share

Advertisements
Categories: Anti-virus Tags: , , , ,

Team Foundation Server vs. Subversion – An Objective Comparison

June 25, 2010 22 comments

I asked by my client to write up a comparison of Microsoft Team Foundation Server (TFS) and one other SCM (Software Configuration Management) system, so they could evaluate whether TFS was a goof solution or not. I picked Subversion as the other one to compare to, because it is one of the most popular systems out there. I tried to stay away from most of the “religious wars” about TFS vs. Subversion and tried to look at it objectively in several key areas.

Ease of Use and Learning Curve

TFS: For developers with a background in using Visual SourceSafe and Microsoft development tools, TFS is much more familiar.

Subversion: This requires more of a learning curve for developers familiar with Microsoft environments. Instead of the more familiar check-in/check-out paradigm, Subversion uses the edit/merge/commit concept.

IDE Integration

TFS: By far the best integration into the Visual Studio IDE, and the best choice for programming in .NET languages. Not the best choice if you’re not developing in Visual Studio.

 

Subversion: Fairly good integration into Visual Studio, especially with additional third-party tools and plug-ins, but not as good as TFS. This is probably the better choice if you’re not programming in a .NET language, though, especially if you’re not using Visual Studio.

 

Scope and Productivity

TFS: In addition to source control, TFS also has features that help with project management, especially Agile development, test driven development (TDD), managing test scripts, and defect tracking. TFS is not marketed as a pure source control product, it is an application lifecycle management product.

Subversion: Subversion is only a source control tool, and doesn’t include any project management, testing, or defect tracking functionality.

 

Management

TFS: TFS is integrated with Active Directory, and users are Active Directory users. Has a nice GUI interface for management. TFS also has better support for implementing overall corporate or project check-in policies, and better support for measuring metrics.

Subversion: Subversion can be made to work with Active Directory, but it can be tricky to set up.

 

Features Unique to Each System:

TFS (not available on Subversion):

  • Shelving – Shelving is a way of saving all of the changes from your local development workstation to the TFS server without actually checking in. At a later time you, or anyone else, can “un-shelve” them to a workstation. This can be useful in a variety of situations:
    • Allowing others to review your code on their own machine
    • Switching tasks, for example to fix a defect, before you’re done with the code you have checked out.
    • Saving your progress onto a server, which is backed up.
  • Work Item Integration – associating a check-in to a work item, such as a defect or task. That code can then be tracked along with that work item.
  • Merge History Tracking – stores history of all merges and allows you to query it. This is great for collaborative team environments.

Subversion (not available on TFS):

  • Anonymous Access – Anyone can grab a read-only copy of the code to look at it. This is a bigger advantage for open source development environments than it is for the typical corporate IT environment.
  • Patch Submission – Subversion can compare two completely different builds of the code and generate a patch to update one version to the other. While TFS can do something like this, it is much easier to do in Subversion.
  • Offline Support – Subversion allows for offline work, when the user is not connected to the network or is not on-site. Again, this isn’t a big deal for most corporate IT environments but can be important for open source development.

 

Web Server

TFS: TFS requires IIS as a web server.

Subversion: Subversion is designed to work with Apache, not IIS. It can be made to work with IIS, but most of those solutions still require Apache to be installed and proxies to be created between the two.

 

Software Requirements

TFS: Windows Server 2003 or 2008, IIS, Active Directory, SQL Server.

Subversion: Apache, MySQL

Cost

TFS:

  • Visual Studio 2010 Ultimate (7 licenses) – retail is $6900/license, but the price varies greatly on volume of licenses and contracts or agreements previously existing with Microsoft. It also depends if you have an MSDN Subscription or not (or if you buy one along with Visual Studio). Other editions of Visual Studio 2010 will have more limited functionality with TFS, but will also cost less.
  • Team Foundation Server 2010 – $500
  • TFS Client Access License – $500 for first 5 developers, plus $500/developer after that.

Subversion: Free (open source)

All in all, I think both systems are quite capable. Currently we use Visual SourceSafe 2005, so pretty much anything would be an improvement. However, TFS is a better choice for us overall because:

  1. We’re exclusively in a .NET development environment.
  2. We’re working at a large government agency, so the cost isn’t a huge obstacle.
  3. The client likes the support that comes with TFS.
  4. The client already has contracts in place with Microsoft, thus lowering their initial cost of adoption for TFS.

For open source projects, or small projects either at home or at start-ups, I think Subversion would be an excellent alternative.

Share

Binding an SSL Certificate to a Web Site in IIS 7

June 23, 2010 1 comment

I run my own Exchange 2007 server, which requires an SSL certificate to enable all functionality (like syncing to my iPhone). A few days ago, my SSL certificate expired so I renewed it and installed the new one. As soon as I did that, I could no longer sync my phone or use Outlook Web Access (OWA). In fact, I got a “Page Not Found” error when navigating to the server using “https”.

The solution to the problem turned out to be simple, but it took me a while to figure out. Mainly because I haven’t done a lot of configuration on IIS 7, as the place I’m currently consulting at uses older technologies like IIS 5 and IIS 6 (government work…it isn’t always bleeding-edge, by a long shot, but it can be stable…).

IIS 7 gives you the option to bind an SSL certificate to each website. My old certificate was bound to the Default Website, and when I deleted the certificate the binding was obviously removed. When I installed the new certificate, I forgot to rebind it. So here’s how you do it.

Start up IIS 7 and select the web site you want to bind an SSL certificate to (in this example, “Default Website”):

1 

Next, click on “Bindings…” on the right-hand menu. This will bring up the site bindings menu. If you still have the old https binding listed here, click “Remove” before proceeding. Trying to edit the old binding can be problematic and doesn’t always work.

2

After that, click “Add…” to bring up the “Add Site Binding” dialog.

3

In the “SSL certificate” dropdown, choose the certificate you want to bind to this website. Click “OK” to close out of all dialogs, and then make sure to restart IIS. That’s it! 🙂

Share

Categories: Exchange, SSL Tags: , , ,

Reference for WordPress.com Shortcodes

June 12, 2010 Leave a comment

Wow, two posts in one day! Not much else to do while I sit here watching people tear out our old carpet and install new carpet. Everything’s unhooked and has been moved out to make room, so it’s just me and my laptop for the rest of the day.

I find myself looking up the syntax for these shortcodes pretty often, so I thought I’d post it. What’s a shortcode? It’s like an HTML tag, but using square brackets instead of angled brackets. WordPress interprets them as shorthand for doing something more complicated. They can be very handy, so check them out if you’re not already familiar with them. Here is the list of shortcodes supported by WordPress.

Share

Categories: Wordpress Tags: ,

Querying Newly Added Entities in LINQ to SQL

June 12, 2010 Leave a comment

In LINQ to SQL, when you want to add a new record to the database, you have to follow these steps:

  1. Create the object in memory.
  2. Attach it to the current context, using either InsertOnSubmit() or InsertAllOnSubmit().
  3. Submit the context, using SubmitChanges().

The other day, I was working on some complicated logic and as part of debugging I tried to check if a certain object had already been attached to the context (step #2). Unfortunately, this doesn’t work. Let’s say I had a Customer table in the database, represented in LINQ as follows:

Customer

Then I add a new Customer using this code:

  1:             using (var ctx = new MyDataContext(connectionString))
  2:             {
  3:                 Customer newCustomer = new Customer
  4:                 {
  5:                     Id = Guid.NewGuid(),
  6:                     Name = "James Bond",
  7:                     AccountNumber = "007",
  8:                     JoinDate = new DateTime(1953, 3, 15)
  9:                 };
 10:
 11:                 ctx.Customers.InsertOnSubmit(newCustomer);
 12:
 13:                 int count = (from c in ctx.Customers
 14:                              select c).Count();
 15:             }
 16:

Assuming that there were 10 records in the table prior to executing this code, the value of count in line 13 will still return 10. This is because even though newCustomer is attached to the context, LINQ will not “see” it when you query until it has been submitted.

Instead of adding it directly to the context, if you add it to the Entity collection of another Entity, like in the following example, you would have the exact same results.

  1: using (var ctx = new MyDataContext(connectionString))
  2: {
  3:      Customer newCustomer = new Customer
  4:      {
  5:           Id = Guid.NewGuid(),
  6:           Name = "James Bond",
  7:           AccountNumber = "007",
  8:           JoinDate = new DateTime(1953, 3, 15)
  9:      };
 10: 
 11:      var myOrder = (from o in ctx.Orders
 12:                     where o.Id == orderId
 13:                     select o).Single();
 14: 
 15:      order.Customers.Add(newCustomer);
 16: 
 17:      int count = (from c in ctx.Customers
 18:                   select c).Count();
 19: }

 

If you need it to return in the results, you have to submit the context first:

  1:             using (var ctx = new MyDataContext(connectionString))
  2:             {
  3:                 Customer newCustomer = new Customer
  4:                 {
  5:                     Id = Guid.NewGuid(),
  6:                     Name = "James Bond",
  7:                     AccountNumber = "007",
  8:                     JoinDate = new DateTime(1953, 3, 15)
  9:                 };
 10:
 11:                 ctx.Customers.InsertOnSubmit(newCustomer);
 12:                 ctx.SubmitChanges();
 13:
 14:                 int count = (from c in ctx.Customers
 15:                              select c).Count();
 16:             }
 17:

Now, the count in line 14 will return 11 instead of 10.

It’s a fairly simple concept, but when you’re writing complicated code sometimes that’s the exact type of thing you can overlook. Unfortunately, I haven’t found a way to actually query what LINQ has pending for submission. If anyone has ideas, please let me know!

Share

Categories: C#, LINQ Tags: , , , ,

Smush It

June 1, 2010 1 comment

This is a handy little tool for anyone creating or maintaining websites or blogs (which isn’t just developers these days). Yahoo! has a free web-based tool called Smush.It that will convert any JPG, GIF, or PNG file to a smaller, more compressed version. This means faster downloads and lower bandwidth requirements for your site (and $$$ savings, depending on your hosting service). Plus it’s just plain nice to do for your site visitors – nobody likes waiting around for pictures to load, especially on slower mobile devices. Smush.It can achieve up to a 70% reduction in some cases, without any quality loss. Not bad for free.

Share

Categories: Graphics Tags: , , , , ,

Planning Out Unit Tests

May 30, 2010 1 comment

Test driven development is the practice of writing unit tests before writing any code. It’s very helpful in knowing when to stop writing code (when all the tests pass) so you don’t create unnecessary code bloat. TDD is a common practice in Agile or Extreme Programming methodologies.

I’m a fan of test driven development (TDD) about 99% of the time. The 1% I don’t like it is when writing code that I’m not sure how to write. When you’re prototyping, it’s hard to write unit tests ahead of time, because you’re not sure how the code is supposed to work or even what it’s supposed to do yet. But this post is about the 99% of the time it is worthwhile (perhaps I’ll talk about that other 1% in more detail at a later time).

So for the 99% of the time that it is beneficial to use TDD, how do you know how many unit tests to write and what to test? A web app I’m currently working on is used to process applications for licenses through a large state agency. When it came time to write a unit test for the application approval method, ApproveApplication(), we sat down and came up with all of the variables that could affect the approval process. A few mathematical calculations later and we discovered that there were roughly 3.2 billion combinations of the variables. Clearly, we were not going to write 3.2 billion unit tests for a single method. This is the first rule to remember when writing unit tests – you do not need to test every possible combination of variables.

We went into a conference room and wrote out all of the most likely use cases and came up with 523 tests. If this number results in an amount that fits your scope and schedule, then you can stop reading here and go write those tests! But for us, 523 tests for a single approval method was not acceptable, because our business domain consists of 11 different applications, so we were really talking about 5,753 unit test. We decided to see if any of these tests could be combined to reduce the total number even further. At this point, I bet one of my coworkers, Christine Lambden,  that we couldn’t get the number down to 80 tests or less. She disagreed. But more on this later…

When trying to combine unit tests, avoid combining two tests into one if you just end up with a single test that is twice as long. This won’t gain you anything, except a meaningless reduction in the number of tests. The second rule is do not combine tests unless it gains you something meaningful.

First we looked at combining tests that were testing the same business cases, or where business cases overlapped. This got us down to roughly 140 tests, give or take a few. It also makes use of the third rule: combine tests with overlapping or duplicated use cases.

The next step was to combine tests that exercised the same section of code. Since the same piece of code doesn’t need to be tested more than once, combine tests that exercises that same piece of code.

The final step was to improve the performance of the unit tests. In our particular case, the setup for each test is very time-consuming, so by combining tests where we could would save us a considerable amount of time every time we ran unit tests. So if it makes a significant impact, combine tests if it will help performance.

In summary, my rules of planning out unit tests in order of importance are:

  1. Do not test every combination of variables.
  2. Combine tests when you can, but not unless it gains you something meaningful.
  3. Combine or eliminate tests with overlapping or duplicates business use cases.
  4. Combine or eliminate tests that exercise the same piece of code.
  5. Combine tests if it will significantly improve the performance of unit test execution.

Oh, and about that bet…our final tally was 43 tests, so I definitely owe my coworker lunch. That should be Rule #6: Never bet against coworkers with more real-world experience than yourself. That’s okay, though, because whenever I speak with her, I usually end up learning something new, so I don’t think I really lost at all. 🙂

Share