1. Uncomment LoadModule php5_module in /etc/apache2/httpd.conf
2. Start up Web Sharing in System Preferences

However, even after doing that, my PHP-based website still couldn’t connect to it’s MySQL database. It just showed this error when I tried to load the site:

Database Error: Unable to connect to the Database: Could not connect to MySQL.

All of the database settings in my app (a Joomla website) were correct, but still I couldn’t get it to work.

It turns out that the problem is due to conflicting socket locations between OS X and other types of UNIX. In my case PHP was configured to access MySQL (locally) at /var/mysql/mysql.sock whereas the socket was really at /tmp/mysql.sock. Changing this in the PHP config fixed the problem

Solution

Create a custom PHP settings file:

sudo cp /etc/php.ini.default /etc/php.ini

then edit the default_socket definition for your database driver to point to the correct socket.In my case the driver is the default MySQL driver and the correct socket is /tmp/mysql.sock, so it changed from this:

; Default socket name for local MySQL connects. If empty, uses the built-in
; MySQL defaults.
; http://php.net/mysql.default-socket
mysql.default_socket = /var/mysql/mysql.sock

to this:

; Default socket name for local MySQL connects. If empty, uses the built-in
; MySQL defaults.
; http://php.net/mysql.default-socket
mysql.default_socket = /tmp/mysql.sock

It’s important to note that there will be several definitions of default_socket for different drivers (each of which has a different prefix for it’s settings) so it’s important that you change the correct one, based on what your app is using.

After doing this restart Web Sharing (in System Preferences) and everything should work

Using the getURL() function you can download any file by it’s URL. What makes this even more useful is that you can give it a vector of URLs, and it will download them in parallel (by performing asynchronous downloads), and returning the results in a vector of the same length as the original.

But what if the file to be downloaded is large, but you’re only interested in a small part of it? That’s where gatherers come in. If you provide a gatherer (S3-style) object to the write parameter of the getURL() function, this object will be called whenever data is downloaded from one of the input URLs. That’s a great feature, but unfortunately it’s not well documented.

Solution

1. Gatherer Objects

Below is a constructor for a very simple gatherer that just returns a string of the contents of the downloaded file. This could be adapted to do more complex things.

SimpleGatherer <- function(txt=character()){
  # SimpleGatherer is a constructor function that returns a new
  # gatherer object. txt is the variable that stores the contents of the
  # downloaded file
  #
  # This code is heavily based on basicTextGatherer() from RCurl

  reset <- function(){
    # reset() is called when the gatherer is first created. It initialises txt
    txt <<- character()
  }
  update <- function(str){
    # update() is called whenever new data is downloaded. Here it appends it
    # to txt
    txt <<- paste(txt, str, sep="")
  }
  value <- function(){
    # value() is called when we want the result
    return(txt)
  }

  # gatherer is the new gatherer object that we want to return
  gatherer <- list(reset=reset, update=update, value=value)
  class(gatherer) <- c("RCurlTextHandler", "RCurlCallbackFunction")
  gatherer$reset()

  return(gatherer)
}

Then call getURL() with the write argument set to an instance of your new gatherer object, eg:

getURL("http://missingreadme.wordpress.com/", write=SimpleGatherer())

2. Asynchronous Gatherer Objects

In order to use a custom gatherer for parallel/asynchronous downloads, you must create a custom gatherer object containing one gatherer object for each of your URLS, like this:

SimpleAsyncGatherer <- function(n){
  # n is the number of URLs you're downloading
  gatherer <- lapply(1:n, SimpleGatherer)
  class(gatherer) <- "MultiTextGatherer"
  return(gatherer)
}

Note that if you don’t specify a custom gatherer using write, getURL automatically creates an asynchronous gatherer for you using the default gatherer object (basicTextGatherer()).

Use this gatherer as you would before, but with multiple URLs.

getURL(rep("http://missingreadme.wordpress.com/", 5), write=SimpleAsyncGatherer(5))

> ls
function (name, pos = -1, envir = as.environment(pos), all.names = FALSE,
    pattern)
{
    if (!missing(name)) {
        nameValue <- try(name)
        if (identical(class(nameValue), "try-error")) {
            name <- substitute(name)
            if (!is.character(name))
                name <- deparse(name)
            pos <- name
        }
        else pos <- nameValue
    }
    all.names <- .Internal(ls(envir, all.names))
    if (!missing(pattern)) {
        if ((ll <- length(grep("[", pattern, fixed = TRUE))) &&
            ll != length(grep("]", pattern, fixed = TRUE))) {
            if (pattern == "[") {
                pattern <- "\\["
                warning("replaced regular expression pattern '[' by  '\\\\['")
            }
            else if (length(grep("[^\\\\]\\[<-", pattern))) {
                pattern <- sub("\\[<-", "\\\\\\[<-", pattern)
                warning("replaced '[<-' by '\\\\[<-' in regular expression pattern")
            }
        }
        grep(pattern, all.names, value = TRUE)
    }
    else all.names
}

