If you happen to write Word Press posts in one of the Cyrillic-based languages (i.e. Russian, Bulgarian, Ukrainian, Belarusian, etc.) and are using post’s title in Permalinks then you know that your post’s URL will become an unreadable mash of encoded characters (like %45%f0%…)

I got finally tired of changing encoded slugs to their latin equivalents on my son’s blog, and started looking for ways to automate this process. The Cyrillic Slugs plug-in written by Petko Bossakov was my only alternative at the time in WordPress plug-in repository. Unfortunatelly that plug-in didn’t work for me, since Cyrillic Slugs expects the page to be written in Windows-1251 encoding, and my blog uses WP’s default/recommended UTF-8. Hence Cyr2Lat Slugs plug-in was born.

Here’s a sample that illustrates what this plug-in does.

Before Cyr2Lat Slugs:

1. You write a post with title “Пример заголовка”
2. WordPress creates permalink like this:
   http://www.myblog.com/2008/12/19/%d0%bf%d1%80%d…b2%d0%ba%d0%b0

After Cyr2Lat Slugs:

1. You write a post with title “Пример заголовка”
2. WordPress creates permalink like this:
   http://www.myblog.com/2008/12/19/primer-zagolovka

Cyr2Lat Slugs is based on Petko’s original idea and uses one of his functions, but otherwise is written in a more contemporary, object-oriented fashion. It also uses strtr function instead of str_replace which should be much faster.

Please note that you have to save post (click Save or Publish button) for slug conversion to take place!

Version: 1.0
Requirements: WP 2.3+ (WP MU compatible)
Author: Ruslan Ulanov
License: GPL

Download Cyr2Lat Slugs plug-in now.

Installation:

1. Copy file cyr2lat-slugs.php to folder wp-content/plugins/ on your server.
2. Activate Cyr2Lat Slugs in Plugins menu of your blog’s admin interface.
3. You’re done. There are no options to configure.

Comments are welcome (moderated, no spam please).

 
#
*In Russian*

Cyr2Lat Slugs это плагин для платформы Word Press, который переводит русские буквы в заголовке поста в латиницу (транслит), тем самым делая URL читаемым и доступным для поисковиков.

Продемонстрируем работу плагина Cyr2Lat Slugs на примере.

До установки Cyr2Lat Slugs:

1. Вы пишете пост с заголовком “Пример заголовка”
2. WordPress создает для него пермалинк:
   http://www.myblog.com/2008/12/19/%d0%bf%d1%80%d…b2%d0%ba%d0%b0

После установки Cyr2Lat Slugs:

1. Вы пишете пост с заголовком “Пример заголовка”
2. WordPress создает для него пермалинк:
   http://www.myblog.com/2008/12/19/primer-zagolovka

Примечание: Пост необходимо сохранить (нажать кнопку Save или Publish), чтобы заголовок был переведен в латиницу!

Версия: 1.0
Требования: WP 2.3+ (работает в WP MU)
Автор: Руслан Уланов
Лицензия: GPL

Загрузить Cyr2Lat Slugs.

Установка:

1. Скопируйте файл cyr2lat-slugs.php в папку wp-content/plugins/ на сервере.
2. Активируйте Cyr2Lat Slugs в меню Plugins административного интерфейса вашего блога.
3. Готово. Больше ничего конфигурировать не надо.

Комментарии приветствуются (но модерируются, для отсеивания спама).

This document specifies Best Practices for delivering Web content to mobile devices. The principal objective is to improve the user experience of the Web when accessed from such devices.

It’s a good step toward making the Web accessible to millions of small screen devices, not blessed with a combination of iPhone’s hi-res LCD and a powerful Safari browser.

The document is available from W3C’s web site http://www.w3.org/TR/2008/REC-mobile-bp-20080729/

Unlocker really rocks.  It integrates into the right click menu and can show you what processes have a lock on a file.  You can shutdown the process (preferred) or simply unlock the file.  Not only is it free, but the author provides a comparison matrix against 19 other utilities that unlock files and it is apparent he has put some thought into making his comprehensive!

Obviously you have to be circumspect about ending processes to release a file lock - but I’ve seen Windows Explorer hang on to a file until reboot when it isn’t really using it. 

Visit Site

Source: http://desktopengineer.com

Quoting the site…
Microsoft patterns & practices was created to meet the demands of architects and application developers seeking guidance on how to apply Microsoft’s array of products and technologies to common application development scenarios and technical challenges. Microsoft patterns & practices are Microsoft’s proven recommendations for how to design, develop, deploy, and operate architecturally sound application for the Microsoft platform.

Check it out in Microsoft patterns & practices Developer Center.

• 2 kernel-mode termination techniques
• 12 user-mode process termination techniques
• 2 suspension techniques
• 2 fatal crash techniques

This arsenal makes APT ideal for testing the resistance of software to termination attacks, testing the configuration of your own security programs, as well as allowing you to terminate stubborn software that simply refuses to die.

Kernel Kill #1 - Attempts to terminate the process from a driver using the kernel-level ZwTerminateThread function against every thread in the target process.
Main functions: ZwTerminateThread (ntoskrnl.exe)

