diff --git a/aivika-experiment-chart.cabal b/aivika-experiment-chart.cabal
--- a/aivika-experiment-chart.cabal
+++ b/aivika-experiment-chart.cabal
@@ -1,5 +1,5 @@
 name:            aivika-experiment-chart
-version:         1.0
+version:         1.1
 synopsis:        Simulation experiments with charting for the Aivika library
 description:
     This package complements the Aivika and Aivika Experiment packages with
@@ -51,7 +51,7 @@
                      lens >= 3.9,
                      data-default-class < 0.1,
                      colour >= 2.3.3,
-                     aivika >= 1.0,
-                     aivika-experiment >= 1.0
+                     aivika >= 1.1,
+                     aivika-experiment >= 1.1
 
     ghc-options:     -O2
diff --git a/examples/BassDiffusion.hs b/examples/BassDiffusion.hs
--- a/examples/BassDiffusion.hs
+++ b/examples/BassDiffusion.hs
@@ -1,6 +1,7 @@
 
 import System.Random
 import Data.Array
+
 import Control.Monad
 import Control.Monad.Trans
 
@@ -36,16 +37,6 @@
                        Left "adopters"] } ]
     }
 
-exprnd :: Double -> IO Double
-exprnd lambda =
-  do x <- getStdRandom random
-     return (- log x / lambda)
-     
-boolrnd :: Double -> IO Bool
-boolrnd p =
-  do x <- getStdRandom random
-     return (x <= p)
-
 data Person = Person { personAgent :: Agent,
                        personPotentialAdopter :: AgentState,
                        personAdopter :: AgentState }
@@ -71,20 +62,23 @@
   do setStateActivation (personPotentialAdopter p) $
        do modifyRef potentialAdopters $ \a -> a + 1
           -- add a timeout
-          t <- liftIO $ exprnd advertisingEffectiveness 
+          t <- liftParameter $
+               randomExponential (1 / advertisingEffectiveness)
           let st  = personPotentialAdopter p
               st' = personAdopter p
           addTimeout st t $ selectState st'
      setStateActivation (personAdopter p) $ 
        do modifyRef adopters  $ \a -> a + 1
           -- add a timer that works while the state is active
-          let t = liftIO $ exprnd contactRate    -- many times!
+          let t = liftParameter $
+                  randomExponential (1 / contactRate)    -- many times!
           addTimer (personAdopter p) t $
             do i <- liftIO $ getStdRandom $ randomR (1, n)
                let p' = ps ! i
                st <- selectedState (personAgent p')
                when (st == Just (personPotentialAdopter p')) $
-                 do b <- liftIO $ boolrnd adoptionFraction
+                 do b <- liftParameter $
+                         randomTrue adoptionFraction
                     when b $ selectState (personAdopter p')
      setStateDeactivation (personPotentialAdopter p) $
        modifyRef potentialAdopters $ \a -> a - 1
@@ -109,7 +103,7 @@
      adopters <- newRef 0
      ps <- createPersons
      definePersons ps potentialAdopters adopters
-     runEventInStartTime IncludingCurrentEvents $
+     runEventInStartTime $
        activatePersons ps
      experimentDataInStartTime
        [("potentialAdopters",
diff --git a/examples/Furnace.hs b/examples/Furnace.hs
--- a/examples/Furnace.hs
+++ b/examples/Furnace.hs
@@ -33,15 +33,13 @@
 -- processor.
 
 import Data.Maybe
-import System.Random
+
 import Control.Monad
 import Control.Monad.Trans
 
 import Simulation.Aivika
 import Simulation.Aivika.Queue.Infinite
 
-import qualified Simulation.Aivika.DoubleLinkedList as DLL
-
 import Simulation.Aivika.Experiment
 import Simulation.Aivika.Experiment.Chart
 
@@ -311,26 +309,26 @@
   do furnace <- newFurnace
   
      -- initialize the furnace and start its iterating in start time
-     runEventInStartTime IncludingCurrentEvents $
+     runEventInStartTime $
        do initializeFurnace furnace
           startIteratingFurnace furnace
      
      -- generate randomly new input ingots
-     runProcessInStartTime IncludingCurrentEvents $
+     runProcessInStartTime $
        inputProcess furnace
 
      -- load permanently the input ingots in the furnace
-     runProcessInStartTime IncludingCurrentEvents $
+     runProcessInStartTime $
        loadingProcess furnace
      
      experimentDataInStartTime
        [(totalIngotCountName,
          seriesEntity "total ingot count" $
-         queueStoreCount (furnaceQueue furnace)),
+         enqueueStoreCount (furnaceQueue furnace)),
              
         (loadedIngotCountName,
          seriesEntity "loaded ingot count" $  -- actually, +/- 1
-         queueOutputCount (furnaceQueue furnace)),
+         dequeueCount (furnaceQueue furnace)),
              
         (readyIngotCountName,
          seriesEntity "ready ingot count" $
diff --git a/examples/MachRep3.hs b/examples/MachRep3.hs
--- a/examples/MachRep3.hs
+++ b/examples/MachRep3.hs
@@ -13,7 +13,6 @@
 -- until both machines are down. We find the proportion of up time. It
 -- should come out to about 0.45.
 
-import System.Random
 import Control.Monad
 import Control.Monad.Trans
 
@@ -126,10 +125,10 @@
               
               machine pid
 
-     runProcessInStartTimeUsingId IncludingCurrentEvents
+     runProcessInStartTimeUsingId
        pid1 (machine pid2)
 
-     runProcessInStartTimeUsingId IncludingCurrentEvents
+     runProcessInStartTimeUsingId
        pid2 (machine pid1)
      
      let result =