Ramblings of the Sleepy...

Filtering an Enum by Attribute

David — Thu, 09 Jul 2009 16:59:08 +0000

I had a curve ball thrown at me this morning—changing requirements. It happens and was easily solved by a couple of custom attributes and a helper method.

UPDATE: I’ve updated the code (and explaination) for FilterEnumWithAttributeOf below to tidy it up a bit.

In our current project, there is an enum of standard, static “periods” (times of days students are in school). Easy enough.

BeforeSchool = 0,
FirstPeriod = 1,
SecondPeriod = 2,
etc.

But what happens if we want to “query” our list down a bit… say a certain group only wanted a subset of the “periods”.

I could create an entirely different Enum — Group1Period and Group2Period.

But then handling things in FluentNHibernate’s automapping would get freaked out with the Period property.

So, what about a custom attribute?

I can assign multiple custom attributes to the same Enum field so I can be in Group1 and Group2 at the same time.
I can keep the same Enum “Period” for my ORM layer.
Now how do I query it down…?

Here’s an abstracted example of how the enum looks right now:

public enum Period
{
    [Elementary][Secondary]
    [Description("Before School")]
    BeforeSchool = 0,
 
    [Elementary]
    Homeroom = 12,
 
    [Secondary]
    [Description("1st")]
    First = 1,
}

Elementary and Secondary (our two groups, in this case) are “logicless” attributes (I’m just looking at them as flags, not passing/storing information).

[AttributeUsage(AttributeTargets.Field)]
public class ElementaryAttribute : Attribute
{
}
 
[AttributeUsage(AttributeTargets.Field)]
public class SecondaryAttribute : Attribute
{
}

Now, to filter out those pesky periods based on the attributes.

Update:

Old Code!

public IEnumerable<TEnum> FilterEnumWithAttributeOf<TEnum, TAttribute>()
{
    foreach (var field in
        typeof (TEnum).GetFields(BindingFlags.GetField |
                                 BindingFlags.Public |
                                 BindingFlags.Static))
    {
        foreach (var attribute in 
            field.GetCustomAttributes(typeof (TAttribute), false))
        {
            yield return (TEnum) field.GetValue(null);
        }
    }
}

New Code!

public static IEnumerable<TEnum> FilterEnumWithAttributeOf<TEnum, TAttribute>()
    where TEnum : struct
    where TAttribute : class
{
    foreach (var field in
        typeof(TEnum).GetFields(BindingFlags.GetField |
                                 BindingFlags.Public |
                                 BindingFlags.Static))
    {
 
        if (field.GetCustomAttributes(typeof(TAttribute), false).Length > 0)
            yield return (TEnum)field.GetValue(null);
    }
} 

Why new code?

Well, after looking over the code, I don’t need to iterate through each attribute, simply see if the field contains it (Length > 0). If it does, then return it. That cuts a loop out of our code and performs the same function. I also added two generic constraints. You can’t constrain by Enum, but struct works well.

I’m passing in two generics in this case—TEnum, which is the type of the of the Enum and TAttribute.. the type of the attribute. Yeah, I realize that my creativity of naming is pretty low. Work with me here, alright?

Past that, the loops are pretty easy.

Loop through each field of the enumeration. Return the field (GetField) and be sure to check Public and Static fields.
Loop through each custom attribute on each field (returned by GetField) and only return the fields that match the type of our attribute. I pass along the false parameter (do not inherit) because I’m not interested in inherited attributes. You could leave this as true. YMMV.
If the field’s attribute’s contains our type, yield out the actual Enum value (a string of the field isn’t as useful).

Now, for using it…

var enums = FilterEnumWithAttributeOf<Period, ElementaryAttribute>();
 
foreach (var period in enums)
{
    Console.WriteLine(“{0}, {1}”.AsFormatFor(period, (int)period));
}

Easy enough. ElementaryAttribute returns:

BeforeSchool, 0
Homeroom, 12
AfterSchool, 10
etc..

Running the same code, but asking for SecondaryAttribute returns:

BeforeSchool, 0
First, 1
Second, 2
etc..

Sweet.

Tags: enum, c#, generics

AutoMappings in NHibernate – A Quick Runthrough