and the code for that method will be printed on the screen.

However, if you try the same thing on an S4 method (the newer, object-oriented style) then you get something more obtuse:

> # load the package I'm currently using (from bioconductor)
> library("Rsamtools")
Loading required package: IRanges

Attaching package: 'IRanges'

The following object(s) are masked from 'package:base':

    cbind, Map, mapply, order, paste, pmax, pmax.int, pmin, pmin.int, rbind, rep.int, table

Loading required package: GenomicRanges
Loading required package: Biostrings
> readPileup
standardGeneric for "readPileup" defined from package "Rsamtools"

function (file, ...)
standardGeneric("readPileup")

Methods may be defined for arguments: file
Use  showMethods("readPileup")  for currently available ones.

However, this makes sense if you consider how S4 works. Because it allows method overloading, there could be multiple method definitions depending on the parameters given to the method at runtime (it’s signature). So to get correct method definition, you need to specify the signature as well.

Solution

Use showMethod to show all of method signatures that are defined for the method in question, and getMethod to retrieve the code for a particular method and signature:

> showMethods("readPileup")
Function: readPileup (package Rsamtools)
file="character"
file="connection"

Here we can see that for readPileup there are two method definitions, one with signature "character" and one with signature "connection". Then if you call getMethod for one of these signatures you will be able to see the code:

> getMethod("readPileup", "connection")
Method Definition:

function (file, ...)
{
    .local <- function (file, ..., variant = c("SNP", "indel",
        "all"))
    {
        variant <- match.arg(variant)
        switch(variant, SNP = , all = .readPileup_SNP(file = file,
            ..., variant = variant), indel = .readPileup_indel(file = file,
            ...))
    }
    .local(file, ...)
}

Signatures:
        file
target  "connection"
defined "connection"

Note that if showMethods displays “inherited from” below a particular signature, then this isn’t a full method definition, but is just inherited from the definition for another signature (and you should call getMethod on that signature instead).

rnafuncs.cpp:341: error: ‘sprintf’ was not declared in this scope
rnafuncs.cpp:361: error: ‘sprintf’ was not declared in this scope

rnafuncs.cpp:582: error: ‘sprintf’ was not declared in this scope
rnafuncs.cpp:588: error: ‘sprintf’ was not declared in this scope

I thought that looked a bit odd (how could a standard function like sprintf not be declared?) but after a little googling I found this page (in Japanese – I suggest using Google translate if you can’t read Japanese), where the author points out that the source file in question does not include stdio.h which defines sprintf. After editing rnafuncs.cpp to include including stdio.h everything compiled without any errors (although there were still a few minor warnings).

Solution

Inside the Vienna RNA Package source folder (for me this is ViennaRNA-1.8.4), open RNAforester/src/rnafuncs.cpp and add #include <stdio.h> on line 9, so that it looks like this:

#include
#include
#include
#include
#include
#include
#include
#include 

#ifndef WIN32
#include "config.h"
#endif

After saving, it should compile and install without errors.

Note

If you want to use RNAForester you will also need to install the g2 graphics package (as explained in INSTALL). In Ubuntu this package is called libg20, and you can install it using Synaptic.

Solution

Submodules are always headless when they are comitted: you are only committing a tag, not the code that is in the submodule folder.

There are two scenarios for updating a submodule (in all of the following, I assume that you have already initialised and updated your submodule):

• You want to update the submodule locally and push the update to the repository:
  1. Change your submodule from a headless branch (the state that it will be in after running git submodule update) onto a working branch (eg. origin/master), using git checkout
  2. Update the submodule using git pull from inside the submodule’s directory
  3. Change to the parent directory of the submodule and add the submodule directory to the staging area using git add
  4. Commit using git commit
  5. If you’re using a remote repository, now use git push

  Note that this will commit the submodule tag that was pushed most recently, not the code that’s actually in the submodule directory, therefore any code in the submodule that was not pushed will be lost (as explained in Pro Git)

• Someone else updates the submodule and you want to pull the change from the repository:
  1. Use git submodule update to pull the changes from the repository. This will overwrite your local version of the submodule with a headless branch (if you’d like to now edit it, use the procedure above).

It’s also worth remembering that the submodule directory acts like a git repo in it’s own right, so changes made and commands run inside that directory will affect the submodule whereas changes and commands used outside will affect the parent project instead.

mid = (low + high) / 2

but this will overflow if both low and high are very large. You can read the full article here.

I guess the take-home point here is to bear overflows in mind when performing integer arithmetic, especially in core areas of code where your data structures could potentially grow to an enormous size in the future (after all, “640K ought to be enough for anybody”).

Solution

