Google has a content delivery network (CDN) dedicated to serving the most popular open source JavaScript libraries here. This will give you faster delivery and better caching for your clients. The Google CDN chooses the best server to provide the library from based on the client location.

Along with location based delivery it also gives you the benefit of saving load on your server and delivering more of your local content faster. Most popular browsers limit the amount of connections from a server that can be made for downloading content and by pushing off your JavaScript loading onto Google’s servers you are freeing up connections that can be used for the rest of your application.

Currently Google hosts jQuery, Prototype, script.aculo.us, MooTools, Dojo, SWFObject, YUI, and Ext.

One of the major issues I saw in VS2010 Beta was the lack of box selection (i.e holding alt and selecting columns of text). The Visual Studio editor team has released a new video of the new powerful box selection features they are working on and I'm really excited about them!  These new features include multi-line editing and copying/pasting.

Check out this post which includes a video of the new features in action.

I love it when I see "The Project file '' has been renamed or is no longer in the solution"! Its just not a very detailed error and doesn't even tell you what project its looking for.

What the error really means is you have a project reference and that project is no longer in the solution. This happens a lot with web projects and the easiest way to solve it is right click on your project and go to "Property Pages" and in the References section you'll see the reference name and the offending reference will have (unavailable) next to it.

On Thursday, May 9th, 2008 the Utah Python User Group decided to settle the debate that has plagued us developers since the beginning of time: If you were a programming language, what editor would you use?

I was tasked with showing Eclipse with the PyDev plugin in all its glory–but we all know–real men / developers don’t use IDE’s, so we are going to talk about using Python and Vim together, reaching a state of Zen that the Dalai LLama would be jealous of and establishing more Feng Shui than Martha Stewart’s Kitchen.

Freely jump between your code and python class libraries

There are 2 ways to add your ability to jump between python class libraries, the first is to setup vim to know where the Python libs are so you can use ‘gf’ to get to them (gf is goto file). You can do this by adding this snippet to your .vimrc:

python << EOF
import os
import sys
import vim
for p in sys.path:
    if os.path.isdir(p):
        vim.command(r"set path+=%s" % (p.replace(" ", r"\ ")))
EOF

With that snippet you will be able to go to your import statements and hit ‘gf’ on one of them and it’ll jump you to that file.

Continuing accessibility of the Python class libraries we are going to want to use ctags to generate an index of all the code for vim to reference:

$ ctags -R -f ~/.vim/tags/python.ctags /usr/lib/python2.5/

and then in your .vimrc

set tags+=$HOME/.vim/tags/python.ctags

This will give you the ability to use CTRL+] to jump to the method/property under your cursor in the system libraries and CTRL+T to jump back to your source code.

I also have 2 tweaks in my .vimrc so you can use CTRL+LeftArrow and CTRL+RightArrow to move between the files with more natural key bindings.

map <silent><C-Left> <C-T>
map <silent><C-Right> <C-]>

You can also see all the tags you’ve been to with “:tags”

Code Completion

To enable code completion support for Python in Vim you should be able to add the following line to your .vimrc:

autocmd FileType python set omnifunc=pythoncomplete#Complete

but this relies on the fact that your distro compiled python support into vim (which they should!).

Then all you have to do to use your code completion is hit the unnatural, wrist breaking, keystrokes CTRL+X, CTRL+O. I’ve re-bound the code completion to CTRL+Space since we are making vim an IDE! Add this command to your .vimrc to get the better keybinding:

inoremap <Nul> <C-x><C-o>

Documentation

No IDE is complete without the ability to access the class libraries documentation! You’ll need to grab this vim plugin. This gives you the ability to type :Pydoc os.path or use the keystrokes <Leader>pw and <Leader>pW to search for the item under the cursor. (Vim’s default <Leader> is “\”).

Syntax Checking

Vim already has built in syntax highlighting for python but I have a small tweak to vim to give you notifications of small syntax errors like forgetting a colon after a for loop. Create a file called ~/.vim/syntax/python.vim and add the following into it:

syn match pythonError "^\s*def\s\+\w\+(.*)\s*$" display
syn match pythonError "^\s*class\s\+\w\+(.*)\s*$" display
syn match pythonError "^\s*for\s.*[^:]$” display
syn match pythonError “^\s*except\s*$” display
syn match pythonError “^\s*finally\s*$” display
syn match pythonError “^\s*try\s*$” display
syn match pythonError “^\s*else\s*$” display
syn match pythonError “^\s*else\s*[^:].*” display
syn match pythonError “^\s*if\s.*[^\:]$” display
syn match pythonError “^\s*except\s.*[^\:]$” display
syn match pythonError “[;]$” display
syn keyword pythonError         do

