The success of Firefox over recent years can be partly attributed to the extensions that beef up what’s already a great browser into something truly amazing. Firebug’s one of the most popular extensions, and for good reason. I’ve used it for editing CSS, viewing AJAX requests, DOM manipulation and debugging JavaScript. To say it’s been helpful is a large understatement, and it’s why I use Firefox as my main browser for web development.

Packt Publishing’s lengthily titled ‘Firebug 1.5 : Editing, Debugging, and Monitoring Web Pages’ starts the reader off gently with a ‘Getting Started’ chapter, discussing Firebug’s history, installation and Firebug Lite, a JavaScript version for non-Firefox browsers. In cases where a particular problem occurs on Safari, for example, the lite version can be extremely useful. Chapter 2 introduces the various Firebug tabs and gives a good overview of Firebug’s main capabilities. Chapters 3, 4, 5 and 6 expand on the HTML, CSS and DOM functionality, and provide a great, in-depth examination of what’s possible.

Chapter 7 – ‘Performance Tuning Our Web Application’ – looks at the Net panel, and once again, the discussion is thorough and well-written. Not only does it give information about Firebug, but by its very nature, delves into HTTP headers and XMLHttpRequest monitoring.

Chapter 8 – ‘AJAX Development’ explains the console.debug call that I’ve made on several occasions, as well the (new to me) console.assert for for assertions and the useful console.dir(object) for giving a DOM tab style object dump for the supplied object parameter.

Chapter 9 – ‘Tips and Tricks for Firebug’ also had something new for me, console.group() and console.groupEnd(), which are functions that group ouput in the output console. When there are lots of debug statements being fired out to the console window, it can be useful to group them, and I’ve already used this to my benefit since reading the book.

Chapter 10 – ‘Necessary Firebug Extensions’ takes a look at ways of making Firebug even better by using 8 extensions that empower their users to more accurately diagnose and fix performance issues, manage cookies and improve SEO.

Chapter 11 – ‘Extending Firebug’ builds on Chapter 10′s introduced extensions by describing how to build your own. To keep things in proportion, it’s a fairly small chapter, building a small ‘Hello World’ extension, but it does give food for thought.

The book closes with an Appendix detailing Firebug’s API, and a look ahead at Firebug 1.7

Overall, this is a well-written and descriptive book, and although it is probably more suitable for a new to intermediate Firebug user, I found quite a few ‘ooh – I didn’t know that’ moments throughout that make it worthwhile for any reader who designs and develops websites.

I’ve been more used to unit testing in a C# environment, particularly NUnit and MS Unit, so googletest was a fresh look at unit testing for C++. Note that the screenr title is incorrect, it should read ‘Getting started with googletest – the Google C++ Testing Framework :)

Cost

There once was a time when the standard IDE for developing ASP.NET apps, Visual Studio, was prohibitively expensive for the average Joe. In late 2007, Microsoft released its first versions of ‘Express’ software, aimed at students and hobbyists. Though Express incarnations have fewer features than their full version cousins, they do offer the possibility of exploring ASP.NET. The Microsoft website offers a download page for Visual Web Developer 2008 Express Edition. An express version of SQL Server is also available, and can be downloaded from the SQL Server 2008 download page.

MVC Support

The MVC pattern is an established and well-recognised way of building web applications, and is familiar to RoR, Java and PHP developers. For many years, MVC was not available as a standard approach to developing ASP.NET websites, but Microsoft has recognised the deficiency and have (at the time of writing) released version 1.0 Release Candidate of ASP.NET MVC. The release has had a mixed response from the ASP.NET community, many of whom are used to the traditional code-behind model. Despite the inevitable squabbles as to which way is best, many have welcomed the MVC approach for its separation of concerns and finer control over JavaScript and markup. To find out more about the release candidate, head over to Scott Guthrie’s blog post.

Learning Resources

A big advantage for anybody learning a new technology is the wealth of learning material that is available. Although you can rely on a large number of books, the ASP.NET learn website contains many videos on both traditional and MVC ASP.NET as well as data access.

