Stored Javascripts in MongoDB

Introduction

Coming from a relational database background, technologies such as stored procedures and user defined functions have always helped out when building a database infrastructure. MongoDB provides the same sort of code storage in stored javascripts in the database.

Creating a stored javascript

Creating a stored javascript into a database is a straight forward process of adding an item to the system.js collection.

> db.collection.js.save({_id: "greaterThan10", 
...                      value: function (x) { return x > 10 }});

Ok, this isn’t the most useful of functions. We’re testing if the value passed in the greater than 10. We’re able to use this in queries of our own using $where syntax like so:

> db.people.find({$where: "greaterThan10(this.age)"})

This would get all of the “people” documents out of the database where they were over the age of 10. This is quite verbose of such a simple example, but you can see that by filling out the function in the saved javascript with more complex operations, you could achieve a lot with a little.

Removing a stored javascript

Working with the collection as usual, you can simply remove your stored javascript by id.

> db.collection.js.remove({_id: "greaterThan10"})

Testing

As a final note, once you’ve created your stored javascript you can test it using eval easy enough.

> db.eval("return greaterThan10(9);")
false
> db.eval("return greaterThan10(11);")
true

This is just a short introduction into the world of stored javascripts. The internal workings of MongoDB is all based on javascript, so it’s a good idea to have your skills nice and sharp before going in!

64bit ABI Cheatsheet

Introduction

Using a few different articles around the web, I thought it might be a good idea to aggregate all of the information around calling conventions in 64bit land. This could come in handy when wanting to write a cross OS compliant library at the assembly level. This particular article will directly target the assembly programming layer so that topics like C++ name mangling and caller clean-up are removed from its scope.

References

• x86 calling conventions
• x86-64.org documentation
• Mac OSX 64 bit Assembly System Calls

Microsoft

Windows will use RCX, RDX, R8 and R9 for the first four integer or pointer arguments. XMM0, XMM1, XMM2 and XMM3 are used for floating point arguments. Additional arguments are passed via the stack (right to left).

An integer or pointer return value will be returned in RAX. Floating point return will be in XMM0.

System V

System V operating systems will use RDI, RSI, RDX, RCX, R8 and R9. XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6 and XMM7 will be used to pass floating point parameters. RAX will hold the syscall number. Additional arguments are passed via the stack (right to left).

Return values are sent back via RAX.

Syscall Numbers

It’s interesting to note the structure of the syscall number when it comes time to execute. Looking at syscall_sw.h, you’ll see that apple machines want a 2 in the higher-order double word such that the write syscall, normally passed as 0x04 would be passed as 0x2000004 in OSX.

That’s it for today. Just a cheat sheet really.

Entering Unicode Characters in VIM

Introduction

Just a quick tip sheet on how to enter unicode characters into a text page when using vim. From time to time I’ve needed characters listed up here just to give my applications that little extra touch.

Entering characters by code

In all of these examples, the n’s are the code and ^V means Control-V.

That’s it!

Working with Audio in Haskell (Part 1)

Introduction

Digital signal processing, audio processing and the like are all rather complex topics of study. I have a personal interest in these fields as I try to create guitar processing effects from time to time. Today’s post is all about taking the first steps in getting our hands on some audio and associated information from within Haskell.

hsndfile

For today’s post, I’ll be using the library hsndfile to do all of the heavy lifting as far as opening audio files and interpreting information. The files that we’ll work with will need to be in wave format. The demonstration in this post will simply open an audio file, read some information about the file and then close the file.

Project setup

I’ve created a Haskell project using cabal so that I can manage the hsndfile dependency locally to this application. You may already have this installed globally on your system, but if you follow along here, you should have it installed to your project in not time.

Setup your project as usual:

$ mkdir sndtest
$ cd sndtest
$ touch LICENSE
$ cabal init

Just select all of the defaults when setting up your project (well, that’s what I did, anyway). We need to add hsndfile as a dependency to our project, so we’ll specify this in our sndtest.cabal file. Open it up and make sure that your build-depends reads as follows.

build-depends:         base ==4.5.*,
                       hsndfile ==0.5.3

Of course, you may have some different version of base, but here’s where I was at anyway. Create a new file in your project called Test.hs. We’ll now fill out this file with the code that will open a file, read its information, close the file and then display the information to screen.

module Main where

import Sound.File.Sndfile as SF

