import random

def random_generator(low, high, count): 
    """Get a generator to return count random numbers between low and high."""
    while count > 0:
        yield random.randint(low, high)
        count -= 1

def random_subsequence(sequence, count, start=0, end=None):
    """Choose count elements from the sequence, optionally restricted between 
    start and end.
    """
    if not end or end > len(sequence) - 1:
        end = len(sequence) - 1

    return (sequence[r] for r in random_generator(start, end, count))

if __name__ == "__main__":
    sequence = [2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29]
    four_primes = random_subsequence(sequence, 4)
    two_big_primes = random_subsequence(sequence, 2, len(sequence)/2)

    print "Four primes:", list(four_primes)
    print "Two big primes:", list(two_big_primes)

Notes: This is similar to the library random.sample() method, except if count is greater than or equal to len(sequence), you can produce “sub” sequences which are longer than the original sequence.

This works equally well with strings or any other subscriptable object (like xrange).

private static void Main(string[] args)
{
    options = new Options(args);
    if (options.Help)
    {
        // TODO: Write help
        return;
    }

    ...

“Hey, remember the last time you were creating a web application that needed to run in both HTTP and HTTPS? Remember how you had to write logic to detect the current request’s scheme, because you had to generate URLs as https:// when you were secure? Remember that you never thought there was a problem until Jimmy in Marketing looked at your site in Internet Explorer 5.5, and he said to your boss, ‘It says, “Are you sure you want to display insecure items?”, what’s that mean?’

Yeah, you don’t have to do that anymore.”

The problem is essentially this:

When you’re creating a link on a page that may be viewed securely (https://site.com/page.html), you have to change the protocol of the link to match the scheme you’re using. If you don’t, people using Internet Explorer get a dialog box in their face every time they load the page.

The usual method for fixing this is to add logic to your application which finds out (using various methods) whether the page is being accessed securely (https://) or insecurely (http://), and generates an appropriate prefix. You then take this prefix and stuff it in front of every generated link.

RFC 1808 § 2.4.3 says basically, just leave off scheme: from your url, and the web browser will figure it out for you.

Instead of writing your links like this:

    def make_url(url):
        if do_magic_to_see_if_we_are_secure():
            scheme = "https://"
        else:
            scheme = "http://"
        return scheme + url
    print make_url("site.com/page.html")

All you have to do is this:

    url = "//site.com/page.html"

Now when you go to https://site.com, your link becomes “https://site.com/page.html”.

When you go to http://site.com, your link becomes “http://site.com/page.html”.

Done. No code. One less special case for IE.

A few weeks ago I ran into this situation on a Windows 2003 R2 Server. This is what it told me:

Seriously?

In reality, I know that the filesystem has to be updated (written to) in order to delete a file. You have to mark the space that the file occupies as “available.” But really, did no one on the NTFS team consider saving a few kilobytes for emergencies?

Details:
F1 in explorer triggers the HELPCTR.EXE program to launch. While this behavior itself isn’t (easily) configurable, you can convince Windows that HELPCTR.EXE has a different location, say “c:\windows\system32\cscript.exe”, for example. (Cscript is the program that Windows uses to run script host files. It simply quits if you run it without arguments.)

Open RegEdit.exe, go to HKEY_LOCAL_MACHINE \ Software \ Microsoft \ Windows \ CurrentVersion \ AppPaths. Find “HELPCTR.EXE”, and replace it’s default entry with “C:\Windows\system32\CSCRIPT.EXE”.

That’s it. Now in Windows Explorer, F1 effectively does nothing.

Side effects:
1. Windows uses the AppPaths to find applications. This means that the Help Center will also stop working from the start menu. If you’re the kind of person who gets annoyed with the Help Center running on F1, you probably won’t mind that the icon in the start menu doesn’t work either.

2. This is a system level change (HKEY_LOCAL_MACHINE). This means that other users of your computer also will not be able to access the help center.

3. Use F1 as an application launcher. Just replace the path with a useful application. Pressing F1 now opens this application.

4. I only know that this works for sure in Windows XP. I don’t ever plan to operate a machine that has Vista, so I can’t tell you if it will work there. Same goes for Windows 7.

On May 17th, 2003, I bought this compact fluorescent light bulb for $5.99. A couple days ago it finally stopped working, ending it’s 76 month career of generating photons. I’m pretty sure this was one of the first compact fluorescent bulbs that I’ve ever bought. And, as far as I know, this has been the longest lasting. Over the last few years, I have purchased about 50 CFL’s. I’ve replaced every bulb in my house with CFL’s, except two or three that are infrequently used. This one I bought for full price, but my local nationwide non-independent retailer will sometimes sell CFL bulbs for 99¢ as part of some government program.

I was and still am a bit skeptical about CFL bulbs. Why? Well, about half of the CFL bulbs that I have bought (especially the 99¢ ones) only last about three to nine months, which is no better than an incandescent bulb. Sure, they have a “5 year warranty”, but it sure seems like an awful lot of work to get a light bulb replaced under warranty. Not to mention that the shipping charges for the replacement bulb are probably equal to the cost of a new one. But what really burns me up is that you can’t throw them away. Each bulb has between 1 and 5 mg of mercury in them (less than 1/10000 oz.). That doesn’t seem like much, but environmental mercury is highly toxic and already a huge problem. Each little bit that gets in the ground water quickly travels up the food chain. Those at the top of the food chain get the highest concentrations (hint: people are the top of the food chain). Last year, about 100 million CFL bulbs were sold. Those bulbs contain about 50,000 lbs. of mercury, all of which will likely be tossed in the trash. Oh, and most of them emit ultraviolet radiation. You’re probably fine if you stay more than a foot a way from the bulb.

I am also skeptical about power savings, and being a numbers guy, I wondered what the savings actually are. Here are the results.

Estimated Savings: about $40, about 450 kWh, and about 1000 pounds of CO₂.

So, there you have it. Even if your CFL bulb burns out after a year, you still save about a dollar when compared with an incandescent. I have about 30 CFL light bulbs in my house. This means every year I’m saving about $100. Not bad.

I’m still upset about the mercury. I already trashed a number of bulbs before realizing that they all contained mercury. Now I’m just saving them in a box until I can find a recycler.

I look forward to LED bulbs. They aren’t made with mercury, they don’t emit ultraviolet radiation, and they use 1/4 as much power as a CFL. Unfortunately, right now they are so expensive that I would have to run one for 6 years just to break even with my $5.99 CFL bulb (9 years for a 99¢ model). And they aren’t really bright enough. Most are less than half as bright as an incandescent 60W bulb. As time goes by though, they will get less expensive and brighter. And just one LED bulb can potentially replace 100 incandescent bulbs, saving about $500 in energy over it’s lifetime. Not bad for a bunch of diodes.

dmidecode displays a bunch of other information as well, including information on the RAM modules themselves:

Handle 0x0017
DMI type 17, 27 bytes.
Memory Device
Array Handle: 0x0014
Error Information Handle: No Error
Total Width: 72 bits
Data Width: 64 bits
Size: 1024 MB
Form Factor: DIMM
Set: 1
Locator: DIMM#1B
Bank Locator: Bank 1
Type:
Type Detail: Synchronous
Speed: 533 MHz (1.9 ns)
...


We’re doing some RAM upgrades on a couple of old servers, and this method sure beats taking the server offline and physically looking at the motherboard.

An even better idea would be to keep this sort of information in your IT records somewhere.

But I still have a real short attention span. If anything, it’s shorter than it was last year. I also have an additional problem: I tend to create databases that have lots of preloaded data. This means that when I run tests or when I’m doing model development, I have to wait for all that data to load. Waiting sucks. Plus, in order to be able to test with the SQLite database, I have to keep my SQL compatible with both the MySQL and sqlite engines (usually not a problem, but sometimes it can be).

Solution? I put my database on a RAM disk. I now have full speed unit tests. If I make a model change, I can toss the whole database and reload everything instantly. When I’m running unit tests, I can run them against the same database engine that I use in production.

Current Method (still a bit rough)

Load up your favorite RAM disk software. I don’t have a favorite yet, but so far I’m having good luck with the free one from http://www.romexsoftware.com.

Create yourself a RAM disk, put it on your favorite drive letter (I use R:\). The disk doesn’t have to be large, since there probably won’t be tons of data on it. I only have 2GB of memory on my laptop, so I made a dainty 64MB RAM disk. (Note: if you are running 32-bit windows and have more than 3GB of RAM, you might be able to make your unusable memory into a RAM disk .. there are some details on the site above).

Make yourself a “Create Ramdisk MySQL.cmd” batch file (see below). Edit the necessary variables so they’ll work on your system, then run the file. Since the contents of ram disks are frequently lost (like when you reboot), the setup here needs to be automated. The batch file does 3 things. It creates the needed folders on the ram disk. It copies over your “mysql” database (so your passwords will still work). And it installs a Windows service for the ramdisk mysql (called MySQLR).

Make a copy of your my.ini file called my_ramdisk.ini (or whatever you like). Edit this new file and change the appropriate data directories to R:\mysql_volatile\data and R:\mysql_volatile\innodb.

If you need to have your normal mysql server running, then alter the my_ramdisk.ini so so the server runs on a different port (you will also have to alter the port number in your settings.py). I only use the mysql server on my computer for development, so can just turn it off before starting the ramdisk mysql.

Start up the ram disk mysql. After running the batch file, you’ll have a new service called MySQLR. Use the service control manager gui, or, since you’re going to be on the command line to run your unit tests anyway, just type sc start mysqlr.

And finally, connect to your new mysql server and create a database for your project.

Listing: “Create Ramdisk MySQL.cmd”

SETLOCAL

rem install a service for the ramdisk mysql
%mysqld% --install MySQLR --defaults-file=%config%


Notes:
Remove the MySQLR service by running mysqld-nt.exe --remove MySQLR.

You might want to alter the batch file to copy the django application’s database to the ramdisk as well (saves you having to run that step manually).

Unit tests with the RAM disk MySQL is around 30 times faster than normal MySQL, and only about a second and a half slower than using the SQLite backend.

The JavaHL native client for Subclipse adapter was blowing up the JVM. In retrospect, I should have figured this out earlier, since the JVM doesn’t really crash that often. Because the JavaHL is calling into the svn shared lib’s on my machine, it has the possibility to crash.

The workaround is pretty simple: uninstall the JavaHL client adapter and install the SVNKit client adapter. The SVNKit adapter is pure java code, so it doesn’t call into the libraries directly. Any bugs that may exist in SVNKit will just throw java exceptions instead of killing the JVM.