This one came across the news wire today. I just wanted to make a note of it so that I don’t loose it.
There’s plenty in here that will allow you to take any site from 0 to hero.
http://ivanzuzak.info/2012/11/18/the-web-engineers-online-toolbox.html
Didn’t want to lose this bookmark, so thought I’d pop it here for later.
I would expect that you’ll see some posts about this topic shortly.
It’s a morbid title, I agree but it is quite important. Unix daemons really need to listen to the messages (read as: signals) being sent to them and responding correctly. At the very least, if every daemon implemented the following it’d be a breath of fresh air:
/** Responds to signals of interest */
void daemon_signalhandler(int sig) {
switch (sig) {
case SIGHUP:
/* this should just refresh configs and restart */
break;
case SIGTERM:
/* mark the server as no longer running */
break;
}
} This block of code by itself is pretty useless. The other half of the equation is attaching this function to the signals of interest as well as ignoring signals we’re not interested in (or that we’re not interested in those signals turning our daemon to toast).
/* attach the signal handlers now */
signal(SIGCHLD, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGHUP, daemon_signalhandler);
signal(SIGTERM, daemon_signalhandler); Well, that’s it really and remember - die well.
Breakout the pop-corn, it’s movie time.
http://techchannel.att.com/play-video.cfm/2012/2/22/AT&T-Archives-The-UNIX-System
I need to crawl before I can walk, so a lot of “toy code” is being written using Haskell. It’s taken me a while to get to this point, but I now have cards being shuffled to players:
module Cards where
import System.Random
import Data.Maybe
import Data.List
import Data.Function
import Test.HUnit
import Test.QuickCheck
-- | Card values for uno cards
data CardValue = Naught | One | Two | Three
| Four | Five | Six | Seven | Eight | Nine
| Skip | Reverse | DrawTwo | Wild | WildDrawFour
deriving (Show, Eq, Enum)
-- | Possible card colours
data CardColour = Red | Blue | Green | Yellow
deriving (Show, Eq, Enum)
-- | Defines the attributes of a card
data Card = Card CardValue (Maybe CardColour)
deriving (Show)
-- | Seeds a list of cards with a random value
seedCards :: StdGen -> [Card] -> [(Card, Int)]
seedCards g [] = []
seedCards g (c:cs) = x:seedCards ng cs
where (seed, ng) = randomR(1, 10000) g :: (Int, StdGen)
x = (c, seed)
-- | Makes a randomly shuffled deck of cards
makeShuffledDeck :: StdGen -> [Card]
makeShuffledDeck g = [x | c <- sorted, let x = fst c]
where cards = seedCards g deck
sorted = sortBy (compare `on` snd) cards
deck = val ++ take 10 (cycle spec)
val = [Card v (Just c) | v <- [Naught .. DrawTwo], c <- [Red .. Yellow]]
spec = [Card v Nothing | v <- [Wild .. WildDrawFour]]
tests = TestList $ map TestCase
[assertEqual "add tests here" 1 1]
prop_empty c1 = (c1::Int) == c1
runTests = do
runTestTT tests
quickCheck prop_empty
-- | Main entry point
main :: IO ()
main = runTestsThere is a lot more to do before this becomes of use. The real think work being conducted here is really between seedCards and makeShuffledDeck. These two functions alone provide randomization to the ordered deck so it can be shuffled.
I hope to post some more on this topic, but I’d like to have a fully functional (or close to) application before I do so.