Intrinsic jQuery Support

The lightweight open source JavaScript library that’s taken the web by storm is now fully supported by Microsoft. As well as full intellisense support in Visual Studio, Microsoft will be using the library as-is, without forking or changing the code from the main jQuery branch. What’s more, Microsoft will be using jQuery as a basis for future ASP.NET and ASP.NET AJAX features. I feel this counters the argument of Microsoft not supporting open-source software.

Career Prospects

Microsoft’s ubiquity means that learning ASP.NET and supporting technologies will do no harm to your career prospects. .NET skills are ranked as some of the most in-demand in the UK.

With all the furore surrounding Ruby on Rails, you’d be forgiven for forgetting that any other web application framework ever existed. The fact is, of course, that there are many to choose from, and one leading PHP-based framework is MVC-based CodeIgniter.

The CodeIgniter website is a great place to start for newcomers and more experienced developers alike, but I still like a good book, that I can hold in my hand and digest. Wrox’s Professional CodeIgniter is such a book, and presents a good overview of the framework that’s getting deserved attention in the web development community.

The book weighs in at a fairly lightweight 336 pages, but covers various aspects of CodeIgniter development, together with a history of the Model View Controller Pattern and an examination of Agile Development that is often employed by modern web-centric development teams. Whilst these discussions are not completely necessary to experienced programmers looking at getting to grips with CodeIgniter, they may benefit others who are looking for a more rounded introduction to web development. Being familiar with MVC and agile-development, I skipped these sections and headed for some CodeIgniter code.

Chapter 3 satisfies my code craving, where an overview of CodeIgniter is presented, covering such topics as the default installation, configuration, CodeIgniter libraries, helpers, and models, views and controllers, the foundation of any CodeIgniter site.

Chapters 4-8 walks through the development of an e-commerce style website with a shopping cart, categories and products, and a dashboard for managing details of the site. Chapter 9 covers some security issues, and although the information is presented, it is not intended as an exhaustive coverage of PHP Security. There is never a one book fits all situation, and for PHP security, you’re likely to find Essential PHP Security of great use.

The book concludes with an brief examination of the site launch, though this adds little of any significant importance.

It’s good to see a CodeIgniter book, and the quality of the writing is generally high, with easy to follow code examples. The book is very thin on AJAX coverage, which is quite a negative. Used in conjunction with the excellent CodeIgniter forums and website, it’s likely to prove a great resource for learning the framework.

The book’s list of Chapters is as follows:

1. Welcome to the MVC World
2. Agile Methodologies and Approaches
3. A 10,000-Foot View of CodeIgniter
4. Creating the Main Website
5. Building a Shopping Cart
6. Creating a Dashboard
7. Improving the Dashboard
8. Last-minute Upgrades
9. Security and Performance
10. Launch

I recently deployed a WPF app on a server that allowed the user to stop and start some application-related services. The purpose of the app was to allow users with administrative rights an easy way to manage the services that they needed to manage. Granted, they could manage the services through the services MMC, but the little WPF app was a requirement, and it’s our job as developers to make things easier for our clients – right?

All went well until a change of requirements meant that a user without administrative rights needed to use the program to stop and start the required services. When I tried to use the app, I got an exception – quite rightly, stopping and starting the services required admin rights. We needed the restricted user to be able to log on and use the app, but still needed to restrict their permissions.

So – step in programmatic impersonation in C# – a way to give restricted users the power that that’s required, all within the confines of your application.

The first thing to point out is that I got quite a bit of this code from a google search, but I had to do a bit of work to get things in a state that I found really useful.

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Runtime.InteropServices;
using System.Linq;
using System.Security.Principal;
using System.Text;

namespace ServiceControllerApp.Security
{
    public class Impersonator : IDisposable
    {
        private WindowsImpersonationContext _impersonatedUser = null;
        private IntPtr _userHandle;