David — Fri, 26 Jun 2009 19:58:00 +0000

For most of my projects, at least since I’ve moved to NHibernate/Fluent NHibernate, I’ve been trapped using the existing data structures of prior iterations. Funky naming conventions (many due to cross-cultural, international column naming), missing data relationships, and general craziness.

Having used Fluent Mappings (creating a class that implements ClassMap) in the past, they were a huge jump up from writing painful data objects, connecting them together, and recreating the wheel with “SELECT {column} from {table}” code. Create a map, use the fluent methods to match column to property, and away you go.

In a recent project, I’ve had the opportunity to build a new system from the ground up. With this, I decided to dive head first into using the AutoMappings functionality of Fluent NHibernate.

This post is somewhat a rambling self-discussion of my explorations with AutoMappings.

What are AutoMappings?

The FluentNHibernate wiki provides a simple definition:

[…] which is a mechanism for automatically mapping all your entities based on a set of conventions.

Rather than hand-mapping each column to a property, we create conventions (rules) to map those.. automatically. Hey look, auto…mappings.

How?

Using the same fluent language, configuring AutoMapping is an exercise in implementing conventions for the logical naming and handling of data.

Fluently
    .Configure()
    .Database(MsSqlConfiguration.MsSql2005
                  .ConnectionString(cs => cs
                                              .Server(“server”)
                                              .Database(“db”)
                                              .Username(“user”)
                                              .Password(“password”)
                  )
                  .UseReflectionOptimizer()
                  .UseOuterJoin()
                  .AdoNetBatchSize(10)
                  .DefaultSchema(“dbo”)
                  .ShowSql()
    )
    .ExposeConfiguration(raw =>
                             {
                                 // Testing/NHibernate Profiler stuffs.
                                 raw.SetProperty(“generate_statistics”, “true”);
                                 RebuildSchema(raw);
                             })
    .Mappings(m =>
              m.AutoMappings.Add(AutoPersistenceModel
                                     .MapEntitiesFromAssemblyOf<Walkthrough>()
                                     .ConventionDiscovery.Setup(c =>
                                                                    {
                                                                        c.Add<EnumMappingConvention>();
                                                                        c.Add<ReferencesConvention>();
                                                                        c.Add<HasManyConvention>();
                                                                        c.Add<ClassMappingConvention>();
                                                                    })
                                     .WithSetup(c => c.IsBaseType = type => type == typeof (Entity)))
                  .ExportTo(@”.\”)
    );

As you can see above, the only difference from a fluent mappings configuration is in the actual Mappings area. Good deal! That helps ensure my existing work using fluent mappings could translate without too much headache.

I’ve specified four conventions. Each of these conventions have interfaces that provide the necessary methods to ensure your rules are appied to the correct objects.

EnumMappingConvention

internal class EnumMappingConvention : IUserTypeConvention
{
    public bool Accept(IProperty target)
    {
        return target.PropertyType.IsEnum;
    }
 
    public void Apply(IProperty target)
    {
        target.CustomTypeIs(target.PropertyType);
    }
 
    public bool Accept(Type type)
    {
        return type.IsEnum;
    }
}

The great thing about these methods is they’re fluent enough to translate to English.

Accept… targets where the property type is an enumeration.

Apply… to the target that the “Custom Type Is” the property type of the target.
NOTE: This translates from a ClassMap into: Map(x => x.MyEnumFlag).CustomTypeIs(typeof(MyEnum));

Accept… a type that is an enumeration.

ReferenceConvention

The Reference convention handles those reference relationships between our classes (and the foreign keys).

internal class ReferencesConvention : IReferenceConvention
{
    public bool Accept(IManyToOnePart target)
    {
        return string.IsNullOrEmpty(target.GetColumnName());
    }
 
    public void Apply(IManyToOnePart target)
    {
        target.ColumnName(target.Property.Name + “Id”);
    }
}

The most important part here is enforcing how your foreign keys are going to be named. I prefer the simple {Object}Id format.

Car.Battery on the object side and [Car].[BatteryId] on the database side.

HasManyConvention

The HasManys are our lists, bags, and collections of objects.

internal class HasManyConvention : IHasManyConvention
{
 