Kernel Kill #2 - Attempts to terminate the process from a driver using the kernel-level ZwTerminateProcess function against the target process.
Main functions: ZwTerminateProcess (ntoskrnl.exe)

Kill #1 - Attempts to terminate the process using the TerminateProcess function. This is the same as the End Process function in Windows Task Manager, but as APT aquires SeDebugPrivilege before calling TerminateProcess it is typically able to terminate more processes than Task Manager can. This is the most common method of forceful process termination.
Main functions: OpenProcess, TerminateProcess (kernel32.dll)

Kill #2 - Attempts to terminate the process by sending Close messages (called WM_CLOSE) to all windows in the target process. This method only works if 1) the target process has at least one window, and 2) the target process doesn’t handle the WM_CLOSE message (many programs don’t).
Main functions: SendMessage WM_CLOSE (user32.dll)

Kill #3 - Attempts to terminate the process by sending Close messages (called WM_QUIT) to all windows in the target process. This method only works if 1) the target process has at least one window, and 2) the target process doesn’t handle the WM_QUIT message (many programs don’t).
Main functions: SendMessage WM_QUIT (user32.dll)

Kill #4 - Attempts to terminate the process in the same manner as Kill #7, but sends SC_CLOSE system messages rather than WM_CLOSE window messages. Again, this method only works if 1) the target process has at least one window, and 2) the target process doesn’t handle the SC_CLOSE message (most programs usually don’t).
Main functions: SendMessage SC_CLOSE (user32.dll)

Kill #5 - Attempts to terminate the process by terminating every individual thread in the target process by using the TerminateThread function. When the last active thread is terminated the process is also terminated.
Main functions: OpenThread, TerminateThread (kernel32.dll)

Kill #6 - Attempts to terminate the process by creating a new thread in the context of the target process, which has a starting address (stored in the EIP register) which is the address of the ExitProcess function in kernel32.dll.
Main functions: CreateRemoteThread, ExitProcess (kernel32.dll)

Kill #7 - Attempts to terminate the process by using the EndTask function in user32.dll. This is the same as the End Task function in Windows Task Manager.
Main functions: EndTask (user32.dll)

Kill #8 - Attempts to terminate the process by attaching to it as a debugger, using the DebugActiveProcess function in kernel32.dll. To terminate the target process, the debugger process simply needs to terminate itself, at which point the process being debugged (the target process) is also terminated.
Main functions: DebugActiveProcess (kernel32.dll)

Kill #9 - Attempts to terminate the process by modifying the EIP register of all existing threads so that they all point to the ExitProcess function in kernel32.dll. This is similar to Kill #3, but doesn’t involve the creation of any new thread. Instead, existing threads are used.
Main functions: SetThreadContext (kernel32.dll)

Kill #10 - Attempts to terminate the process using the completely undocumented WinStationTerminateProcess function. This method only works if the Terminal Services service is enabled.
Main functions: WinStationTerminateProcess (winsta.dll)

Kill #11 - Attempts to terminate the process using the CreateRemoteThread DLL injection method. This method is very similar to Kill #6, but the call to ExitProcess is made by an injected DLL.
Main functions: CreateRemoteThread, LoadLibrary, ExitProcess (kernel32.dll)

Kill #12 - Attempts to terminate the process by using an accomplice process to do the termination. APT injects ‘kill code’ into a newly allocated temporary area of memory within an accomplice process, which then executes a call to TerminateProcess on the target process within the context of the accomplice process.
Main functions: CreateRemoteThread, WriteProcessMemory, TerminateProcess (kernel32.dll)

Crash #1 - Attempts to fatally crash the target process by setting the access level for the targets memory region to PAGE_NOACCESS, effectively preventing all read/write/execute operations. This quickly forces the process to crash due to inability to execute code.
Main functions: VirtualProtectEx (kernel32.dll)

Crash #2 - Attempts to fatally crash the target process by overwriting the targets memory region, effectively eliminating all program code which crashes the target process due to it attempting to execute invalid code.
Main functions: WriteProcessMemory (kernel32.dll)

Suspend #1 - Attempts to suspend each thread in the target process individually using the SuspendThread function in kernel32.dll. Resume capability also available with this method.
Main functions: OpenThread, SuspendThread, ResumeThread (kernel32.dll)

Suspend #2 - Attempts to suspend the process using the NtSuspendProcess function in ntdll.dll. Resume capability also available with this method.
Main functions: NtSuspendProcess, NtResumeProcess (ntdll.dll).

It explains how to address IE7 compatibility issues in CSS.
In short, there were several bugs in CSS parser of IE6. Some CSS constructs (filters) that were applied by IE6 are ignored by IE7 and above - like “* html”. We could take advantage of these broken filters to create IE6-specific rules.

For example, first define a style that will look fine in IE7:

#box { top: 2px; }

then (below that rule in CSS file) use CSS filter “* html” to override it with IE6 style:

* html #box { top: 4px; }

This second rule will be ignored by IE7 and above, but will fix the problematic style in IE6.

There’s another approach to fixing IE6/IE7 issues - it’s conditional comments.

