Planet Open Ghana

to processes · gzip 1.3.12 bzip2 1.0.5 LZMA 4.32.0beta3 LZMA SDK 4.43

// This is the trivial plant, which just grows and grows
RULE "Very simple Rule"
GROW BY 1
RULE "Start"
WHEN Length <= 0
GROW BY 1
SET TAG = "Root1"

RULE "Story 1"
WHEN TAG = "Root1"
// No Percentage means 100%
BRANCH ANGLE = 70°, LENGTH = 2, Tag = ""
       ANGLE = -70°, LENGTH = 2, Tag = ""
       ANGLE = 0°, LENGTH = 1, TAG = "Root2"
SET TAG = ""

RULE "Story 2"
WHEN TAG = "Root2"
BRANCH AT 100% ANGLE = 70°, LENGTH = 1.5, Tag = ""
               ANGLE = -70°, LENGTH = 1.5, Tag = ""
               ANGLE = 0°, LENGTH = 1, TAG = "Root3"
SET TAG = ""

RULE "Story 3"
WHEN TAG = "Root3"
BRANCH AT 100% ANGLE = 70°, LENGTH = 1, Tag = ""
               ANGLE = -70°, LENGTH = 1, Tag = ""
               ANGLE = 0°, LENGTH = 1, TAG = "Root4"
SET TAG = ""

RULE "Story 4"
WHEN TAG = "Root4"
BRANCH AT 100% ANGLE = 70°, LENGTH = 0.5, Tag = ""
               ANGLE = -70°, LENGTH = 0.5, Tag = ""
               ANGLE = 0°, LENGTH = 0.5, Tag = "Tip"
SET TAG = ""

RULE "Star"
WHEN TAG = "Tip"
Blossom
data User = User {
	userName :: String,
	uses :: [Computer]
	}
data Computer = Computer {
	computerName :: String,
	owner :: User -- references the Users
	}
data State = State [User] [Computer]

testState = let user = User "Conrad" [computer]
                computer = Computer "Z3" user 
            in State [user] [computer]
data User = User {
	userId :: Int,
	userName :: String,
	uses :: [Int] -- references the Computers
	}
data Computer = Computer {
	computerId :: Int,
	computerName :: String,
	owner :: Int -- references the Users
	}
data State = State [User] [Computer]

testState = State
		[User 0 "Conrad" [1]]
		[Computer 1 "Z3" 0]
let State _ cs = testState in head cs
userId
ExplicitState
ExplicitUser
ExplicitComputer
ImplicitState
ExplicitState
ImplicitState
newtype Id v = Id v deriving (Show, Typeable, Data)
newtype Ref v = Ref Int deriving (Show, Typeable, Data)
data User ref = User {
	userId :: Int,
	uses :: [ref (Computer ref)]
	}
data Computer ref = Computer {
	computerId :: Int,
	owner :: ref (User ref)
	}