Now that you have the basics covered, lets get more complicated checking added. Add these 2 lines to your .vimrc so you can type :make and get a list of syntax errors:

autocmd BufRead *.py set makeprg=python\ -c\ \"import\ py_compile,sys;\ sys.stderr=sys.stdout;\ py_compile.compile(r'%')\"
autocmd BufRead *.py set efm=%C\ %.%#,%A\ \ File\ \"%f\"\\,\ line\ %l%.%#,%Z%[%^\ ]%\\@=%m


You will have the ability to to type :cn and :cp to move around the error list. You can also type :clist to see all the errors, and finally, sometimes you will want to check the syntax of small chunks of code, so we’ll add the ability to execute visually selected lines of code, add this snippet to your .vimrc:

python << EOL
import vim
def EvaluateCurrentRange():
eval(compile('\n'.join(vim.current.range),'','exec'),globals())
EOL
map <C-h> :py EvaluateCurrentRange()


Now you will be able to visually select a method/class and execute it by hitting “Ctrl+h”.

Browsing the source

Moving around the source code is an important feature in most IDE’s with their project explorers, so to get that type of functionality in vim we grab the Tag Listplugin. This will give you the ability to view all opened buffers easily and jump to certain method calls in those buffers.

The other must-have feature of an IDE when browsing code is being able to open up multiple files in tabs. To do this you type :tabnew to open up a file in a new tab and than :tabn and :tabp to move around the tabs. Add these to lines to your .vimrc to be able to move between the tabs with ALT+LeftArrow and ALT+RightArrow:


map <silent><A-Right> :tabnext<CR>
map <silent><A-Left> :tabprevious<CR>


Debugging

To add debugging support into vim, we use the pdb module. Add this to your ~/.vim/ftplugin/python.vim to have the ability to quickly add break points and clear them out when you are done debugging:

python << EOF
def SetBreakpoint():
    import re
    nLine = int( vim.eval( 'line(".")'))

    strLine = vim.current.line
    strWhite = re.search( '^(\s*)', strLine).group(1)

    vim.current.buffer.append(
       "%(space)spdb.set_trace() %(mark)s Breakpoint %(mark)s" %
         {'space':strWhite, 'mark': '#' * 30}, nLine - 1)

    for strLine in vim.current.buffer:
        if strLine == "import pdb":
            break
    else:
        vim.current.buffer.append( 'import pdb', 0)
        vim.command( 'normal j1')

vim.command( 'map <f7> :py SetBreakpoint()<cr>')

def RemoveBreakpoints():
    import re

    nCurrentLine = int( vim.eval( 'line(".")'))

    nLines = []
    nLine = 1
    for strLine in vim.current.buffer:
        if strLine == ‘import pdb’ or strLine.lstrip()[:15] == ‘pdb.set_trace()’:
            nLines.append( nLine)
        nLine += 1

    nLines.reverse()

    for nLine in nLines:
        vim.command( ‘normal %dG’ % nLine)
        vim.command( ‘normal dd’)
        if nLine < nCurrentLine:
            nCurrentLine -= 1

    vim.command( ‘normal %dG’ % nCurrentLine)

vim.command( ‘map <s-f7> :py RemoveBreakpoints()<cr>’)
EOF

With that code you can now hit F7 and Shift-F7 to add/remove breakpoints. Then you just launch your application with !python % (percent being the current file, you can declare your main file here if its different).

Another tweak I use is to have my vim inside screen with a horizontal split, that way I can see the python interpreter and debug while still having vim there so I can easily fix my code.

Snippets

A great time saver with standard IDE’s is code snippets, so you can type a few key strokes and get a lot of code out of it. An example of this would be a django model, instead of typing out the complete declaration you could type ‘mmo<tab><tab>’ and have a skeleton of your model done for you. To do this in vim we grab the Snippets EMU plugin.

Check out a great screencast of snippetsEmu in action here

Emacs

Here is a great post on how to do the same with Emacs.

Although XSL is very powerful, I’m sometimes more comfortable with doing certain operations in C# and luckily it is pretty simple to call C# libraries from XSL.