Consider the following code that should be placed in the HEAD section of HTML:

<!–[if IE 6]>
<link rel=”stylesheet” type=”text/css” href=”/css/ie6.css” />
<![endif]–>

The <!–[if IE 6]> and <![endif]–> tags are used to filter out content that will be parsed by IE6 browser only, any other browser will ignore anything that’s inside these tags.

For more info see About Conditional Comments on MSDN or more user-friendlier explanation at  Quirksmode.

http://www.irt.org/faq.htm

For example sprintf:

function sprintf( ) {
    // http://kevin.vanzonneveld.net
    // +   original by: Ash Searle (http://hexmen.com/blog/)
    // + namespaced by: Michael White (http://crestidg.com)
    // *     example 1: sprintf(”%01.2f”, 123.1);
    // *     returns 1: 123.10
 
    var regex = /%%|%(\d+\$)?([-+#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
    var a = arguments, i = 0, format = a[i++];
 
    // pad()
    var pad = function(str, len, chr, leftJustify) {
        var padding = (str.length >= len) ? ” : Array(1 + len - str.length >>> 0).join(chr);
        return leftJustify ? str + padding : padding + str;
    };
 
    // justify()
    var justify = function(value, prefix, leftJustify, minWidth, zeroPad) {
        var diff = minWidth - value.length;
        if (diff > 0) {
            if (leftJustify || !zeroPad) {
            value = pad(value, minWidth, ‘ ‘, leftJustify);
            } else {
            value = value.slice(0, prefix.length) + pad(”, diff, ‘0′, true) + value.slice(prefix.length);
            }
        }
        return value;
    };
 
    // formatBaseX()
    var formatBaseX = function(value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
        // Note: casts negative numbers to positive ones
        var number = value >>> 0;
        prefix = prefix && number && {‘2′: ‘0b’, ‘8′: ‘0′, ‘16′: ‘0x’}[base] || ”;
        value = prefix + pad(number.toString(base), precision || 0, ‘0′, false);
        return justify(value, prefix, leftJustify, minWidth, zeroPad);
    };
 
    // formatString()
    var formatString = function(value, leftJustify, minWidth, precision, zeroPad) {
        if (precision != null) {
            value = value.slice(0, precision);
        }
        return justify(value, ”, leftJustify, minWidth, zeroPad);
    };
 
    // finalFormat()
    var doFormat = function(substring, valueIndex, flags, minWidth, _, precision, type) {
        if (substring == ‘%%’) return ‘%’;
 
        // parse flags
        var leftJustify = false, positivePrefix = ”, zeroPad = false, prefixBaseX = false;
        for (var j = 0; flags && j < flags.length; j++) switch (flags.charAt(j)) {
            case ‘ ‘: positivePrefix = ‘ ‘; break;
            case ‘+’: positivePrefix = ‘+’; break;
            case ‘-’: leftJustify = true; break;
            case ‘0′: zeroPad = true; break;
            case ‘#’: prefixBaseX = true; break;
        }
 
        // parameters may be null, undefined, empty-string or real valued
        // we want to ignore null, undefined and empty-string values
        if (!minWidth) {
            minWidth = 0;
        } else if (minWidth == ‘*’) {
            minWidth = +a[i++];
        } else if (minWidth.charAt(0) == ‘*’) {
            minWidth = +a[minWidth.slice(1, -1)];
        } else {
            minWidth = +minWidth;
        }
 
        // Note: undocumented perl feature:
        if (minWidth < 0) {
            minWidth = -minWidth;
            leftJustify = true;
        }
 
        if (!isFinite(minWidth)) {
            throw new Error(’sprintf: (minimum-)width must be finite’);
        }
 
        if (!precision) {
            precision = ‘fFeE’.indexOf(type) > -1 ? 6 : (type == ‘d’) ? 0 : void(0);
        } else if (precision == ‘*’) {
            precision = +a[i++];
        } else if (precision.charAt(0) == ‘*’) {
            precision = +a[precision.slice(1, -1)];
        } else {
            precision = +precision;
        }
 
        // grab value using valueIndex if required?
        var value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];
 
        switch (type) {
            case ’s’: return formatString(String(value), leftJustify, minWidth, precision, zeroPad);
            case ‘c’: return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
            case ‘b’: return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case ‘o’: return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case ‘x’: return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case ‘X’: return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
            case ‘u’: return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case ‘i’:
            case ‘d’: {
                        var number = parseInt(+value);
                        var prefix = number < 0 ? ‘-’ : positivePrefix;
                        value = prefix + pad(String(Math.abs(number)), precision, ‘0′, false);
                        return justify(value, prefix, leftJustify, minWidth, zeroPad);
                    }
            case ‘e’:
            case ‘E’:
            case ‘f’:
            case ‘F’:
            case ‘g’:
            case ‘G’:
                        {
                        var number = +value;
                        var prefix = number < 0 ? ‘-’ : positivePrefix;
                        var method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
                        var textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
                        value = prefix + Math.abs(number)[method](precision);
                        return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
                    }
            default: return substring;
        }
    };
 
    return format.replace(regex, doFormat);
}