data State ref = State [User ref] [Computer ref]
Id
Ref
User Id
User Ref
Ref (User Ref)
(* -> *) -> *
Show
Id
Ref
StandaloneDeriving
deriving instance Show (User Id)
deriving instance Show (User Ref)
deriving instance Show (Computer Id)
deriving instance Show (Computer Ref)
deriving instance Show (State Id)
deriving instance Show (State Ref)
unrefState :: State Ref -> State Id
unrefUserRef :: State Id -> Ref (User Ref) -> Id (User Id)
unrefUserRef (State l _) (Ref i) = Id $ fromJust $
	find (\u@(User i' _) -> i == i') l 
unrefComputerRef :: State Id -> Ref (Computer Ref) -> Id (Computer Id)
unrefComputerRef (State _ l) (Ref i) = Id $ fromJust $
	find (\u@(Computer i' _) -> i == i') l 
unrefState
unrefState :: State Ref -> State Id
unrefState (State us cs) =
	let unrefState = State (map (unrefUser unrefState) us)
	                       (map (unrefComp unrefState) cs)
	in unrefState
  where unrefUser :: State Id -> User Ref -> User Id
        unrefUser s (User i refs) = User i (map (unrefComputerRef s) refs)

	unrefComp :: State Id -> Computer Ref -> Computer Id
	unrefComp s (Computer i ref) = Computer i (unrefUserRef s ref)
let
unrefUser :: State Ref -> User Ref -> User Id
unrefState
unrefSomething
gunref :: State Ref -> a Ref -> a Id
State Ref
User Ref
a
b
gunref :: (Data (a Id), Data (a Ref)) =>  State Ref -> a Ref -> a Id
Data
deriving instance Data (User Id)
deriving instance Data (User Ref)
deriving instance Data (Computer Id)
deriving instance Data (Computer Ref)
deriving instance Data (State Id)
deriving instance Data (State Ref
Typeable
Typeable
instance Typeable1 ref => Typeable (User ref) where
	typeOf _ = mkTyConApp (mkTyCon "User")     [typeOf1 (undefined :: ref ())]
instance Typeable1 ref => Typeable (Computer ref) where 
	typeOf _ = mkTyConApp (mkTyCon "Computer") [typeOf1 (undefined :: ref ())]
instance Typeable1 ref => Typeable (State ref) where 
	typeOf _ = mkTyConApp (mkTyCon "State")    [typeOf1 (undefined :: ref ())]
everywhere
Data.Generics
gfoldl
gunfold
Data.Dynamic
Data
data AData where AData :: Data a => a -> AData
instance Show AData where show (AData a) = "<" ++ show (typeOf a) ++ ">"

fromADataE :: forall b. Data b => AData -> b
fromADataE (AData d) = case cast d of
	Just v -> v
	Nothing -> error $ "Type error, trying to convert " ++
			   show (typeOf d) ++ " to  " ++
			   show (typeOf (undefined :: b)) ++ "."
AData
everywhere
type ADataT = AData -> Maybe AData

extADT :: forall a b. (Data a, Data b) => ADataT -> (a -> b) -> ADataT
extADT at t a@(AData v) = case cast v of 
		Just x ->  Just (AData (t x))
		Nothing -> at a

doNothing :: ADataT
doNothing = const Nothing
ADataT
doNothing
extADT
extT
everywhereADT :: forall a b. (Data a, Data b) => ADataT -> a -> b

-- first check if we can transform this value already
everywhereADT f v = case f (AData v) of
        -- if so, coerce it to the users’ requested type, which hopefully goes well
	Just r ->  fromADataE r 
	-- if not, we need to recurse into the data structure
	Nothing -> recursed

	-- for that, we first need to figure out the arguments to the 
        -- constructor. We store them in the untyped list
  where args :: [AData]
        (Const args) = gfoldl k z v
	-- gfoldl lets us have a look at each argument. We wrap it in AData
        -- and append it to the list
	k (Const args) arg = Const (AData arg : args)
	z start = Const []

	-- We need the data constructor of the input data type. If the user did not want
        -- it to be transformed, it will be the same
	c = toConstr v

	-- To give better error messages, we make sure that the outmost type constructor
        -- of the requested type actually has the data constructor we were given. Otherwise
        -- gunfold will complain in a non-helpful way
	input_type = dataTypeRep (constrType c)
	output_type = dataTypeRep (dataTypeOf (undefined :: b))

	recursed = if input_type /= output_type
                   then error $ "Can not convert <" ++ show input_type ++ ">"++
                                            " to <" ++ show output_type ++ ">."
	-- the types match, so we assemble the output type, using gunfold
                   else snd (gunfold k' z' c)
	k' :: forall b r . Data b => ([AData], b -> r) -> ([AData],r)

	-- we start by reversing the input list
	z' start = (reverse args,start)
	
	-- then we call us recursively on the argument and feed the result
        -- to the output constructor
	k' ((AData a) : args, append) = (args, append (everywhereADT f a))

-- Used for folding (we don’t need to retain the original constructor)
data Const a b = Const a 
bool2Int :: Bool -> Int
bool2Int False = 0
bool2Int True = 1

*Main> everywhereADT (doNothing `extADT` bool2Int) True :: Int
1
*Main> everywhereADT (doNothing `extADT` bool2Int) True :: ()
*** Exception: Type error, trying to convert Int to  ().
*Main> everywhereADT (doNothing `extADT` bool2Int) (True,False) :: (Int,Int)
(1,0)
*Main> everywhereADT (doNothing `extADT` bool2Int) ([True,False],True,()) :: ([Int],Int,())
([1,0],1,())
*Main> everywhereADT (doNothing `extADT` bool2Int) ([True,False],True,()) :: [()]
*** Exception: Can not convert  to .
*Main> everywhereADT (doNothing `extADT` bool2Int) [True] :: [Bool]
[*** Exception: Type error, trying to convert Int to  Bool.
gunref :: (Data (a Id), Data (a Ref)) =>  State Ref -> a Ref -> a Id
gunref s w = let unrefState = gunref' unrefState s
             in gunref' unrefState w

gunref' :: (Data (a Id), Data (a Ref)) =>  State Id -> a Ref -> a Id
gunref' unrefState = everywhereADT unref'
  where unref' = doNothing `extADT`
		 unrefUserRef unrefState `extADT`
		 unrefComputerRef unrefState
Ref
*Main> testState 
State [User {userId = 0, uses = [Ref 1]}] [Computer {computerId = 1, owner = Ref 0}]
*Main> gunref testState testState 
State [User {userId = 0, uses = [Id (Computer {computerId = 1, owner = Id (User {userId = 0,
uses = [Id (Computer {computerId = 1, owner = Id (User {userId = 0, uses = ..
{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, GADTs,
             FlexibleContexts, StandaloneDeriving, ScopedTypeVariables #-}
\Mansym
\mansym
\Womansym
\womansym
\Boysym
\boysym
\Girlsym
\girlsym
endless = [0..] -- All natural numbers!
main = print (endless !! 10)
endles = [0..]
main = print (endless !! (10^9) )
ulimit -S -v 1000000
test: out of memory (requested 1048576 bytes)
list = "Oh, happy day! Oh, happy day. "
cycle' list = list ++ cycle' list
main = do let rlist = cycle' list
          print ( rlist !! (10^9), rlist !! 0 )
list = "Oh, happy day! Oh, happy day. "
main = do let rlist = cycle list
          print ( rlist !! (10^9), rlist !! 0 )
cycle xs = xs' where xs' = xs ++ xs'
xs'
/etc/sysctl.d/vm.conf
vm.overcommit_memory = 2
vm.overcommit_ratio = 0
/etc/rcS.d/S30procps
/etc/rcS.d/S37procps
rm
pam-dbus
UsePAM yes
/etc/ssh/ssd_config
/etc/pam.d/
pam_dbus
pam_unix
pam_succeed_if
auth ? pam_succeed_if.so quiet user = guest
if..then..else
pam_unix
pam_unix
auth [default=2 success=ignore] pam_succeed_if.so quiet user = guest
auth [success=ok new_authtok_reqd=done ignore=ignore default=die] pam_dbus.so
auth [default=1] pam_permit.so
auth required pam_unix.so
auth [default=2 success=ignore] pam_succeed_if.so quiet user = guest
auth required pam_permit.so
auth [default=1] pam_permit.so
auth required pam_unix.so
407 Proxy Authentication Required
gksudo synaptic
gksu /usr/sbin/synaptic
gksudo /usr/sbin/synaptic

		W	D	L	Points	Language	Code lines
1.	Kroschinsky	904	242	54	2954	Python	589
2.	Schulz	858	263	79	2837	Python	544
3.	Breitner	837	281	82	2792	Haskell	264
4.	Jackermeier	754	306	140	2568	Perl	183
5.	Roth	574	338	288	2060	C++	1731
6.	Eitel	567	355	278	2056	Ruby	352
7.	Reichel	342	328	530	1354	Python	266
8.	Zimmermann	303	400	497	1309	Java	1070
9.	Apensiv	190	353	657	923	Perl	410
10.	Maraun	150	300	750	750	C++	690
11.	Golemo	131	319	750	712	Python	104
12.	Ziegelwanger	120	337	743	697	C++	868
13.	Fuest	32	254	914	350	Python	645

Planet Open Ghana

Kofi Boakye: Back Again !!

Joachim Breitner: Introducing L-seed

The idea

The plant code

The gameplay

The game code

The call for help

Thanks

Joachim Breitner: Third place in AI programming contest

Joachim Breitner: Points of View

Odzangba Dake: Greetings from Ho

Joachim Breitner: Buzz free

Joachim Breitner: Bejeweled AI in Haskell

Odzangba Dake: GZIP vs. BZIP2 vs. LZMA

Joachim Breitner: Server updated to Lenny

Joachim Breitner: In a Letter to Ghana’s President

Kwasi Kwakwa: What else I’ve been watching

Kwasi Kwakwa: In which the absentee host returns. Again

Odzangba Dake: Graphical Hardware Information Tools

Odzangba Dake: How To Fix Partition Table Order

Joachim Breitner: Reliability testing for python-dbus applications

Joachim Breitner: Openmoko User Meeting in Karlsruhe

Joachim Breitner: darcswatch uploaded to hackage

Odzangba Dake: Recover Deleted Files Using Linux

Odzangba Dake: openSUSE 11.1… sigh Pt.1

Joachim Breitner: Handling explicit and implicit recusion in Haskell data

Implicit referencing

Explicit referencing

Duplicated representation

Annotated representation

Not so kind kinds

Toggling a type parameter

Satisfied already?

Typeable and Data

everywhere is not enough

Wrapped Data

AData transformers

The ugly part

Almost done

Odzangba Dake: Meet The New Member Of The Family…

Joachim Breitner: MuMer relaunch – preview online

Joachim Breitner: 19 months of laptop battery data

Joachim Breitner: Good LaTeX Font Overview

Joachim Breitner: Linux Journal on the Neo FreeRunner

Odzangba Dake: Reserve A Zain Number

Odzangba Dake: Leash Runaway Applications

Joachim Breitner: My very first font

Kwasi Kwakwa: HE WON!!!!!

Kwasi Kwakwa: *Hat tip*

Odzangba Dake: Ghana Telecom… arrgh*&%$#!

Odzangba Dake: Using Ubuntu Without X

Kwasi Kwakwa: Recent additions to the bookshelf

Joachim Breitner: Infinite loops in Haskell

Kwasi Kwakwa: And its done (pretty much)

Joachim Breitner: Haskell work in Dresden

Kofi Boakye: H E L P ??Need LinuxCD

Odzangba Dake: People, Software Freedom Day

George Gyau: How do I disable the ping response?

George Gyau: Custom teaser length by View using node.tpl.php

Joachim Breitner: vm.overcommit_memory = 2, vm.overcommit_ratio = 0

George Gyau: S Leone president declares assets

George Gyau: Google launches internet browser

Joachim Breitner: Debian on the FreeRunner

Kwasi Kwakwa: Not dead, missing or abandoned

Joachim Breitner: Xmonad on my mobile phone

Joachim Breitner: pam-dbus: authentication by bubbles

Joachim Breitner: Flow control with pam configuration

George Gyau: Changing Server Timezone On Ubuntu

Joachim Breitner: One Week with an OpenMoko Freerunner

The hardware

The software

Development

The community

George Gyau: Adeona, free Laptop-Tracking System

George Gyau: The server encountered an internal error or misconfiguration

Odzangba Dake: The Hunt Continues…

Odzangba Dake: Frustrations…

Odzangba Dake: Synaptic proxy configuration problems

Odzangba Dake: What to do when you lose your password

`everywhere` is not enough

Kwasi Kwakwa: Hat tip