    public bool Accept(IOneToManyPart target)
    {
        return target.KeyColumnNames.List().Count == 0;
    }
 
    public void Apply(IOneToManyPart target)
    {
        target.KeyColumnNames.Add(target.EntityType.Name + “Id”);
        target.Cascade.AllDeleteOrphan();
        target.Inverse();
    }
}

We want to make sure that we haven’t added any other key columns (the Count == 0), and then apply both the naming convention as well as a few properties.

Cascade.AllDeleteOrphan() and Inverse() allows our parent objects (Car) to add new child objects (Car.Battery (Battery), Car.Accessories (IList)) without separating them out.

ClassMappingConvention

Finally, the important Class mapping. This convention ensures that our tables are named property with pluralization.

public class ClassMappingConvention : IClassConvention
{
    public bool Accept(IClassMap target)
    {
        return true; // everything
    }
 
    public void Apply(IClassMap target)
    {
        target.WithTable(PluralOf(target.EntityType.Name));
    }
}

I’m using a pluralization method from one of my base libraries that I borrowed from Hudson Akridge. This helper method works really well and I don’t need to add additional references and libraries into my application just to handle the table names.

public static string PluralOf(string text)
  {
      var pluralString = text;
      var lastCharacter = pluralString.Substring(pluralString.Length – 1).ToLower();
 
      // y’s become ies (such as Category to Categories)
      if (string.Equals(lastCharacter, “y”, StringComparison.InvariantCultureIgnoreCase))
      {
          pluralString = pluralString.Remove(pluralString.Length – 1);
          pluralString += “ie”;
      }
 
      // ch’s become ches (such as Pirch to Pirches)
      if (string.Equals(pluralString.Substring(pluralString.Length – 2), “ch”,
                        StringComparison.InvariantCultureIgnoreCase))
      {
          pluralString += “e”;
      }
      switch (lastCharacter)
      {
          case “s”:
              return pluralString + “es”;
          default:
              return pluralString + “s”;
      }
  }

Save and build. The ExportSchema method will generate the SQL and/or regen the database based on the specifications you’ve provided to it. and you’re ready to hit the ground running!

Tags: fluent+nhibernate, automapping, nhibernate, sql+server+2005, .net+3.5, c#

Rendering the Web Equally on Mobile Devices

David — Fri, 26 Jun 2009 15:57:00 +0000

I’ve been digging through the Interwebs for a while now and, I thought, had worked out all of the “kinks” of rendering on a mobile device—specifically iPhones.

The special ‘viewport’ meta tag means the world to iDevices.

meta name=“viewport” content=“width = device-width” />

I’m faced with a new challenge—the Palm Pre’s built-in web browser. My shiny new phone is great, but it isn’t without glitches.

The first glitch I’ve found appears to be a DNS issue— http://myserver/web won’t resolve; however, http://123.45.67.89/web will. It seems to be touchy. Most of our webs work just fine, others don’t. I haven’t narrowed it down to a single server or architecture as it seems to be a bit of everything. Wonky.

The next glitch is more important—the rendering. One of our tools is a simple form-based tool that looks great on the iPhone; however, renders partial screen and “garbles” when you move around the screen.

Palm Pre:

iTouch/iPhone:

I’ve also found that anything in an ASP.NET Update Panel (like those Select buttons) are unusable. Other webs I’ve used (Bank of America, etc) use AJAX just fine, so I don’t think it’s that—probably a coding issue I need to dig into and resolve.

UPDATE: Explicitly adding “LoadScriptsBeforeUI=’true’” to the ASP.NET ScriptManager seems to help with this.. a little.

Anyone else worked specifically with the Pre devices and rendering? I’d appreciate any meta tags or layout ideas that worked. The Pre isn’t a common device in our organization—yet.

Tags: Palm+Pre, iPhone, asp.net, ajax, mobile+web

Benchmarks : Comparing LINQ to NHibernate Transforms/Grouping

David — Fri, 12 Jun 2009 14:07:37 +0000

Yesterday, I wrote about setting up NHibernate to query up, group, count, and transform results and return them into a control. Why did I go to such effort? Well, the original LINQ query I had that refined the results didn’t perform up to par. As some may note, premature optimization is never a good practice so I needed some stats to back up the claims.

