I just purchased a new desktop for home and decided to go Windows 7 RC (64bit) for fun.  Wow.  I think our friends in Redmond may have gotten it right this time.  I like Seven so far and hope I keep liking it.  I’ve been developing an increasing dislike for Microsoft products over the last few years.  This is my first positive experience since XP replaced 98. 

Stay Tuned.

Warning – this post is a rant (sorry).

I’ve had it with Trend Micro.  For several years I have been a fan of this often overlooked player in the anti-virus and  security space. 

Like a lot of techies, I often get to play the role of family or neighborhood tech support guy.  Usually, these episodes begin with a friend saying something like this:  “man my (our) computer is really slow.  It’s got a bad virus and I can’t get rid of it.”

My typical response is to tell them to bring the offending PC over for the weekend.  I usually purchase a new hard drive and install the old drive as a secondary – re-install Windows – then my favorite and recommended anti-virus software (formerly Trend Micro) and then proceed to copy files, desktop settings and other user profile preferences to the new OS.   In the past, every machine that I’ve performed surgery on has gone back to the owner with a copy of Trend Micro PCcillian or more lately, Trend Micro Internet Security with instructions to activate the software and maintain the subscription.   Again – in the past – accompanied by my recommendation of Trend Micro as the best value in anti-virus and internet security.

Never Again!  

After 5 years of being a fan of  Trend and their products - I’m done. 

The latest incarnation of Trend’s software – well – it just sucks.   It takes too long to load and update and Trend has become too hard to do business with.

My machines (6 at home) can take as much as 20 minutes to load the latest Trend software after log in.  And the machine is unusable during this time.   Who knows what it’s doing?  For the most part there is no drive activity, but I am entertained by the groovy animated icon in my system tray with the little grey Trend logo spinning and spinning.   Doing nothing that I can determine.  Just spinning.   20 minutes to load.  Really? 

That’s not all.   Since I have so many PCs at home, each year (in the past) I have purchased a multi-user license from Trend.  The price has been economical and the products (until this one) good.   But this year, when my subscription expired and it came time to re-up.  Guess what!   The link on the pop-up box from Trend’s product took me to a page where I was NOT ABLE to purchase the product or renew my subscription.    I got only cryptic errors about my software key being invalid.

Took me about two weeks and multiple calls to Trend to figure out that they had changed their business model and that Trend would not longer condescend to sell a multi-user license to me directly. It must have been too much trouble for them to update their software to not offer me the link!   It turns out Trend decided to stop selling multi-user licenses (not single user licenses, just the multi-user ones), directly.  I had to purchase from a re-seller.   Okay…

In hindsight, I should have stopped right there.  But purchasing from reseller was not such a big deal for me because – at the time – I was till convinced that this was the security package for me and couple of dozen people I’ve recommended it to since 2005. 

Never Again!

After making my purchase I waited, then waited, and then waited some more.  In fairness, the reseller told me when I made my purchase that “it sometimes takes Trend a while to ship orders.”   How long could it take I thought.  All I need is some download instructions and a key.  Just wait for the email.   Right!

Never Again!

After two weeks of waiting (without current virus protection on my PC), I called the reseller back and insisted that I get my product or a refund.  After a few calls, an apology, and a reminder about the aformentioned warning about Trend’s responsiveness to paying customers – the reseller was able to get Trend to respond and I finally got my download info and keys.

The the fun really began.

Installing Trend Micro Internet Security 2008 required a manual uninstall of the previous Trend product (you remember the one that was offering me an upgrade link in a pop-up window), followed by an install of the new product – which – incredibily enough – requried tech support.   Ever heard of InstallShield there at Trend?  

But I’m still optomistic, I guess because of the 4-5 years of history I have with this product.   Read On.

After installation my, PC pretty much stopped being a useful tool.  Trend Micro Internet Security slows down a re-boot so much that I’m afraid to reboot my laptop and have to use Standby as my default mode of transportation.   A re-boot requires at least 30 minutes of waiting (after log in) for the crappy Trend software to finish loading.  The PC is unusable during this mystery process.   But that’s not all.

Once the software has finally gotten it’s act together, I get 4-5 prompts to download updates each day.  Usually in the middle of something important or with a critical deadline.  I guess I can’t blame Trend for that.   Keeping updates current when it comes to virus software is key.   I have to say however that for the last several years, 1 update per day seemed to keep my PCs safe enough.