        public Impersonator()
        {
            _userHandle = new IntPtr(0);

            string user = "servicecontroller";
            string userDomain = ConfigurationManager.AppSettings["MachineDomain"];
            string password = "yourpassword";

            bool returnValue = LogonUser(user, userDomain, password, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, ref _userHandle);

            if (!returnValue)
                throw new ApplicationException("Could not impersonate user");

            WindowsIdentity newId = new WindowsIdentity(_userHandle);
            _impersonatedUser = newId.Impersonate();
        }

        #region IDisposable Members

        public void Dispose()
        {
            if (_impersonatedUser != null)
            {
                _impersonatedUser.Undo();
                CloseHandle(_userHandle);
            }
        }

        #endregion

        #region Interop imports/constants
        public const int LOGON32_LOGON_INTERACTIVE = 2;
        public const int LOGON32_LOGON_SERVICE = 3;
        public const int LOGON32_PROVIDER_DEFAULT = 0;

        [DllImport("advapi32.dll", CharSet = CharSet.Auto)]
        public static extern bool LogonUser(String lpszUserName, String lpszDomain, String lpszPassword, int dwLogonType, int dwLogonProvider, ref IntPtr phToken);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public extern static bool CloseHandle(IntPtr handle);
        #endregion
    }
}

Impersonator is a simple class that uses interop to call Win32 LogonUser and CloseHandle functions. We have to use interop because .NET doesn’t provide the equivalent methods.

The code shown above has a user, domain and password actually in the code – for some situations this is a security risk, so the credentials should be obtained in another manner, but for my needs, it was satisfactory, and their direct inclusion simplifies this example.

The class has a WindowsImpersonationContext to manage the impersonation, and the constructor sets up the required logon rights using the LogonUser interop.

Crucially, the impersonation must end, with an equivalent Log Off – and the class implements IDisposable to call the required log off code. Using the class is easy.

using (Impersonator impersonator = new Impersonator())
{
    // code in here
}

The good thing is that because the class implements IDisposable, you don’t have to pepper your code with the log off code equivalent. I hope it’s of use to somebody wishing to implement impersonation.

I can’t quite remember there ever being this much furore about the release of a web browser. Together with a large number of blogs mentioning the release of Google’s new Chrome browser, the BBC and Sky have carried large reports on their news programmes, and people at work, unconcerned with IE8 or Firefox 3 releases, have asked me about it. Even my wife, who normally couldn’t give a hoot about web browsers, has mentioned it. So, I downloaded and installed it. Here I present a first impression, or two.

I didn’t even know about Chrome until a day or so before its release. Once considered the David in the classic bible story, Google now seems to be amassing quite an armoury in its assault of Goliath Microsoft. Some people are now concerned that its very qualities as a rising star have now morphed into those of a Microsoft that they have always despised. They want to own the Internet, and I find that neither surprising or unconventional.

So, beyond the discussion of monopolies and competition, honour and integrity, let’s have a look at the browser itself.

Getting Started

To download the install package was less than 500k, but to download the main install took an age. I wonder how big the main install package is?
Currently, it’s only available for Windows machines, but a Mac and Linux version is on the cards.

Using

Chrome’s tabbed browsing is nothing new, but each tab runs in its own process, so theoretically, a typical browser crash results only in a ‘crashed tab’, allowing you to close just the tab and carry on seamlessly. A welcome feature. I’ve had to end the firefox process countless times because a page on a particular tab has caused a terminal problem.
Doing a Control + F (find on page) doesn’t overlap the page with a modeless dialog (like IE), but merges the dialog with menu bar at the top right of the main window. If text is found on the page, it is highlighted, like Safari. If the text is found, the number of occurrences is shown on the dialog. The particular occurrence (say, 1 of 3) is highlighted in orange, and others are highlighted in yellow. A useful feature.

Opera’s ‘Speed Dial’ has been reproduced, but the sites shown are those that you have visited most often. Hmm… a useful feature methinks.

Ever wanted to save some of your browsing history, but not all? Um, perhaps you have been browsing a site or two… perhaps to buy your partner a surprise gift? Well, select ‘New incognito window’ from the file menu and all browsing done within will be secret. Very useful. I buy a lot of gifts. :)