Overnight, I wrote up a quick test to query up both ways and benchmark the results. Here’s what I found.

The “test”:

public void TEMP_quick_compare_of_linq_to_nhibernate()
{
    var schoolId = 120;
 
    var benchmark = new Benchmark();
    using (var repository = new IncidentRepository())
    {
        benchmark.Start();
        var resultsFromLinq = 
            repository.GetCountByIncidentCodeWithLinq(schoolId);
        foreach (var item in resultsFromLinq) 
        {
            Console.WriteLine(item);
        }
        benchmark.Stop();
        Console.WriteLine(“Linq: {0}”.AsFormatFor(benchmark.ElapsedTime));
 
        benchmark.Start();
        var resultsFromNhibernate = 
            repository.GetCountByIncidentCode(schoolId);
        foreach (var item in resultsFromNhibernate)
        {
            Console.WriteLine(item);
        }
        benchmark.Stop();
        Console.WriteLine(“NHibernate: {0}”.AsFormatFor(benchmark.ElapsedTime));
    }
}

Setting up the benchmark (and the NHibernate Init) are outside of the benchmark—they’re necessary overhead. I’m also iterating through each of the results as part of the benchmark to ensure that everything is evaluated. Past that, pretty basic. On the database side, I’ve disabled statement caching to not sway the results as much.

With 24 records (the test data in the system), the results were pretty clear. The average of running the benchmark 100 times resulted in…

Linq: 00:00:00.7050000
NHibernate: 00:00:00.0190000

With 24 records, NHibernate was about 37x faster.

That’s nice, but what happens in a few weeks when there are a few thousand records? I populated a few hundred of each incident type into the system, giving me almost 4000 records (the anticipated monthly load of the system by the customer). How’d that change our averages?

Linq: 00:00:00.8869746
NHibernate: 00:00:00.1381518

Now we’re only 6x faster with NHibernate vs. LINQ. The duration from 24 to 4000 records for LINQ jumped ~.18 seconds for a 25% gain where as NHibernate jumped ~.11 seconds for a 626% gain.

So, with that, my original gut feeling and assumptions were wrong. More and more records don’t really slow down the LINQ filtering.. at least not by much. The performance gain is still appparent between the two methods (.88 sec vs. .13 sec); however, how much of that time is eaten up by rendering, server latency, etc and not by the actual processing?

Tags: nhibernate, linq, performance, c#, asp.net, optimization

Grouping and Transforming Using NHibernate

David — Thu, 11 Jun 2009 20:37:15 +0000

Okay, I’ve got to be doing this wrong.

Call it premature optimization, but I forsee an old LINQ method being a performance bottleneck when we hit a few hundred thousands records—especially for the ASP.NET charting control to render in any useful time period.

So, what do I do? I figure pushing that computation back down to the database would be a good first step.

Unfortunately, grouping, sorting, and such are a serious pain in the ass. Unless, as I said, I’m doing it wrong.

Original Code – Grouping and Counting ala LINQ

private IList GetIncidentsGroupedByIncidentCode()
{
    using (var repository = new IncidentRepository())
    {
        var allIncidents = 
            repository.GetAllBySchoolId(SessionManager.CurrentSchoolId);
 
        var incidentsByCode = from i in allIncidents
                              group i by i.IncidentCodeId
                              into grouping
                                  orderby grouping.Count()
                                  select new
                                             {
                                                 IncidentCodeId = grouping.Key,
                                                 Count = grouping.Count(),
                                                 Description = 
                                                    GetIncidentCodeDescription(grouping.Key)
                                             };
        return incidentsByCode.ToList();
    }
}

Grab all incidents (using NHibernate repository) and use LINQ to transform them into a new handy anonymous type that consisted of the IncidentCodeId, a Count (by IncidentCodeId), and the Description which uses the IncidentCodeId to grab the description (the incident code description is coming from an entirely different system/database, hence the method to go fetch it).

I can simply return an IList rather than specifying the type (since it’s anonymous) and get away with loading up my Chart Control—not a problem.

Newish Code – Grouping and Counting ala NHibernate