The really frustrating part is that everytime I get an update prompt, my hope is that this update will be the one that cures the 30 minute delay in using my PC after login.   No such luck.  It’s good to have a dream I guess.

My conclusion from all of this is that Trend has completely lost sight of what their product is for and what their former customers wanted.  A good, reasonably priced security suite that does not render their PC a paper weight.

My recommendation to anyone considering purchasing Trend Micro Internet Security 2008. 

RUN AWAY!!!  

Trend Micro Internet Security 2008 is apparently a poorly architected product from an company that has lost sight of the purpose of it’s products.

Never Again

PS.   I bet they went offshore.

Glenn Carney
Former Trend Micro customer and endorser.

This is a revised version of my original post (C# Application Settings Utility Class). Thanks to a comment received I have revised this code to make the class inheritable. Please see below:

Revised code for appSettings class (note the addition of the abstract keyword in class declaration):

    public abstract class appSettings
    {
        public delegate void AppSettingsEventHander(object o, AppSettingsEventArgs e);

        // Declare Class Events
        public event AppSettingsEventHander SettingsEvent;

        private string _myPath;
        public string myPath
        {
            get { return _myPath; }
            set { _myPath = value; }
        }

        private StringCollection _myLocations;

        public StringCollection MyLocations
        {
            get { return _myLocations; }
            set { _myLocations = value; }
        }

        // Additional Application specific setting properties can be added here as needed...

        public appSettings()
        {
            InitAppSettings();
        }

        public appSettings(string sPath)
        {
            InitAppSettings();
            this.Load(sPath);
        }

        private void InitAppSettings()
        {
            this._myLocations = new StringCollection();
        }

        public bool SaveAppSettings(string thePath)
        // Returns True if Saved successfully, False otherwise.
        // Raises Event that includes exception and reason if case of error
        {
            try
            {
                XmlSerializer xs = new XmlSerializer(this.GetType());
                FileStream fs = new FileStream(thePath, FileMode.Create);
                xs.Serialize(fs, this);
                fs.Close();
            }
            catch (FileNotFoundException fex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.FileNotFound, fex);
                SettingsEvent(this, e);
                return false;
            }
            catch (Exception ex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, ex);
                SettingsEvent(this, e);
                return false;
            }
            return true;
        }

        public appSettings GetAppSettings(string thePath)
        {
            // Returns new appSettings object if successfull, null appSettings otherwise
            // Raises Event that includes exception and reason if case of error

            try
            {
                appSettings appSet;
                XmlSerializer xs = new XmlSerializer(this.GetType());
                FileStream fs = new FileStream(thePath, FileMode.Open);
                appSet = (appSettings)xs.Deserialize(fs);
                fs.Close();
                return appSet;
            }

            catch (FileNotFoundException fex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, fex);
                SettingsEvent(this, e);
                return (appSettings)null;
                ;
            }
            catch (Exception ex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, ex);
                SettingsEvent(this, e);
                return (appSettings)null;
            }
        }

        public bool Load(string thePath)
        {
            // This function loads the settings file directly to "this" instance of appSettings
            // instead of returning the appSettings Object
            // Returns true on success, false otherwise
            // Raises Event that includes exception and reason if case of error

            try
            {
                appSettings appSet;
                XmlSerializer xs = new XmlSerializer(this.GetType());
                FileStream fs = new FileStream(thePath, FileMode.Open);
                appSet = (appSettings)xs.Deserialize(fs);
                foreach (System.Reflection.PropertyInfo pi in this.GetType().GetProperties())
                {
                    if (pi.CanWrite)
                    {
                        try
                        {
                            pi.SetValue(this, pi.GetValue(appSet,null),null);
                        }
                        catch (Exception ex)
                        {
                            pi.SetValue(this, null, null);
                        }
                    }
                }
                fs.Close();
            }

            catch (FileNotFoundException fex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, fex);
                SettingsEvent(this, e);
                return false;
                ;
            }
            catch (Exception ex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, ex);
                SettingsEvent(this, e);
                return false;
            }
            return true;
          }

    }  //  </class appSettings>

    public class AppSettingsEventArgs : EventArgs
    {
        // Constructor
        public AppSettingsEventArgs(settingsEventReason reason, object objInfo)
        {
            this._settingsEvent = reason;
            this._objInfo = objInfo;
        }

        private object _objInfo;
        private settingsEventReason _settingsEvent;

        // Public Property(s) to return value(s)
        public object objInfo
        {
            get { return _objInfo; }
        }

        public settingsEventReason eventReason
        {
            get { return (settingsEventReason)_settingsEvent; }
        }
    }   // </ ChangeEventArgs> 

    public enum settingsEventReason
    {

        FileNotFound = 1,
        // Add additional event reasons to enum here
        OtherException = 99
    }

