diff --git a/backend/Grid.hs b/backend/Grid.hs
index aaf4149..0dd6cde 100644
--- a/backend/Grid.hs
+++ b/backend/Grid.hs
@@ -4,21 +4,15 @@ module Grid where
 import Data.HashSet (HashSet)
 import qualified Data.HashSet as HS
 
-import Control.Applicative
-
-import Data.Maybe
 import Data.List
 import Data.Ord
 
 import Control.Monad
 import Control.Monad.Random
-import Control.Monad.Random.Class
 
 import Data.Text.Lazy (Text)
 import qualified Data.Text.Lazy as T
-import qualified Data.Text.Lazy.IO as T
 
-import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HM
 
 import Data.Map (Map)
@@ -81,7 +75,7 @@ trigramsAround' t g x =
 
 trigramsAround :: Trigrams -> Grid -> Coord -> [(Grid,Int)]
 trigramsAround t g x = sortBy (flip $ comparing snd)
-    [ (g,x) | (g,Just x) <- trigramsAround' t g x]
+    [ (g',x') | (g',Just x') <- trigramsAround' t g x ]
 
 -- Fails if there is no trigrams around this coordinate,
 pickSomeTrigram :: MonadRandom m => Trigrams -> Grid -> m (Maybe Grid)
@@ -93,7 +87,7 @@ pickSomeTrigram t g = do
         grids -> do
             k <- getRandomR (2000,20000)
             u <- getRandomR (5,20)
-            let grids' = filter (\(g,v) -> v > k && not (bad g)) grids
+            let grids' = filter (\(g',v) -> v > k && not (bad g')) grids
                 n = length grids' `div` u + 1
             case grids' of
                 [] -> return Nothing
@@ -141,9 +135,6 @@ emptyGrid = replicate 4 "    "
 emptyPos :: Grid -> Coord -> Bool
 emptyPos g x = g `at` x == ' '
 
-neighbour :: Coord -> Coord -> Bool
-neighbour (x,y) (x',y') = max (abs (x - x')) (abs (x + x')) == 1
-
 neighbours :: Coord -> [Coord]
 neighbours (x,y) = filter okCoord $ concat
     [
diff --git a/backend/Main.hs b/backend/Main.hs
index 8d7afca..e70db93 100644
--- a/backend/Main.hs
+++ b/backend/Main.hs
@@ -1,5 +1,4 @@
-{-# LANGUAGE OverloadedStrings, DeriveGeneric, GeneralizedNewtypeDeriving,
-             ViewPatterns, RecordWildCards #-}
+{-# LANGUAGE RecordWildCards #-}
 module Main where
 
 import Prelude hiding (words)
@@ -8,34 +7,19 @@ import Data.Monoid (mconcat)
 import Control.Monad.IO.Class (liftIO)
 
 import Control.Applicative hiding ((<|>))
-import Control.Monad.Random
-import Control.Monad.Random.Class
 import Control.Monad
 import Control.Concurrent.STM
 
 import Network.Wai.Middleware.RequestLogger (logStdout)
 import Network.Wai.Middleware.Static
-import Web.Scotty
+import Web.Scotty hiding (next)
 
 import Data.Aeson hiding (json)
-import GHC.Generics
-
-import Data.Maybe
 
 import Network.WebSockets as WS
--- import Network
 
 import Data.Map (Map)
 import qualified Data.Map as M
-import Data.HashMap.Strict (HashMap)
-import qualified Data.HashMap.Strict as HM
-import Data.HashSet (HashSet)
-import qualified Data.HashSet as HS
-
-import Data.Text.Lazy (Text)
-import qualified Data.Text.Lazy as T
-import qualified Data.Text.Lazy.IO as T
-import qualified Data.Text.Lazy.Read as T
 
 import Control.Concurrent
 import Data.Time.Clock
@@ -113,7 +97,7 @@ main = do
                                 let (mod_score,mod_history)
                                         | ok        = ((+ value),((word_text,value):))
                                         | otherwise = (id,id)
-                                userMod name mod_score mod_history db
+                                void $ userMod name mod_score mod_history db
                                 return ok
                             return Response
                                 { correct = ok
@@ -137,7 +121,7 @@ main = do
             (mg,users) <- atomically $ liftM2 (,) grid_var (readTVar db)
             timeout <- calc_next_change
             case mg of
-                Just grid -> do
+                Just{} -> do
                     let scores =
                             [ (u,user_score,user_words)
                             | (u,User{..}) <- M.toList users
@@ -165,7 +149,7 @@ main = do
             print $ "ms to next change: " ++ show ms
             return ms
 
-    forkIO $ forever $ do
+    void $ forkIO $ forever $ do
         p <- atomically play_mode
         let delay = if p then play_length else score_length
         t0 <- getCurrentTime
@@ -197,7 +181,7 @@ main = do
                 (`withJust` sendToAll) =<< makeGridMsg
 
     -- Web server
-    forkIO $ scotty 3000 $ do
+    void $ forkIO $ scotty 3000 $ do
 
         middleware logStdout
         middleware $ staticPolicy $ mconcat
diff --git a/backend/Server.hs b/backend/Server.hs
deleted file mode 100644
index e29551d..0000000
--- a/backend/Server.hs
+++ /dev/null
@@ -1,83 +0,0 @@
-{-# LANGUAGE ScopedTypeVariables, OverloadedStrings, DeriveGeneric, RecordWildCards #-}
-module Main where
-
-import ClientProtocol
-import ServerProtocol
-
-import Data.Aeson
-
-import Control.Exception as E
-
-import System.IO (Handle,hClose)
-
-import Network.WebSockets as WS
-import Network
-
-import Control.Concurrent.STM
-
-import Data.Text (Text)
-import qualified Data.Text as T
-import qualified Data.Text.IO as T
-
-import Control.Monad
-import Control.Monad.IO.Class (liftIO)
-import Control.Concurrent (forkIO)
-
-import Network.Wai.Middleware.RequestLogger (logStdout)
-import Network.Wai.Middleware.Static
-import Web.Scotty hiding (json)
-
-import Data.Map (Map)
-import qualified Data.Map as M
-
-import Data.Monoid
-
-main :: IO ()
-main = do
-    users <- newTVarIO M.empty
-    forkIO $ scotty 3000 $ do
-        middleware $ staticPolicy $ mconcat
-            [ noDots
-            , foldr1 (<|>) (map hasSuffix
-                ["html", "js", "css", "jpg", "txt"])
-            ] <|> only (zip ["","/"] (repeat "index.html"))
-    runServer "0.0.0.0" 8000 (app users)
-
-receiveJSON :: FromJSON a => WebSockets Hybi10 (Maybe a)
-receiveJSON = fmap decode WS.receiveData
-
-sendJSON :: ToJSON a => Sink Hybi10 -> a -> IO ()
-sendJSON s = WS.sendSink s . DataMessage . Text . encode
-
-app :: TVar (Map String (Sink Hybi10)) -> Request -> WebSockets Hybi10 ()
-app users rq = do
-    WS.acceptRequest rq
-    WS.spawnPingThread 1
-    liftIO . putStrLn . ("Client version: " ++) =<< WS.getVersion
-    sink <- WS.getSink
-    login sink `catchWsError` handleErr sink
-  where
-    login sink = forever $ do
-        msg <- receiveJSON
-        case msg of
-            Just Connect{..} -> do
-                liftIO . atomically $ modifyTVar users (M.insert username sink)
-                liftIO $ sendJSON sink (Connected username)
-                listen username
-            _ -> return ()
-
-    listen username = forever $ do
-        msg <- receiveJSON
-        case msg of
-            Just Send{..} -> do
-                users' <- liftIO . atomically $ readTVar users
-                forM_ (M.elems users') $ \ sink' ->
-                    liftIO (sendJSON sink' (Broadcast username message))
-                        `catchWsError` handleErr sink'
-            _ -> return ()
-
-    handleErr sink e = liftIO $ do
-        putStrLn $ "Got an error: " ++ show e
-        atomically $ modifyTVar users (M.filter (/= sink))
-
-
diff --git a/russell.cabal b/russell.cabal
index 56ed8df..7338be3 100644
--- a/russell.cabal
+++ b/russell.cabal
@@ -11,7 +11,7 @@ cabal-version:       >=1.8
 
 executable russell
   main-is:           Main.hs
-  ghc-options:       -threaded -O2
+  ghc-options:       -threaded -O2 -Wall
   hs-source-dirs:    backend
   build-depends:
         base >=4.5