public IList GetCountByIncidentCode(int schoolId)
{
    using (var tx = Session.BeginTransaction())
    {
        var criteria = Session.CreateCriteria(typeof (Incident));
 
        // Only get those matching the requested SchoolId
        criteria.Add(RestrictionsHelper<Incident>.Eq(x => x.SchoolId, schoolId));
 
        // Setup our projections.
        // IncidentCodeId is what we’re using as an Identifier.
        // Id is what we’re counting, so the results of the “GroupedResult” go into Result
        // and we’re grouping by IncidentCodeId
        criteria.SetProjection(Projections.ProjectionList()
                                   .Add(Projections.Property(“IncidentCodeId”), “Identifier”)
                                   .Add(Projections.Count(“Id”), “Result”)
                                   .Add(Projections.GroupProperty(“IncidentCodeId”)));
        // Order THAT mess by Result
        criteria.AddOrder(Order.Asc(“Result”));
 
        // Now, since we can’t use anonymous objects (??), we have to use a funky Java
        // method to transform it into a typed result.
        criteria.SetResultTransformer(Transformers.AliasToBean(typeof (GroupedResult)));
 
        // Convert this all to a list.
        var result = criteria.List<GroupedResult>() as List<GroupedResult>;
 
        // Commit… or get committed.
        tx.Commit();
        if (result != null)
        {
            // We can’t do this inline (??), so go back into the list and iterate through… grabbing
            // descriptions.
            result.ForEach(x =>
                                {
                                    var description =
                                        GetIncidentCodeDescription(x.Identifier.ConvertTo<int>());
                                    x.Description = description;
                                });
        }
 
        // Holy crap, we’re done!
        return result;
    }
}

What… the… heck?

Amazingly enough, that works (changing the chart’s column names, of course). And it’s relatively quick… But woah, what a mess.

It also adds annoying little ‘result’ objects into the mix.

public class GroupedResult
{
    public int Identifier { get; set; }
    public string Description { get; set; }
    public int Result { get; set; }
}

Strongly typed is stellar and I’m pretty sure I could have some generic objects. [Identifier/Description/Result] could work for counts, averages, most anything that is grouped up, but that just twitches me out a bit to have random classes sitting around for data transformations.

So, good readers—how is this REALLY supposed to work? All that to generate the guts of:

SELECT COUNT(IncidentCodeId) as Result, IncidentCodeId
FROM Incidents
WHERE SchoolId = :schoolId
GROUP BY IncidentCodeId
ORDER BY Result

Tags: fluent+nhibernate, nhibernate, sql

Performing SELECT.. WHERE IN using a Repository

David — Mon, 08 Jun 2009 16:54:49 +0000

As I’ve discussed in the past, a few of my repository pattern practices are borrowed and built on the nice S#arp Architecture project. Here’s another situation where I needed a bit more functionality.

Disclaimer: If there’s a better way to do this—I’m all ears and emails.

By default, the FindAll method builds up the NHibernate criteria by iterating through a key/value pair. Easy enough.

‘Id, 12345’ generates ‘WHERE Id = 12345’.

But what happens when I want to do something with an array?

‘Id, int[] {12345, 67890}’ should generate ‘WHERE Id IN (12345, 67890)’

Thankfully, the Restrictions class has an In method, but how can I add that flexibility to the FindAll method?

Here’s what the FindAll method looks like to start off:

public T Find(IDictionary<string, object> propertyValuePairs)
{
    Check.Require(propertyValuePairs != null,
                  “propertyValuePairs was null or empty”);
    Check.Require(propertyValuePairs.Count > 0,
                  “propertyValuePairs must contain at least one pair”);
 
    var criteria = Session.CreateCriteria(typeof (T));
    propertyValuePairs
        .ForEach(x =>
                 criteria.Add(Restrictions.Eq(x.Key, x.Value)));
 
    return criteria.List() as List;
}

That’s nice. Iterate through each, but assuming an Eq (Equals) relationship between the key and the value.

After a bit of dinking, checking to see if the object is a typeof(ICollection) seems to be the most reliable considering Restrictions.In(key,value) accepts Collections for the value parameter.

This allows you to pass arrays, lists, and dictionaries.