Here is how you would reference the revised class in your application code:

    public class appSettingsInheritedClass : appSettings
    {

    }

Using this approach, you can then simply add new application settings properties to this declaration as shown below:

    public class appSettingsInheritedClass : appSettings
    {
        public int iSetting1;
        public string sSetting2;
    }

Any properties you add in this way are automatically saved and loaded when you call SaveSettings or Load respectively.

Thanks.

G

Please note that a revised version of this code is now located here .

I wanted to create a self-contained (I’ll explain what I mean by this later) and re-usable template class that I could add to any C# application for the purpose of saving and loading application settings (user preferences, path names, etc.) in XML.

My goal was to be able to add new properties to the class without having to write additional code to have them load. This way, I would only need to add the necessary private variable and the associated public property (e.g. get & set) for each new applicatoin setting.

Yes, I know that .NET 2.0 and Visual Studio 2005 have a similar function built in, but I prefer to have full control of my application. Also I wanted to customize an event that could notify my application if/when the settings did not save or were not loaded successfully.

I wanted the class to be “self-contained”, that is, I wanted all of the code necessary to load and save the settings built into the class. That way, I could just add the appSettings class to my project and go.

This solution uses XML Serialization to store my application settings in an XML document. On retrieval, in the Load method, it uses Reflection to enumerate the properties of the class and assign their values to the local “this” instance of the class.

For illustration purposes, I also included a GetAppSettings method. This method loads the settings into a new instance of the class. But this method has a disadvantage: Because GetAppSettings returns a new instance of the appSettings class, to use it I would first have to instantiate an instance of the class. For example, to use GetAppSettings my application’s code would look something like this:

appSettings thowAwaySettings = new appSettings();

appSettings theRealSettings = throwAwaySettings.GetSettings("C:\some path");

thowAwaySettings = null;	// dispose of the first class

I was not satisfied with the GetAppSettings approach because of the need for an initial “helper” instance of the class which would be thown away. I also thought that this approach diminished the “self-contained” aspect I was trying to achieve.

A better approach would be have the class be able to “self load”. Eliminating the need for the second instance. I implemented the self load using Reflection in the Load method.

Using the Load method my application code can look like this:

appSettings appSet = new appSettings();

appSet.Load("C:\Some Path");

But wait, yet another enhancement is a custom constructor for the class that accepts a path parameter. When called with a valid path, the class could automatically Load itself. So then my applications code can look like this:

appSettings appSet = new appSettings("C:\Some Path");

Much better I think.

Here’s my code. Feel free to use and re-distribute. Comments welcome.

———————————————————————————————

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml.Serialization;

namespace foo
{

    public class appSettings
    {
        public delegate void AppSettingsEventHander(object o, AppSettingsEventArgs e);

        // Declare Class Events
        public event AppSettingsEventHander SettingsEvent;

        private string _myPath;
        public string myPath
        {
            get { return _myPath; }
            set { _myPath = value; }
        }

        // Additional Application specific setting properties can be added here as needed...

        public appSettings(string sPath)
        {
            this.Load(sPath);
        }