main :: IO ()
main = do
  -- open the file that we want to know about
  f <- SF.openFile "test.wav" SF.ReadMode SF.defaultInfo

  -- read the information about the file out
  let info = SF.hInfo f

  -- close the file
  SF.hClose f

  -- display information about the file
  putStrLn $ "format:      " ++ (show $ SF.format info)
  putStrLn $ "sample rate: " ++ (show $ SF.samplerate info)
  putStrLn $ "channels:    " ++ (show $ SF.channels info)
  putStrLn $ "frames:      " ++ (show $ SF.frames info)

This is pretty straight forward. First up, we import Sound.File.SndFile qualified as SF so we know when we’re using something from this import. Dissecting the main function, firstly we open the file using openFile. This function expects the path to the audio file (in this case we’re using “test.wav” which by the way you’ll have to find something), we’re only reading from the file at the moment so we specify ReadMode and finally we have the info parameter which is useful to us when we’re writing a new file (so we can tell it what format to write in, etc), but for reading we just use defaultInfo.

We now read the stream information about the file using hInfo, the result of which will give us back a value of type Info. This info packet tells us the number of frames in the file, the sample rate, number of channels, header and sample format, number of sections and if the file is seekable or not.

Now that we have the information from the stream, we can close it off. We do this with hClose. Now we can interrogate the Info value with a series of print statements. We’ve got a module ready to run, but we need to tell our project that it’s the entry point to run. In the sndtest.cabal file, make sure you set your main-is: attribute like so.

main-is:           Test.hs

Build and Run<

We’ve created our project and finished our code. Let’s build and run the application. The first build is going to take a bit more time as cabal-dev will need to resolve all of the dependencies that it doesn’t yet have. Get this process moving with the following command.

$ cabal-dev install

All going well, you should be able to launch your executable and check out the results:

$ dist/build/sndtest/sndtest
format:      Format {headerFormat = HeaderFormatWav, sampleFormat = SampleForm
atPcm16, endianFormat = EndianFile}
sample rate: 48000
channels:    2
frames:      302712

That’s it for today’s post. Hopefully I’ll get back to this topic soon so I can write some more about audio processing.

Mutable State with IORef

Introduction

Haskell goes to great lengths to control state but one way you can achieve mutable state in Haskell is by use of IORef. IORef gives you the ability to assign a reference to a variable in the IO monad. This at least decorates your code in such a way that it’s obvious to you, the developer and Haskell that there will be side effects. Today’s post, I’ll create a very simple example usage of IORef. We’ll construct a counter that we can increment and decrement.

Declaring our type

import Data.IORef                        
                                         
data Counter = Counter { x :: IORef Int }

First of all, we import Data.IORef to give us access to IORef. We declare our counter data type using record style, the only member of which is the value that counts. It’s an IORef Int to mean it references a variable in the IO monad that will be of type Int. So, it’s not so blatant that you’re dragging the integer value around with you, rather you’re dragging something closer to a pointer to the value or reference. To build one of our types, we need to use newIORef which references our actual value and we wrap it up in our Counter data type.

makeCounter :: Int -> IO Counter        
makeCounter i = do iref <- newIORef i   
                   return (Counter iref)

makeCounter takes in an initial integer that will seed our counter and returns a Counter in the IO monad. Getting our hands on the reference and doing something with it is pretty simple with the use of modifyIORef. Using this information, we can increment our counter with the following function.

incCounter :: Int -> Counter -> IO ()            
incCounter i (Counter c) = do modifyIORef c (+ i)

modifyIORef actually gives us the ability to pass a function to modify the referenced value. Be careful with modifyIORef though. As with a lot of things in Haskell, this is lazy. We’re operating on IO actions here so it’s all “promises to do something” or “will do it later when I need to” type operations, so repeatedly calling this without emitting the value will make these promises pile up. There is a strict and non-lazy evaluated version called modifyIORef'. Finally, when we want to get our hands on the referenced value and do something with it (in our example here, we’ll just present it to screen) we use readIORef. readIORef will take our IORef and just made it a value in the IO monad meaning we can simply use <- to emit the value.

showCounter :: Counter -> IO ()               
showCounter (Counter c) = do c' <- readIORef c
                             print(c')        

This all pretty straight forward. Seeing this Counter run from GHCI is pretty straight forward.

λ> c <- makeCounter 1
λ> showCounter c
1
λ> incCounter 1 c
λ> showCounter c
2

There you have it - mutable state with IORef.