public List FindAll(IDictionary<string, object> propertyValuePairs)
{
    Check.Require(propertyValuePairs != null,
                  “propertyValuePairs was null or empty”);
 
    Check.Require(propertyValuePairs.Count > 0,
                  “propertyValuePairs must contain at least one pair”);
 
    ICriteria criteria = Session.CreateCriteria(typeof (T));
 
    propertyValuePairs
        .ForEach(x =>
                     {
                         if (x.Value.IsA<ICollection>())
                         {
                             // add WHERE key IN (value)
                             criteria.Add(Restrictions.In(x.Key, (ICollection) x.Value));
                         }
                         else
                         {
                             // add WHERE key = value
                             criteria.Add(Restrictions.Eq(x.Key, x.Value));
                         }
                     });
    return criteria.List() as List;
}

Here’s my (now) passing test that I used to test this logic as I built it:

[Fact]
public void can_find_students_by_array_of_student_ids()
{
    var studentsToFind = new int[] { 622100, 567944, 601466 };
 
    var criteria = new Dictionary<string, object>();
    criteria.Add(“Id”, studentsToFind);
    criteria.Add(“Grade”, “09″);
 
    var sut = new StudentRepository();
    var students = sut.FindAll(criteria);
 
    students.Count.ShouldBeEqualTo(1);
    students.ShouldContainMatching(x => x.Id == 567944);
    students.ForEach(x => 
        Console.WriteLine(“{0}, {1}”.AsFormatFor(x.FullName, x.Id)));
}

Test Passed. Woot. The generated SQL is also nice and clean (really loving NHProf… though I trimmed out the excess columns for brevity).

SELECT this_.Id as Id7_0_, [..]

this_.Grade as Grade7_0_, [..]

FROM custom.student_lkup this_

WHERE this_.Id in (622100 /* :p0 */,567944 /* :p1 */,601466 /* :p2 */)

and this_.Grade = 09 /* :p3 */

Tags: sharp+architecture, nhibernate, sql, patterns, c#, fluent+nhibernate

Comparing Google and Bing

David — Mon, 01 Jun 2009 21:17:16 +0000

Bing, the latest iteration of Windows Live Search, is now available for use and has been getting quite a few rave reviews. Miguel Carrasco wrote a lengthy post discussing the benefits of Bing over Google; however, maybe I’m old fashioned, but I see a lot of the hype as overhead.

Not to nitpick, but searching DIRECTLY for product names will return advertisements and sponsored sales information—no matter the search engine. Miguel’s post (searching for a Nikon D60 camera). Using my new fanboy item, the Palm Pre, as an example, I can see that the Google page actually has FEWER (real estate) “advertisements” than the Bing search.

Bing has a whopping 6 sponsored links… along with something called Bing cashback that I haven’t really read up on yet. That along witht he lost space on the left seems like a lot of waste.

Google drops off a bit of space for the 3 sponsored links, but keeps it thin and uses it’s integration with YouTube to show previews and group the video results to the top.

BUT… how much does that matter? If Google’s page takes a moment more to load, do the background graphics, fancy headers, and AJAX postbacks on the Bing page make up that difference?

“Previews” in Google and Bing

An exciting point with Bing is the content previews. Hover over a search result and it provides a bit more information. This, however, has been in Google’s search for quite a while if you turn on the functionality.

I’ll admit, I like the hover effect. Clean, renders relatively quickly (noticed a bit of delay on some pages, but not too bad), and seems to parse content well. But is it ground breaking? Nah, not really.

Google’s had it for a while, though I’ll admit, I rarely use it (I used it more while doing heavy research in school).

The difference is that Google’s requires you to turn it on… For those who don’t use it, the dynamic filtering is FANTASTIC (and provides that handy “left side bar” that Bing is raving about). Remember—Google was originally focused on extremely streamlined results—”more text” and AJAX postbacks would be considered evil.

If you really do need more images, using Google’s “Images on the page” provides a cool look at what graphics are on the page.

Are product searches always what we do? Nah!

How often do we actually search for a product name—especially in the workplace? When I’m looking for my Pre, sure, but 90% of the day is spent searching for error messages, code snippets, and forum messages. Face it, I JFGI it all day long. I encourage coworkers to JFGI. Etc.