First, you’ll need the code that you will call from XSL, this can just be a normal POCO, doesn’t have to be anything specific to XML/XSL:

    public class StringExtension
    {
        public string Proper(string data)
        {
            CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
            TextInfo textInfo = cultureInfo.TextInfo;
            return textInfo.ToTitleCase(data.ToLower());
        }
    }

Then you need to use the XsltArgumentList class to add an extension object to your Xsl Transform:

   class Program
    {
        static void Main()
        {
            XPathDocument doc = new XPathDocument("data.xml");
            XslCompiledTransform trans = new XslCompiledTransform();
            StringBuilder sb = new StringBuilder();
            StringWriter sw = new StringWriter(sb);
            trans.Load("stylesheet.xslt");
            XsltArgumentList args = new XsltArgumentList();
            StringExtension ext = new StringExtension();
            args.AddExtensionObject("ext", ext);
            trans.Transform(doc, args, sw);
            Console.WriteLine(sw.ToString());
            Console.ReadLine();
        }
    }

Now all you have to do is register the namespace in your XSL (i.e xmlns:”ext”) and you can use the extension by calling ext:Proper():

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
    xmlns:ext="ext"
 >
  <xsl:output method="text" indent="yes"/>
  <xsl:template match="/">
    <xsl:for-each select="People/Person">
      First Name: <xsl:value-of select="ext:Proper(@FirstName)"/><br />
      Last Name: <xsl:value-of select="ext:Proper(@LastName)"/><br />
    </xsl:for-each>
  </xsl:template>
</xsl:stylesheet>

Here are some really useful command line shortcuts that I found on a forum awhile back but don't remember now:

F1 Repeats the letters of the last command line, one by one
F2 Displays a dialog asking user to "enter the char to copy up to" of the last command line
F3 Repeats the last command line
F4 Displays a dialog asking user to "enter the char to delete up to" of the last command line
F5 Goes back one command line
F6 Enters the traditional CTRL+Z (^z)
F7 Displays a menu with the command line history
F8 Cycles back through previous command lines (beginning with most recent)
F9 Displays a dialog asking user to enter a command number, where 0 is for first command line entered

We've all seen the Server Tags cannot contain <% ... %> constructs which comes from trying to use server side <% .. %> inside a server side control:

<asp:TextBox runat="server" Text="<%= ConfigurationManager.AppSettings["Title"] %>" />

You have a few ways around this, the easiest and most common way is to assign the properties server side:

this.textBox1.Text = ConfigurationManager.AppSettings["Title"];

But I like being able to do as much of my property setting in markup as possible so if I ever need to change the property it doesn't require a complete re-build/re-deploy.

The more elegant/fun solution would be to use an ExpressionBudiler, you've most likely used this class already if you've ever worked with a a multilingual website, to have controls pull globalized text from your resx resources you do the following:

<asp:Label runat="server" Text="<%$ Resources:Text, ParticipantHeader %>" />

This is using a ResourceExpressionBuilder, there is also an AppSettingsExpressionBuilder and a ConnectionStringsExpressBuilder built into the .NET framework that you can use. If these don't do what you want you can always build your own, you can see an example of a custom ExpressionBuilder at the MSDN Documentation.

In the upcoming release of ASP.NET 4.0 they have introduce 2 really nice features for SEO, the first one is being able to progmattically add Meta Keywords and Description to the page:

Page.MetaDescription = "Foo";
Page.MetaKeywords = "Foo, Bar, Baz";

Which will render the following in the header:
<meta name="description" content="Foo" /> <meta name="keywords" content="Foo, Bar, Baz" />

The 2nd nice feature added to ASP.NET 4.0 is 301 permanent redirects via the Response.RedirectPermanent("page.aspx") method. So now in your Global.asx.cs you can manage 302 redirects for pages who have moved like this:

protected void Application_BeginRequest(object sender, EventArgs e)
{
    if (Request.FilePath == "/Product/23.aspx")
    {
        Response.RedirectPermanent("/Products/23/", true);
    }
}

This gives you the ability to easily manage files that are indexed in a search engine but have moved progrmatically rather than doing it through your webserver (which is much better for people who are using shared hosting).

Mikael Söderström has created a ribbon control using jQuery, it is very impressive and will be greate to give your online applications a similar feel to what people are used to on the desktop. You can download it here and can see a demo here