A few days ago Firefox 3.0 Beta 1 was released.  This is a major revision packed with some seriously awesome features.  Here's a rundown of some of the major features for normal users, power users, and developers (this is not an exhaustive list, but it covers a lot of ground-- also note that I've only tested Firefox 3.0 Beta 1 on Windows):

SQLite - SQLite databases are now used to store cookies, download history, a new concept called "Places" and other things.  This information being stored in a series of databases (in *.sqlite files) means that we can use SQLite front-ends to do SQL CRUD queries against the stored information.  Even if we don't use the SQLite databases directly, developers from all over the world will be able to create very powerful extensions to the features using the SQLite databases.  There's already at least one SQLite manager built as a Firefox extension.  Firefox has actually been using SQLite for a while, but it's only really been used for XUL and extension development.  If you are unfamiliar with SQLite, you should seriously check into it-- it's really awesome.  It's also the storage system for Google Gears.

Places - As I just mentioned, the new concept of "Places" is also stored in the database.  This feature tracks web surfing trends similarly to how various media players track music listening trends.  So, after a bit of surfing you'll be able to see what pages you visit most often.  Places also shows what bookmarks you have recently tagged, your most recently used tags, and a few other things.  Even if we don't use this feature in Firefox as is I'm sure more extensions will be built to help make Places more useful.  I can already visualize an extension to mash Places metadata with your Windows Media most-popular metadata to give you a view of all your favorite things in one place.

Tags and Easier Bookmarking - Firefox 3.0 also introduces del.icio.us-like tags to bookmarks.  This isn't that big of a deal to me, because with Firefox 2.0 you could install the del.icio.us bookmark extension to replace your static Firefox bookmarks to allow del.icio.us manage all your bookmarks.  It was so integrated that CTRL-D even sent your bookmark to del.icio.us.  The exciting part of Firefox 3.0 tagging is that the next del.icio.us extension will probably be faster and even easier to use in Firefox 3.0 since Firefox now has built in mechanisms for this.  Using the Firefox 3.0 tags feature by itself is nice too, though.