Rather than calculating the average of the low and high bounds, calculate the difference between the two and use that to find the pivot:

mid = low + ((high - low) / 2)

(This is the most language neutral way of calculating it, although Josh does offer more efficient versions for languages with bit-shifting)

Thanks go to Tech Tips Tricks for showing me how to do this (note that Tech Tip Tricks suggests also deleting a user preference file, but this file doesn’t exist on any system that I’ve tried this on)

Solution

Delete this file:

/Applications/Microsoft Office 2008/Office/OfficePID.plist

then when you next start office it will ask for your new license key.

Solution

Write a module similar to the following, the include it from your models in order to gain access to the association.

module AssociationModule
  def self.included(base)
    base.has_many :things, :class_name => "#{base.name}Thing"
  end
end

I just had an interesting coding problem where I needed to have a quick recursive function in Ruby on Rails and I didn’t want to move it into it’s own method. A lambda or proc would have been perfect but it needed to be recursive (and “how can you self-reference a lambda” I thought?). Well it turns out it’s not that hard. It seems that variables defined outside of a lambda are still in-scope inside of the lambda.

I learned how to do this from Josh Susser, who has a Ruby on Rails specific example.

Solution

Here is a simple example to calculate factorials using a lambda:

factorial = lambda do |n|
  n <= 1 ? 1 : (n * factorial.call(n - 1))
end

.

After struggling with using Samba for filesharing on our mac-only network (the final straw was file permissions that just wouldn’t work for everyone), I finally gave up and decided to try using AFP instead. I’d looked at it before, but it didn’t look easy to set up or production ready, but things have changed and I didn’t find it hard at all and it’s now working far better than Samba ever did.

There are two components to natural looking AFP:

1. AFP (obviously)
2. Zeroconf

(Zeroconf is the unbranded name for Bonjour, and is necessary to advertise your AFP volume over the network) In the case of Ubuntu these are provided by Netatalk and Avahi respectively, and as neither come by default on Ubuntu we have to install and configure both (but it’s not as hard as it sounds).

Solution

1. Netatalk

Since Ubuntu 9.04 Netatalk has worked “out-of-the-box”, so all you need to do is install it (and tweak the settings slightly). Run the following command to install it:

sudo apt-get install netatalk

The next step is optional, but it should make your AFP server a little quicker. By default Netatalk turns on support for filesharing with pre-OS X Macs, but this is normally redundant. To turn it off, open /etc/default/netatalk and change the matching part of the file to:

ATALKD_RUN=no
PAPD_RUN=no
CNID_METAD_RUN=yes
AFPD_RUN=yes
TIMELORD_RUN=no
A2BOOT_RUN=no

The final step is to tell Netatalk which directories it should share. By default it will only share users home directories, but to share any other folders (such as shared folders), open /etc/netatalk/AppleVolumes.default and add the following to the bottom (for each directory that you wish to share):

/your/path  VolumeName allow:@groupname options:usedots,upriv

There are a number of options that you can set here, for the full description see this page.

Now if you restart AFP:

sudo /etc/init.d/netatalk restart

it should be working, although you can only connect using the IP address of your Ubuntu machine. I’d recommend testing that it works at this point by opening Finder and selecting Go -> Connect To Server, then entering “afp:://yourip/”, logging in with an Ubuntu user account and making sure that it works.

2. Avahi

To install Avahi (and mDNS which helps it imitate Bonjour), run the following command:

sudo apt-get install avahi-daemon libnss-mdns

Then open /etc/nsswitch.conf and add “mdns” to the end of the following line so that it looks like this:

hosts: files mdns4_minimal [NOTFOUND=return] dns mdns4 mdns

Finally we need to configure Avahi to advertise the AFP service. To do this, create a new file at /etc/avahi/services/afpd.service, and enter the following into it:

<?xml version="1.0" standalone='no'?><!--*-nxml-*-->
<!DOCTYPE service-group SYSTEM "avahi-service.dtd">
<service-group>
    <name replace-wildcards="yes">%h</name>
    <service>
        <type>_afpovertcp._tcp</type>
        <port>548</port>
    </service>
    <service>
        <type>_device-info._tcp</type>
        <port>0</port>
        <txt-record>model=MacPro</txt-record>
    </service>
</service-group>

The first service tag advertises AFP (which uses port 548 by default). The second service tag tells OS X what icon to use for your Ubuntu machine in finder, you can set this to: Macmini, iMac, MacPro, Xserve, MacBook, MacBookPro or MacBookAir as appropriate.

Now if you restart Avahi using this command:

sudo /etc/init.d/avahi-daemon restart

your AFP volume should appear on any Mac on the network.

Note

Netatalk 2 doesn’t handle symbolic links how you’d expect (at best the contents of a symlink might be inaccessible). This is a design feature, not a bug, and the Netatalk team recommend avoiding their use in shared volumes.