TIL: Linux Productivity Tools and Rust Ownership Concepts

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

-- xmonad.hs configuration for volume control
import XMonad.Util.EZConfig
import XMonad.Actions.Volume

myKeys = 
    [ ("M-<F1>", toggleMute >> return ())
    , ("M-<F2>", lowerVolume 4 >> return ())
    , ("M-<F3>", raiseVolume 4 >> return ())
    ]

main = xmonad $ defaultConfig 
    `additionalKeysP` myKeys

-- Alternative using shell commands
volumeKeys = 
    [ ("<XF86AudioMute>", spawn "amixer set Master toggle")
    , ("<XF86AudioLowerVolume>", spawn "amixer set Master 5%-")
    , ("<XF86AudioRaiseVolume>", spawn "amixer set Master 5%+")
    ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Check current turbo boost status
cat /sys/devices/system/cpu/cpufreq/boost

# Disable turbo boost to reduce heat/improve battery
echo 0 | sudo tee /sys/devices/system/cpu/cpufreq/boost

# Re-enable turbo boost for performance
echo 1 | sudo tee /sys/devices/system/cpu/cpufreq/boost

# Check current CPU frequencies
cat /proc/cpuinfo | grep MHz

# Monitor CPU temperature
sensors

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# ~/.config/fusuma/config.yml
swipe:
  3:
    left:
      command: 'xdotool key alt+Right'  # Browser forward
    right:
      command: 'xdotool key alt+Left'   # Browser back
    up:
      command: 'xdotool key super'      # Show activities
    down:
      command: 'xdotool key ctrl+alt+d' # Show desktop
  4:
    left:
      command: 'xdotool key ctrl+alt+Right' # Switch workspace
    right:
      command: 'xdotool key ctrl+alt+Left'  # Switch workspace
    up:
      command: 'xdotool key ctrl+alt+Up'    # Show all workspaces
    down:
      command: 'xdotool key ctrl+alt+Down'  # Show current workspace

pinch:
  in:
    command: 'xdotool key ctrl+minus' # Zoom out
  out:
    command: 'xdotool key ctrl+plus'  # Zoom in

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Install fusuma
sudo gem install fusuma

# Add user to input group
sudo gpasswd -a $USER input

# Start fusuma
fusuma

# Run as daemon
fusuma -d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Ownership Rules:
// 1. Each value in Rust has a single owner
// 2. When the owner goes out of scope, the value is dropped
// 3. There can only be one owner at a time

fn ownership_examples() {
    // Basic ownership
    let s1 = String::from("hello");
    let s2 = s1; // s1 is moved to s2, s1 is no longer valid
    // println!("{}", s1); // This would compile error!
    println!("{}", s2); // This works
    
    // Function ownership
    let s = String::from("world");
    takes_ownership(s); // s is moved into function
    // println!("{}", s); // This would compile error!
    
    let x = 5;
    makes_copy(x); // x is copied (integers implement Copy trait)
    println!("{}", x); // This still works
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // some_string goes out of scope and is dropped

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
} // some_integer goes out of scope, but nothing special happens

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// Borrowing allows using values without taking ownership
fn borrowing_examples() {
    let s1 = String::from("hello");
    
    // Immutable borrow
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len); // s1 still valid
    
    // Mutable borrow
    let mut s2 = String::from("hello");
    change(&mut s2);
    println!("{}", s2);
    
    // Borrowing rules demonstration
    let mut s = String::from("hello");
    
    // Multiple immutable borrows are fine
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    
    // But can't have mutable borrow while immutable borrows exist
    // let r3 = &mut s; // This would compile error!
    
    // After immutable borrows are done, mutable borrow is fine
    let r3 = &mut s;
    println!("{}", r3);
}

fn calculate_length(s: &String) -> usize { // s is a reference to a String
    s.len()
} // s goes out of scope, but because it doesn't have ownership, nothing is dropped

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// Common patterns for working with ownership

// 1. Returning ownership from functions
fn create_string() -> String {
    let s = String::from("hello");
    s // Return moves ownership to caller
}

// 2. Taking and returning ownership
fn process_string(s: String) -> String {
    // Process the string
    format!("{} processed", s)
}

// 3. Borrowing for read-only operations
fn read_string(s: &String) -> usize {
    s.len() // Just reading, no ownership needed
}

// 4. Mutable borrowing for modifications
fn modify_string(s: &mut String) {
    s.push_str(" modified");
}

// 5. Clone when you need independent copies
fn clone_example() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Explicit clone
    
    println!("{} {}", s1, s2); // Both are valid
}

// 6. Using lifetimes with references
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// 7. Struct with borrowed data
struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
    
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Simple notification
echo "Volume: 50%" | ghosd

# With positioning
ghosd --position=top --timeout=2000 << EOF
System Update Available
Click to install
EOF

# Integration with volume control
amixer set Master 5%+ | grep -o '[0-9]*%' | ghosd --position=center

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# Implementation of "no zero days" tracking
from datetime import datetime, timedelta
import json

class ProgressTracker:
    def __init__(self, goal: str):
        self.goal = goal
        self.entries = []
    
    def log_progress(self, description: str, time_spent: int = 0):
        """Log daily progress, no matter how small"""
        entry = {
            'date': datetime.now().isoformat(),
            'description': description,
            'time_spent_minutes': time_spent
        }
        self.entries.append(entry)
        print(f"✓ Progress logged: {description}")
    
    def get_streak(self) -> int:
        """Calculate current streak of non-zero days"""
        if not self.entries:
            return 0
        
        today = datetime.now().date()
        streak = 0
        
        for i in range(len(self.entries) - 1, -1, -1):
            entry_date = datetime.fromisoformat(self.entries[i]['date']).date()
            expected_date = today - timedelta(days=streak)
            
            if entry_date == expected_date:
                streak += 1
            else:
                break
        
        return streak
    
    def summary(self):
        """Show progress summary"""
        total_time = sum(entry['time_spent_minutes'] for entry in self.entries)
        streak = self.get_streak()
        
        print(f"Goal: {self.goal}")
        print(f"Total entries: {len(self.entries)}")
        print(f"Total time: {total_time} minutes")
        print(f"Current streak: {streak} days")

# Usage example
tracker = ProgressTracker("Learn Rust")
tracker.log_progress("Read about ownership and borrowing", 30)
tracker.log_progress("Completed 3 exercises on ownership", 45)
tracker.summary()