Coupled with this feature is the ability to simply click on a star to have your page sent to "Places" (it's actually very similar to the star in Gmail).  Another click of the star gives you a nice out-of-the-way box to set tags on the link.  It's actually very similar to what the del.icio.us extension did in Firefox 2.0, thus making me think even more that there will soon be an awesome del.icio.us extension for Firefox 3.0.

ACID2 Test Passed - It's official: Internet Explorer is the only major web browser that doesn't pass the ACID2 test (and it doesn't get near it).  Firefox has always been close (yes, since V1.0 it has the shape of a face) , but it finally crossed the finish line.  Internet Explorer's rendering on the other hand still looks like someone slaughtered a pig.  If you don't know what the ACID2 test is, it's THE test for a web browsers CSS usefulness.  The better the rendering, the better the browser can render.  As you will see in a moment, Internet Explorer is SO far off that it's not even CLOSE to being a 7th generation web browser (...and I do not apologize for bashing IE -- there's always time for that.)

Here are the renderings of Firefox 3.0b1, Opera 9.24, Safari 3.04, and Internet Explorer 7 (and 6) for the ACID 2 test:

Sheesh... notice any similarities? If you think IE7 is a major improvement over IE6, think again. It's just the 6th generation IE6.5 in a 7th generation skin (i.e. has tabs and integrated search).  Adding XMLHttpRequest doesn't make it a 7th generation browser (XMLHttpRequest was NOT in IE before IE7-- before IE7, the IE world had only ActiveX controls and Java proxies for remote scripting.  These are the opposite of standardized components.)  Trying adding window.addEventListener, removing that horrendous ClearType, and getting somewhere near the shadow of the ball park of the ACID2 test and we'll talk.

JavaScript 1.8 - Some people know it and take it for granted, yet others don't realize it and are offended by it: Firefox has the most powerful JavaScript in any web browser at all.  Most of us know that Internet Explorer's CSS is just about nonexistent, but most people don't know that Opera's analogous in the area of JavaScript.  Safari is a close second.  Firefox is the only web browser that continually and consciously has a constant flow of documented JavaScript features.  Internet Explorer is actually pretty good in this area (I know-- it's shocking) and Opera is continually getting better and better, but Firefox is head and shoulders above everyone else (and none of this is to even mention how are advanced Firefox' DOM implementation is -- Firefox even has native base64 conversion functions!). 

Firefox 1.5 had JavaScript 1.6, which included iterative methods (i.e. forEach), like in C# 2.0, and E4X.  Firefox 2.0 had JavaScript 1.7, which provided a functional programming feel to JavaScript similar to LINQ's functional nature.  Firefox 3.0 now has JavaScript 1.8 and takes JavaScript functional programming to the next level by including lambda expressions.  If you love C# 3.0, you will love JavaScript 1.8.  Firefox 3.0 may or may not also have client-side JSON serialization.  If it does, it should seriously fit nicely with the WCF 3.5 JSON feature.  By now, any one who still sees Firefox as anti-Microsoft technology needs to repent.

There are also new DOM features, like two new drag events and support for Internet Explorer's clientTop and clientLeft attributes.  Firefox 3.0 also has a scriptable idle service allowing you to check to see how long as user has been idle.  I wish I had that 8 years ago when I created a web-based screen saver for a kiosk.  Another thing I wish I had years ago is Firefox 3's new getElementsByClassName function.  Since it's native (C++) it's MUCH faster than any artificial JavaScript implementation (see John Resig's benchmarks.)

For more information on Firefox' powerful development capabilities, check out the MDC (Mozilla Development Center-- the Firefox equivalent of MSDN).  There you will find a detailed references for the DOM, JavaScript, AJAX, XSLT, CSS, SOAP, XML-RPC, SVG, Canvas (which was Silverlight before Silverlight and native to Firefox, Safari, and Opera-- notice which browser is missing?), XUL, and a whole host of other technologies you probably never knew existed or never knew were native in Firefox.  If you do ANY client-side web development, you need to check out these references and keep them close by.  The samples alone will save you hours of wasted debugging.

Lower Memory Utilization - Now, to be clear I'm not one of those far too uptight people who cry every time SQL Server uses multiple GBs of memory.  On the contrary I'm usually ecstatic to see that I'm actually using the memory that I paid so much money for.  I'm not too uptight about Firefox using a lot of memory either as I know it's caching everything it sees.  Since I use Firefox more than anything else, I have no problem with it using more memory than anything else-- that includes Photoshop.  However, Firefox 3.0 uses a lot less memory.  You can do simple configuration tweaks in Firefox 2.0 to make it use a lot less memory and to even release memory when you minimize and this all without any extensions, but Firefox 3.0 cleans up the memory as you go.  As I was watching the memory charts of Firefox, I was shocked to see it return 30MB of memory upon closing a tab.  Now it's going to be Safari that's the target of memory usage paranoid.

Webmail Handlers - This isn't a feature I've seen yet, but I'm really hoping comes to Gmail soon.  I'll just quote the release notes: "...web applications, such as your favorite webmail provider, can now be used instead of desktop applications for handling mailto: links from other sites. Similar support is available for other protocols (Web applications will have to first enable this by registering as handlers with Firefox)."  If Gmail does that registration, I'll finally be able to replace Google Chat as my mailto handler.

Offline Applications - This needs to be explicitly utilized by the developers of each particular web application, but now Firefox theoretically doesn't need Google Gears in order to use online application locally.  Firefox 2.0 already had one interesting offline feature in the form of HTML 5's sessionStorage attribute.  This feature was conceptually similar to ASP.NET's ViewState in that it persists across page refreshes, but not across pages.  Firefox 3 included two new events for offline functionality: "online" and "offline".  When an application goes offline, the offline event is raise and similarly with the online event.   I've checked out these events and they are rock-solid.  There are also other offline application features in Firefox 3.0, but they aren't that well documented yet.  You can see an example of the concept of office applications by using Google Reader and Google Gears.  I expect this feature to be available in Gmail soon and hopefully without ever needing a plugin.

One Click Website Info - When you click on the website icon in the address bar you get a box of information telling you a little about the website.  Really what were talking about here is SSL websites.  You can click the icon to get a quick view of the SSL information.  I personally just like the idea of not having to double-click.  I know, I'm picky.  It's the little things in life that make the difference, right?

Native viewing of ZIP files - This feature is not that well documented from what I've seen, but it's really awesome!  It allows you to view ZIP and JAR files directly in Firefox 3.0 by using the following pattern: jar:http://www.mywebsite.com/MyZipFile.zip!/.   Thus jar:http://www.davidbetz.net/dotnetcourse/CSharpLanguage.zip!/ (copy, don't click) views the contents of one of my course samples.  You know you're intrigued now.

There are also many new security features like the forged website blocker which stops you (or, your relatives) from going to verified phishing web sites and malware protection which does the same for malware web sites.  There are also user experience enhancements.  Now when you type in the address bar you are filtering by page title and URL, compared to just filtering by URL previously.  Also, zooming now attempts to zoom images and text, not just text, though I'm not finding that to be all that successful; safari on the iPhone/iPod touch still owns that one.  Other development features include support for animated PNGs (APNG), the ability to use a web service as a content handler, support for rgba and hsla colors, and... ready for this? Cross-site XMLHttpRequest!  That's right, we will finally be able to do cross-domain AJAX without script block hacks!  Other normal user/power user features include a permanent restart button (in Tools->Add-ons), a much better application content-type screen, a really, really nice page info window which includes a cookie viewer and the supposed ability to enable and disable images, popup windows, cookies, and extension and theme installations per web site.

On the negative side, the new download window is absolutely horrible.  Firefox' download manager and download options actually get worst with each major Firefox release.  The download setup is finally as bad as Safari's.  Firefox 1.0 had absolutely the best download setup I've ever seen.  You could go to the options screen and with the click of a button, a My Downloads folder was created and downloads would start going there.  That actually made sense!  In Firefox 1.5, they got rid of that awesome selling point, forcing you to make the folder yourself or suffer having all your downloads be thrown all over your desktop.  Lame.  At least in Firefox 1.5 you could click the button next to "All files downloaded to:" and have access to your downloads in a folder view of your desktop.  In Firefox 3.0 you can't even do that! I'm never getting to my downloads again! Well, not never, because the Firefox developer have to be smart enough to fix that and even if they aren't, Firefox has an awesome extension system that allows anyone to make a quick fix using XML, JavaScript and CSS.  Furthermore, the download manager API has been updated so extension developers can do much more.  It's also been moved from RDF to SQLite, thus allowing even more extensibility.

With all these additions, it's not hard to see that Firefox 3.0 is a major upgrade over previous versions pushing the Firefox dynasty even further in the face of its competition (that is, Opera and Safari-- IE isn't in the ball park.)  Some would criticize this statement though and possibly even say that I have double standards.  They would say that when Firefox gets a feature I proclaim it as awesome and slam other browsers for not having it, but when those other browsers get a feature that Firefox lacks, I ignore it.  To be sure, when other browsers get a feature that it lacks I very much criticize Firefox for it.  Their lack of perfection on the ACID2 test in Firefox 2.0 was a good example and their lousy download manager in Firefox 3.0 beta 1 is another.  I slammed them rather hard for that and submitted/voted for all kinds of other bugs in Firefox.  Furthermore, I love other browsers as well.  For example, because of it's beautiful anti-aliasing and support for the CTRL-L and CTRL-K shortcuts, I use Safari about as much these days.  Even still, Firefox is leaps and bounds ahead of the rest.  The zip viewer means nothing, the SQLite is only "cool", the "Places" is something I'm not too excited about, because it's the JavaScript, CSS, DOM and extension support that actually matters.  Web browsers need to be standards compliant and have a strong development feature set to be acceptable in today's web.  Opera will probably always be flashier, but Firefox will probably always be smarter.

As I've stated initially, there's more to Firefox 3.0 than what I've mentioned here.  If you want to know more about any point of Firefox 3.0, just check out the many links above or the developer notes below.  For more developer information, I highly suggest going to the Mozilla Developer Center.  For other information, just check out the release notes and it's links.

Related Links

• Firefox 3.0 Beta 1 Release Notes
• Firefox 1.5 for Developers
• Firefox 2 for Developers (supplemental to Firefox 1.5 for Developers)
• Firefox 3 for Developers (supplemental to Firefox 2 for Developers)

One of the nicest features of C# 3.0 is one of the most subtle: automatic properties.  It's really nothing more than syntactical sugar and saves us a little bit of typing, but it's been a big help in making my code more self-documenting.  If you're unfamiliar with automatic properties, here is what one looks like:

public Int32 Id { get; set; }

When that single line is compiled and viewed in Reflector, you get the following:

[CompilerGenerated]
private int <Id>k__BackingField;

public int Id
{
    [CompilerGenerated]
    get
    {
        return this.<Id>k__BackingField;
    }
    [CompilerGenerated]
    set
    {
        this.<Id>k__BackingField = value;
    }
}

The new syntax is equivalent to a classic C# property.  Note that this property has a get accessor and a set accessor.  This is the only type of automatic property you will be able to create.  You need the full {get; set; } for the automatic property to compile.  { get; } or { set; } won't cut it.  If you need a property with only a get or set accessor, then you need to use a classic C# property.  However, you can use { get; private set; } for a read-only property.  It will create both accessors, but only the get accessor will be public.  Also keep in mind that the Visual Studio 2008 code-snippet shortcut "prop" now creates an automatic property and "propg" creates an automatic property with a private set accessor.

Since this feature helps so greatly in the readability of the code, I have added a new feature to XAG: minimized properties.  Here is what the classical C# 2.0 syntax would look like for simple DTO (data transfer object) using XAG:

<Assembly xmlns:x="http://www.jampadtechnology.com/xag/2006/11/">
    <SimpleType x:Key="ClassKey" Type="Class" AutoGenerateConstructorsByProperties="True" Namespace="ClassNamespace"  AccessModifier="Public">
        <Properties AccessModifier="Public">
            <Id Type="Int32" />
            <Name Type="String" />
            <Title Type="String" />
        </Properties>
    </SimpleType>
</Assembly>

Using XAG's express type creation, the XML compiles to the following C# code:

using System;

namespace ClassNamespace
{
    public class SimpleType
    {
        private Int32 id;
        private String name;
        private String title;
        public Int32 Id {
            get { return id; }
            set { id = value; }
        }

        public String Name {
            get { return name; }
            set { name = value; }
        }

        public String Title {
            get { return title; }
            set { title = value; }
        }

        public SimpleType(Int32 id, String name, String title) {
            this.Id = id;
            this.Name = name;
            this.Title = title;
        }

        public SimpleType( ) {
        }
    }
}

That's painfully verbose when compared with automatic properties.  The new feature in XAG allows you to choose between a classic property and a minimized property (an automatic property in C# 3.0).  Below is the same XAG DTO done with Minimized properties.  In this example, notice that AutoGenerateConstructorsByProperties is set to false (the default).  This is because C# 3.0 has feature called object initializers, which allow you to set properties when you instantiate an object without needing any special constructor.

<Assembly xmlns:x="http://www.jampadtechnology.com/xag/2006/11/">
  <SimpleType x:Key="ClassKey" Type="Class" Namespace="ClassNamespace" AccessModifier="Public">
    <Properties AccessModifier="Public" Minimized="True">
      <Id Type="Int32" />
      <Name Type="String" />
      <Title Type="String" />
    </Properties>
  </SimpleType>
</Assembly>

By simply setting Minimized to true (and optionally, AutoGenerateConstructorsByProperties to false), you get the following C# 3.0 code:

using System;

namespace ClassNamespace
{
    public class SimpleType
    {
        public Int32 Id { get; set; }
        public String Name { get; set; }
        public String Title { get; set; }

        public SimpleType( ) {
        }
    }
}

You can also use this new minimize option with the existing options Static (a Boolean) and Mode (Blank, "GetOnly", or "SetOnly"), but you obviously can't use it with the Backing option.   The Backing option has a default value of true which means that the property is backed by a private field.  There is no such thing as an automatic property with an explicit backing field; that's the entire point of an automatic property.  The following example demonstrates a few legal combinations for properties in XAG.  Notice that you can tell XAG that you want all but a few specified properties to be minimized.

<Assembly xmlns:x="http://www.jampadtechnology.com/xag/2006/11/">
    <SimpleType x:Key="ClassKey" Type="Class" Namespace="ClassNamespace"  AccessModifier="Public">
        <Properties AccessModifier="Public" Minimized="True">
            <Id Type="Int32" />
            <Name Type="String" Static="true" Mode="GetOnly" />
            <Title Type="String" Minimized="False" Backing="False" Mode="GetOnly" />
        </Properties>
    </SimpleType>
</Assembly>

This XML code compiles to the following C# 3.0 class:

using System;

namespace ClassNamespace
{
    public class SimpleType
    {
        public Int32 Id { get; set; }

        public static String Name { get; private set; }

        public String Title {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public SimpleType( ) {
        }
    }
}

In C# 3.0, you could use that code with an object initializer like this:

SimpleType st = new SimpleType( )
{
    Id = 8
};

Int32 id = st.Id; // id == 8

You can find more information about my XML Assembly Compiler at http://www.jampadtechnology.com/xag/.

Related Links

• XAG Website
• Overview of C# 3.0
• ESV Bible Web Service 2.0 Framework for .NET 3.5 (object initializer examples)

If you don't already know, .NET 3.5 is finally out and with it came VS 2008.  I've been using it full time for many months now and there are some features which I've come to love and others which I find completely worthless.  Here is a quick break down of what I find cool (be sure to check out the links section to see more resources):

• RESTful Web Services in WCF
• VS 2008 Multi-Targeting
• C# 3.0
  • Object and Collection Initializers
  • Anonymous Types
  • Query Syntax
  • Automatic Properties
  • Lambda Expressions
  • Extension Methods
• LINQ (my del.icio.us) (Scott Guthrie's Series) (101 Samples from MSDN)
  • With Objects
  • With "Data"
  • With XML

Notice I didn't mention anything about ASP.NET AJAX becoming native (or should I say naive?). This is an incredibly poorly designed technology bordering on the quality of Internet Explorer (ok ok, not even a leaky nuclear core is quite that bad).  The JavaScript intellisense is a complete joke and only gets in the way, the Sys namespaces pollute the Firebug watch window so you can never see your objects, and the syntax is painfully non-intuitive.    The only nice feature it has its it's does have is the ability to allow you to access ASMX services from JavaScript.  Having said that, the year is almost 2008.  It's not 2002 and therefore we use WCF, not ASMX.  In WCF 3.5 we can very easily create very flexible and powerful REST-based JSON services (adding straight XML support if needed with a single endpoint configuration element).  There's just no need to have SOAP turn your 6-byte request into a 300 byte message.  It adds up.  So, ASP.NET AJAX ("Atlas") is complete obsolete in my book. If you want to do real AJAX, then learn the fundamentals and whip out prototype/script.aculo.us and use WCF 3.5 for your service interaction.

Now, if you're looking for an awesome resource for learning/mastering .NET 3.5 and C# 3.0, I highly recommend the book Accelerated C# 2008 by Trey Nash. It gets right to the point and doesn't mess around with entry-level nonsense. You get the knowledge you need right away and from it I estimate an experience induction of at least 7 months.

For full .NET Framework 3.5 examples, check out my Minima .NET 3.5 Blog Engine (on which this site runs) and my ESV Bible Web Service 2.0 Framework for .NET 3.5.

Links

• .NET Framework 3.5 Download
• Accelerated C# 2008 by Trey Nash (Source Code)
• Visual C# 2008 Keybinding Reference Poster
• .NET Framework 3.5 Common Namespaces and Types Poster

A while back, the guys over at the ESV Bible web site announced their new REST-based interface to replace their old SOAP interface.  This new interface provides the same functionality as the old, but allows for 5,000 queries per day instead of 500 previously and is based on REST architectural principles.  Because the service is fundamentally chatty, it made sense to switch to REST.  In the context of a Bible web service, it's hard to justify a 200-byte XML message when your actual request is 6 bytes ("John 1").  Also, because the method call is in the URI, the entire call is simplified all the more.

For those of you who are completely unfamiliar with REST interfaces, all you really need to know is that it's a resource (or noun) based architecture.  That is to say instead of calling, for example, a "GetItem" method, you simply access an "item" entity.  You access what the thing is, not what the thing does; kind of a web-based reversal of encapsulation.  In other words, instead of giving a server a command (a verb), you are accessing the resource directly (a noun).  There's obviously more to REST than this and you can get more information from this nice article titled "Building Web Services the REST Way".

RESTful architecture really is a nice way to telling a system what you want, not how to get it.  This is really the point of framework design and abstraction in general.  In light of this it's obvious to see that, as awesome as REST is, it's not how .NET developers want to think when working working on a project.  When I'm working with something I want to focus on the object at hand, not on the URLs and parameters.  For this reason, I built a .NET 3.5 framework that allows easy and efficient access to the new ESV Bible REST web service.  Here are some samples of how to use it:

Here's a simple passage query returning HTML data:

ESVBibleServiceV2 service = new ESVBibleServiceV2( );
String output = service.PassageQuery("Galatians 3:11");

With the flip of a switch you can turn it into plain text:

ESVBibleServiceV2 service = new ESVBibleServiceV2(OutputFormat.PlainText);
String output = service.PassageQuery("Galatians 3:11");

For more flexibility, you may use the provided parameter objects.  Using these in C# 3.0 is seamless thanks to object initializers:

PassageQueryParameters pqp = new PassageQueryParameters( ) { Passage = "John 14:6" };
ESVBibleServiceV2 service = new ESVBibleServiceV2(new PlainTextSettings( )
{
    LineLength = 100,
    Timeout = 30
});
String output = service.PassageQuery(pqp);

Here is a simple sample of accessing the verse of the day (in HTML without the audio link -- optional settings):

ESVBibleServiceV2 service = new ESVBibleServiceV2(new HtmlOutputSettings( )
{
    IncludeAudioLink = false
});
String output = service.DailyVerse( );

You can also access various reading plans via the provided .NET enumeration:

ESVBibleServiceV2 service = new ESVBibleServiceV2( );
String output = service.ReadingPlanQuery(new ReadingPlanQueryParameters( )
{
    ReadingPlan = ReadingPlan.EveryDayInTheWord
});

Searching is also streamlined:

ESVBibleServiceV2 service = new ESVBibleServiceV2( );
String output = service.Query("Justified");

Here is a length example showing how you can use the QueryInfoAsObject method to get information about a query as a strongly-type object:

ESVBibleServiceV2 service = new ESVBibleServiceV2( );
QueryInfoData result = service.QueryInfoAsObject("Samuel");

Console.WriteLine(result.QueryType);
Console.WriteLine("----------------------");
if (result.QueryType == QueryType.Passage) {
    Console.WriteLine("Passage: " + result.Readable);
    Console.WriteLine("Complete Chapter?: " + result.IsCompleteChapter);
    if (result.AlternateQueryType != QueryType.None) {
        Console.WriteLine(String.Format("Alternate: {0}, {1}", result.AlternateQueryType, result.AlternateResultCount));
    }
}

if (result.HasWarnings) {
    foreach (Warning w in result.Warnings) {
        Console.WriteLine(String.Format("{0}: {1}", w.Code, w.Readable));
    }
}

Here is the output:

For more advanced users, the Crossway XML format is also available:

ESVBibleServiceV2 service = new ESVBibleServiceV2(new CrosswayXmlVersion10Settings( )
{
    IncludeWordIds = true,
    IncludeXmlDeclaration = true
});
String output = service.PassageQuery(new PassageQueryParameters( )
{
    Passage = "Galatians 3"
});
Console.WriteLine(output);

That same XML data is also retrievable as an XmlDocument for pure XML interaction:

ESVBibleServiceV2 service = new ESVBibleServiceV2( );
XmlDocument output = service.PassageQueryAsXmlDocument("Galatians 3");

For more flexible XML interaction, you may use XPath:

ESVBibleServiceV2 service = new ESVBibleServiceV2( );

String output = service.PassageQueryValueViaXPath(new PassageQueryParameters( )
{
    Passage = "Gal 3:4-5",
    XPath = "//crossway-bible/passage/surrounding-chapters/current"
});

Sometimes, however, you will want more than one result from XPath:

String[] output = service.PassageQueryValueViaXPathMulti(new PassageQueryParameters( )
{
    Passage = "Gal 3:4-5",
    XPathSet = new[]
    {
        "//crossway-bible/passage/surrounding-chapters/previous",
        "//crossway-bible/passage/surrounding-chapters/next"                
    }
});

Here's what the result looks like the debugger:

I've also copied the documentation for functions and parameters into the .NET XML comments, so you can quickly and easily see what a certain function or parameter does and it's default:

The new API uses your existing ESV Bible Web Service access key.  To use this key in this framework you simply add an element called ESVBibleServiceKey to the addSettings in your configuration file (a sample is provided with the framework).  You may also set it in any one of the parameter objects (i.e. PassageQueryParameters, QueryParameters, etc...), which override the key in the configuration file.  Per the API, you can use TEST for testing and IP for for general purpose queries.

Lastly, I would like to mention that this framework minimizes traffic by only sending options that deviate from defaults. So, for example, if you set IncludeWordIds to false and IncludeXmlDeclaration to true, only the IncludeXmlDeclaration value will be sent over the wire since IncludeWordIds is false by default.

You can access this ESV Bible Web Service 2.0 framework on CodePlex at the address in the links section.  Enjoy!

Links

• ESV Bible Web Service 2.0 Framework on CodePlex
• "Building Web Services the REST Way" Article by Roger L. Costello
• Official ESV Bible Web Service API

Today I noticed the book "Prototype and script.aculo.us: You never knew JavaScript could do this!" and while you do not need a book to learn P&S, this book will definitely induce a good 6 months to a year of experience into your skill set.  The book is available on Amazon in print or on the book's website in PDF format.

If you only want to know the basics of P&S, then you'll be fine with looking over the Prototype documentation and script.aculo.us samples.  However, regardless of how deep you want to go, you should definitely check out the freely available source code for the book available on the book's website.

As always, let the tools do the work, but don't rely on them for everything.  It's critically important that you understand AJAX developer from a deep mechanical level before you start using JavaScript or AJAX frameworks.  If you aren't well-versed in JavaScript and AJAX development, then I highly recommend AdvancED DOM Scripting: Dynamic Web Design Techniques by Jeffery Sambell.

Related Links

• "Prototype and script.aculo.us: You never knew JavaScript could do this!" by Christophe Porteneuve (Amazon)
• "Prototype and script.aculo.us: You never knew JavaScript could do this!" by Christophe Porteneuve (PDF and Sample Code)
• AdvancED DOM Scripting: Dynamic Web Design Techniques by Jeffery Sambell.
• Prototype JavaScript Framework Website
• script.aculo.us Website
• Blog Entry on Prototype and Scriptaculous

Many years ago I wrote a paper on accelerated learning and experience induction.  This paper explains how I induce weeks of experience in days, months of experience in weeks, and years of experience in months and how to dramatically learn new technologies with little to no investment.  I know people who have worked in a field for 4 years, but only have 6 months worth of skill (usually VB developers -seriously).  I also know people who have worked for 6 months, but have over 4 years of skill (usually Linux geeks; paradoxically, VB developers usually are quicker to learn .NET basics than PHP developers, though they usually switch places in more advanced studies.)  How can anyone expect to gain skill by doing the exact same job for 4 years (e.g. building database driven interfaces, cleaning data, writing reports)?  Obviously, calendar-years of experience is not directly related to skill-years of experience.  As it turns out, my learning techniques are not uncommon.

Today, author Timothy Ferris (Four Hour Work Week) posted a blog entry about how he learns languages in an incredibly short timeframe.  His post was fascinating to me for many reasons, one of them being that his first step is as follows: "Before you invest (or waste) hundreds and thousands of hours on a language, you should deconstruct it."  This is the same first step in my accelerated learning method.  Apparently I was on to something!  In his deconstruction method, he asks a few key questions and does some component and paradigm comparisons to give you some idea of the language scope and of its difficulty.  Based on what you learn from the deconstruction, you should have a good idea of what the language entails.

In my learning system, I refer to this deconstruction as "learning the shell", which is followed by "learning the foundations", then "learning the specifics" -- Shell, Foundations, Specifics -- my SFS (pronounced "sifs") method.  The method exploits Pareto's Law, allowing you to learn 20% of the technology at first to give you 80% of the return.  That's MUCH more than what most so-called "experts" have anyhow!  As it turns out, Timothy Ferris uses Pareto's Law in his language learning as well.  You can hear about this in his interview with my other role model, Scott Hanselman.

For more information on Timothy Ferris' other life-optimization work, check out his book The Four Hour Work Week and his blog.

Related Links

• Four Hour Work Week
• Timothy Ferris' Blog
• Scott Hanselman's Interview with Timothy Ferris on the Four Hour Work Week