So how does Bing and Google stack up when searching for a less commercial, more technical request? I’ve recently dug into db40 and needed to dig up some ideas for id generation. I remember reading a blog post recently about it, but couldn’t remember who wrote it.

Bing returned an interesting result set… but didn’t turn up (in the first 10) what I was looking for…

Nearly all of the results were root domains or directories—nothing real specific (blog posts, forum posts, etc) from the titles. Since the cool Bing “sorting and grouping” doesn’t appear to apply to everything quiet yet (not sure if that’s context-based or a newness/lack of indexing), I was left with “all results”.

On the other hand, Google appears to put more priority on the title of the page. Notice on the Bing search results, “Id Generation” didn’t appear in ANY of the page titles whereas they’re in all of the titles of the Google results.

The title doesn’t mean these are the BEST results; however, with news stories, blog posts, etc—the takeaway point will usually be in the title.

The blog post I was wanting showed up second in the Google results. The Bing results referenced Tuna’s blog a few places; however, didn’t actually reference the post for “Id Generation in db4o”. The one time it WAS mentioned (the 4th result of Bing), it was a stale link to the front page of Tuna’s blog—not the actual post.

Conclusion

The selling point to Google for many years now has been two fold:

1) Extremely clean, fast user interface
2) Reliable and relevant results

I moved away from AltaVista, Yahoo, and other engines years ago because they wanted to be ‘cute’ and while Bing has potential, it’s already too cute for my tastes without any real benefit.

It’ll be interesting to see how Bing grows—and how it affects Google. It’s too early, however, to say that Bing is this saving grace—especially if you’ve never dug into all of the features of Google.

Tags: Bing, Google, search+engine, comparison

Configuring Oracle SQL Developer for Windows 7

David — Fri, 29 May 2009 15:55:42 +0000

I’m fully Vista-free now and loving it; however, Oracle SQL Developer has (once again) decided to simply be annoying to configure.

Yes, I realize Oracle hates Microsoft. Girls, you’re both pretty—please grow up.

Anyway, after a bit of hunting, I think I’ve found a good mix for those of us who love SQL Developer for coding and testing, but don’t “use” a lot of the Oracle proprietary ~~junk~~ features that comes with it.

Originally, I was going to include a couple of the configuration files; however, they’re spread out EVERYWHERE and, frankly, I can’t find them all. I also can’t figure out a way to import settings (without blowing my settings away first).

File Paths

As I mentioned before, some of the configuration files are spread out—everywhere. Here’s where the most common files are located.

sqldeveloper.conf – \sqldeveloper\bin\

ide.conf – \ide\bin\

User-Configured Settings – %appdata%\SQL Developer\

I prefer to make my modifications in sqldeveloper.conf; however, a lot of the resources that pop up on Google make them in ide.conf. Why? I’m not sure. sqldeveloper.conf simply CALLS ide.conf. Meh.

Fixing Memory Consumption on Minimize

I found a reference to JDeveloper (another Java utility) that discussed how JDeveloper (and similarly, SQL Developer) pages everything when you minimize the window.

To fix this, open up sqldeveloper.conf and add the following line:

AddVMOption -Dsun.awt.keepWorkingSetOnMinimize=true

Fixing Aero Basic Theme

Tired of your IDE swapping back to Aero Basic whenever you launch SQL Developer? Me too. For now, Oracle reports that SQL Developer doesn’t support the full Aero Theme… or does it?

To enable Aero support (or at least keep it from bouncing back to Aero Basic), open up sqldeveloper.conf and add the following line:

AddVMOption -Dsun.java2d.noddraw=true

The Oracle forums also recommend trying the following line:

AddVMOption -Dsun.java2d.ddoffscreen=false

That option; however, never resolved the issue for me. Your mileage may vary.

Cleaning Up The UI

The default UI leaves a lot to be desired for Oracle SQL Developer. Here’s a few UI tips to try out. These settings are found under Tools > Preferences.

Change the Theme – Environment > Theme.

I like Experience Blue. It’s clean, simple, and goes well with Windows 7’s look and feel.