What about us Geeks?

One of the main reasons I love Firefox is its extensions, particularly the web developer toolbar and Firebug. Right-clicking on a page and selecting ‘Inspect Element’ provides a poor-man’s Firebug. It’s early days, but it’s there.

However, this is the tip of the iceberg. Chrome provides ‘Gears‘, an effort aimed at developers, and allowing for the browser to be extended. Quite how this will pan out remains to be seen, but I’m sure well see some good things coming from the Gears initiative.

Chrome uses Webkit for its rendering engine, so if you’ve been using Web Standards and your sites look good on Safari, Firefox and Opera, you’ll have no issues.

Together with the obvious start-up speed, Chrome’s JavaScript rendering engine has been built by the ground up and promises faster execution speed.

The ACID2 test renders perfectly.

What next?

I’m not one for discussing the rights and wrongs of Google’s strategy, nor am I prepared to muse the future of the Internet. I have read many blog comments that another standards compliant browser will be the final nail in the coffin for IE. I disagree. Though people have turned away from IE to some extent with the advent of Firefox, I think that it’ll be mainly those in the know that will try Google’s browser. Though the trend appears to suggest that Internet Explorer is losing popularity, in the short term, I feel that Firefox users will try Chrome. I started this post using Chrome, and having got to this point, like it quite bit. For now, it’s only the lack of firebug that’s stopping me switch for good.
I welcome the browser – competition is good.

Asides

Surely I’m not the only one to recognise the similarity between the Chrome logo and Simple Simon, the memory game that I owned in the 80s.

Do a Google search for Chrome, and the Browser is listed as result number 3, though there is a ‘news story’ at the top of the results page. I wonder how long it’ll be before it’ll be returned as number 1? :)

I just went through the motions of uploading the images used in this post to Flickr, and I couldn’t use their photo upload page with Chrome. Oh well, back to Firefox :)

Many years ago, I spent 6 months in India. For the first three months, I was staying at a rural polytechnic in Uttar Pradesh, and I tried to learn some Hindi for my own interest, and because I felt it would help me settle in and go some way to befriending the mainly non English-speaking people in the area. Some of my fellow travellers felt no need to make an effort, and insisted on saying English words more loudly and slowly. Funnily enough, this doesn’t really work.

I make this comparison to people who bring coding style and standards from previous languages. I’ve recently been working on C# code that screams of work from a former VB programmer. There are prefixes to all the variable names to indicate their type, constants are capitalised, method parameters are prefixed with additional information as to whether they are passed by reference, and members are prefixed with ‘m’.

public const string cstrDataGridXml = "DataGridDetails.xml";

public EditableTable(string p_strTableName,string p_strTableDesc, bool p_bExtended)
{
	mstrTableName = p_strTableName;
	mstrTableDescription = p_strTableDesc;
	mbExtended = p_bExtended;
}

I find this type of thing mildly infuriating – it’s like going to India and shouting English. To bring this old coding style to a new language blurs the distinction of coding standards between languages, the very coding standards which are established because of language features. To mix the styles blurs this distinction, and reduces the clarity and purpose of those coding standards.

I come from a C++ background, and although I don’t touch the stuff these days, you can bet that if I returned, I’d be coding as I did back in the year 2000. Now I’m doing C#, I use those the standards defined by Microsoft, who, to be fair, should know a thing or two about C#.

Having started Ruby and Ruby on Rails, I code Ruby like a Ruby programmer – so you won’t find any m_ prefixes for member variables or such like. Perhaps one day, another Ruby programmer will look at my code. If it’s styled like Ruby, their understanding and comfort in reading my code will be maximised.

This naming also extends to control prefixes in ASP.NET and WinForms. Drop a TextBox onto a web form and by default, you’ll get TextBox1. So why change the prefix to txtBox?

I think it’s important for developers to respect the language they’re programming in, and code accordingly – although the exact content of a coding standard for language ‘X’ promotes contention, a mishmash surely doesn’t have any advantages.