What software is available that will let me control a camera from a computer, so I can shoot a lime lapse sequence?

The camera is a Nikon D60. I am looking for freely available software.

I am aware of the DIYPhotobits.com Camera Control software, which I have used once. The problem with this program was that I was shooting a time lapse during sunset. Because of the auto-adjustment, the shutter speed went up to 8 seconds after it got dark. This pushed up the time difference between frames from 10 seconds in the start to 18 seconds in the end. In the result video everything seems to speed up in the end. I am looking for software that allows compensating for this.

In baseball, a player can replaced by any other player who hasn't yet appeared in the game. Can this replacement be made after a player has started batting and is still at the plate?

AS a SharePoint developer, how common is it to use and work with windows communication foundation? What context? Any real based example?

My daughter and I were playing softball and on the next field were a bunch of guys playing cricket. She asked me Why is Cricket called Cricket? I had no idea and figured this was a good place to find out.

  1. t
    Once I've heard a teacher saying never to pronounce the letter "T" with the sound "T", start with the sound "D" [in English]. So she said we should say [di], but not [ti].
    But when I listen to the books, I've heard the French people start with "T", so I wonder, who is right?

  2. p
    The same as above. Which sound should I start with? Sound "P" or sound "B"?

I have a 1998 Chevrolet Cavalier, and in the winter it becomes very hard to turn the key in the locks in the car door. I've literally ripped the rubber off the key's grip from forcing the key to turn.

How can I keep the locks on my car from sticking?

I did this project last year, under some interesting constraints: it's a thin webserver which lives in a Raspberry Pi, which is networked to an embedded system in an industrial sign which is running a proprietary and heavily modified version of *nix. I didn't touch the embedded system in the sign at all.

The whole thing is a kinetic sculpture, installed in a private residence.