Change Fonts – Code Editor > …

There are quite a few fonts that can be configured. Here’s what I changed:

Code Insight – Segoe UI, 12
Display – check ‘Enable Text Anti-Aliasing’
Fonts – Consolas, 11
Printing – Consolas, 10

Disable Unnecessary Extensions – Extensions > …

Honestly, I don’t use ANY of the extentions, so I disabled everything as well as unchecking ‘Automatically Check for Updates’. I’ve noticed that load time for the UI is insanely fast now (well, insanely fast for a Java app on Windows).

Window Locations

The only thing that I can’t figure out how to fix is the window location and placement. Example: When you open a new worksheet, the results area is not visible (you have to drag that frame up each time). That annoys me to no end and I can’t find a place to ‘save current window layout’ or similar. Ideas?

That’s it!

With that, SQL Developer loads up quickly, connects, and displays just fine in Windows 7.

Tags: Oracle, Raptor, Oracle+SQL+Developer, Windows+7

Visual Studio 2010 & .NET Framework 4.0 Beta 1 Out

David — Mon, 18 May 2009 18:05:27 +0000

For MSDN Subscribers, VS2010 and .NET 4.0 beta 1 have hit the downloads site.

After reading through Microsoft’s “Overview” page—my biggest hope is that it doesn’t do “too much”. Visual Studio is already a monolith of hard drive cranking pain as it is. My Cray is still being held up by our purchasing department—I hope I don’t need it. Maybe they took Win7’s approach that less is more and trimmed things down?

Overview: http://www.microsoft.com/visualstudio/en-us/products/2010/default.mspx

Beta Docs: http://msdn.microsoft.com/en-us/library/dd831853(VS.100).aspx

The biggest point of interest (so far, I mean—it’s still downloading) is the warning for Win7 RC:

NOTE: If you are installing Visual Studio 2010 Beta 1 on Windows 7 RC, you may receive a compatibility warning when installing SQL Server 2008. For more information and a workaround, please click here.

The link, however, sends you to an explaination of the error—which is simply that Win7 RC requires SQL Server 2008 SP1 or 2005 SP3. If I remember right, I thought the error message SAID that. I guess Microsoft is just covering all of the bases.

Finally, it looks like the “official” tag on Twitter is #vs10; however, quite a few of us have been using #vs2010. Follow both for the full scope.

I’ve got about 20 minutes left on the download and a VM waiting for this to be loaded. More to come!

Tags: visual+studio+2010, .net+4.0, vs10

Fixing Streaming In Windows 7 (.asx Files)

David — Mon, 18 May 2009 13:18:15 +0000

After tolerating the issue for all of the last beta and since installing RC, I decided to dedicate sometime into it this afternoon to research the cause and look for a fix.

The problem:

When attempting to play any .asx streaming playlist file, Windows would report that it could not locate the stream.

“Windows Media Player cannot play the file. The Player might not support the file type or might not support the codec that was used to compress the file.”

The initial response (usually) to this is that the codec is missing or corrupted. I think I tried almost every possible of codecs around–no dice.

The fix:

A bit of registry “checking” is in order. There are four keys I updated:

[HKEY_CLASSES_ROOT\.avi]
@=”WMP11.AssocFile.AVI”

[HKEY_CLASSES_ROOT\.asf]
@=”WMP11.AssocFile.ASF”

[HKEY_CLASSES_ROOT\.asx]
@=”WMP11.AssocFile.ASX”

[HKEY_CLASSES_ROOT\.wmv]
@=”WMP11.AssocFile.WMV”

Note: The @= equates to the (Default) value.

Browse the web to a streaming source (I used Solo Piano Radio–calm, relaxing music while reading and such) and launch the streaming link. It should work like a champ–like it has for years.

So far I’ve implemented this on three different computers with Windows 7–-so far, so good.

Resources:

According to the official Microsoft Windows 7 (Media) forums, it seems one of the Windows Live installers is to blame; however, if you catch the verbiage, they seem to relate it to another vendor. I wonder if “vendor” without much more of a second thought.

The fact that this issue survived to RC shocks me; however, all things considered—Win7 is still running like a champ.

Tags: Windows+7, asx, streaming, wmp12