diff --git a/src/byte_data.rs b/src/byte_data.rs
index 581f3df..049d73f 100644
--- a/src/byte_data.rs
+++ b/src/byte_data.rs
@@ -11,7 +11,7 @@ pub struct Params{
     pub n: usize,
     pub m: usize,
 }
-/// data struct contains shards matrix where each "shard" is row
+/// data struct od type `T` contains data matrix with dimensions `n`*`m`
 /// the matrix contains n rows, k of which are source data and the rest (n-k) are parity
 #[derive(Clone, Debug)]
 pub struct Data<T>{
@@ -19,21 +19,21 @@ pub struct Data<T>{
     pub matrix: Vec<Vec<T>>,
 }
 
-impl DataMatrix<u8> for Data<u8> {
+impl DataMatrix<u8> for Data<Option<u8>> {
     type Params = Params;
 
     /// new from random
     fn new_random(params: Self::Params) -> Self {
         let mut rng = rand::rng();
         // generate random data shards
-        let matrix: Vec<Vec<u8>> = (0..params.n)
+        let matrix: Vec<Vec<Option<u8>>> = (0..params.n)
             .map(|i| {
                 if i < params.k {
-                    // data shard: random u8
-                    (0..params.m).map(|_| rng.random::<u8>()).collect()
+                    // data: random u8
+                    (0..params.m).map(|_| Some(rng.random::<u8>())).collect()
                 } else {
-                    // parity shard: zero
-                    vec![0u8; params.m]
+                    // parity: zero
+                    vec![None; params.m]
                 }
             })
             .collect();
@@ -43,35 +43,42 @@ impl DataMatrix<u8> for Data<u8> {
         }
     }
 
-    /// Update col `c` in shards.
-    /// given `new_col` will replace the column `c` or `shards[0..k][c]`
+    /// Update col `c` in matrix.
+    /// given `new_col` will replace the column `c` or `matrix[0..k][c]`
     fn update_col(&mut self, c: usize, new_col: &[u8]) {
         // sanity checks
         assert!(
             new_col.len() == self.params.k,
-            "new_row length ({}) must equal k ({})",
+            "new_col length ({}) must equal k ({})",
             new_col.len(),
             self.params.k
         );
         assert!(
             c < self.params.m,
-            "row index {} out of bounds; must be < {}",
+            "col index {} out of bounds; must be < {}",
             c,
             self.params.m
         );
 
-        // write into each of the k data shards at position c
-        for i in 0..self.params.k {
-            self.matrix[i][c] = new_col[i];
+        // write into each of the k data rows at position c
+        for i in 0..self.params.n {
+            if i < self.params.k {
+                self.matrix[i][c] = Some(new_col[i]);
+            }else{
+                self.matrix[i][c] = None;
+            }
         }
     }
 
-    /// Print all shards
+    /// Print all matrix
     fn pretty_print(&self) {
         for (i, shard) in self.matrix.iter().enumerate() {
             print!("Row {:>2}: ", i);
-            for &b in shard {
-                print!("{:>3} ", b);
+            for opt in shard {
+                match opt {
+                    Some(byte) => print!("{:>3} ", byte),
+                    None       => print!("  - "),
+                }
             }
             println!();
         }