Because of some of the project constraints (i.e., we were working in someone's house) I wasn't as aggressive refactoring as I would otherwise have been. There are also no tests. Bad, I know, but it was a situation where the complexity of the project was almost certainly not going to grown in any dramatic way beyond its current level.

Here is the code for the Tornado server. A sanitized fork of the entire repo is here.

The stack is Python/Tornado, HTML, JS and SASS.

""" theSculpture server.

    Launch the server with 'python sculptureController.py' Currently the server defaults to port
    8888. The server provides an interface to the theSculpture,
    allowing the sculpture's mode to be changed.

    Front end and back end code by Liav Koren 2013 - 2014. """

    import tornado.httpserver
    import tornado.ioloop
    import tornado.options
    import tornado.web
    import tornado.auth
    import tornado.escape
    import os
    from tornado.options import define, options
    import tornado.httputil
    import time
    import paramiko
    import subprocess
    import json

    define("port", default=8888, help="run on the given port", type=int)

    class ModeHandler(tornado.web.RequestHandler):
        ''' Handler for the main interface. This serves up the mode selector page. '''

        ssh = ""

        def get(self):
            self.render('modes.html', current_mode='TESTING')

        def post(self):
            """ Mode handler. The mode selector page presents 'slow', 'medium', 'fast',
            'return to landing page' and 'logout' options to user. This handler is also
            the endpoint for the main page options 'ON' and 'OFF'. Slow, medium, fast, on
            and off all initiate a series of remote operations on theSculpture that involve
            opening an SSH tunnel, triggering various shell scripts and transfering files
            between the Pi and theSculpture. """

            path = ""
            data = self.request.arguments

            if 'slow' in data or 'slow-swatch' in data:
                path = '/home/pi/theSculpture/dat/slower1.dat'
            if 'medium' in data or 'medium-swatch' in data:
                path = '/home/pi/theSculpture/dat/med.dat'
            if 'fast' in data  or 'fast-swatch' in data:
                path = '/home/pi/theSculpture/dat/AGH4.dat'
            if 'on' in data or 'on-swatch' in data:
                self.write(json.dumps({"file_transfer": "finished"}))
            if 'off' in data or 'off-swatch' in data:
                self.write(json.dumps({"file_transfer": "finished"}))

            if path:

        def file_transfer_mock(self, path):
            """ A debugging utility method for accepting commands but not
            passing them on to theSculpture. """
            new_path = "new path is: %s" % path
            print new_path
            self.write(json.dumps({"file_transfer": "finished"}))

        def kill_theSculpture(self):
            """ Turns theSculpture off. """
            cmd = "cd /bin; ./kill_theSculpture.sh"

        def reset_theSculpture(self):
            """ Restarts theSculpture from an off or currently running state. """

        def file_transfer(self, path):
            """ This function deals with resetting theSculpture and
            transferring the new dat files. """
            print "waiting 30s"
            print "starting scp"
            proc = subprocess.Popen(['scp', path,
                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            print "stdOut: %s " % proc.stdout.readline()
            print "stdErr: %s" % proc.stderr.readline()
            self.write(json.dumps({"file_transfer": "finished"}))

        def talk_to_sign(self, cmd):
            ''' Talk_to_sign calls open_ssh to get an ssh client object, then emits
            commands to the target system.'''
            if not self.ssh:
                self.ssh = self.open_ssh_tunnel('***.**.57.230', 'root', 'foobar')
            stdin, stdout, stderr = self.ssh.exec_command(cmd)
            if stderr.readlines():
                print "Error: %s" % stderr.readlines()
            if stdout.readlines():
                print "Cmd returned: %s" % stdout.readlines()

        def get_current_sign_status(self): # ToDo: narrow the exception handling
            ''' Tries to get the current state of the sign and return it to the
            client. '''
            if not self.ssh:
                self.ssh = self.open_ssh_tunnel('***.***.1.105', 'pi', 'foobar')
            stdin, stdout, stderr = self.ssh.exec_command('cat test')
            if stderr.readlines():
                print "Error reading current sign state."
            output = stdout.readlines()
            if output:
                print "current sign state is: "
                print output[0][:-1]
                return output[0][:-1]

        def open_ssh_tunnel(self, ip, username, passwd):
            ''' Provides a ssh client to the talk_to_sign method '''
                s = paramiko.SSHClient()
                s.connect(ip, username = username, password = passwd)
                return s
            except paramiko.AuthenticationException:
                    {"status": "Failed to login to sign server successfully."}))
            except paramiko.ChannelException:
                    {"status": "Error opening channel to sign server."}))
            except paramiko.SSHException:
                    {"status": "SSH error when trying to contact sign server."}))

    class MainHandler(ModeHandler):
        """ The landing page once the user has logged in. """

        def get(self):

    def main():
        settings = dict(
            template_path=os.path.join(os.path.dirname(__file__), "static"),
            static_path=os.path.join(os.path.dirname(__file__), "static"),
        application = tornado.web.Application([
            (r"/mode", ModeHandler),
            (r"/", MainHandler),
            (r"/main", MainHandler),
        ], **settings)
        http_server = tornado.httpserver.HTTPServer(application)

    if __name__ == "__main__":

I'm designing a program which makes queries to a database stored locally which could potentially contain a lot of sensitive information. As such the information must be kept secure as possible from any possible attack. I plan on doing this by encrypting the data by AES-256 in CBC mode. The encryption / decryption key will be kept secure.

My question is, using this scheme, how should the database be encrypted to ensure the data is kept secure against attacks? Originally I planned on encrypting the database cell by cell (with each row having 10 or so columns) and storing a unique, randomly generated IV for each row.

However, to my understanding of the generated stream this could cause problems as I would be using the same key + IV combination to encrypt / decrypt all the cells of this row. This would allow an attacker to potentially compute the XOR of two cells and reveal enough information where they could decrypt the entire row (two-time pad). I know this is more of a problem in CTR mode but I have read that it could also be a problem in CBC if two of the cells began with the same sequence of bytes. Please correct me if I misunderstand the concept of this type of attack as I am still a little unsure of its exact mechanism.

Encrypting the entire database itself is not very pretty and obviously will cause performance issues if the database is large enough. Therefore, the only other method I could think of is having EACH CELL have a unique, random IV which on the surface seems like a lot of extra data to have to store but I will go this route if need be.

Just as a side note; this program isn't being implemented anywhere in which security will be an issue. It is more of a side project for myself to learn the intricacies of cryptography and ways of defending against attacks. Thank you for all your help in advance!

For some spells, like Darkvision, no one else can cast permanency on you to make the effect last until dispelled*. So for non-caster's there's no way to permanently get that... unless you can find a way to use someone else's caster level while casting a spell, such as when reading a scroll.

*Permanency makes the duration of certain other spells permanent. You first cast the desired spell and then follow it with the permanency spell.

Depending on the spell, you must be of a minimum caster level and must expend a specific gp value of diamond dust as a material component.

You can make the following spells permanent in regard to yourself. You cannot cast these spells on other creatures. This application of permanency can be dispelled only by a caster of higher level than you were when you cast the spell.

Can there be a scroll of permanency? - Yes, according to Ernir, but the cost (both for CL and diamond dust) would depend on what you intend to make permanent with it, thus it would be a very specific item.

However, once you get it: When using UMD to successfully cast it, while under the influence of a spell that's to be made permanent, will that work?

When playing Puzzle Strike online, my friends and I encountered a sort of "Sudden Death" mode that activated after many turns of a particularly slow game, resulting in 2-Gems being anted each turn instead of 1-Gems. We could not figure out exactly what the trigger of this was - likely some specific number of turns - or whether or not this rule was supposed to be used in the physical version. I do not believe the rule exists in the Version 1 Rulebook. What is the trigger of this Sudden Death mode that increases the ante, and is it universal to all versions of the game?