        public bool SaveAppSettings(string thePath)
        // Returns True if Saved successfully, False otherwise.
        // Raises Event that includes exception and reason if case of error
        {
            try
            {
                XmlSerializer xs = new XmlSerializer(this.GetType());
                FileStream fs = new FileStream(thePath, FileMode.Create);
                xs.Serialize(fs, this);
                fs.Close();
            }
            catch (FileNotFoundException fex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.FileNotFound, fex);
                SettingsEvent(this, e);
                return false;
            }
            catch (Exception ex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, ex);
                SettingsEvent(this, e);
                return false;
            }
            return true;
        }

        public appSettings GetAppSettings(string thePath)
        {
            // Returns new appSettings object if successfull, null appSettings otherwise
            // Raises Event that includes exception and reason if case of error

            try
            {
                appSettings appSet;
                XmlSerializer xs = new XmlSerializer(this.GetType());
                FileStream fs = new FileStream(thePath, FileMode.Open);
                appSet = (appSettings)xs.Deserialize(fs);
                return appSet;
                fs.Close();
            }

            catch (FileNotFoundException fex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, fex);
                SettingsEvent(this, e);
                return (appSettings)null;
                ;
            }
            catch (Exception ex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, ex);
                SettingsEvent(this, e);
                return (appSettings)null;
            }
        }

        public bool Load(string thePath)
        {
            // This function loads the settings file directly to "this" instance of appSettings
            // instead of returning the appSettings Object
            // Returns true on success, false otherwise
            // Raises Event that includes exception and reason if case of error

            try
            {
                appSettings appSet;
                XmlSerializer xs = new XmlSerializer(this.GetType());
                FileStream fs = new FileStream(thePath, FileMode.Open);
                appSet = (appSettings)xs.Deserialize(fs);
                foreach (System.Reflection.PropertyInfo pi in this.GetType().GetProperties())
                {
                    if (pi.CanWrite)
                    {
                        try
                        {
                            pi.SetValue(this, pi.GetValue(appSet,null),null);
                        }
                        catch (Exception ex)
                        {
                            pi.SetValue(this, null, null);
                        }
                    }
                }
                fs.Close();
            }

            catch (FileNotFoundException fex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, fex);
                SettingsEvent(this, e);
                return false;
                ;
            }
            catch (Exception ex)
            {
                AppSettingsEventArgs e = new AppSettingsEventArgs(settingsEventReason.OtherException, ex);
                SettingsEvent(this, e);
                return false;
            }
            return true;
          }

    }  //  </class appSettings>

    public class AppSettingsEventArgs : EventArgs
    {
        // Constructor
        public AppSettingsEventArgs(settingsEventReason reason, object objInfo)
        {
            this._settingsEvent = reason;
            this._objInfo = objInfo;
        }

        private object _objInfo;
        private settingsEventReason _settingsEvent;

        // Public Property(s) to return value(s)
        public object objInfo
        {
            get { return _objInfo; }
        }

        public settingsEventReason eventReason
        {
            get { return (settingsEventReason)_settingsEvent; }
        }
    }   // </ ChangeEventArgs> 

    public enum settingsEventReason
    {

        FileNotFound = 1,
        // Add additional event reasons to enum here
        OtherException = 99
    }

} // </namespace>

—————————————————————————————————

Glenn Carney is a software developer, trainer, consultant and leader based in Overland Park, Kansas.

OK, I’ll admit it. Those commercials on TV with the young, cool Mac guy and the not-so-cool, (some would say fat – but not me), PC guy might be to blame. And yes, maybe my mid-life crisis is showing. Or maybe it’s because I’m getting tired of waiting for my Windows XP laptop to boot and load all the necessary security add-on software. Or maybe it’s that I’ve given Microsoft enough of my money over the years. Or maybe it’s that I’m so impressed with my first iPod.

But I’m considering buying a Mac for the first time.

Now this may not sound to you like a subject worthy of a blog, but for me it is. You see, not only have I give the good folks in Redmond a ton of money in my life (and career), but I’ve also made a good living for many years by developing software for Windows. I’ve been a loyal defender of the Windows world – despite all it’s warts – and a career-long “eschewer” of the Mac as a plaything for those too cool or obtuse to give in to the pull of gravity.

But I think I want a Mac.

Not for work – yet. But for home. Unless I’m working remotely and need Windows Remote Desktop to get into the office, at home I mostly read and send email, edit photos and rip, organize and burn music.

First, the design of the iMac is very impressive. The large, high-definition screen is reason enough to want one. Add to that the simplicity of the OS, the a attention to how – and for what – most of us use a computer in our daily lives and the argument for the change begins to get legs.

The iMac, (like the iPod and iPhone), is a fine example of outside-in design. Outside-in design first takes into consideration the needs of the the person using the device or system. The relatively large HD screen, relatively small desktop footprint are the most obvious examples. The outside-in approach extends in to the operating system software, where most of the applications that I will use are thoughtfully and conveniently accessible from the desktop. I’ve learned a few things about interface design over the years. 20 years developing software will do that. And let me tell you, the folks at Apple have got interface design nailed.

Don’t take my word for it. Do the research yourself check out some information on excellence in design and then compare the concepts you find with the iPod or iPhone. Then take a look at an iMac the next time you are at the electronics store.

Here are a few good places to start:

• The work of Edward Tufte at www.edwardtufte.com
• The Design of Everyday Things by Donald Norman

I think I want a Mac